Summer School on
Generative and Transformational Techniques
in Software Engineering
4 - 8 July, 2005, Braga, Portugal
List of tutorials
Don Batory: Feature Oriented Programming
: 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.
: 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
Ira Baxter: Compiling Fast XML reader/writers from DTDs using Program Transformations
: 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.
: 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
: 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.
: 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
: 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.
: 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
: 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.
: 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
: 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.
: 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
Program transformation in calculational form is supported by the program calculator Yicho, see http://www.ipl.t.u-tokyo.ac.jp/yicho/
Erik Meijer: Object, relational, and XML mapping
: 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.
: 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
: 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).
: 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.