Bernd Kolb

Markus Voelter

Arno Haase

Artem Tikhomirov

Model-driven software development (MDSD) is not just about generating code. Several additional challenges have to be mastered. These include: how to get usable graphical and textual editors for your domain specific language (DSL), how to validate your models against your metamodels, how to define model modifications and transformations and finally, how to write scalable, maintainable and extensible code generators. In this tutorial we show how to tackle all these challenges, based on a collection of open source tools: Eclipse, Eclipse Modeling Framework (EMF), Graphical Modeling Framework (GMF) as well as openArchitectureWare. We believe that this tool chain provides a proven and stable stack for making MDSD a practical reality.

The tutorial will be highly interactive with only a minimum of slides, many live presentations show the tools at work.

Outline

1. Introduction
   In this part we will show the roadmap through the tutorial and explain various fundamentals (such as the workflow of the generation process and the general interplay between metamodel, editor description models, constraints and code generation templates).
2. Metamodel
   In this section we use Eclipse EMF, as well as the graphical Ecore Editor supplied by GMF to build a simple metamodel. The example will be based on a component-based system whose behaviour will be described using state machines. Based on the EMF metamodel, we can then generate the metamodel implementation classes using EMF's code generators.
3. Editors
   This is the first major part of the tutorial. Based on the metamodel defined above, we will use Eclipse GMF to build a graphical editor for the component structure of the system as well as for the state machine. Important subtopics are the definition a palette, a graphical concrete syntax as well as the mapping of the metamodel constructs to the concrete syntax defined. Additionally we will have a look on textual DSLs and Editors
4. Constraints
   Before we take a look at transformations, it is essential to verify the correctness of the candidate model “drawn” with the just built graphical editor. For example it is important to ensure unique-name constraints of states and other issues such as that for each trigger event in the statemachine a corresponding operation has to be defined on the component's interface. We will show the implementation of such constraints in OCL as well as with openArchitectureWare's constraint checking language.
5. Transformations
   The second major part of the tutorial looks at transformations. We will show a simple model-to-model transformation using declarative transformation languages provided by the Eclipse Modeling Project such as ATL or XTend.
6. Codegeneration
   Out of the transformed model we will now generate code using the XPand, another language provided by oAW.
7. Recipes
   As we are normally not able to generate the whole implementation code, we have to show the generator user how to integrate his hand-written code with the generated code. For this purpose we use the oAW-Recipe-Framework.
8. Wrap up/Summary
   The wrap up takes a look at some of the alleys we couldn't explore in the tutorial and hints at alternative tools and more generally, projects and tools to closely observe in the future.

Required Knowledge

Bernd Kolb focuses on model-driven software development and eclipse technologies. As a consultant he worked in different domains from tooling for automotive embedded systems to enterprise Java applications. He is a regular speaker at conferences and has written a number of articles as well as co-authored a book. Bernd is a committer in the Eclipse Modeling Project and can be reached via e-mail to b.kolb {_at_} kolbware.de

Markus Voelter works as an independent consultant and coach for software technology and engineering. He focuses on software architecture, middleware as well as model-driven software development. Markus is the author of several magazine articles, patterns and books on middleware and model-driven software development. He is a regular speaker at conferences world wide. Markus can be reached at voelter at acm dot org via or www.voelter.de

Arno Haase is an independent softwarearchitect. His areas of interest include model driven software development - both generators and interpreters - and making domain specific abstractions an explicit part of a system. He is a committer of openArchitectureWare, an end-to-end toolchain for model-driven development thatis part of Eclipse GMT.

Artem is Principal Engineer at Borland Software Corporation and currently works on the Eclipse Graphical Modeling Framework (GMF) project. He has been development lead of Borland’s Together® Edition for Eclipse product, and currently leads development on the generative tooling side of GMF