Here are some keynote presentations. Each entry has a citation, an abstract, and a hypertext link to a PDF copy of the presentation. Click here for copyright notice.
Model Driven Engineering Languages and Systems, October 2008
The Objects and Arrows of Computational Design.
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
transformations called features. In this paper, basic relationships between MDE
and SPL are explored using the language of modern mathematics.
Brazilian Symposium on Software Engineering, October 2007
A Modeling Language
for Program Design and Synthesis.
Software engineers define structures called programs and use tools to
manipulate, transform, and analyze them. A modeling language is needed to
express program design and synthesis as a computation, and elementary algebra
fits the bill. I review recent results in automated software design, testing,
and maintenance and use the language of elementary mathematics to explain and
relate them. Doing so outlines a general and simple way to express and
understand the relationships between different topics in program synthesis.
Abstract State Machine (ASM) Workshop, June 2007
Modularizing Theorems for Software Product Lines: The Jbook Case Study
A goal 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, compiling,
and executing bytecode for the Java language. We show how features modularize
program source, theorem statements and their proofs. By composing features, the
source code, theorem statements and proofs for a program are assembled. The
investigation in this paper reveals a striking similarity of the refinement
concepts used in Abstract State Machines (ASM) based system development and
Feature-Oriented Programming (FOP) of software product lines. We suggest to
exploit this observation for a fruitful interaction of researchers in the two
communities.
European Joint Conferences on Theory and Practice of Software (ETAPS) Compiler Construction Conference, April 2007
"Program Refactorings, Program Synthesis, and Model-Driven Design".
Program refactoring, feature-based and aspect-oriented software synthesis, and model-driven development are disjoint research areas. However, they are all architectural metaprogramming technologies as they treat programs as values and use functions (a.k.a. transformations) to map programs to other programs. In this paper, I explore their underlying connections by reviewing recent advances in each area from an architectural metaprogramming perspective. I conjecture how these areas can converge and outline a theory that may unify them.
Principles of Programming Languages (POPL), January 2007
"From Implementation to Theory in Product Synthesis". (Tech Report)
Future software development will rely on product synthesis, i.e., the synthesis of code and non-code artifacts for a target component or application. Prior work on feature-based product synthesis can be unified by applying elementary ideas from category theory. Doing so reveals (a) important and previously unrecognized properties that product synthesis tools must satisfy, and (b) non-obvious generalizations of current techniques that will guide future research efforts in automated product development."Using Modern Mathematics as an FOSD Modeling Language"
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 software product lines, but demands little mathematical sophistication from its users. Doing so has three practical benefits: (1) it offers a simple and principled mathematical description of how FOSD transforms, derives, and relates program artifacts, (2) it exposes previously unrecognized commuting relationships among tool chains, thereby providing new ways to debug tools, and (3) it reveals new ways to optimize software synthesis.
Aspects, Dependencies, and Interactions Workshop (ADI), June 2006
International Conference on Algebraic Methodology And Software Technology (AMAST), July 2004"Feature Interactions in Feature-Based Program Synthesis", University of Texas at Austin, Dept. Computer Sciences, TR-06-52, September 2006. A feature is an increment in product functionality. Features can encapsulate different program representations, programs can be synthesized by feature composition, and programs can be declaratively specified using features. We explain in this paper how feature-based program synthesis works, how features interact, how interactions are controlled, and explore the relationship between features and aspects.
International Workshop on Program Comprehension (IWPC), June 2004"A Science of Software Design"
Underlying large-scale software design and program synthesis are simple and powerful algebraic models. In this paper, I review the elementary ideas upon which these algebras rest and argue that they define the basis for a science of software design.
Dagstuhl for Domain-Specific Program Generation, March 2003"Program Comprehension in Generative Programming: A History of Grand Challenges".
The communities of Generative Programming (GP) and Program Comprehension (PC) look at similar problems: GP derives a program from a specification, PC derives a specification from a program. A basic difference between the two is GP’s use of specific knowledge representations and mental models that are essential for program synthesis. In this paper, I present a historical review of the Grand Challenges, results, and outlook for GP as they pertain to PC.
"The Road to Utopia: A Future for Generative Programming".
The future of software engineering lies in automation, and will exploit the combined strengths of generative programming, domain-specific languages, and automatic programming. While each of these areas is still in its infancy, a spectacularly successful example of their combination was realized twenty-five years ago: relational query optimization. In this paper, I chart the successes and mindset used by database researchers to generate efficient query processing programs automatically. I argue that the road that they have so successfully followed is the same road that the generative programming, domain-specific languages, and automatic programming communities are now traversing.
Smalltalk und Java in Industrie and Ausbildung, Erfurt, Germany, October 1998
"Product-Line Architectures"
Today's software design methodologies are aimed at one-of-a-kind applications, designs are expressed in terms of objects and classes, and software must be coded manually. We argue that future software development will be very different and will center around product-line architectures (i.e., designs for families of related applications), refinements (a generalization of today's components), and software plug-and-play (a codeless form of programming).
Software Quality Institute Symposium on Software Reliability, April 1997
"Intelligent Components and Software Generators."
The production of well-understood software will eventually be the responsibility of software generators. Generators will enable high-performance, customized software systems and subsystems to be assembled quickly and cheaply from component libraries. These components will be intelligent: they will encapsulate domain-specific knowledge (e.g., "best practice" approaches) so that their instances will automatically customize and optimize themselves to the system in which they are being used. In this paper, we explore the topics intelligent components and software generation as they pertain to the issues of software productivity, performance, reliability, and quality.
Copyright Notice: This material is presented to ensure timely dissemination of scholarly and technical work. Copyright and all rights therein are retained by authors or by other copyright holders. All persons copying this information are expected to adhere to the terms and constraints invoked by each author's copyright. In most cases, these works may not be reposted without the explicit permission of the copyright holder.