List of Tutorials
Krzysztof Czarnecki: Model-Based Evolution
: Any new software engineering method usually works perfectly the first
time it is applied. The method guides the developers in producing
multiple artifacts such as documentation and code. The real trouble
starts when any of the artifacts need to be evolved. As a consequence,
other artifacts need to be co-evolved in order to reestablish
consistency. The evolution challenge applies to model-driven
development, too. However, models can help to make it less painful. In
this tutorial, I will analyze evolution in model-driven development and
present several techniques to address the challenge, such as guided
model editing, multi-level customization, reverse engineering, and
: Krzysztof Czarnecki
is an Assistant Professor at the University of
Waterloo, Canada. Before coming to Waterloo, he spent eight years at
DaimlerChrysler Research working on the practical applications of
generative programming. He is co-author of the book "Generative
Programming" (Addison-Wesley, 2000), which is regarded as founding work
of the area and is used as a graduate text at universities around the
world. He was a keynote speaker the 2006 International Conference on
Generative Programming and Component Engineering (GPCE) and will be the
program chair for MoDELS 2008. His current work focuses on realizing the
synergies between generative and model-driven software development..
Jean-Marie Favre: Software Linguistics and Language Engineering
: The notion of language is central to transformational technics, MDE and informatics. Language descriptions includes grammars, but also metamodels, schemas, ontologies, DSL, etc. The many stakeholders dealing with large software systems have different needs in terms of languages, leading to a software tower of babel. "Software languages" are languages too and should be studied as such. This tutorial revisit what linguistics could bring to informatics, and this is much more than the theory of formal languages. We coin Software Linguistics the scientific study of "software languages", and Language Engineering, the engineering discipline aiming at designing, compositing and evolving these languages over time.
: Jean-Marie Favre
is Assistant Professor at the University of Grenoble, France. His research work aims at integrating reverse engineering and model driven engineering applied to large scale software products. His experience in language (reverse) engineering and evolution comes both from academia and collaborations with very large software companies. He is member of various networks on software evolution, reverse engineering and MDE. He co-organized various international events and workshops in particular the ATEM series. He served as PC of several international conferences. He is co-author of a book in french "Beyond MDA : Model Driven Engineering".
Stan Jarzabek: Software Reuse Beyond Components with XVCL
: The main challenge in reuse is handling variability - similarities and differences across software systems (e.g., Product Line members). The reuse objective is to exploit similarities to avoid repetitive development work. Software architecture and component-based approaches are important means to address reuse goal and they are covered in the course. At the same time, we point to limitations of these approaches and show a pragmatic way to better exploit similarity patterns in software, considerably raising reuse benefit: We do initial design using conventional programming methods, and then apply generative technique of XVCL to build generic structures to unify similarity patterns for which conventional techniques fail to provide effective generic solutions. By applying such mixed-strategy approach, on average, we reduce conceptual complexity (and maintenance effort) of a program solution by 60%, raising the levels of reuse by similar rates.
: Stan Jarzabek
is an Associate Professor at the Department of Computer Science, School of Computing, National University of Singapore (NUS). He spent 12 years of his professional career in industry and 20 years in academia. Stan is interested in all aspects of software design, in particular techniques for design of adaptable, easy to change (high-variability) software. He gave 2-day courses on product line approach for industries and at major international conferences. Stan was a General Chair for GPCE'06, 5th Int. Conf. on Generative Programming and Component Engineering, October 2006, Portland, Oregon. He published over 100 papers at international conferences and journals (recent paper won ACM Distinguished Paper Award and two others were selected as best papers). In May 2007, CRC will publish Stan's book: Effective Software Maintenance and Evolution: Reuse-based Approach. He was a Principal Investigator in a multi-national collaborative project involving universities (NUS and the University of Waterloo), and companies in Singapore and Toronto.
Oege de Moor: OO queries over OO programs with .QL
: Programs are relations: inheritance between classes, the called-by
relation between methods, and so on. Many tasks in software engineering
benefit by exposing those relations via queries, e.g. finding common bugs,
computing metrics, and identifying all locations impacted by a proposed
change. We introduce the .QL query language for expressing such queries.
Next, participants will be guided through the use of .QL on a
substantial project, writing queries of their own in a hands-on
session. Finally we outline how .QL capitalises on 30+ years of
theoretical work by others in the databases community, and some more recent
research in programming tools. A preview of the tools used in these lectures can be found at
: Oege de Moor
is the CEO of Semmle Ltd, the company that develops .QL
and SemmleCode. He started his career in programming in 1982 with
the development of a word processor for Arabic and Hebrew. After
an undergraduate degree in computer Science at Utrecht (the Netherlands),
he did his graduate work at Oxford. At present he is a professor of
computer science there, and a fellow of Magdalen College. He has
held visiting appointments at Chalmers University (Sweden), the
University of Tokyo (Japan), and Microsoft Research (Redmond and
Josť Nuno Oliveira: Data Transformation by Calculation
: This tutorial addresses the foundations of data-model transformation. A
catalog of transformations is presented which includes abstraction and representation
relations and associated constraints, all expressed in an algebraic style
via the pointfree-transform, a technique resembling the Laplace transform
in mathematics: predicates are converted to binary relation terms (of the algebra of programming)
in a 2-level style encompassing both data and operations.
Data-calculation, which also includes transformation of recursive data models into
"flat" database schemas, has been in use at Minho as alternative to standard database design
and is the foundation of the "2LT bundle" of tools available from the UMinho Haskell libraries.
: Josť Nuno Oliveira
is associate professor at the Theory and Formal Methods
Group of Minho University. He graduated from the U.Porto and received
his PhD in Computer Science from the U.Manchester, where he became interested
in formal methods and transformational techniques. He is a member of the
Formal Methods Europe (FME) association, where he convenes a subgroup on education.
Since his PhD work on data-flow program transformation, he became interested
in data refinement techniques and calculational database design. His research
is currently focussed on the application of the algebra of programming to
abstract modelling and model-driven software design.
Markus Pueschel: How to Write Fast Numerical Code
: The complexity of modern microarchitectures poses a major challenge for developers of high performance numerical software. To run fast, it is not sufficient that a program is based on an algorithm with minimal operations count. Various other optimizations need to be performed including loop unrolling, adaptation to the memory hierarchy, and the use of special instruction sets. We introduce these and other techniques using the discrete Fourier transform and matrix-matrix multiplication as examples. Further, we overview Spiral
, a program generation system for transforms, which performs these optimizations automatically to produce code that rivals the best human-tuned code in performance.
: Markus Pueschel
is an Associate Research Professor of Electrical and Computer Engineering at Carnegie Mellon University. He received his Diploma (M.Sc.) in Mathematics and his Doctorate (Ph.D.) in Computer Science, in 1995 and 1998, respectively, both from the University of Karlsruhe, Germany. His research interests include computing, algorithms, applied mathematics, and signal processing theory/software/hardware.
Walid Taha: A Practical Guide to Building Staged Interpreters
: Writing a staged interpreter is a strikingly direct way to build
compilers. After a brief introduction to staging, we consider how to
apply this technique to a series interpreters for increasingly more
sophisticated languages. We see how popular language features can be
modeled in an interpreter, and how this affects the staging process.
The tutorial does train you in an immediately applicable skill. But
more importantly, it aims to bring to light a number of profound
insights on the utility and synergy of a range of ideas from
programming languages theory.
: Walid Taha
lead the development of the semantics of staged computation,
type systems for multi-stage languages, and implementing multi-stage
languages like MetaOCaml and MetaOCaml Concoqtion. Currently, he leads
the Resource-aware Programming (RAP) research group at Rice University,
Houston, TX. He is the principal investigator on a number of NSF, Texas
ATP, and SRC research grants and contracts on various aspects of resource
aware programming. Taha is actively involved in development of both the
embedded software and generative programming research communities.
Eelco Visser: Domain-Specific Language Engineering
: The goal of domain-specific languages (DSLs) is to increase the productivity of software engineers by abstracting from low-level boilerplate code. Introduction of DSLs in the software development process requires a smooth workflow for the production of DSLs themselves. This tutorial gives an overview of all aspects of DSL
engineering: domain analysis, language design, syntax definition, code generation, deployment, and evolution, discussing research challenges on the way. The concepts are illustrated with DSLs for web applications built using several DSLs for DSL engineering: SDF for syntax definition, Stratego/XT for code generation, and Nix for software deployment.
: Eelco Visser
is Associate Professor at Delft University of Technology.
His research is motivated by improving the productivity of software engineers through tool support and better programming abstractions, and has centered around tools for language engineering, with contributions in syntax definition, program transformation, domain-specific languages, and software deployment. His contributions include scannerless generalized LR parsing, generic traversal strategies, and dynamic rewrite rules. With his students he has designed and built a number of language engineering and software deployment tools, including the syntax definition formalism SDF, the Stratego/XT language and toolset for program transformation, and the Nix software deployment system.