EclipseCon 2007 March 5-8, Santa Clara California

(3627) MDSD from Frontend to Code using Eclipse Modeling Technologies

Bernd Kolb (KolbW@re / Applied-Abstractions), Markus Voelter (Independent), Arno Haase (independent), Artem Tikhomirov (Borland)

· Long Tutorial

Monday, 08:00, 10 hours | Room 202


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.


  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

Attendees must have a solid understanding of object-orientation and architectural concepts as well as working knowledge of Java. A basic understanding of Model-Driven Software Development is helpful but not necessary. Working knowledge in the use of Eclipse is very useful (since all our tooling will be based on Eclipse).

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_}

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

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

Floor Plan

Gold sponsors

Ingres logo

BEA logo

IBM logo

Business Objects logo

Klocwork logo

Windriver logo

Red Hat logo

Actuate logo

Silver sponsors

Compuware logo

Sybase logo

Google logo






Code Gear




Innoopract logo

Lynux Works

Media sponsors

Eclipse Magazine logo logo

Methods and Tools logo

Eclipsezone logo

Addison-Wesley logo

Eclipse Magazin logo

Embedded Computing logo

SD Times logo

Enterprise Open Source logo

ACM Queue logo

TheServerSide Java Symposium

Eclipse Review logo

Software Test & Performance logo

Eclipse Developers Journal logo

Eclipse Source logo