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.
To search for multiple keywords separate each keyword
by a comma: keyword , keyword
architectures, analysis, aspects, categories, commuting diagrams, computational design, derivatives, Dense Linear Algebra (DLA),
Design by Transformation (DxT), design rules, Design Rule Checking (DRC), evolution, feature interactions, feature models, geodesic,
higher-order transformations, kubes, MDA, MDD, MDE, mixin layers, optimization, optional feature problem, origami, refactoring,
streaming, safe composition, semantics, testing, UML, verification, wizards, P3 (P1/P2/P3/DiSTiL data structure generator).
See all keynote publications
D. Batory. A Theory of Modularity for Automated Software Design. Keynote at International Conference on Modularity (MODULARITY), Fort Collins, Colorado, March 2015.
Automated Software Development (ASD) are technologies
for developing customized programs automatically and compositionally
from modules. The foundations of ASD are
domain-specific algebras, where each program in the target
domain maps to a unique expression. Algebraic identities are
used to optimize programs automatically. In this keynote,
I trace the history of ASD and present a general theory of
modularity for ASD that follows from its tenets.
PPTX of presentation
aspects, categories, commuting diagrams, feature models, geodesic, MDE, mixin layers, optimization, UML, relational query optimization
D. Batory, R. Goncalves, B. Marker, J. Siegmund. Dark Knowledge and Graph Grammars in Automated Software Design . Keynote at Conference on Software Language Engineering (SLE) 2013.
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 foundation for modern automated software development. The sentences of a grammar are designs of complex dataflow systems. We explain how graph grammars provide a framework to encode expert knowledge, produce correct-by-construction derivations of dataflow applications, enable the generation of high-performance code, and improve how software design of dataflow applications can be taught to undergraduates.
keynote, DxT, MDE, MDA, MDD
D. Batory. The Challenges and Science of Variability . Keynote at Dagstuhl Seminar on Analysis, Test and Verification in The Presence of Variability, February 2013.
Variability is everywhere: in our social structures, in the
universe, and in our software. In this talk, I review some of the
key challenges that variability brings to software development,
and how theories of automated software design will hinge on mathematical
theories of variability.
keynote, homomorphisms, testing
D. Batory. P2: A Twenty+ Year Retrospective . Keynote at Dagstuhl Seminar on Software Synthesis, April 2012.
There is a resurgence in work on container data structures. I review work on the P2 series
of container data structure generators, and present lessons that I've learned and that others may find of interest.
The key ability of generators is optimization: finding feasible solutions to a programming problem are
easy in many domains. The hard part is finding efficient solutions.
keynote, P2, optimizations
D. Batory and B. Delaware. Towards Verification of Product Lines . Keynote at Interactive Theorem Proving (ITP), August 2011.
Although mechanized proof assistants are powerful verification tools, proof development can still be difficult and time-consuming. It becomes even more challenging when proofs are needed for product lines. A product line is a family of similar programs. Each program is constructed by a distinct (linear) combination of features, where a feature or feature module encapsulates program fragments that are added to a program to introduce a new capability or functionality to that program.
The first part of my presentation reviews basic concepts on product lines and how programs are synthesized using feature modules. The second part addresses product line verification. I explain how proofs for product lines can be engineered using feature modules. Each module contains proof fragments which are composed to build a complete proof of correctness for each product. A product line of programming languages is considered, where each variant includes metatheory proofs verifying the correctness of its syntax and semantic definitions. The approach has been realized in the Coq proof assistant, where the proofs of each feature are independently certifiable by Coq. Proofs are composed for each language variant, where Coq mechanically verifies that the composite proofs are correct. As validation, a core calculus for Java in Coq was formalized which can be extended with any combination of casts, interfaces, or generics.
This is joint work with Benjamin Delaware and William Cook.
keynote, semantics, safe composition, verification, feature interaction
D. Batory FOSD - A Science of Software Design . Keynote at Dagstuhl Seminar on Feature Oriented Software Development, January 2011.
keynote, categories, commuting diagrams, feature interactions, MDA, MDE, MDD, mixin layers
D. Batory. On the Importance and Challenges of FOSD. Keynote at First Workshop on Feature Oriented Software Development (FOSD), Denver, Colorado, October 2009.
Among the key elements of mature engineering is automated production: we understand the technical problems
and we understand their solutions; our goal is to automate production as much as possible to increase product quality,
reduce costs and time-to-market, and be adept at creating new products quickly and cheaply.
Automated production is a technological statement of maturity: 'We have built these products so often by hand that
we have gotten it down to a Science'. Models of automated production are indeed the beginnings of a Science of
Automated Design (SOAD). Feature Oriented Software Development (FOSD) will play a fundamental role in SOAD,
and I believe also play a fundamental role in the future of software engineering.
In this presentation, I explain what distinguishes FOSD from other software design disciplines and enumerate key
technical barriers that lie ahead for FOSD and SOAD.
PDF of presentation
Survey and responses for this keynote
keynote, evolution, feature interactions, featue models, kubes, origami, refactoring, semantics, testing, verification
D. Batory (work with T. Riché). Refinement and Optimization of Streaming Architectures. Keynote at Software Engineering and Data Engineering (SEDE), Las Vegas, June 2009 and the Software Engineering and Databases (JISDB), San Sebastian, Spain, September 2009.
We present a Model Driven Engineering approach to explain, verify,
build, and test dataflow or streaming software architectures that
are to be parallelized for performance or availability. Componentconnector
models are incrementally elaborated by transformations
that refine or optimize architectural designs. We re-engineered two
significant case studies to illustrate the generality of our work: (1)
recoverable crash fault tolerant servers and (2) join parallelizations
in database machines.
PDF of presentation
DxT, keynote, pipe-and-filter, architectural refinement, optimization, riche
D. Batory. Program Kubes: Dimensions of Variability in Software Synthesis. Keynote at Variability Modeling in Software-Intensive Systems (VAMOS), January 2009, and the Software Product Line Evolution Workshop, Pune, India, February 2009.
It is common in software product lines to have orthogonal and interacting
sets of features. In such cases, the design of a program can expressed as a
matrix of program transformations, where both rows and columns denote features.
The technique is called Origami, as the matrix is folded in precise ways
(thereby composing transformations) until a scalar is produced. This scalar is
an expression (a composition of transformations) that synthesizes the program
when it is evaluated. Origami generalizes to n-dimensional arrays, where each
axis defines a dimension of variability. Previously our understanding of Origami
was intuitive; here we present a mathematical explanation of Origami that
exposes its principles and integrates diverse topics: database technology (data
cubes), mathematics (ideas from tensors and categories), programming languages
(the expression problem), and software design (feature interactions).
PDF of presentation
keynote, origami, categories, commuting diagrams, computational design, feature interactions, feature models, tensors
D. Batory, M. Azanza, and J. Saraiva. The Objects and Arrows of Computational Design. Keynote at Model Driven Engineering Languages and Systems (MODELS), October 2008.
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.
PDF of Presentation
Interesting blogs on MODELS keynote: blog1, blog2.
MDE, MDD, MDA, categories, keynote, recommended theory
D. Batory. A Modeling Language for Program Design and Synthesis. Advances in Software Engineering, E. Börger and A. Cisternino (editors), LNCS 5316. Keynote at Brazilian Symposium on Software Engineering, October 2007.
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.
boerger, Computational Design, commuting diagrams, keynote, geodesic
D. Batory and E. Börger. Modularizing Theorems for Software Product Lines: The Jbook Case Study. Journal of Universal Computer Science (JUCS). Keynote at Abstract State Machine (ASM) Workshop, June 2007.
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.
verification, semantics, boerger
D. Batory. Program Refactorings, Program Synthesis, and Model-Driven Design . Keynote at European Joint Conferences on Theory and Practice of Software (ETAPS) Compiler Construction Conference, April 2007.
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.
MDD, MDE, MDA, categories, commuting diagrams, refactoring, keynote, recommended theory
D. Batory. From Implementation to Theory in Product Synthesis . Keynote at Principles of Programming Languages (POPL), January 2007.
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.
Published version of this paper.
MDD, MDE, MDA, categories, commuting diagrams, computational design, geodesic
S. Apel and J. Liu. "On the Notion of Functional Aspects in Aspect-Oriented Refactoring". Keynote at Workshop on Aspects, Dependencies, and Interactions (ADI), Nantes, France, 2006.
In this paper, we examine the notion of functional aspects in context of aspect-oriented refactoring. Treating aspects as functions reduces the potential interactions between aspects significantly. We propose a simple mathematical model that incorporates fundamental properties of aspects and their interactions. Using this model, we show that with regard to refactoring functional aspects are as flexible as traditional aspects, but with reduced program complexity.
refactoring, aspects, keynote
D. Batory A Science of Software Design . Keynote at International Conference on Algebraic Methodology And Software Technology (AMAST) 2004.
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.
D. Batory Program Comprehension in Generative Programming: A History of Grand Challenges . Keynote at International Workshop on Program Comprehension (IWPC) 2004.
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.
D. Batory. The Road to Utopia: A Future for Generative Programming . Keynote at Dagstuhl Seminar on Domain-Specific Program Generation, March 2003.
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.
D. Batory Product-Line Architectures . Keynote at Smalltalk und Java in Industrie and Ausbildung, Erfurt, Germany, October 1998.
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).
D. Batory Intelligent Components and Software Generators . Keynote at Software Quality Institute Symposium on Software Reliability, Austin, Texas, April 1997
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.