Summer School on

Generative and Transformational Techniques

in Software Engineering

4 - 8 July, 2005, Braga, Portugal


List of tutorials

Don Batory: Feature Oriented Programming

Abstract: Feature Oriented Programming (FOP) is a design methodology and tools for program synthesis. The goal is to specify a target program declaratively in terms of the features that it offers, and to synthesize an efficient program that meets these specifications. FOP has been used to develop product-lines in widely varying domains, including compilers for extensible Java dialects, fire support simulators for the U.S. Army, network protocols, and program verification tools.

AHEAD is an algebraic model of FOP that is based on step-wise development, a methodology for building programs by adding one feature at a time. The incremental units of design are program extensions that encapsulate the implementation of an individual feature. AHEAD models treat base programs as constants and program extensions as functions (that add a specified feature to an input program). Application designs are thus expressions -- compositions of functions and constants -- that are amenable to optimization and analysis.

This tutorial reviews core results on FOP that pertain to compositional programming and reasoning, automatic programming, domain-specific languages, generative programming, AOP, and software product-lines. In covering these topics, we present models and tools for synthesizing code and non-code artifacts, automatic algorithms for validating and optimizing feature compositions, and multi-dimensional models of programs and tool-suites.

Bio: Don Batory holds the David Bruton Centennial Professorship at The University of Texas at Austin. He received a B.S. (1975) and M.Sc. (1977) degrees from Case Institute of Technology, and a Ph.D. (1980) from the University of Toronto. He was a faculty member at the University of Florida in 1981 before he joined the Department of Computer Sciences at the University of Texas in 1983. He is an Associate Editor of Transactions on Aspect-Oriented Development (2004-), was an Associate Editor of IEEE Transactions on Software Engineering (1999-2002), Associate Editor of ACM Transactions on Database Systems (1986-1992), a member of the ACM Software Systems Award Committee (1989-1993; Committee Chairman in 1992), Program Co-Chair for the 2002 Generative Programming and Component Engineering Conference, the Program Chair for the 1995 International Conference on Software Reuse and the 1999 Workshop on Software Reuse. He has given numerous tutorials on Product-Line Architectures, Generators, and Reuse, and is an industry-consultant on product-line architectures.

Ira Baxter: Compiling Fast XML reader/writers from DTDs using Program Transformations

Abstract: Program transformations are natural tools to use for code generation purposes. Building full-custom program transformation systems for single code generators is not economical. Practical transformation tools must share vast amounts of infrastructure for parsing, analyzing, transforming and prettyprinting, organized so that a small amount of custom work can achieve desired code generation.

This tutorial dissects an implementation of a specific code generation task, motivated by the need for applications to have small and fast "readers" of application specific XML documents for Java. The implementation is based on using the DMS Software Reengineering Toolkit, an industrial strength program transformation system. The tutorial will cover the general capabilities of DMS, but focus in detail on how the DMS infrastructure is parameterized by language definitions (lexing, token conversion, parsing, and prettyprinting), how the transformations are encoded to carry out refining the input description, how they are sequenced to achieve the final result, and demonstrate the process of building up all the parts of a working tool. Other issues that such tools must generally address will be visited briefly.

The tutorial clarifies what must be given to such tools, and what working with such tools is like. The tutorial assumes some basic background in compiler technology, XML, and Java.

Bio: Dr. Baxter has been involved with computing since 1966, implementing a minicomputer timesharing system in 1970. He worked for a number of years in industry where he designed compilers, time-sharing and network operating systems. In 1990, he received a Ph.D. from the University of California at Irvine, where he studied design reuse using transformational methods. Dr. Baxter spent several years with Schlumberger, working on a PDE-solver generator for CM-5 supercomputers (Sinapse). He consulted for Rockwell International on industrial automation software engineering tools for several years. In 1995, he founded Semantic Designs, to build commercial tools for automating mass software change using program transformation. Dr. Baxter is the principal architect of DMS, and also the principal designer and compiler implementer of PARLANSE, the parallel programming language underlying DMS. Dr. Baxter has been and organizer of number of software engineering related conferences, recently as program Co-chair for the International Conference on Software Maintenance (2002). He has presented tutorials on program transformations in general several times at ICSM, ICSE, and GCSE.

Jean Bezivin: Metamodelling and Model Driven Software Development

Abstract: OMG's MDA initiative is a particular variant of a more general trend called model driven development (MDD). The basic ideas of MDD are germane to many other approaches such as generative programming, domain specific languages, and software factories. MDA may be defined as the realization of MDD principles around a set of OMG standards like MOF, XMI, OCL, UML, CWM, and SPEM.

This tutorial will compare the established principle "Everything is an object", as it has shaped 30 years of object technology, with the MDD principle "Everything is a model". In both cases, such a unification principle is helpful in driving the technology in the direction of simplicity, generality, implementation efficiency and power of integration. Two core relations, namely representation and conformance, are associated to the MDD unification principle, as inheritance and instantiation were associated to the object unification principle in the 80's.

The tutorial adopts a style that combines (i) identification of basic MDD principles; (ii) practical characteristics of MDD (direct representation, automation and open standards); (iii) original MDD scenarios; (iv) the discussion of suitable tools and methods. The tutorial reviews other technical spaces, e.g., grammarware, to relate their principles to MDD, to understand how operations like model transformation and model weaving compare to similar operations performed elsewhere, and to indicate capacities and limits of MDD for handling separation of concern in software development processes.

Bio: Jean Bézivin is professor of computer science at the University of Nantes, France and a member of the ATLAS INRIA research group. He got his Master degree from the University of Grenoble and PhD from the University of Rennes before spending several years, as an assistant professor, at the University of Brest. He also spent a year as a research fellow at the Queen's University of Belfast (Northern Ireland) and one year at the Concordia University of Montreal (Canada). He has been very active in Europe in the object-oriented community, starting the ECOOP series of conference (with P. Cointe), the TOOLS series of conferences (with B. Meyer), and the UML/MODELS series of conferences (with P.-A. Muller) and several workshops on related subjects. He started in 1979 at the University of Nantes, one of the first Master programs in Software Engineering entirely devoted to Object Technology (Data Bases, Concurrency, Languages and Programming, Analysis and Design, etc.). His present research interests include model-driven software engineering.

Shigeru Chiba: Program Transformation With Reflective and Aspect-Oriented Programming

Abstract: A meta-programming technique known as reflection can be regarded as a sophisticated programming interface for program transformation. It allows software developers to implement various useful program transformation without serious efforts. Although the range of program transformation enabled by reflection is quite restricted, it covers a large number of interesting applications. In particular, several non-functional concerns found in web-application software, such as distribution and persistence, can be implemented with program transformation by reflection. Furthermore, a recently emerging technology known as aspect-oriented programming (AOP) provides better and easier programming interface for program transformation. One of the roots of AOP is reflection and thus this technology can be regarded as an advanced version of reflection.

In this tutorial, we will discuss basic concepts of reflection, such as compile-time reflection and runtime reflection, and its implementation techniques. The tutorial will also cover connection between reflection and aspect-oriented programming. Finally, several typical applications of those technologies will be illustrated during the tutorial.

Bio: Shigeru Chiba is an associate professor at Tokyo Institute of Technology, Japan. He received the PhD degree in computer science from The University of Tokyo in 1996. His PhD research was done at Xerox PARC in USA. Before moving Tokyo Institute of Technology, he has been working at University of Tokyo and University of Tsukuba. He has been also a short-term visiting professor at Ecole des Mines de Nantes in 1999 and Paris VI in 2004. He has been developing several software products including OpenC++, OpenJava, and Javassist, which have been distributed as open source software and widely used in both academia and industry.

Jean-Luc Hainaut: The Transformational Approach to Database Engineering

Abstract: In the database engineering realm, an increasing number of bodies (e.g., OMG) and of authors recognize the merits of transformational approaches, that can produce in a systematic way correct, compilable and efficient database structures from abstract models. Transformations that are proved to preserve the correctness of the source specifications have been proposed in virtually all the activities related to schema engineering: schema normalization, logical design, schema integration, views derivation, schema equivalence, data conversion, reverse engineering, schema optimization, wrapper generation and others. The proposed tutorial addresses both basic and practical aspects of database transformation techniques. The concept of transformation is developed, together with its properties of semantics-preservation (or reversibility). Major database engineering activities are redefined in terms of transformation techniques, and the impact on CASE technology is discussed. These principles are applied to case studies in various domains, including database logical design, database reverse engineering and database to XML translation. They are illustrated by the use of DB-MAIN, a programmable CASE environment that provides a large transformational toolkit.

Bio: Jean-Luc Hainaut is a full professor in Information System and Database Engineering at the Institute of Informatics of the University of Namur, Belgium. He has been involved in research in database engineering since 1971. He is a co-author of the seminal paper of the Merise method, published in 1974. He is the author of several books (in French) on Database Modelling and Database Design, and of more than 50 recent journal and conference proceedings papers. He has presented tutorials on Conceptual Modelling, Transformation-based Database Engineering and Database Reverse engineering, notably in VLDB, ER and CAiSE conferences. He is heading the LIBD - Laboratory of Database Applications Engineering - the purpose of which is to develop general methodologies and CASE tools to assist practitioners in solving such engineering problems as database design, database reverse engineering, federated datatabases, database evolution, active databases, temporal databases, XML and web engineering. Two of the major results of his research activities, namely the DB-MAIN CASE environment and a wide spectrum database reverse engineering methodology, are distributed by ReveR, a spin-off of the LIBD.

Zhenjiang Hu: Program Optimization and Transformation in Calculational Forms

Abstract: The world of program optimization and transformation takes on a new fascination when viewed through the lens of program calculation. Unlike the traditional fold/unfold approach to program transformation over arbitrary programs, the calculational approach imposes restrictions on program structures, resulting in suitable calculational forms such as catamorphisms, anamorphisms and hylomorphisms that enjoy a collection of generic algebraic laws for program manipulation. In this tutorial, we will explain the basic idea of program calculation, demonstrate that a lot of program optimizations and transformations, including the well-known fusion and tupling, can be concisely reformalized in calculational forms, and show that program transformation in calculational forms is of higher modularity and more suitable for efficient implementation. In particular, we shall detail a concrete application in structured parallel programming, illustrating how to apply the calculational approach to structure parallel computations, systematically derive efficient parallel programs, and automatically optimize parallel programs via transformation.

Bio: Zhenjiang Hu is an associate professor of the school of information science and technology, the University of Tokyo. He received his BS and MS in computer science from Shanghai Jiao Tong University in 1988 and 1990 respectively, and his Ph.D in information engineering from the University of Tokyo in 1996. His current research concerns functional programming, program transformation (calculation), high level parallel programming, and algorithm derivation. He is particularly interested in the theory of program calculation based on programming algebras, and is looking into how to apply this theory to automatic program optimization, systematic parallelization of sequential programs, and efficient manipulation of structured documents.

Links: Program transformation in calculational form is supported by the program calculator Yicho, see

Erik Meijer: Object, relational, and XML mapping

Abstract: In many respects dealing with persistent data is the most interesting aspect of programming. Data exists before the programs runs and remains after the program has terminated. Even though there is an abundant amount of research on data integration in programming languages, most popular programming languages, whether they are statically typed such as Java, C#, C(++), Haskell, SML, Python, etc. or dynamically typed such as Perl, Python, Ruby, Groovy, ... do not deal very well with persistent data. The state of the art is still using various string-based APIs.

In this tutorial, we will discuss various aspects of dealing with persistent data in contemporary object-oriented languages such as Java or C#. In particular we will discuss the challenges in dealing with the impedance mismatch between relational data, objects, and XML.

Bio: Erik Meijer is a member of the WebData and the C# design team at Microsoft where he currently works on language design and type-systems for data integration in programming languages. Prior to joining Microsoft he was an associate professor at Utrecht University and adjunct professor at the Oregon Graduate Institute. Erik is one of the designers of the standard functional programming language Haskell98.

Tom Mens: On the Use of Graph Transformations for Model Refactoring

Abstract: Since all software is subject to evolution, there is a clear need for better ways to support and automate various aspects of software evolution (e.g., software refactoring). To address this need, formal approaches can be used (e.g., graph transformation). In this tutorial, we will explain how the formalism of graph transformation can be used to formalise and reason about software refactoring. Amongst others, we will show how graph transformations can be used to formally specify refactorings, to reason about behaviour preservation properties, and to deal with structural conflicts that can occur when applying refactorings. Existing graph transformation tools, such as Fujaba and AGG, can help us during this process. Another important advantage of graph transformation is that it allows us to reason about refactoring in a language-independent way, enabling us to apply the mechanism at higher levels of abstraction too (e.g., UML design models).

Bio: Tom Mens received the degrees of Licentiate in mathematics in 1992, Advanced Master in computer science in 1993, and PhD in science in 1999 at the Vrije Universiteit Brussel. He has been a teaching and research assistant, a research councellor for industrial research projects, and a postdoctoral fellow of the Fund for Scientific Research ? Flanders (FWO). Since October 2003 he lectures on software engineering and programming languages at the Université de Mons-Hainaut. He has published numerous peer-reviewed articles on the topic of software evolution, and has been co-organiser, program committee member and referee of many international workshops and conferences. He is cofounder and coordinator of two international scientific research networks on software evolution, financed by the FWO and the European Science Foundation, respectively. He is a copromotor of a FWO interuniversity research project on software refactoring.