Don Batory

Don Batory
University of Texas at Austin | UT · Department of Computer Science

About

226
Publications
10,919
Reads
How we measure 'reads'
A 'read' is counted each time someone views a publication summary (such as the title, abstract, and list of authors), clicks on a figure, or views or downloads the full-text. Learn more
10,515
Citations
Citations since 2016
14 Research Items
2588 Citations
20162017201820192020202120220100200300400
20162017201820192020202120220100200300400
20162017201820192020202120220100200300400
20162017201820192020202120220100200300400

Publications

Publications (226)
Article
Full-text available
Many analyses on configurable software systems are intractable when confronted with colossal and highly-constrained configuration spaces. These analyses could instead use statistical inference, where a tractable sample accurately predicts results for the entire space. To do so, the laws of statistical inference requires each member of the populatio...
Chapter
Real-world need whose features not only have boolean values satisfying boolean constraints, but also have numeric attributes satisfying arithmetic constraints. A key operation on s finds near-optimal performing products, which requires counting the number of SPL products. Typical constraint satisfaction solvers perform poorly on counting. (Numbers,...
Chapter
Stepwise design of programs is a divide-and-conquer strategy to control complexity in program modularization and theorems. It has been studied extensively in the last 30 years and has worked well, although it is not yet commonplace. This paper explores a new area of research, finding efficient products in colossal product spaces, that builds upon p...
Conference Paper
Feature models were invented in 1990 and have been recognised as one of the main contributions to the software product line community. Although there have been several attempts to establish a sort of standard variability modelling language, there is still no consensus. There can be many motivations to have one but there is one that is very importan...
Conference Paper
Since the mid-2000s, Propositional Logic (PL) has been the de facto language to express constraints in Feature Models (FMs) of Software Product Line (SPLs). PL was adequate because product configurations were formed by binary decisions including or not including features in a product. Inspired by both prior research and practical systems (eg., SPLs...
Conference Paper
Full-text available
Analyses of Software Product Lines (SPLs) rely on automated solvers to navigate complex dependencies among features and find legal configurations. Often these analyses do not support numerical features with constraints because propositional formulas use only Boolean variables. Some automated solvers can represent numerical features natively, but ar...
Conference Paper
Efficiently testing large configuration spaces of Software Product Lines (SPLs) needs a sampling algorithm that is both scalable and provides good t-wise coverage. The 2019 SPLC Sampling Challenge provides large real-world feature models and asks for a t-wise sampling algorithm that can work for those models. We evaluated t-wise coverage by uniform...
Conference Paper
Regression testing checks that recent project changes do not break previously working functionality. Although important, regression testing is costly when changes are frequent. Regression test selection (RTS) optimizes regression testing by running only tests whose results might be affected by a change. Traditionally, RTS collects dependencies (e.g...
Conference Paper
X15 is the first tool that can apply common object-oriented refactorings to Java Software Product Lines (SPLs). X15 is also the first tool that programmers can write custom scripts (to call refactorings programmatically) to retrofit design patterns into Java SPLs. We motivate and illustrate X15's unique capabilities in this paper.
Conference Paper
Refactoring is a staple of Object-Oriented (OO) program development. It should be a staple of OO Software Product Line (SPL) development too. X15 is the first tool to support the refactoring of Java SPL codebases. X15 (1) uses Java custom annotations to encode variability in feature-based Java SPLs, (2) projects a view of an SPL product (a program...
Conference Paper
Full-text available
Software Product Lines (SPLs) are highly configurable systems. This raises the challenge to find optimal performing configurations for an anticipated workload. As SPL configuration spaces are huge, it is infeasible to benchmark all configurations to find an optimal one. Prior work focused on building performance models to predict and optimize SPL c...
Conference Paper
Software engineering involves a lot of change as code artifacts are not only created once but maintained over time. In the last 25 years, major paradigms of program development have arisen -- agile development with refactorings, software product lines, moving sequential code to multicore or cloud, etc. Each is centered on particular kinds of change...
Article
Dataflow programs are widely used. Each program is a directed graph where nodes are computations and edges indicate the flow of data. In prior work, we reverse-engineered legacy dataflow programs by deriving their optimized implementations from a simple specification graph using graph transformations called refinements and optimizations. In MDE spe...
Conference Paper
A software product line (SPL) is a family of programs that are differentiated by features --- increments in functionality. Systematically testing an SPL is challenging because it requires running each test of a test suite against a combinatorial number of programs. Feature models capture dependencies among features and can (1) reduce the space of p...
Conference Paper
Managing complexity is a fundamental goal of software engineering. One of the core techniques that has been successful in practice is that which separate concerns, especially variants of architectural abstractions called components and connectors. We present and illustrate a theory about the general structure of General Theories of Software Enginee...
Chapter
Full-text available
A Structured Document Algebra (SDA) defines modules with variation points and how such modules compose. The basic operations are module addition and replacement. Repeated addition can create nested module structures. SDA also allows the decomposition of modules into smaller parts. In this paper we show how SDA modules can be used to deal algebraica...
Conference Paper
How do experts navigate the huge space of implementations for a given specification to find an efficient choice with minimal searching? Answer: They use “heuristics” – rules of thumb that are more street wisdom than scientific fact. We provide a scientific justification for Dense Linear Algebra (DLA) heuristics by showing that only a few decisions...
Article
Full-text available
Design by Transformation (DxT) is an approach to software development that encodes domain-specific programs as graphs and expert design knowledge as graph transformations. The goal of DxT is to mechanize the generation of highly-optimized code. This paper demonstrates how DxT can be used to transform sequential specifications of an important set of...
Conference Paper
Many dense linear algebra (DLA) operations are easy to understand at a high level and users get functional DLA code on new hardware relatively quickly. As a result, many people consider DLA to be a "solved domain." The truth is that DLA is not solved. DLA experts are rare because the "tricks" and variety of algorithms they need to get high performa...
Article
Design by Transformation (DxT) is a top-down approach to mechanically derive high-performance algorithms for dense linear algebra. We use DxT to derive the implementation of a representative matrix operation, two- sided Trmm. We start with a knowledge base of transformations that were encoded for a simpler set of operations, the level-3 BLAS, and a...
Conference Paper
Mechanizing the development of hard-to-write and costly-to-maintain software is the core problem of automated software design. Encoding expert knowledge (a.k.a. dark knowledge) about a software domain is central to its solution. We assert that a solution can be cast in terms of the ideas of language design and engineering. Graph grammars can be a f...
Chapter
Features can interaction in various was, both in positive and intended ways, as well as in critical and inadvertent ways. Communication between features is natural and often desired, but if not identified and managed properly, feature interactions can cause unexpected erroneous behaviors and result in critical system states. This chapter takes a cl...
Chapter
Besides language-based techniques, which encode variability with available concepts within programming languages (discussed in the previous chapter), external tools can also be used to implement and manage variability.
Chapter
Refactoring is an important activity in software development, maintenance, and evolution.
Chapter
Variability raises new challenges for establishing correctness or any kind of functional or nonfunctional guarantees about programs. Traditional testing, type checking, static analysis, verification, or software and performance measurement are well-established for individual systems, but they do not scale to product lines when analyzing ever produc...
Chapter
In this chapter, we introduce basic concepts that arise in the engineering of feature-oriented software product lines. We narrow down the term feature , introduce an overall development process, and illustrate how to model and formalize variability in product lines.
Chapter
There are many ways to implement variable code; some have been used long before the advent of software product lines. Even a simple if statement offers a choice between different execution paths. To prevent cluttering of code with if statements, to enhance feature traceability, to provide extensibility without the need to change the original source...
Chapter
There are several attempts to support the development and management of feature-oriented product lines by means of tool support that exceeds traditional tools such as preprocessors, build systems, and version control systems. They typically build on concepts of build systems and conditional compilation, but provide tool support that goes beyond tra...
Chapter
Software product lines aim at empowering software vendors to tailor software products to the requirements of individual customers. In this sense, software product lines follow a development that emerged in industrial manufacturing over the last 200 years. Starting with handcrafting of individual goods, the advent of mass production scaled the produ...
Chapter
In Part I, we described a process to develop feature-oriented product lines. It involves domain and application engineering, each comprising several phases, from domain and requirements analysis to implementation and product derivation.
Chapter
After reading the chapter, you should be able to explain the key concepts of collaboration-based design and feature-oriented programming, understand the key mechanisms of AspectJ and write simple aspects in this language, implement product lines with feature-oriented and aspect-oriented languages and their combination, discuss trade-offs between th...
Conference Paper
Many programs can be configured through dynamic and/or static selection of configuration variables. A software product line (SPL), for example, specifies a family of programs where each program is defined by a unique combination of features. Systematically testing SPL programs is expensive as it can require running each test against a combinatorial...
Conference Paper
We narrate insights from a collaboration between researchers in Software Engineering (SE) and in the domain of Dense Linear Algebra (DLA) libraries. We highlight our impressions of how software development for computational science has traditionally been different from the development of software in other domains. We observe that scientific softwar...
Article
A classical approach to program derivation is to progressively extend a simple specification and then incrementally refine it to an implementation. We claim this approach is hard or impractical when reverse engineering legacy software architectures. We present a case study that shows optimizations and pushouts ---in addition to refinements and exte...
Conference Paper
To implement dense linear algebra algorithms for distributed-memory computers, an expert applies knowledge of the domain, the target architecture, and how to parallelize common operations. This is often a rote process that be-comes tedious for a large collection of algorithms. We have developed a way to encode this expert knowledge such that it can...
Conference Paper
Full-text available
The efforts of an expert to parallelize and optimize a dense linear algebra algorithm for distributed-memory targets are largely mechanical and repetitive. We demonstrate that these efforts can be encoded and automatically applied to obviate the manual implementation of many algorithms in high-performance code.
Article
The efforts of an expert to parallelize and optimize a dense linear algebra algorithm for distributed-memory targets are largely mechanical and repetitive. We demonstrate that these efforts can be encoded and automatically applied to obviate the manual implementation of many algorithms in high-performance code.
Conference Paper
Software architectures can be presented by graphs with components as nodes and connectors as edges. These graphs, or models, typically encode expert domain knowledge, which makes them difficult to understand. Hence, instead of presenting a complete complex model, we can derive it from a simple, easy-to-understand model by a set of easy-to-understan...
Conference Paper
Full-text available
Customizable programs and program families provide user-selectable features to allow users to tailor a program to an application scenario. Knowing in advance which feature selection yields the best performance is difficult because a direct measurement of all possible feature combinations is infeasible. Our work aims at predicting program performance...
Conference Paper
Full-text available
Mechanized proof assistants are powerful verification tools, but proof development can be difficult and time-consuming. When verifying a family of related programs, the effort can be reduced by proof reuse. In this paper, we show how to engineer product lines with theorems and proofs built from feature modules. Each module contains proof fragments...
Conference Paper
A Software Product Line (SPL) is a family of programs where each program is defined by a unique combination of features. Testing or checking properties of an SPL is hard as it may require the examination of a combinatorial number of programs. In reality, however, features are often irrelevant for a given test - they augment, but do not change, exis...
Article
Full-text available
We show how transformations organize and explain the designs of legacy pipe-and-filter-architectures. We start with an elementary architecture and progressively transform it to a detailed executable architecture. In this paper, we (a) present an MDE-based foundation of how domain-specific design knowledge can be organized by transformations, (b) il...
Conference Paper
A Software Product Line (SPL) is a family of programs where each program is defined by a unique combination of features. Developing a set of programs with commonalities and variabilities in this way can significantly reduce both the time and cost of software development. However, as the number of programs may be exponential in the number of feature...
Conference Paper
Full-text available
Multicore, multithreaded processors are rapidly becoming the platform of choice for high-throughput request-processing applications (RPAs). We refer to this class of modern parallel platforms as multi-⋆ systems. In this paper, we describe the design and implementation of Lagniappe, a translator that simplifies RPA development by transforming portab...
Conference Paper
A software product line is a family of programs where each program is defined by a unique combination of features. Product lines, like conventional programs, can be checked for safety properties through execution monitoring. However, because a product line induces a number of programs that is potentially exponential in the number of features, it wo...
Conference Paper
Full-text available
We present a general approach to the incremental development of model-based applications using endogenous transformations, i.e. transformations whose input and output models conform to the same metamodel. Our work describes these transformations as model deltas that, when composed, deliver a complete model. We establish a relationship between a met...
Article
Full-text available
Model driven engineering (MDE) of software product lines (SPLs) merges two increasing important paradigms that synthesize programs by transformation. MDE creates programs by transforming models, and SPLs elaborate programs by applying transformations called features. In this paper, we present the design and implementation of a transformational mode...
Article
Recent advances in mechanical techniques for systematic testing have increased our ability to automatically find subtle bugs, and hence, to deploy more dependable software. This paper builds on one such systematic technique, scope-bounded testing, to develop a novel specification-based approach for efficiently generating tests for products in a sof...
Conference Paper
I summarize some personal observations on the topic of automated software design and synthesis that I accumulated over twenty years. They are intended to alert researchers to pitfalls that may be encountered and to identify goals for future efforts in advancing software engineering education and research.
Article
Full-text available
This ICB Research Report constitutes the Proceedings of the 4th International Workshop on Variability Modelling of Software-intensive Systems (VaMoS'10), which was held from January 27-29, 2010 at the Johannes Kepler University Linz. --
Conference Paper
Programs can be composed from features. We want to verify automatically that all legal combinations of features can be composed safely without errors. Prior work on this problem assumed that features add code monotonically. We generalize prior work to enable features to both add and remove code, describe our analyses and implementation, and review...
Conference Paper
In feature-oriented programming, a feature is an increment in program functionality and is implemented by a feature module. Programs are generated by composing feature modules. A generated program may be used by other client programs but occasionally must be transformed to match a particular legacy interface before it can be used. We call the misma...
Article
While it is well known that crosscutting concerns occur in many software projects, little is known about the inherent properties of these concerns nor how aspects (should) deal with them. We present a framework for classifying the structural properties of crosscutting concerns into (1) those that benefit from AOP and (2) those that should be implem...
Conference Paper
A software product-line is a family of related programs that are distinguished in terms of features. A feature implements a stakeholders' requirement. Different program variants specified by distinct feature selections are produced from a common code base. The optional feature problem describes a common mismatch between variability intended in the...
Conference Paper
A software product line (SPL) is a family of related program variants in a well-defined domain, generated from a set of features. A fundamental difference from classical application development is that engineers develop not a single program but a whole family with hundreds to millions of variants. This makes it infeasible to separately check every...
Conference Paper
Full-text available
Features express the variabilities and commonalities among programs in a software product line (SPL). A feature model defines the valid combinations of features, where each combination corresponds to a program in an SPL. SPLs and their feature models evolve over time. We classify the evolution of a feature model via modifications as refactorings, s...
Conference Paper
We present a Model Driven Engineering approach to ex- plain, verify, build, and test dataflow or streaming soft- ware architectures that are parallelized for performance or availability. Component-connector models are incrementally elaborated by transformations that refine or optimize archi- tectural designs. We re-engineered two significant case s...
Conference Paper
Full-text available
Programs of a software product line can be synthesized by composing features which implement a unit of program func- tionality. In most product lines, only some combination of features are meaningful; feature models express the high- level domain constraints that govern feature compatibility. Product line developers also face the problem of safe co...
Conference Paper
We present a novel specification-based approach for generating tests for products in a software product line. Given properties of features as first-order logic formu- las, our approach uses SAT-based analysis to automat- ically generate test inputs for each product in a product line. To ensure soundness of generation, we introduce an automatic tech...
Conference Paper
The automation of software product line (SPL) analyses is of growing interest to both practitioners and researchers. In particular, automated analyses of variability models (like feature or decision models) and languages that foster declarative specifications of programs using those models are now common. We note that many of the problems that SPL...
Conference Paper
Feature modules are the building blocks of programs in software product lines (SPLs). A foundational assumption of feature-based program synthesis is that features are composed in a predefined order. Recent work on virtual separation of concerns reveals a new model of feature interactions that shows that feature modules can be quantized as composit...
Conference Paper
A functional aspect is an aspect that has the semantics of a transformation; it is a function that maps a program to an advised program. Functional aspects are composed by function composition. In this paper, we explore functional aspects in the context of aspect-oriented refactoring. We show that refactoring legacy applications using functional as...
Conference Paper
Computational Design (CD) is a paradigm where both program design and program synthesis are computations. CD merges Model Driven Engineering (MDE) which synthesizes programs by transforming models, with Software Product Lines (SPL) where programs are synthesized by composing transforma tions called features. In this paper, basic relationships betwe...
Conference Paper
Full-text available
Model driven development (MDD) of software product lines (SPLs) merges two increasing important paradigms that synthesize programs by transformation. MDD creates programs by transforming models, and SPLs elaborate programs by applying transformations called features. In this paper, we present the design and implementation of a transformational mode...
Article
Software product lines (SPL) usually consist of code and non-code artifacts written in different languages. Often they are created by decomposing legacy applications into features. To handle different artifacts uniformly (code, doc- umentation, models, etc.), current SPL technologies either use an approach that is so general that it works on charac...
Conference Paper
We propose an ASM-based method to integrate into current feature-based software design practice modular verification techniques.
Article
A gvvoal of software product lines is the economical assembly of programs in a family of programs. In this paper, we explore how theorems about program properties may be integrated into feature-based development of software product lines. As a case study, we analyze an existing Java/JVM compilation correctness proof for defining, interpreting, comp...
Conference Paper
Modeling languages are a fundamental part of automated software development. MDD, for example, uses UML class diagrams and state machines as languages to define applications. In this paper, we explore how Feature Oriented Software Development (FOSD) uses modern mathematics as a modeling language to express the design and synthesis of programs in so...
Article
Framework-based application development requires appli-cations to be implemented according to rules, recipes and conventions that are documented or assumed by the frame-work's Application Programming Interface (API), thereby giving rise to systematic usage patterns. While such usage patterns can be captured cleanly using conventional aspects, their...
Conference Paper
Software product lines aim to create highly configurable programs from a set of features. Common belief and recent studies suggest that aspects are well-suited for implementing features. We evaluate the suitability of AspectJ with respect to this task by a case study that refactors the embedded database system Berkeley DB into 38 features. Contrary...
Conference Paper
Full-text available
Programs of a software product line can be synthesized by compos- ing modules that implement features. Besides high-level domain constraints that govern the compatibility of features, there are also low-level implementation constraints: a feature module can refer- ence elements that are defined in other feature modules. Safe com- position is the gu...