Contents of the lectures

Prof. Don Batory

The future of software engineering lies in automation -- automatically performing the largely-rote, tedious, and error-prone tasks that are manually done today by high-paid experts. At the forefront of automation research is the generation of customized software and related artifacts. While this is an extremely rich and promising technical area, it is also immature and poorly understood. Generation is at the confluence of many "hot" topics in software engineering: component-based software development, product-line architectures, product-families, aspect-oriented programming, multi-dimensional separation of concerns, meta programming, compositional programming, collaboration-based object-oriented designs, and design patterns. Generation is center-stage for a simple reason: to produce programs automatically requires precise models of how programs, or rather program families, can be synthesized from primitive parts. What these parts are and what composition means is fundamental -- and all of the above-listed areas offer different answers to these questions. Further, since software design is largely an art-form today, creating such models is an essential first step toward a science of software design and software generation.

This tutorial is a sequence of lectures. The goal is to present a documented and tested vision for a science (or pre-science) of software design. That is, we present a model of a large body of knowledge on software design and implementation that is organized in a highly systematic way and is governed by a small number of general truths or laws that are mathematically (i.e., algebraically) expressible. Mathematical representations are crucial, because they are essential to scalability and automated reasoning.

Material in PDF-format (2.5 MB)

Tutorial in PDF-format (5.5 MB)

Dr. Ira Baxter

Lecture 1: Introduction to Program Transformation. Program Transformation Systems are software tools that modify other software source programs. They are essentially generalized compilers, in which the various compiler parts can be customized to achieve a surprisingly wide variety of useful automated changes to source code. This leverage ensures that program transformation systems are destined to become a standard part every programmer's stable of tools, just like editors, compilers, and design tools. Lecture 1 will provide background on the origin of transformation systems as one historical attack on complete automation of programming. It will also provide basic theory, along with set of concepts and components useful for comparing various transformation systems.

Lecture 2: Theory of Program Transformation. We will explore the theory of transformation systems, considering types of transforms, various styles of specifications, semantics, how transformations can preserve meaning. Choosing the order in which transformations are applied changes performance properties of the final program, and we will consider means for specifying that order, called metaprogramming.

Lecture 3: Practical Program Transformation Systems. Two specific program transformation systems will be discussed in some detail to give the student some practical details: XSLT (based on XML), widely considered useful for code generation purposes, and DMS, the author's tools for analysis, enhancement and reengineering of large scale source codes. Several applications of DMS will be discussed, including implementing test coverage tools for any language, detecting and removing the typically 10% duplicate code in large systems, and automated translation of one programming language to another.

Dr. Craig Cleaveland

Lecture 1: Domain Engineering Concepts: Commonalities, variabilities, and separation of concerns. Commonalities and variabilities are major conceptual building blocks in domain engineering. Separating the concerns of commonalities and variabilities is one of the chief challenges in any domain engineering application. Definitions, examples, and stories will illustrate these concepts.

Lecture 2: An introduction to XML and its role in domain engineering. XML terminology, syntax, techniques and tools will be introduced with an emphasis on how XML can be used in domain engineering applications.

Lecture 3: A comparison of various program generation techniques. A simple program generator example is presented and its elaboration using a variety of implementation techniques is given. Techniques will include Java and the DOM API, XSLT (an XML transformation system), Java Server Pages, Java Tag libraries, and template languages.

Dr. Krzysztof Czarnecki

Lecture 1: Introduction to Generative Programming This lecture gives an overview of the main concepts, methods, and technologies of generative programming. The covered topics will include motivation for the approach, single systems vs. system families, generative development process, generative modeling, technology mappings, and overview of generative technologies.

Lecture 2: Generative Programming: First example using C++ In this lecture, we will demonstrates all the necessary steps of the generative development process using a simplified example. The target technology will be C++ templates and template metaprogramming. The covered topics will include the basics of feature modeling, derivation of a family architecture from feature models, component implementation using generic programming, generator implementation using template metaprogramming, active libraries, and open programming environments.

Lecture 3: Generative Programming: A programming-language-independent example The second example is based on an actual industrial project involving a family of embedded software systems. Using this example, we will demonstrate static configuration using a general-purpose graphical configuration tool. The configuration space of a system family will be defined using a feature modeling tool and directly imported into the configuration tool. As a next step, the programming-language-independent generation technology based on Craig Cleaveland's Template Language and XML is used to generate the variable parts of a concrete system.

Dr. Jörg Striegnitz

Lecture 1: Generic Programming with C++. Generic programming is about raising the level of abstraction of software components to make them usable in a wide variety of situations. C++ supports generic programming by the means of templates, whose syntax and semantics will be explained during this lecture. Lecture 1 thereby provides the background that is necessary for Lecture 2.

Lecture 2: Template Metaprogramming. Template metaprograms are programs that are executed during compile-time. They can be used for the computation of values, the composition of components, the generation of code, for partial evaluation, and several other program optimizations. Lecture 2 provides an introduction to this programming technique.