GPCE Tutorials

Monday, September 22

9:00 - 10:30	Exectable UML: A Foundation for Model-Driven Archtitecture (Part 1) From a Program Family to a Domain-Specific Language (Part 1) Multi-stage Programming in MetaOCaml (Part 1)
10:30 - 11:00	Coffee break
11:00 - 12:30	Exectable UML: A Foundation for Model-Driven Archtitecture (Part 2) From a Program Family to a Domain-Specific Language (Part 2) Multi-stage Programming in MetaOCaml (Part 2)
12:30 - 13:30	Lunch
13:30 - 15:00	Generative Programming (Part 1) Domain-Specific Languages and Generators for Model-Driven Development (Part 1)
15:00 - 15:30	Coffee break
15:30 - 17:00	Generative Programming (Part 2) Domain-Specific Languages and Generators for Model-Driven Development (Part 2)

Tuesday, September 23

10:15 - 11:45	Model-Driven Architecture Distilled (Part 1)
11:45 - 12:00	Coffee break
12:00 - 13:30	Model-Driven Architecture Distilled (Part 2)
13:30 - 14:30	Lunch

Tutorial Details

Exectable UML: A Foundation for Model-Driven Archtitecture

Stephen J. Mellor (Project Technology, Inc.)

Stephen J. Mellor is Vice-President and co-founder of Project Technology, Inc., a company focused on tools to execute and
translate UML models. He is active in the OMG, chairing the consortium that added executable actions to the UML, and he is now active in specifying MDA. Last year, he completed his latest book "Executable UML: A Foundation for Model-Driven Architecture." He has almost finished his latest book "MDA Distilled," available from Addison Wesley in late 2003. In his copious spare time, he is a member of the IEEE Software Industrial Advisory Board. He was a Guest Editor for a special issue on Model-Driven Development published September 2003.

From a Program Family to a Domain-Specific Language

Charles Consel (INRIA / LaBRI / ENSEIRB)
Claus Brabrand (INRIA / LaBRI / ENSEIRB)

An increasing number of domain-specific languages (DSLs) are being developed and successfully used in a variety of areas including networking, telecommunications, and financial products. Yet, the development of a DSL is still an obscure process and its assessment is often partial. The first part of this tutorial proposes to structure the development of a DSL on the notion of a program family. We outline the main steps of such a development. Furthermore, we argue that a program family provides a basis to assess a DSL. The ideas discussed in this presentation are directly based on our experiences in developing DSLs for various domains and studying existing ones. The second part of this tutorial presents a case study on a DSL, DynDoc, for the dynamic generation of HTML/XML documents in Web services. Finally, we broaden the scope of this tutorial by presenting a domain, namely communication services, where DSLs can be used as a paradigm for software development.

Level: Between introductory and intermediate
Required experience: Programming experience and basic notations in programming languages.
Expected audience: Participants working in domains where developed programs share a lot of commonalities.
Expected benefits: more concise, more robust, easier program development.

Charles Consel is a professor of Computer Science at ENSEIRB/University of Bordeaux I. He leads the Compose group at
INRIA/LaBRI. He has been designing and implementing domain-specific languages (DSLs) for a variety of areas including device drivers, programmable routers, and stream processing. These DSLs have been validated with real-sized applications and showed measurable benefits compared to applications written in general-purpose languages. His research interests include language design, program analysis, compilation and compiler generation, prototyping, program transformation, and formal specification.

Claus Brabrand received his PhD in computer science from the BRICS Research Center at the University of Aarhus, Denmark, 2003. He is currently a research scientist at INRIA and the University of Bordeaux INRIA/LaBRI. Areas of interest and research include: domain specific languages, general purpose languages, program analysis, compilers, and Web technology.

Multi-stage Programming in MetaOCaml

Walid Taha (Rice University)
Cristiano Calcagno (Imperial College London)

Multi-stage programming is a new paradigm for developing generic programs that do not pay a runtime overhead. The key underlying technology is program generation. In addition, languages designed to support this paradigm (such as MetaOCaml) help the programmer avoid many of the difficulties that are traditionally encountered in developing program generators. This tutorial will introduce you to the basics of this paradigm as well as of programming in MetaOCaml. Numerous examples will be used to illustrate the practice of multi-stage programming.

Level: The tutorial level is introductory (requires almost no experience with any specific programming language.)
Required experience: Familiarity with a functional language, or generic typing, would be useful, but is not necessary.
Expected audience: Software engineers, graduate and undergraduate students, researchers. Attendees will gain understanding of a high-level model of program generation

Walid Taha is an Assistant Professor at Rice University, USA. He played a lead role in development of both the multi-stage programming paradigm and the MetaOCaml implementation.

Cristiano Calcagno is a Researcher at Queen Mary University, UK. He has made significant contributions to the theory of multi-stage programming, and is the main developer of the MetaOCaml system.

Generative Programming

Krzysztof Czarnecki (University of Waterloo)
Ulrich Eisenecker (University of Applied Sciences Kaiserslautern, Zweibrücken)
Simon Helsen (University of Waterloo)

System family engineering seeks to exploit the commonalities among systems from a given problem domain while managing the variabilities among them in a systematic way. In system family engineering, new system variants can be rapidly created based on a set of reusable assets (such as a common architecture, components, models, etc.). Generative programming aims at modeling and implementing system families in such a way that a given system can be automatically generated from a specification written in a domain-specific language. In this tutorial, participants will learn how to perform domain analysis (i.e., identify and document the commonalities and variabilities within a system family using feature modeling) and domain design (i.e., develop a common architecture for a system family), and implement program generators using a number of different technologies, such as frame-based code generation, template-based code generation, and model transformations. We will also discuss the relationship between Generative Programming and Model-Driven Architecture.

Level: Intermediate
Required Experience: Being able to read Java and C++ code would be helpful (but not required)
Expected audience: This tutorial is aimed at researchers and practitioners interested in modeling and implementation technologies to achieve reusability and to automate application engineering.

Krzysztof Czarnecki is an Assistant Professor at the University of Waterloo, Canada. Before coming to Waterloo, he spent 8 years at DaimlerChrysler Research working on the practical applications of generative programming (GP). Together with Ulrich Eisenecker, he co-authored the book "Generative Programming" (Addison-Wesley, 2000). His current research focuses on realizing the synergies between GP and MDA.

Ulrich W. Eisenecker is a professor for computer science at the University of Applied Sciences Kaiserslautern, Zweibruecken, where he directs the Institute of Componentware and Window-Interfaces. He has been working on generative programming for more than five years and is responsible for several projects in generative programming research funded by industry and public institutes.

Simon Helsen is a Postdoctoral Research Fellow at the University of Waterloo, where he recently joined Krzysztof Czarnecki. His current research focusses on the applicability and viability of MDA in the context of Generative Programming. Before coming to Waterloo, he was a research assistant at the Universities of Tübingen and Freiburg where he worked with Peter Thiemann on program specialization and partial evaluation.

Domain-Specific Languages and Generators for Model-Driven Development

Juha-Pekka Tolvanen (MetaCase Consulting)

Domain-Specific Modelling (DSM) provides a viable solution for improving development productivity by raising the level of abstraction beyond coding. With DSM, the models are made up of elements representing concepts that are part of the domain world, not the code world (like e.g. in UML). These languages follow domain abstractions and semantics, allowing developers to
perceive themselves as working directly with domain concepts. In several cases, final products can be automatically generated from these high-level specifications with domain-specific code generators.

This tutorial introduces DSM by emphasizing the differences to modelling languages originating from the semantics of programming languages. This is followed by examples from various fields of software product development. The main part of the tutorial addresses the guidelines for implementing DSM for various application domains: how to identify the necessary language
constructs; what options are available for code generation; and what are the industry experiences.

Level: Intermediate
Required experience: Attendees should have significant software development experience, not necessarily OO, must have used at least one methodology and design/generation tool.
Expected audience: This tutorial is for experienced developers, architects, team leaders, and those responsible for developing or selecting a methodology for their software product development.

Juha-Pekka Tolvanen is the CEO of MetaCase Consulting. He received his Ph.D. in 1998 from the University of Jyväskylä, Finland. His area of expertise is in engineering of software development methods for application-specific needs. In this role, Mr. Tolvanen has acted as a consultant worldwide for method development and he has published papers on software development methods in several journals and conferences (www.cs.jyu.fi/~jpt). Mr Tolvanen has good presentation skills and experience on organizing workshops and tutorials. Reference information and third-party feedback reports from past presentations are available upon request.