{ Talks //

 
 

Keynotes

    28.09.2014 | 6th International Workshop on Domain-Specific Languages and models for ROBotic systems (DSLRob-15) | PDF | Abstract
    M. Voelter

    The State of the Art in Language Workbenches


    15.10.2014 | JAXLondon 2014 | PDF | Abstract
    M. Voelter

    Introducing Language-Oriented Business Applications

    Authoring and maintaining the complex structures, calculations or rules that lie at the core of many businesses is tedious and error prone. In many cases, Word, Excel or form-based web applications are used to capture this data. This may be convenient for end users, but it is very hard to check the data for correctness. Since the data is often not backed by a well-defined language, programmers have to manually encode the data in a programming language to make it executable for example as part of a calculation engine in a bank or insurance. This removes the domain experts one step from the actual system -- they always have to go through developers. Many of these problems can be solved using language engineering, which refers to the practice of creating, extending and composing domain-specific languages and their IDEs. Over the last few years, language workbenches have matured to the point where they support notations as diverse as tables, mathematical formulas, box-and-line diagrams, semi-structured text as well as regular, programming language-like textual notations. This makes them very suitable for business applications that, while using user-friendly notations, still rely on well-defined languages and provide IDE support, constraint checking and automatic code generation. In this session I explain what language-oriented business applications are and why they are useful. I illustrate the approach with examples from several real-world domains. The examples are based on a tool chain that uses only Open Source software: it consists of JetBrains MPS plus a few extensions built by the mbeddr project.


    30.09.2014 | MoDeVVa 2014 Workshop | PDF | Abstract
    M. Voelter

    Language Workbenches - Opportunities and Challenges for V&V

    Language workbenches (LWBs) are tools that support the efficient construction of languages. Several LWBs support modular extension and composition of languages, as well as flexibly mixing diverse notational styles in a single model. This has obvious advantages for V&V: languages of different levels of abstraction and levels of formality can be integrated, verification-specific extensions can be modularly introduced and validation is more efficient because programs can be much more readable as a consequence of domain-specific notations. But there are also challenges: How can verification tools deal with (potentially unknown) extensions to the subject languages? Can the semantics implied by language extensions be exploited to speed up the verification? Can the semantics of extensions be proven to be equivalent to their lower-level representation? In this talk I illustrate the opportunities an challenges based on mbeddr, an extensible set of integrated languages for embedded software development built with the JetBrains MPS language workbench. My hope is that the opportunities help establish LWBs as a tool in the V&V community, and the challenges inspire discussions in the workshop and research after the conference.


    27.08.2014 | European Conference on Software Architecture (ECSA) | PDF | Abstract
    M. Voelter

    Language Shapes (Architectural) Thought

    Language shapes thought. Depending on the language we use, it is more or less easy to talk about something. This idea is well known to software developers: we use various different languages to describe different kinds of software systems. Some of these languages are specific to architecture. UML, SysML and the various ADLs can all be used to create models of the architecture of software systems. Depending on the level of detail and the degree of formality of these languages we can even analyze the architecture formally or synthesize aspects of the implementation. However, when using stock languages to model architectures, the architecture will be shaped by the concepts in that language. It becomes hard to describe architectural aspects that are not directly implied by the abstractions provided by that language. I argue that to be able to create high-fidelity architectural models, each system should be described with a custom language, one that faithfully represents the architectural concepts relevant to that system. While UML or SysML can be adapted via profiles, custom domain-specific languages are much better suited for this approach. And thanks to modern language workbenches, building such DSLs is much easier than just a few years ago. In this keynote I look at different approaches to architecture modelling, roughly retracing the path along which my own thinking on the topic evolved over time: from “drawing pictures” in Powerpoint over UML to standalone DSLs to modular extensions of programming languages. I discuss related topics such as requirements engineering and formal analyses. I illustrate the concepts with examples from systems I have been involved in developing.


    26.08.2013 | DADA 2014 Workshop | PDF | Abstract
    M. Voelter

    Architecting Domain-Specific Languages

    Architecture DSLs are a useful tool to capture the cornerstones of platform or product line architectures. In addition, interesting analyses can be performed on the models, and much of the infrastructure and configuration code can be generated. On the flip side, these DSLs themselves must be architected consciously: while many architectural abstractions are specific to any given platform or product line, many other aspects are generic and hence can be reused for several architecture DSLs. In this talk I trace how my thinking on architecture modeling has changed over time, and how this is reflected in the architecture DSLs I have built (or helped to build), and how evolving tools have made these changes possible.


    28.05.2013 | SDA 2013 | PDF | Abstract
    M. Voelter

    Generic Tools, Specific Languages

    Developing software often requires using a number of tools and languages. In embedded software, for example, it is common to use C and its IDE, Matlab/Simulink, a number of custom XML files, a requirements management tool such as DOORS and possibly a UML tool and a variant management tool. The integration of such a zoo of tools is often a major source of (accidental) complexity in development projects. Contrast that with the good old days when everything was text files and command line executables running on the unix shell. This approach had two important properties: the infrastructure was extremely generic (unix shell, pipes, text editors) and the actual contents were easily extensible and composable (new text file formats/languages and new command line tools); a productive environment for a given project or domain could easily be built from the generic infrastructure plus a few custom extensions. ´ In this talk I want to propose that creating (domain-specific) development environments based on language workbenches results in many of the same advantages that we all valued in the unix shell-world. A language workbench is an extremely generic infrastructure that is easily extensible with new languages. It is easy to create domain-specific development tools that can address different aspects of the system with suitable abstractions, but are nonetheless very well integrated in terms of semantics and tooling. In this talk, I will illustrate this idea with mbeddr, which is just such an environment optimized for embedded software development.


    29.03.2012 | CodeGeneration 2012 | PDF | Abstract
    M. Voelter

    Domain-Specific Language Design - A conceptual framework for building good DSLs


    06.10.2011 | 3. Workshop Methodische Entwicklung von Modellierungswerkzeugen (MEMWe2011) | PDF | Abstract
    M. Voelter

    Language Workbenches als Basis fuer integrierte Sprachentwicklung


    28.02.2011 | VAMOS 2011 Workshop | PDF | Abstract
    M. Voelter

    DSLs and Product Lines


    27.03.2011 | WGT 2011 Workshop | PDF | Abstract
    M. Voelter

    The state of the art in (external) DSLs

    The current state of the art in external, mostly textual DSLs are detailed in this keynote. Some conceptual aspects (mainly language modularization), the practical tool reality (Xtext, MPS, Spoofax, ...) as well as some industry experience regarding the adoption of DSLs will be covered.


    18.11.2010 | 3rd RiSE International Summer School (RISS) | PDF | Abstract
    M. Voelter

    DSLs - Examples, Tools, Practices

    In this lecture I will introduce (textual) domain specific languages. I will start out with a short introduction of concepts and terms. Then I will show a couple of example languages harvested from several recent projects. Next I will showcase two interesting (but very different) tools and build simple DSLs with them: Eclipse Xtext and JetBrains MPS. The lecture will conclude with a look at some best practices.


    10.11.2009 | Insight 2009 | PDF | Abstract
    M. Voelter

    Modellierung und Programmierung - Zwei Welten?

    Traditionell sind Modellierung und Programmierung zwei unterschiedliche Dinge: Modellierung meist grafisch, oft informal und Repository-basiert, die Programmierung meist textuell, formal und ausfuehrbar und dateibasiert. Warum ist das so? Gibt es dafuer gute Gruende? Oder ist das historischer Zufall? Wie wuerde Programmieren aussehen, wenn man es mit den Mitteln der Modellierer machen wuerde? Wie wuerde man modellieren mit den Mitteln der Programmierer? In diesem Vortrag argumentiere ich zunaechst, dass Programmierung und Modellierung eigentlich das gleiche sind, nur eben fuer unteschiedliche Aspekte der Softwareentwicklung. Ich gehe auf moderne (Open Source) Language Workbenches ein, mit denen Bau, Verwendung und Integration von Sprachen moeglich wird (Xtext, MPS). Zu guter letzt entwickle ich eine Vision fuer modulare Programmiersprachen, die an den System- oder Projektkontext angepasst werden koennen.


    20.10.2009 | Practical Product Lines 2009 | PDF | Abstract
    M. Voelter

    Language Workbenches and Software Product Lines

    Domain Specific Languages (DSLs) have always played a role in Product Line Engineering. However, they haven't been used much in the Product Line Engineering (PLE) mainstream. I think this is a mistake. DSLs are able to precisely and concisely describe the way a system works. By defining a specific DSL for a particular problem domain, application developers have a very powerful tool at their hand. This keynote will briefly describe DSLs and how they fit into PLE. Then the concept of language workbenches will be introduced. Language workbenches aim at bringing programming and modeling onto the same tooling infrastructure, promising a merger of what has traditionally been called modeling and programming. Finally, I will discuss the idea of modular languages. Instead of building big languages that contain every possible feature on earth, you build language modules which you then include in your programs only if you need them. Several language workbenches support meaningful language modularization, making this approach feasible. In a very real way, this will lead to Product Line Engineering for programming languages. Model driven development has become a well-established approach to software development that is used by many organizations. It is not bleeding edge anymore. In this two-part keynote Steven Kelly and Markus Voelter summarize their experience in using MDD in many different environments. They show what works, what doesn't, and how to avoid pitfalls. Topics covered include domain analysis, language design, model processing, as well as organizational and process related challenges challenges.


    17.06.2009 | CodeGeneration 2009 | PDF | Abstract
    M. Voelter, Steven Kelly

    (Part 1) MDD, The Good, The Bad and The Ugly

    Model driven development has become a well-established approach to software development that is used by many organizations. It is not bleeding edge anymore. In this two-part keynote Steven Kelly and Markus Voelter summarize their experience in using MDD in many different environments. They show what works, what doesn't, and how to avoid pitfalls. Topics covered include domain analysis, language design, model processing, as well as organizational and process related challenges challenges.


    18.06.2009 | CodeGeneration 2009 | PDF | Abstract
    M. Voelter, Steven Kelly

    (Part 2) MDD, The Best, The Worst and The Ugliest

    Model driven development has become a well-established approach to software development that is used by many organizations. It is not bleeding edge anymore. In this two-part keynote Steven Kelly and Markus Voelter summarize their experience in using MDD in many different environments. They show what works, what doesn't, and how to avoid pitfalls. Topics covered include domain analysis, language design, model processing, as well as organizational and process related challenges challenges.


    24.03.2009 | MDD und PLE Konferenz | PDF | Abstract
    M. Voelter

    MDD und PLE Konferenz Keynote

    Im Rahmen von Plattformen und Produktlinien spielt die Beschreibung der zugrundeliegenden Architektur eine wichtige Rolle, da es unerlaesslich ist, dass sie konsequent umgesetzt wird. Gleiches gilt fuer die Variabilitaet, also die Unterschiede zwischen den verschiedenen Produkten der Produktlinie. Die Verwendung von domaenenspezifischen Sprachen (DSLs) ist hier naheliegend. Der Vortrag zeigt die Verwendung von textuellen DSLs zur Beschreibung von Architektur und Variabilitaet - letztere integriert mit Merkmalmodellen. Der Vortrag beginnt mit einem ausfuehrlichen Beispiel und endet mit einigen konzeptionellen Betrachtungen.


    27.09.2008 | ELEPES Workshop 2008 | PDF | Abstract
    M. Voelter

    Keynote ELEPES Workshop


 
 

Invited Talks

    29.10.2015 | SPLASH 2015, Industry Track | PDF | Abstract
    M. Voelter

    Language-Oriented Business Applications - Helping End Users become Programmers

    For a long time, the software engineering community has struggled with getting end users more directly involved in the development of (business) software in order to avoid the infamous Word Requirements Document which is subsequently misunderstood by developers and then implemented wrongly. Recently we have made good progress towards this goal by using domain-specific languages that blur the distinction between prose, traditional code, math formulae, tables, diagrams and form-based applications. In this talk I’ll show examples of languages we have built, explain how we built them, and explore some of the lessons we have learned along the way.


    06.10.2015 | Modeling of Embedded Systems Conference | PDF | Abstract
    M. Voelter

    Die Rolle von Modellen im Embedded Software Engineering

    Wie Software im Allgemeinen muss auch Software für eingebettete Systeme korrekt funktionieren, verständlich, testbar, wartbar und erweiterbar sein und der Entwicklungsaufwand sollte sich in Grenzen halten. Zusätzlich muss Software für eingebettete Systeme aber mit den meist beschränkten Resourcen der Zielhardware zurechtkommen, durch die Umwelt vorgegebene Timing-Constraints einhalten und besonders robust oder fehlertolerant sein. In diesem Vortrag gehe ich darauf ein, wie Modelle bei diesen Herausforderungen helfen können, indem sie genutzt werden, Komplexität durch geeignete Abstraktionen zu reduzieren. Dabei gehe ich sowohl auf etablierte Modellierungssprachen ein (bspw. UML Composite Structure Diagramme, Zustandsmaschinen, Datenflussmodelle) als auch auf die Rolle von domänenspezifischen Sprachen und Language Workbenches. Illustriert wird der Vortrag anhand konkreter Beispiele aus dem industriellen Alltag.


    27.11.2014 | European Conference of Software Engineering Education 2014 | PDF | Abstract
    M. Voelter

    Thoughts on the Collaboration between Software Engineers and Domain Experts (Dinner Speech)

    Computation is ubiquitous, and more and more domains include computer science-y techniques as their core. Examples include computational biology, finance and insurances, controls engineering as well as the software in many many embedded devices. The time-to-market in many domains is expected to decrease, and the need for product customization increases. All of these trends require efficient, frictionless collaboration between software engineers and domain experts. One approach to address this challenge is to better separate domain knowledge from computer science concerns by using domain-specific languages. These are languages that are tailored for a given domain. They let domain experts express themselves in a way that is precise, concise and formal enough so that computer science people can derive executable software through code generation or interpretation. At the same time, they use notations that are aligned with the domain, including prose, text, mathematical symbols, tables and graphics. While promising, this this approach suffers from two problems, both related to education. First, many computer scientists are not experienced with developing languages: they are not conversant in the necessary tools and language design techniques. Second, most domain experts have never learned the abstraction techniques necessary for helping with the design (and later, the effective use) of languages tailored to their domain. Both problems contribute equally to the current inefficient collaboration between computer scientists and domain experts -- despite the growing need for this collaboration. In my talk I will describe the problem based on my experience, and make a few suggestions for how it could perhaps be remedied.


    15.09.2014 | FOSD'14 Workshop | PDF | Abstract
    M. Voelter

    mbeddr's Support for Variability - features and challenges

    mbeddr is an extensible set of integrated languages for embedded software development based on the JetBrains MPS language workbench. While most of the languages are C extensions, mbeddr also supports cross-cutting concerns such as documentation, requirements and product line variability. For the latter, mbeddr supports feature models as well as a mapping onto implementation code (expressed in any language) primarily via negative variability (glorified #ifdefs). SAT solving is used for consistency checking. More recently we have started a composition framework that supports superposition and aspects, also connected to the feature models. In the talk I will demonstrate the capabilities of mbeddr and also illustrate how they are used in current practice. I will close the talk by pointing out the limitations of the current implementation in the hope of perhaps finding support from the academic community for solving these issues. In particular, we are looking for a way to integrate the variability mechanisms with the type systems of implementation languages.


    10.09.2012 | DSM-TP Summerschool 2012 | Abstract
    M. Voelter

    DSL Design


    07.12.2012 | IFIP WG 2.16 Meeting, Austin | Abstract
    M. Voelter

    mbeddr Language Design


    14.12.2012 | CHOOSE Forum 2012 | PDF | Abstract
    M. Voelter

    Modeling and Progamming - isn't it all the same?

    Modeling and programming are often considered two different things. Programming languages are (perceived to be) different from modeling languages. DSLs are different from GPLs. But are they? Should there be a difference between the two worlds? How closely should the two approaches be integrated? In this talk I will argue that programming and modeling are really essentially the same thing; they are only different in terms of the abstraction level. I will show how modular language extension based on language workbenches supports the construction and used of integrated multi-paradigm programming environments and tools. I will use the mbeddr project as an example for this approach. mbeddr is a set of modular extensions to C for embedded software development.


    24.04.2012 | CERN Computing Seminar | PDF | Abstract
    M. Voelter

    Models, DSLs and Code Generation

    Models are abstractions of the real world. They express only those aspects of the target system important for the model's purpose, such as analysis or synthesis. Domain Specific Languages (DSLs) are languages tailored to expressing models in a specific problem domain; they express those models concisely and in a way that makes the implied semantics obvious. Finally, code generation is the way to synthesize executable code from domain-specific models. In this seminar I will introduce the basic concepts and illustrate some of the benefits of using models, DSLs and code generation in software development, show a couple of example languages and introduce two of the most powerful tools in this area: Eclipse Xtext and JetBrains MPS.


    11.10.2011 | ICALEPCS 2011 | Abstract
    M. Voelter

    Trends in Programming Languages

    Over the last couple of years, two major trends have occured in programming languages. One is the demise of Java as the jack of all trades in programming languages. New languages are developed, driven by the need for better support for concurrency and multicore, functional programming and meta programming. Second, the feasibility for niche communities to build their own languages has increased by the advent of language workbenches, tools that support the rapid development of DSLs, languages customized for a given task or problem domain. In this talk, I provide a quick overview over these trends, as well as the relevant languages and tools.


    06.07.2011 | GTTSE 2011 | PDF | Abstract
    M. Voelter

    Language and IDE Development, Modularization and Composition with MPS

    JetBrains MPS is an Open Source language workbench. It uses projectional editing, which means that no parser is involved, and textual, tabular and graphical notations are handled with the same approach. As a consequence, it is an ideal language and IDE development environment. This tutorial has three parts: In part one, I will give a very short introduction to projectional editing. Part two provides examples of existing (modular) languages developed with MPS, showcasing the benefits of the tool and its possibilies. In part three, the longest one, I will show how to define languages in MPS, reusing/extending existing language modules. The tutorial will be mostly live demos; only part one will use a small number of slides.


    04.03.2011 | Modellierung 2011 | Abstract
    M. Voelter

    Textual DSLs in Practice


    22.08.2011 | MAPLE/SCALE Workshop 2011 | PDF | Abstract
    M. Voelter

    Thoughts on DSLs und PLE


    29.03.2011 | RefSQ 2011 | PDF | Abstract
    M. Voelter

    Domain-Specific Languages for Requirements

    An important part of Requirements Engineering is capturing precisely what a software system is supposed to do. The challenge is to express these requirements precisely, without predetermining the way the system is designed or implemented. The use of natural language or “picture drawing” modeling languages leads to ambiguity and inconsistencies. Domain Specific Languages offer a way to solve this dilemma: they are built specifically to precisely represent information for a given domain. In this talk we present a couple of examples of how we have used DSLs for RE. Examples are based on various tools, including Eclipse and JetBrains MPS.


    03.10.2010 | Workshop on OCL and Textual Modelling | Abstract
    M. Voelter

    Practical textual DSLs with Xtext and MPS

    Textual DSLs, as well as the tools to develop and use them, are becoming more and more powerful. For many application scenarios, textual DSLs are much more useful than graphical notations. In this talk I will show two different approaches for DSL definition, parser-based and projectional, illustrating the two appraoches with Xtext and MPS. I will demo building a hello-world level language, and then talk about my experience using these tools in practice.


 
 

Regular Talks

    20.04.2016 | JAX 2016 | PDF | Abstract
    M. Voelter, B. Kolb

    Fachexperten als Programmierer - Erfahrung aus 10 Jahren Projektarbeit

    Die gängige Praxis, dass Fachexperten – z. B. Versicherungsmathematiker, Prozessanalytiker oder Ingenieure – unscharfe Anforderungen in Word-Dokumente erfassen, die dann von Entwicklern gelesen und (miss-)verstanden werden, ist kein besonders produktiver Entwicklungsprozess. Besser wäre, die Fachexperten direkt in die Softwareentwicklung einzubinden und sie Teile des Systems selbst „programmieren“ zu lassen. Benötigt werden dazu Werkzeuge, deren Abstraktionen, Notation und Toolunterstützung möglichst gut an die Domäne angepasst sind. Seit zehn Jahren helfen wir Organisationen dabei, genau dies umzusetzen, und in diesem Vortrag fassen wir die (guten und schlechten) Erfahrungen aus diesen zehn Jahren zusammen; Ziel ist, unseren Zuhörern den Einstieg in dieses vielversprechende Thema zu erleichtern. Unter anderem betrachten wir Dos and Don’ts beim direkten Einbinden von Fachexperten in die Softwareentwicklung, Kriterien, welche Domänen sich für End-User-Programming eignen, sowie Kriterien für die Werkzeuge, die man in diesem Zusammenhang verwenden kann.


    21.04.2016 | JAX 2016 | PDF | Abstract
    M. Voelter

    Not your Daddy’s Language

    Sprachen sind das Fundament des Software Engineerings: Als Entwickler programmieren, spezifizieren, konfigurieren und testen wir damit unsere Systeme. Dabei repräsentieren Sprachen unterschiedliche Abstraktionsebenen eines Systems und verwenden verschiedene, meist textuelle oder grafische Notationen. Sprachen sind allerdings weitaus vielschichtiger. Neben Grafik und Text können Tabellen oder (mathematische) Symbole zum Einsatz kommen, sie können modular erweitert werden, man kann die mit Sprachen erstellten Modelle oder Programme transformieren oder simulieren und verschiedene Aspekte von Korrektheit statisch überprüfen. In diesem Vortrag zeige ich anhand der Open-Source-Language-Workbench JetBrains MPS, wie man all diese Dinge mit vertretbarem Aufwand umsetzen kann und wie man damit neue Anwendungsbereiche und Nutzergruppen für Sprachen und IDEs erschließt.


    05.02.2016 | OOP 2016 | PDF | Abstract
    M. Voelter, B. Kolb

    Wir sind aber keine Programmierer!! Oder doch?

    Seit 10 Jahren helfen wir Organisationen dabei, Domänenexperten, wie z. B. Versicherungsmathematiker oder Ingenieure, direkter in die Software-Entwicklung einzubinden und sie Teile des Systems selbst „programmieren“ zu lassen. Zum Einsatz kommen dazu Werkzeuge, deren Abstraktionen, Notation und Toolunterstützung möglichst gut an die Domäne angepasst sind. In diesem Vortrag fassen wir die (guten und schlechten) Erfahrungen aus diesen Projekten zusammen; Ziel ist, unseren Zuhörern den Einstieg in dieses vielversprechende Thema zu erleichtern.


    28.04.2015 | JAX Finance 2015 | PDF | Abstract
    M. Voelter

    Maintaining Business Knowledge with Language Workbenches

    Financial organizations typically rely on tools such as Word, Excel or form-based applications for domain experts to maintain the knowledge that represents the core business value of the organization (data structures, rules, calculations, formulas). This creates friction and manual work because these documents are hard to check or translate into executable software. The underlying reason is that the documents are not backed by well-defined structures. Language workbenches solve this problem by combining structured documents and proven IDE features (code completion, semantic checks, refactoring, debugging, testing) with notations commonly found in financial applications such as tables, mathematical formulas, box-and-line diagrams, semi-structured text as well as programming language-like textual syntax. In this session I explain what language workbenches are and how they can help in the context of financial applications. I rely on example systems from several real-world domains, built exclusively on Open Source software.


    24.02.2015 | Frankfurter Entwicklertag 2015 | PDF | Abstract
    M. Voelter

    Sprachorientierte Geschäftsanwendungen

    [Der Vortrag musste wegen Krankheit ausfallen; die Folien sind dennoch online.] Domänenspezifische Sprachen sind eine alte Idee: da eine DSL direkt aneiner (fachlichen) Domäne ausgerichtet ist, lassen sich damit Sachverhalte in der Domäne besser (knapper, verständlicher) beschreiben. Wenn die Sprache gut gestaltet ist, lassen sich auf dem Modellen domänenrelevante Analysen durchführen, und es kann lauffähiger Code generiert werden. Im Laufe der letzten Jahre haben sich die Werkzeuge zum Bau von DSLs insofern weiterentwickelt als dass sie nun verschiedenste Notationen unterstützen, darunter Text, Unstrukturierte Prose, mathematische Symbole, Tabellen und Diagramme. Auch das Mischen dieser Notationen ist möglich. Damit lassen sich Sprachen bauen die sich auch für Nicht-Programmierer eignen; Sprachen können damit eine zentrale Rolle in Geschäftsanwendungen spielen. In diesem Vortrag motiviere ich die Idee von Sprachorientierten Geschäftsanwendungen und gehe auf den technischen Hintergrund (DSLs, Tools) ein. Verschiedene Beispiele solcher Anwendungen, basierend auf der JetBrains MPS Language Workbench, runden den Vortrag ab.


    28.01.2015 | OOP 2015 | PDF | Abstract
    M. Voelter

    Language Workbenches - The State of the Art in 2015

    Language Worbenches erlauben die effiziente Entwicklung von Sprachen und IDEs. In den letzten Jahren gab es in diesem Bereich einige interessante Entwicklungen, darunter flexiblere Notationen, um Sprachen auch für Nichtprogrammierer zugänglich zu machen, sowie high-level Beschreibungsformalismen, aus denen verschiedene Aspekte einer Sprachdefinition abgeleitet werden können. In diesem Talk gebe ich einen Überblick über den State of the Art dieser Werkzeuge und gehe dabei anhand von Demos unter anderem auf JetBrains MPS sowie Spoofax der TU Delft ein.


    16.09.2014 | GPCE 2014 | PDF | Abstract
    M. Voelter

    Building mbeddr - a Language Engineering Experiment

    Over the last four years a team at fortiss and itemis have built mbeddr, an extensible set of integrated languages for embedded software development. mbeddr rests on the JetBrains MPS language workbench. MPS has a projectional editor, which enables wide-ranging language modularity and flexible notations that include text, prose, tables, mathematics and graphics. As far as we know, mbeddr is the largest and most sophisticated system built on top of a projectional language workbench. In this talk I will recap the 'mbeddr experience', good and bad. I will show mbeddr and some of the systems built with it, and argue why we think it could not have been built with other existing language workbenches. I will also point out the problems we had to fight with during mbeddr's construction, including those created by MPS as well as those that resulted from our own ignorance. I will close the talk by indentifying some of the areas in which MPS could be (or is currently being) improved: some of them are certainly interesting topics for academic research.


    26.04.2014 | Craft Conference 2014 | PDF | Abstract
    M. Voelter

    The art of building tools - A language engineering perspective

    Developing software often requires using a number of tools and languages. In embedded software, for example, it is common to use C and its IDE, Matlab/Simulink, a number of custom XML files, a requirements management tool such as DOORS and possibly a UML tool and a variant management tool. The integration of such a zoo of tools is often a major source of (accidental) complexity in development projects. Contrast that with the 'good old days' when everything was text files and command line executables running on the unix shell. This approach had two important properties: the infrastructure was extremely generic (unix shell, pipes, text editors) and the actual contents were easily extensible and composable (new text file formats/languages and new command line tools); a productive environment for a given project or domain could easily be built from the generic infrastructure plus a few custom extensions. In this talk I want to propose that creating (domain-specific) development environments based on language workbenches results in many of the same advantages that we all valued in the unix shell-world. A language workbench is an extremely generic infrastructure that is easily extensible with new languages. It is easy to create domain-specific development tools that can address different aspects of the system with suitable abstractions, but are nonetheless very well integrated in terms of syntax, semantics and tooling. In the talk, I illustrate the approach with examples from two domains. One is mbeddr, an open source environment optimized for embedded software development. A second example is taken from the business/insurance domain.


    10.04.2014 | Code Generation 2014 | PDF | Abstract
    M. Voelter, B. Kolb, J. Warmer

    On the way to DSLs for non-programmers

    Traditionally, DSLs have been targeted at 'specialized programmers' or at least at people with a strong technical background such as engineers, mathematicians or scientists. However, DSLs can also be very useful for people who work in fields that are less technical, and more on the business side of the universe. In this session we discuss our experiences in building DSLs for business people, i.e. non-IT people who know their respective domain well. These people are not necessarily experienced in structured (or even formal) representation of their expert knowledge, and might not even be experts in computer usage. Over the last few years, Markus, Jos & Bernd have gained some valuable experience into the kinds of domains, people, languages, and notations that make this approach feasible. It turns out that the requirements for DSLs and the tools used can be quite different for business users. The goal of this session is to present this experience and start a discussion about how to move the field forward. The experiences are taken from Bernd's and Markus's work with Intentional and Achmea Insurance, Jos's work for an insurance company in Porto, and Markus's and Bernd's work on the requirements language in mbeddr.


    06.02.2014 | OOP 2014 | Abstract
    M. Voelter, B. Kolb

    Sprache? Formular? IDE? Applikation?

    Entwickler schreiben Programme, meist mit textuellen Sprachen. IDEs unterstützten sie dabei durch Code Completion, Quick Fixes oder Refactorings. Anwender hingegen arbeiten mit Daten. Dazu verwenden sie Bäume, Formulare, Knöpfe oder Tabellen. Aber arbeiten nicht auch Entwickler oft mit Daten (Konfiguration, Test)? Und schreiben Anwender nicht auch oft Programme (bspw. Geschäftsregeln)? In diesem Vortrag zeigen wir einen hybriden Ansatz, der die Vorteile von Sprachen, Formularen, IDEs und GUI-Applikation flexibel integriert.


    16.01.2014 | The Future of Programming | PDF | Abstract
    M. Voelter

    mbeddr - Extensible Languages for Embedded Software Engineering

    The future of programming inevitably involves future programming paradigms, languages and tools. One such paradigm is the idea of modular languages where (domain-specific) language extensions can be added to a base language, in a modular fashion, as first-class citizens. In terms of tools, language workbenches enable this kind of language modularity by making language and IDE development much easier compared to manually building parsers, linkers and editors. In particular, projectional language workbenches support essentially unlimited extension and composition, while also enabling the use of a wide range of notations including text, symbols, tables and graphics. One particular programming language that exploits this paradigm is mbeddr. It relies on the JetBrains MPS language workbench and provides an extensible set of integrated languages for embedded software engineering. The talk centers around mbeddr and MPS as a case study for extensible languages built with projectional language workbenches.


    10.11.2013 | Oredev 2013 | PDF | Abstract
    M. Voelter

    The Art of Building Tools - A Language Engineering Perspective

    Language Workbenches are tools that support the rapid development, extension and composition of (diverse) languages. This way they are an excellent foundation for building domain-specific development tools: after all, most development tools are essentially just UIs for languages. In this talk I will demonstrate this idea with mbeddr, a open source development tool for embedded software based on the JetBrains MPS language workbench. The talk is mostly demos; I use only a few slides in the intro.


    03.11.2013 | EclipseCon Europe 2013 | Abstract
    M. Voelter, Stefan Schmierer

    Simplifying Complex Embedded Development Processes with mbeddr

    Many of today's industry standards or development processes require software developers to use a multitude of tools to achieve a specific goal, resulting in significant accidental complexity for the user. As an example consider the AUTOSAR standard used in the automotive industry. To develop an AUTOSAR component, users start defining the external shape of the component with an AUTOSAR modeling tool. They then generate a set of component-specific header files against which the implementation is coded. This implementation typically uses several tools, including C IDEs, state machine modeling tools or data flow tools. The tools used in these steps are typically not very well integrated, making the development process slow, tedious and error prone. In this talk we show how this situation can be improved using language engineering based on mbeddr. mbeddr is an open source technology for C-based embedded software development. As a consequence of its being built on top of the MPS language workbench, the existing languages an be arbitrarily extended and composed. Over the last year, BMW Car IT has developed such extensions to simplify AUTOSAR development. Users work only in the mbeddr IDE, using a set of highly integrated C extensions to describe every aspect of an AUTOSAR component (incl. interfaces, contracts, middleware integration and the implementation using state machines and C). The talk also contains a brief introduction of mbeddr as well as an overview of other extensions available to mbeddr users.


    23.04.2013 | JAX 2013 | PDF | Abstract
    M. Voelter

    DSLs und ihre Tools -- State of the Art

    In dieser Session zeige ich den aktuellen Stand bzgl. domaenenspezifischer Sprachen und der Tools, um sie zu implementieren. Dabei gehe ich insbesondere auf die Herausforderungen und Loesungsansätze im Umgang mit mehreren integrierten DSLs ein. Als Beispieltools fungieren u. a. Eclipse Xtext, JetBrains MPS und Spoofax von der TU Delft.


    11.04.2013 | CodeGeneration 2013 | PDF | Abstract
    M. Voelter

    Working with Multiple Languages - Why and How

    A few years ago we were happy when a language workbench helped us develop one single DSL efficiently. However, as we gain more experience with DSLs, it is obvious that, to describe systems meaningfully, a set of languages -- domain specific and general purpose -- needs to used, integrated in a meaningful way. Developing such families of more or less related languages is one of the challenges for today's language workbenches. In this session I discuss why a multi-language approach is necessary or desirable based on a set of examples. I also argue why working with a set of languages requires more than throwing a few independent languages into the same project. I classify the relationships between sets of languages. Finally, we explore whether and how several language workbenches support this approach.


    08.11.2012 | Bits and Chips Embedded Systems 2012 | Abstract
    M. Voelter

    Improving C code quality using language extension

    Writing reliable, high-quality and maintainable C code can be hard: C supports only limited ways for creating user-defined abstractions (no classes, object and the like), the preprocessor has the potential to create a lot of harm (by arbitrarily changing the source on a textual level) and verification of C is expensive because of its low level of abstraction (leading to long tool runtimes and the need to annotate the semantics of the code). These limitations can lead to serious problems, especially in larger code bases and product lines. While modeling and code generation tools can address some of these problems, they suffer from bad integration with manually written code and with other modeling tools. In this session we demonstrate MBeddr C. MBeddr is an open source project that supports language extension and formal verification for C. MBeddr ships with a set of extensions optimised for embedded software development, including state machines, interfaces and components, data types with physical units, as well as support for product line variability and requirements tracing. MBeddr is based on and includes the Jetbrains MPS language workbench, so users can easily build their own extensions for C. MBeddr also integrates a number of verification tools, among them model checkers and SAT solvers. Language extensions can improve the limitations of C discussed above significantly: new, domain-specific abstractions can be defined as native language extensions that come with type checks, static transformations to C and IDE support. The preprocessor and other ‘dangerous’ features of C have been removed and replaced by first-class language extensions. Finally, the more explicit semantics implied by domain-specific extensions makes verification much more practical by reducing cost and overhead.


    24.01.2013 | OOP 2013 | PDF | Abstract
    M. Voelter

    Modular Erweiterbare (domaenenspezifische) Sprachen

    Werkzeuge zur Sprachentwicklung koennen inzwischen deutlich mehr als nur einen Editor fuer eine Grammatik zu generieren. Zu den neueren Features gehoert die Mischung verschiedener Syntaxformen (Text, Tabelle, Grafik), Typsysteme, Sprachmodularisierung und -Komposition und die enge Integration von DSLs und Programmiersprachen, sowie die Unterstuetzung von sprachspezifischen Debuggern. In dieser Session zeige ich diese Features und deren Nutzen anhand verschiedener Beispiele und Tools. Der Schwerpunkt liegt dabei auf Xtext, MPS und Spoofax.


    23.01.2013 | IBM DeveloperWorks Day 2012 | Abstract
    M. Voelter

    Werkzeuge zur DSL Entwicklung - State of the Art


    22.01.2013 | OOP 2013 | Abstract
    M. Voelter, Bernd Kolb

    mbeddr - C Entwicklung fuer das 21. Jahrhundert

    mbeddr ist ein neuer Ansatz zur Entwicklung eingebetteter Systeme. Durch die Verwendung eines erweiterbaren C koennen domaenenspezifische Abstraktionen direkt in C integriert werden. mbeddr umfasst Komponenten, Zustandsmaschinen, Maßeinheiten, Tests, Mocks, sowie Produktlinienvariabilitaet und Requirements. Verifikationsmethoden wie Model Checking und SAT Solving sind integriert. mbeddr ist Open Source und basiert auf JetBrains MPS, Nutzer koennen damit eigene Spracherweiterungen erstellen. Der Vortrag umfasst Konzepte, Demos und Praxiserfahrungen.


    05.11.2012 | W-JAX 2012 | PDF | Abstract
    M. Voelter

    DSL-Design - Ueber den Bau von guten DSLs

    Die Implementierung von DSLs ist mit den heutigen Werkzeugen kein Problem mehr, das Design guter DSLs allerdings schon. In dieser Session diskutiere ich acht Aspekte, die beim Design einer DSL als Leitfaden verwendet werden koennen. Ein Schwerpunkt liegt auf Sprachmodularisierung und der gemeinsamen Verwendung mehrerer DSLs. Fuenf Fallstudien illustrieren die Konzepte.


    10.07.2012 | Java Forum Stuttgart 2012 | PDF | Abstract
    M. Voelter

    Language Engineering mit Language Workbenches

    Moderne Language Workbenches wie Eclipse Xtext oder JetBrains MPS (beide Open Source) erlauben die schnelle und robuste Implementierung nicht-trivialer Sprachen und dazu passender IDEs (Code Completion, Syntax Highlighting, Typsysteme, Refactoring, Debugger). Je nach Werkzeug ist auch die inkrementelle Erweiterung und Komposition von Sprachen moeglich. Dies erlaubt neue Herangehensweisen an die klassischen Herausforderungen des Software Engineering: statt ein Problem direkt mit einer Programmiersprache zu loesen, kann man zunaechst eine passende Sprache oder Spracherweiterung fuer die betreffende Problemklasse bauen. Diese Sprache erlaubt es dann, die betreffende Klasse von Problemen effizienter zu loesen: weniger Code, bessere Analysierbarkeit, bessere Integration der Stakeholder. In diesem Vortrag zeige ich anhand von Beispielen basierend auf Eclipse Xtext und JetBrains MPS welche Moeglichkeiten diese (und aehnliche) Tools bieten.


    10.05.2012 | Karlsruher Entwicklertage 2012 | PDF | Abstract
    M. Voelter

    DSLs im Kontext agiler Softwareentwicklung

    Koennen Domaenenspezifische Sprachen im Rahmen agiler Entwicklung helfen? Wieviel Anfangsinvestition fordern sie? Lassen sich Sprachen iterativ (weiter-)entwickeln? Ist es realistisch, dass man einfach den Generator aendert und neu generiert? Koennen Domaenenexperten wirklich mit DSLs programmieren? In diesem Vortrag werde ich diese Fragen basierend auf meiner Erfahrung zu beantworten versuchen. Dabei werde ich auf eine Reihe von Beispielen eingehen, die aus realen Projekten entnommen sind. Dabei kommen unter anderem auch die beiden Werkzeuge Xtext und MPS zur Sprache.


    09.05.2012 | Karlsruher Entwicklertage 2012 | PDF | Abstract
    M. Voelter

    Robuster C Code durch Spracherweiterung und Model Checking

    Robustheit ist eine wichtige Eigenschaft eingebetteter Software. In diesem Vortrag zeige ich, wie man diesem Ziel durch Spracherweiterung von C naeher kommen kann. Dabei gehe ich auf drei Aspekte ein. Erstens kann die Fehlerrate durch Verwendung angemessener, domaenenspezifischer Abstraktionen reduziert werden, da der detailreiche Implementierungscode automatisch generiert werden kann. Zweitens kann C so erweitert werden, dass das Testen erleichtert wird. Dazu gehoert Unterstueuetzung fuer Mockobjekte, aber auch Pre- und Postconditions auf Interfacemethoden. Drittens lassen sich formale Verifikationstechniken einsetzen, wenn Programme die richrigen Abstraktionen verwenden. Ich zeige dies am Beispiel von Model Checking auf Zustandsmaschinen. Der Vortrag besteht zum großen Teil aus Demos, basierend auf dem mbeddr.com Projektes. Dort entwickeln wir ein erweiterbares C zur effizienten Entwicklung eingebetteter Systeme. Der Code ist Open Source, genauso wie das Werkzeug, auf dem das alles aufsetzt: JetBrains MPS


    07.06.2012 | ICSE 2012 | Abstract
    M. Voelter

    Language Modularity with the MPS Language Workbench

    (This is actually a tool demo, not a presentation) JetBrains MPS is a comprehensive environment for language engineering. New languages can be defined as standalone languages or as modular extensions of existing languages. Since MPS is a projectional editor, syntactic forms other than text are possible, including tables or mathematical symbols. This demo will show MPS based on mbeddr C, a novel approach for embedded software development that makes use of incremental language extension on the basis of C.


    28.03.2012 | CodeGeneration 2012 | PDF | Abstract
    M. Voelter

    mbeddr C - an extensible version of the C programming language

    For a long time, model-based technologies and code generation have been promising to raise the level of abstraction, allow better and faster development of software and integrate domain specific concepts into the development process. However, in reality, and especially in the domain of embedded software, the current status quo is quite different. Throughout the development phases different specialised tools are used for requirements management, design, modelling, coding, debugging and testing. Integrating these tools is non-trivial, often even impossible. A major reason for this integration nightmare is that a number of different languages are used, while the implementation language for most embedded systems is still C. C is an efficient but limited language, performance is key and requirements such as like type safe units, support for state machines or interfaces and components as well as product line variability can add an additional level of complexity. In this talk we will show a new approach of attacking these challenges: An incremental extension of the C programming language using the MPS language workbench.


    10.11.2011 | EclipseCon Europe 2011 | PDF | Abstract
    M. Voelter

    Refrigerators and DSLs

    Building refrigerators involves two major challenges. First, refrigerators have to be as energy efficient as possible. To achieve this, in addition to thicker insulation, the algorithm used for cooling the fridge must be optimized for the configuration of the appliance. Second, Bosch-Siemens-Hausgeraete manufactures a wide variety of refrigerators, and the resulting variability in the cooling algorithms has to be managed efficiently. In this session we describe the development of an Xtext-based textual DSL that addresses both of these challenges. The language supports the description of appliance configuations, as well as the cooling algorithms that run on them. The language is currently being developed at BSH, with direct involvement of the thermodynamicists who are going to use the language subsequently to capture the algorithms they come up with through experimentation. This case in an interesting example of using Xtext, since it involves several related DSLs, a language with expressions and a type systems, an interpreter for simulating and testing the algorithms, as well as a code generator to map the algorithms to C code that will run in the actual device.


    22.09.2011 | TAE Symposium Software Architektur | PDF | Abstract
    M. Voelter

    Eckpfeiler und Trends der Software-Architektur

    Software-Architektur ist ein weitlaeufiges und vielschichtiges Feld. Der Vortrag stellt wichtige, aktuell relevante Aspekte und Techniken der Software-Architektur vor: Architekturdokumentation, Architekturmuster, Modellierung, Codegenerierung, Konsistenzpruefung sowie Wiederverwendung und Variantenmanagement. Die Themengruppen Architekturdokumentation sowie Modellierung und Codegenerierung wird Markus Voelter in zwei Workshops am Nachmittag vertiefen.


    22.09.2011 | TAE Symposium Software Architektur | PDF | Abstract
    M. Voelter

    Modellgetriebene Entwicklung und Domain-Specific Languages am Beispiel eingebetteter Systeme

    Abstraktion des Anwendungsverhaltens und automatische Erstellung des implementierenden Quellcodes bieten vielfaeltige Vorteile, von der Steigerung der Effizenz und Qualitaet bis zur Plattformunabhaengigkeit. Wirkungsvolle und praktisch gut anwendbare Techniken fuer Abstraktion und Codegenerierung sind die modellgetriebene Entwicklung und domaenenspezifische Sprachen (Domain-Specific Languages, DSLs). Der Workshop zeigt anhand zahlreicher konkreter Beispiele wie und warum diese Ansaetze vor allem im Bereich technischer und eingebetteter Systeme Sinn machen.


    22.09.2011 | TAE Symposium Software Architektur | PDF | Abstract
    M. Voelter

    Architekturdokumentation

    Dokumentation ist laestig und ueberfluessig...; naja, nicht wirklich. Vor allem fuer Architekturen, die ueber eine laengere Zeit verwendet werden sollen, ist eine brauchbare und trotzdem nicht zu aufwaendige Dokumentation essentiell. Dieser Workshop geht auf eine Reihe von Best Practices zur Architekturdokumentation ein: Strukturierte Glossare, Patterns, Tutorials und FAQs, Diagramme und Modellierung, einige stilistische Aspekte sowie die Verwendung alternativer Kanaele wie Audio und Video.


    20.09.2011 | itemis Vortragsreihe Stuttgart | PDF | Abstract
    M. Voelter

    Entwicklung eingebetteter Systeme mit Language Workbenches

    Software fuer Eingebettete Systeme wird immer wichtiger, komplexer und umfangreicher. Effizienzsteigerungen in der Entwicklung dieser Software haben direkten Einfluss auf Time-to-Market und Entwicklungskosten fu?r technische Systeme. In der Praxis werden diese Systeme oft von Hand in C, oder mittels Werkzeugen wie Matlab/Simulink, UML oder Ascet entwickelt. Das BMBF Forschungsprojekt Language Workbenches fu?r Eingebettete Systeme (LWES) geht einen anderen Ansatz: die Programmiersprache C wird inkrementell und modular um zusaetzliche Konzepte fuer Embedded-Programmierung erweitert, basierend auf dem JetBrains Meta Programming System, einer frei verfuegbaren, projizierenden Language Workbench. In diesem Vortrag erlaeutern wir die Idee, den aktuellen Stand (anhand von Demos) und zeigen Moeglichkeiten auf, wie man die frei verfuegbaren Ergebnisse und Werkzeuge nutzen kann.


    24.01.2012 | OOP 2012 | PDF | Abstract
    M. Voelter

    DSL Design

    Die Werkzeuge zum Bau von DSL sind ausgereift. Die Implementierung einer DSL ist keine grosse Herausforderung mehr, das Design guter DSLs allerdings schon. Neben Domaenenwissen und Sprachbauerfahrung existieren eine Reihe von allgemeingueltigen Aspekten: in dieser Session entwickle ich eine Systematik zur Beschreibung und Klassifikation von DSLs, die beim Design als Leitfaden verwendet werden kann. Desweiteren stelle ich eine Verknuepfung her zwischen aeußeren Einflussfaktoren und der Klassifikation. Fuenf Fallstudien illustrieren die Konzepte.


    24.01.2012 | OOP 2012 | PDF | Abstract
    M. Voelter

    Testen von DSLs

    DSLs werden entsprechend des besser werdenden Toolsupports immer komplexer. Manuelles testen durch Ausprobieren funktioniert hier nicht mehr, Automatisierung ist notwendig. In dieser Session zeige ich bewaehrte Taktiken zum Testen von DSLs bezueglich Korrektheit von Syntax, Constraints, Typsystem, Scopes und Generatoren bzw. Interpretern. Saemtliche Beispiele sind mittels Eclipse Xtext und JetBrains MPS implementiert, sind aber konzeptionell auch auf andere Werkzeuge uebertragbar.


    21.06.2011 | Jazoon 2011 | PDF | Abstract
    M. Voelter

    DSLs - State of the Art

    Domain Specific Languages have evolved quite a bit over the last couple of years to the point where we now build real application domain DSLs (as opposed to just developer utilities). DSLs are often real languages, as opposed to just descriptions of some structure. DSL builders can use sophisticated textual, graphical and symbolic notations. Language modularization and reuse is becoming available in DSL tools. In this talk I will provide an overview over some state-of-the art language workbenches, and provide a number interesting real-world examples of where DSLs are used successfully. The examples will be based on Xtext, MPS, and possibly, some other tools. Explain the general topic/problem, describe why the delegates should attend the presentation, and highlight the technologies/concepts the presentation is going to cover. Make the main arguments of your proposed presentation clear and why this topic is important DSLs can provide a significant boost to developer productivity. They can often be the bridge between non-programmer stakeholders and the developers. In my daily consulting work, I am more and more involved with building DSLs to be used by domain experts. The main reason why this is becoming more and more realistic is that the tools are becoming more and more mature, to the point where (almost) arbitrary notations can be supported - a key feature for winning the support of non-programmers.I will definitely show examples built with Xtext and MPS, and possibly also with the Intentional Domain Workbench.


    08.12.2010 | Embedded Softare Engineering Kongress 2010 | PDF | Abstract
    M. Voelter

    Erweiterbare Programmiersprachen fuer die Embedded-Entwicklung


    25.05.2011 | CodeGeneration 2011 | PDF | Abstract
    M. Voelter

    Type Systems for DSLs

    Non-trivial DSLs, as they are possible with today's tools, often include expressions. Once you have expressions, you usually also have several different (primitive and user-defined) types that need to be type checked with the help of a type system. In this session, I will explain what type systems are, how they are different from normal constraint checking, and which typing rules you will often need. I will then illustrate the concepts with MPS and Xtext (using the XText typesystem framework).


    25.05.2011 | CodeGeneration 2011 | Abstract
    M. Voelter, Alexander Shatalin

    Introduction to MPS


    17.06.2010 | CodeGeneration 2010 | Abstract
    M. Voelter, Alexander Bernauer, Bernhard Merkle

    Language Workbenches, Product Lines and Lego

    Embedded Systems are challenging: C is an efficient but limited language, performance is key and product line variability can add an additional level of complexity. In this session we will show a new approach of attacking these challenges: incremental extension of the C programming language using language workbenches, specifically MPS. The session is based around a live demo of the approach based on a C system running on the Osek operating system on a Lego Mindstorm ARM processor.


    04.05.2010 | JAX 2010 | PDF | Abstract
    M. Voelter

    Do-it-yourself Java-Spracherweiterung mit MPS

    In vielen Situationen ist es nuetzlich, eine Programmiersprache projekt- oder domaenenspezifisch zu erweitern, um abstraktere, semantisch reichere, und analysierbarere Programme schreiben zu koennen. Das Open-Source-Werkzeug JetBrains MPS erlaubt die inkrementelle Erweiterung von Java, inkl. der IDE und statischer Checks. Diese Session zeigt das Werkzeug und das Vorgehen anhand von Beispielen.


    04.05.2010 | JAX 2010 | PDF | Abstract
    M. Voelter

    DSLs, Modelle und Softwarearchitektur

    Softwarearchitektur beschreibt Konzepte, Konventionen und Vorgehensweisen, die in einem System konsistent umgesetzt werden muessen. Die Erreichung dieser Konsistenz ist in großen Systemen nicht leicht. Domaenenspezifische Architektursprachen, Modelle, Valdierung, Codegenerierung und die Integration mit Codeanalysewerkzeugen versprechen Besserung. Diese Session erlaeutert, wann und wie DSLs, Modelle und Codegenerierung sinnvoll und pragmatisch eingesetzt werden koennen.


    10.10.2009 | Embedded Systems Kongress 2009 | PDF | Abstract
    M. Voelter

    Einfuehrung eines modellbasierten Entwicklungsprozesses mit Open-Source Tools

    Textuelle domaenenspezifische Sprachen sind ein starker Trend in der Software-Entwicklung. Welche Lessons-Learned macht ein mittelstaendisches Unternehmen bei der Einfuehrung von modellbasierter Software-Entwicklung fuer Embedded Systems? In diesem Talk werden an Hand eines realen Projekts die Lessons Learned und die Vorteile des Einsatzes von textuellen domaenenspezifischen Modellen auf Basis von Open Source-Tools eroertert.


    28.01.2010 | OOP 2010 | PDF | Abstract
    M. Voelter

    Using Domain-Specific Languages in Product Line Engineering

    Mainstream PLE uses feature models to describe variability and then maps the variability to source code. DSLs can be a very useful addition here: you can describe variability with DSLs, map feature-based variability to models and add variability to model transformation and code generators. In this session I explain the relationship between PLE and MDD and address the above topics specifically. All concepts will be demonstrated with existing tools, mostly from Eclipse Modeling.


    27.01.2010 | OOP 2010 | PDF | Abstract
    M. Voelter

    From Programming to Modeling – and Back Again

    Is programming = modeling? Are there differences, conceptual and tool-wise? Should there be differences? What if we programmed the way we model? Or vice versa? In this session I explore this question and introduce interesting developments in the space of projectional editing and modern parser technology. This leads to the concept of modular programming languages and a new way of looking at programming. I will demonstrate the idea with tools that are available today, for example TMF Xtext, SDF, JetBrains MPS and Intentional’s Domain Workbench.


    24.01.2011 | OOP 2011 | PDF | Abstract
    M. Voelter

    Live Coding - Embedded Entwicklung und Spracherweiterung mit MPS

    MPS ist ein Open Source Werkzeug, das es erlaubt, Programmier- und Modellierungssprachen zu integrieren und diese dann inkrementell zu erweitern. In dieser Session zeige ich dies anhand von Beispielen fuer die Entwicklung eingebetteter Systeme mit C. Anhand existierender C Spracherweiterungen zeige ich die Vorteile des Ansatzes. Außerdem werden wir eine einfache Spracherweiterung erstellen, um ein Gefuehl dafuer zu bekommen, wie viel Aufwand dazu noetig ist. Die Session besteht zu 100 Prozent aus Demos.


    26.01.2011 | OOP 2011 | PDF | Abstract
    M. Voelter

    DSLs, Modelle und Softwarearchitektur

    Softwarearchitektur beschreibt Konzepte, Konventionen und Vorgehensweisen, die in einem System konsistent umgesetzt werden muessen. Die Erreichung dieser Konsistenz ist in großen Systemen nicht leicht. Domaenenspezifische Architektur-sprachen, Modelle, Validierung, Codegenerierung und die Integration mit Codeanalysewerkzeugen versprechen Besserung. Diese Session erlaeutert (u.a. anhand von Beispielen), wann und wie DSLs, Modelle und Codegenerierung sinnvoll und pragmatisch eingesetzt werden koennen.


    01.03.2011 | Embedded World Conference 2011 | PDF | Abstract
    M. Voelter

    Embedded Software Development with Projectional Language Workbenches

    Developing embedded systems typically requires using a mix of models and code, with the well-known problems of integrating models created with different tools and integrating models with code. Adding the need to efficiently implement product line variability exacerbates the problem. In this talk we propose an alternative approach. Using projectional language workbenches, we have created an implementation of C that can be incrementally extended with language concepts useful for embedded programming. For example, we have implemented state machines, tasks and a set of domain specific languages for robot control. To address product line variability, we can annotate this mix of C, embedded abstractions and 'real' domain specific languages with feature dependency expressions that determine which configuration features certain program or model fragments depend on. These expressions can be evaluated as we edit the program; this means, we can edit the program with everything showing, or we can project it in a way that only shows the code relevant for a given variant. Our approach removes the (arbitrary) distinction between models and code and provides a programming environment that integrates the different abstractions semantically and notationally. Our implementation is available open source at mbeddr.com, the tooling is built on the open-source language workbench JetBrains MPS.


    27.01.2010 | OOP 2010 | PDF | Abstract
    M. Voelter, Andreas Graf

    Modellgetriebene Entwicklung fuer eingebettete Systeme mit Eclipse Tools am Beispiel

    In dieser Session zeigen wir am konkreten Beispiel, wie textuelle DSLs und Codegenerierung erfolgreich zur Implementierung einer Produktlinie fuer Embedded Systeme eingesetzt wurden. Aus Modellen (Komponenten, Busbeschreibung, etc.) werden große Teile des resultierenden C Codes generiert, was zu effektiverer Entwicklung, hoeherer Qualitaet und sinnvollem Umgang mit Produktlinienvariabilitaet gefuehrt hat. Die eingesetzten Tools sind Eclipse-basiert, die Session besteht aus Folien und Live-Demo.


    28.10.2009 | Eclipse Summit Europe 2009 | PDF | Abstract
    M. Voelter, Andreas Graf

    Lightweight Model-Driven Development for Embedded Systems with Eclipse Tools

    Model driven development and code generation is relatively widespread in the development of embedded systems. However, usually, large and expensive UML-based real-time modeling tools are used, typically in conjunction with their own runtime environment. To make this approach scale down to smaller, more agile environments, a more lightweight and flexible approach is needed. In this talk, we show how the Textual Modeling Framework, the Xpand code generation engine and a couple of utilities for managing product line variability in models can be used to develop embedded systems. Architects develop their own domain specific language and code generator, to make sure the abstractions and the generated code fit their needs on the target platform. The talk uses a minimum of slides and is based mostly on a realistic example, showing the DSL, the code generator and the way we've built it.


    29.09.2009 | Telekom TechTalk | PDF | Abstract
    M. Voelter

    Trends in Languages 2009

    Der Sprachenmarkt ist weiter in Bewegung. Die Erkenntnis, dass man auch mit tollen Frameworks keine maechtigen Sprachfeatures ersetzen kann, rueckt in den Vordergrund. Dieser Talk beleuchtet verschiedene Konzepte, die sich in Sprachen wie C# 3.0, Scala, Ruby, Groovy, Fortress, Axum, Boo, Clojure und Erlang finden, darunter funktionale Programmierung, Metaprogrammierung, DSLs und Concurrency mittels Message Passing. Aktualisierter Talk verglichen mit frueheren Praesentationen!


    05.11.2009 | Java User Group Stuttgart | PDF | Abstract
    M. Voelter

    Verbindung von Modellierung und Programmierung ueber DSLs

    Traditionell sind Modellierung und Programmierung zwei verschiedene Dinge. Das eine eher graphisch, dass andere typischerweise textuell. Die verwendeten Tools sind ueblicherweise unterschiedlich und lassen sich nur begrenzt sinnvoll integrieren. Es stellt sich die Frage, warum das so ist, und ob das so sein muss. Mit textuellen DSLs und Language Workbenches lassen sich diese beiden Welten erheblich naeher zusammen bringen, mit der Konsequenz dass man eigentlich nicht mehr zwischen Modellierung und Programmierung unterscheidet. Stattdessen, kann man einfach bei der Softwareentwicklung fuer die verschiedenen Aspekte eines Systems eine zu deren Beschreibung optimal passende Sprache verwenden. Die Sprachen die zur Beschreibung eines Systems notwendig sind sind alle innerhalb einer IDE verwendbar und vollstaendig symbolisch integriert. Dieser Vortrag besteht aus zwei Teilen. Im ersten Teil argumentiere ich, warum Modellierung und Programmierung nicht grundsaetzlich unterschiedliche Taetigkeiten sind, und welche Vorteile sich ergeben, wenn sie denn konzeptionell und tooltechnisch das gleiche waeren. Im zweiten Teil zeige ich anhand von Eclipse TMF Xtext und JetBrains MPS zwei moderne Werkzeuge zur Implementierung von DSLs. Beide Werkzeuge sind Open Source.


    04.11.2009 | Java User Group Mannheim | PDF | Abstract
    M. Voelter

    Verbindung von Modellierung und Programmierung ueber DSLs

    Traditionell sind Modellierung und Programmierung zwei verschiedene Dinge. Das eine eher graphisch, dass andere typischerweise textuell. Die verwendeten Tools sind ueblicherweise unterschiedlich und lassen sich nur begrenzt sinnvoll integrieren. Es stellt sich die Frage, warum das so ist, und ob das so sein muss. Mit textuellen DSLs und Language Workbenches lassen sich diese beiden Welten erheblich naeher zusammen bringen, mit der Konsequenz dass man eigentlich nicht mehr zwischen Modellierung und Programmierung unterscheidet. Stattdessen, kann man einfach bei der Softwareentwicklung fuer die verschiedenen Aspekte eines Systems eine zu deren Beschreibung optimal passende Sprache verwenden. Die Sprachen die zur Beschreibung eines Systems notwendig sind sind alle innerhalb einer IDE verwendbar und vollstaendig symbolisch integriert. Dieser Vortrag besteht aus zwei Teilen. Im ersten Teil argumentiere ich, warum Modellierung und Programmierung nicht grundsaetzlich unterschiedliche Taetigkeiten sind, und welche Vorteile sich ergeben, wenn sie denn konzeptionell und tooltechnisch das gleiche waeren. Im zweiten Teil zeige ich anhand von Eclipse TMF Xtext und JetBrains MPS zwei moderne Werkzeuge zur Implementierung von DSLs. Beide Werkzeuge sind Open Source.


    25.06.2009 | Eclipse Embedded Day Stuttgart | PDF | Abstract
    M. Voelter, Andreas Graf

    The interplay between Models, Generators and Variants

    Efficient embedded software development depends on mastering three essential techniques: increased level of abstraction using semantically rich models, efficient and streamlined implementation through code generation as well as mastering the variability between products in product lines. In this talk we will show how these three techniques can be used together, based on Eclipse tools. We will briefly show how to define modeling languages and code generators and then integrate them with variant management tools. The implementation of variability will be shown in models, handwritten code and generators using an example based on textual DSLs and C.


    17.04.2009 | Microsoft DSL Devcon | PDF | Abstract
    M. Voelter

    Textual DSLs and Code Generation with Eclipse Tools

    As part of the Eclipse Modeling Project, a number of tools for defining DSLs and generating code have been developed over the last couple of years. In this talk, Markus will show a subset of these tools that have proven particularly useful. These include Xtext for definition of textual DSLs and editors, Check for defining constraints, as well as Xtend and Xpand for transforming models and generating code. Markus will motivate the approach by looking at how textual languages are used for software architecture modeling.


    23.04.2009 | JAX 2009 | PDF | Abstract
    M. Voelter

    Architektur als Sprache

    Architekturbeschreibungen sind oft entweder nicht greifbar oder technologiespezifisch. Beide Alternativen sind suboptimal. Alternativen? In dieser Session zeige ich anhand eines ausfuehrlichen Beispiels, wie man fuer eine Architektur eine Sprache entwickelt, die diese formal (und toolverarbeitbar) beschreibt. Der zweite Teil der Session betrachtet Hintergruende und Vorteile dieses Ansatzes.


    23.04.2009 | JAX 2009 | PDF | Abstract
    M. Voelter

    DSL/MDSD Best Practices

    Modellgetriebene Entwicklung und DSLs werden auf immer breiterer Basis angewandt – natuerlich kann man dabei vieles falsch und richtig machen. Basierend auf Projekterfahrungen der letzten paar Jahre, gibt diese Session Denkanstoeße, um unnoetige Probleme zu vermeiden. Von Sprachdesign ueber Codegenerierung bis zum Entwicklungsprozess betrachte ich alle Aspekte der Softwareentwicklung mit DSLs und MDSD.


    23.04.2009 | JAX 2009 | PDF | Abstract
    M. Voelter

    Trends in Sprachen 2009

    Der Sprachenmarkt ist wieder in Bewegung. Die Erkenntnis, dass man auch mit tollen Frameworks keine maechtigen Sprachfeatures ersetzen kann, rueckt in den Vordergrund. Dieser Talk beleuchtet verschiedene Konzepte, die sich in Sprachen wie C# 3.0, Scala, Ruby, Groovy, Fortress und Erlang finden, darunter funktionale Programmierung, Metaprogrammierung, DSLs und Concurrency mittels Message Passing.


    06.05.2009 | SET 2009 | PDF | Abstract
    M. Voelter

    Best Practices fuer Modellgetriebene Entwicklung und DSLs

    Dieser Talk enthaelt in konzentrierter Form ca. 35 Best Practices fuer die Verwendung modellgetriebener Verfahren und domaenenspezifischer Sprachen aus den letzten paar Jahren. Themen umfassen unter anderem die Domaenenanalyse, Strukturierung in Viewpoints, Partitionierungsueberlegungen, die Auswahl einer geeigneten Notation, die Verwendung von generischen Sprachen, die Integration handgeschriebener Codes, die Rollen von Modelltransformationen und eine Reihe organisatorischer Randbedingungen. Ziel des Talks ist, alle wichtigen Themen zumindest angerissen zu haben, um so am Projektstart als Checkliste zu dienen.


    10.12.2008 | Embedded Software Engineering Kongress 2008 | PDF | Abstract
    M. Voelter

    Architektur als Sprache

    Softwarearchitektur wird in der Regel entweder verbal (und damit unpraezise) oder technikspezifisch (und damit nur begrenzt wiederverwendbar) beschrieben. Gerade im Zusammenhang mit langlebenden Systemen oder Produktlinien ist dies ein Problem. In diesem Vortrag moechte der Referent aufzeigen, wie die Definition einer formalen, textuellen, systemspezifischen Architekturdefinitionssprache hier Abhilfe schaffen kann: Im Rahmen der Definition der Architektur definieren die Architekten eine formale Sprache, die die relevanten Architekturkonzepte formal ausdrueckt – dadurch entsteht eine unmissverstaendliche Definition der Architektur des zu erstellenden Systems. Außerdem steht einer automatisierten Weiterverarbeitung durch Tools (Validierung, Codegenerierung) nichts mehr im Wege. Der Referent hat mit o.a. Ansatz in verschiedensten Projekten selbst bereits gute Erfahrungen gemacht. Die Verwendung textueller DSLs bedeutet, dass sich das Vorgehen problemlos in existierende, Quelltextbasierte Entwicklungsumgebungen (bspw. Eclipse) integriert. Durch die automatische Weiterverarbeitung ist sichergestellt, dass das System tatsaechlich der per DSL beschriebenen Architektur entspricht.


    10.12.2008 | Embedded Software Engineering Kongress 2008 | PDF | Abstract
    M. Voelter

    Modellgetriebene Softwareentwicklung mit Eclipse und openArchitectureWare

    Modellgetriebene Softwareentwicklung ist gerade im Embedded-Umfeld nicht mehr aus der taeglichen Praxis wegzudenken. Dabei gibt es zwei unterschiedliche Vorgehensweisen: Auf der einen Seite kann man mit existierenden Modellierungssprachen und Codegeneratoren arbeiten. Auf der anderen Seite kann man seine eigenen domaenenspezifischen Sprachen und die zugehoerigen Generatoren und Werkzeuge selbst bauen. Letzteres hat den Vorteil, dass man seine spezifischen Domaenen- und Technologiekonzepte direkt unterstuetzen kann. Der Aufwand ist deutlich geringer, als im allgemeinen angenommen wird. In dieser Session moechte der Referent zeigen wie man den zweiten Ansatz mit Hilfe von Werkzeugen aus dem Eclipse- und openArchitectureWare-Umfelds umsetzt. Er gibt einen ueberblick ueber alle Aspekte von MDSD: Metamodellierung, Editorbau, Modellvalidierung, Modell-zu- Modelltransformationen und Codegeneratoren. Ziel ist es, einen ueberblick ueber die verfuegbaren Werkzeuge zu geben.


    24.01.2009 | OOP 2009 | PDF | Abstract
    M. Voelter

    Architektur als Sprache – Architekturmodellierung mittels textueller DSLs

    Diese Session zeigt die Beschreibung von Architekturen (incl. Produktlinien-Variabilitaet) mithilfe domaenenspezifischer Sprachen. Eine Architektur-DSL wird zusammen mit der Architektur definiert: Dadurch erhoeht sich das Verstaendnis der Architektur an sich, außerdem wird die nachgelagerte automatische Verarbeitung von Architekturmodellen ermoeglicht. Um das Ganze moeglichst leichtgewichtig zu halten, wird eine textuelle Syntax (plus Visualisierung) verwendet. Der Ansatz wird/wurde in mehreren Projekten erfolgreich eingesetzt


    24.01.2009 | OOP 2009 | PDF | Abstract
    M. Voelter

    Architekturdokumentation in der Praxis

    Dokumentation ist laestig und ueberfluessig...; naja, nicht wirklich. Vor allem fuer Architekturen, die ueber eine laengere Zeit verwendet werden sollen, ist eine brauchbare und trotzdem nicht zu aufwaendige Dokumentation essentiell. In dieser Session moechte ich auf eine Reihe von Best Practices zur Architekturdokumentation eingehen: Dazu zaehlen strukturierte Glossare, Patterns, Tutorials und FAQs, Diagramme und Modellierung, einige stilistische Aspekte sowie die Verwendung alternativer Kanaele wie Audio und Video.


    03.10.2008 | JAOO 2008 | PDF | Abstract
    M. Voelter

    Six Design Principles Illustrated

    In software development, we're all very much influenced by today's technologies and frameworks. There's a tendency to think about, describe and build systems in a way that's specific to the technologies in use today. However, this has a number of disadvantages wrt. complexity, longevity and maintainability. I think it is essential that, in addition to understanding specific technologies, we also (re)consider a number of basic principles of building software and make sure those principles play a central role in day-to-day development. Over the last years I have been collecting and describing some 40 of those principles. In this session, I will provide a short overview over this collection and then describe six of those principles in more detail, including extensive examples.


    05.11.2008 | W-JAX 2008 | PDF | Abstract
    M. Voelter

    Architektur Als Sprache

    Essentieller Teil des Entwurfs einer Architektur ist die Definition der Architekturkonzepte – praezise und technologieneutral. In dieser Session moechte ich zeigen dass sich dazu die Definition einer formalen Sprache (Grammatik, Constraints, etc.) sehr gut eignet. Die erste Haelfte der Session zeigt ein ausfuehrliches Beispiel, die zweite rekapituliert den Ansatz und zeigt, wie die Architekturdefinitionen automatisiert verifiziert und weiterverarbeitet werden koennen.


    11.11.2008 | prio.conference 2008 | PDF | Abstract
    M. Voelter

    Textuelle DSLs mit Eclipse Xtext

    Verglichen mit grafischen Domaenenspezifischen Sprachen haben textuelle DSLs den Vorteil der nahtlosen Integration mit existierenden Entwicklungsinfrastrukturen (CVS/SVN diff/merge). Diese Session beleuchtet die Erstellung textueller DSLs mit Hilfe der Eclipse Xtext Tools. Ich werde zeigen wie man eine DSL und den zugehoerigen Editor (incl. Syntaxhervorhebung, Code Completion, Error Checking) definiert und die erstellten Modelle weiterverarbeitet ? ein Codegenerator wird C# Code aus dem Modell erstellen.


    11.11.2008 | prio.conference 2008 | PDF | Abstract
    M. Voelter

    Architekturdokumentation in der Praxis

    Dokumentation ist laestig und ueberfluessig… naja, nicht wirklich. Vor allem fuer Architekturen die ueber eine laengere Zeit verwendet werden sollen ist eine brauchbare und trotzdem nicht zu aufwaendige Dokumentation essentiell. In dieser Session moechte ich auf eine Reihe von Best Practices zur Architekturdokumentation eingehen: Dazu zaehlen strukturierte Glossare, Patterns, Tutorials und FAQs, Diagramme und Modellierung, einige stilistische Aspekte sowie die Verwendung alternativer Kanaele wie Audio und Video.


    11.11.2008 | prio.conference 2008 | PDF | Abstract
    M. Voelter

    Architektur Als Sprache

    Essentieller Teil des Entwurfs einer Architektur ist die Definition der Architekturkonzepte – praezise und technologieneutral. In dieser Session moechte ich zeigen dass sich dazu die Definition einer formalen Sprache (Grammatik, Constraints, etc.) sehr gut eignet. Die erste Haelfte der Session zeigt ein ausfuehrliches Beispiel, die zweite rekapituliert den Ansatz und zeigt, wie die Architekturdefinitionen automatisiert verifiziert und weiterverarbeitet werden koennen.


    26.06.2008 | CodeGeneration 2008 | PDF | Abstract
    M. Voelter

    Implementation Technqiues for Domain-Specific Languages

    Domain Specific Languages are a hot topic these days. As usual when something is hot and new, there's great confusion about the concepts and the details and various sub-communities form. In this talk I want to provide an overview over the most important approaches to implementing domain specific languages. I will show examples of each of the approaches. (-) dynamic internal DSLs, where the DSL is embedded in a host language and runtime meta programming is used for implementation. Clearly the most prominent example is Ruby. (-) compiled internal DSLs, where compile time metaprogramming or other language features are used to implement the language. Exampls include Converge and Scala. (-) external DSLs using textual or graphical syntax using a generative or interpretative backend. Examples include the Eclipse/oAW world and tools such as MetaEdit+ Finally I talk about what the concept of Language Workbenches adds to the notion of DSLs and I will illustrate some of this using Intentional's approach to the topic, introducing the idea of projectional editors along the way.


    26.06.2008 | CodeGeneration 2008 | PDF | Abstract
    M. Voelter

    Building Interpreters with EMF, Xtext and Scala

    In model-driven software development, code generation is the primary means of getting from the models to code. However, there are cases when interpretation is the way to go: whenever you want to be able to edit the model at runtime, you'll typically need an interpreter. In this session I will introduce a small framework that supports efficient construction of interpreters. The language syntax is defined using oAW's Xtext, which automatically creates EMF ASTs from a textual syntax. We then build an interpreter for the language using the Scala programming language. The framework is itself constructed using model-driven development techniques and code generation.


    13.03.2008 | QCon London 2008 | PDF | Abstract
    M. Voelter

    External Textual DSLs Made Simple

    External Textual DSLs are a sweet spot in DSL-land: their textual nature allows for simple integration with existing development infrastructures (such as CVS or SVN). Being external, they are not limited by the syntax of a host language and can provide static (compile time) error checking. Traditionally, the drawback of this kind of DSL was that the construction of the grammar and a fancy editor was quite a lot of work. In this session I will briefly talk about the tradeoffs between textual/graphical/internal/external DSLs and then proceed to build a textual DSL, complete with a syntax coloring, code completing and constraint checking editor. We will then look at how to process the program written in the DSL by either writing a compiler (aka code generator) and an interpreter. The goal of the session is to convince the audience that building an external textual DSL is easier and better than working with XML! The examples will use Eclipse TMF/openArchitectureWare tooling.


    17.03.2008 | EclipseCon 2008 | PDF | Abstract
    M. Voelter, Bernd Kolb

    Textual DSLs with Eclipse Modeling

    Model-Driven Software Development is often perceived as coming with a big overhead: developing the DSL (editos, meta models), as well as the backend (transformations and generators) is perceived to be a lot of work. In this session we want to show an extremely lightweight approach for buiding DSLs using TMF's Xtext and M2T's Xpand. Based on a grammar definition, we use Xtext to build a custom editor for a textual DSL. Further customization of the generated editor results in a convenient way of editing textual models. A code generator based on Xpand generates executable code from the textual models. While graphical DSL's à la GMF are useful and valuable, textual DSLs have the advantage that they can be diffed and merged with existing text based tooling (such as CVS or SVN diff/merge) and are perceived by many developers as more agile and pragmatic. In this session we will show that building textual DSLs including convenient editors is a matter of minutes or a few hours.


    17.03.2008 | EclipseCon 2008 | Abstract
    M. Voelter, Bernd Kolb

    Code Generation with M2T Xpand

    This session is an introduction to writing robust and scalable code generators using M2T's Xpand language. We show the basics of the language as well as several best practices and advanced features. These include the use of extension functions to factor out complex expression that are reused at several locatios in the templates. We also show how to use template aspects to build variants of existing templates without invasively changing the original templates definitions. This allows the adaptation of existing generators (such as the one in GMF) to your own needs. Finally, we will look at the tool support that is available for integrating generated and manually written code. The session shows how to generate code from EMF and UML2 models, and explains how to integrate code generation into a modeling workflow defined with the Eclipse Modeling Workflow Engine.


    23.04.2008 | JAX 2008 | PDF | Abstract
    M. Voelter

    Trends in Sprachen 2008

    Der Sprachenmarkt ist wieder in Bewegung. Die Erkenntnis, dass man auch mit tollen Frameworks keine maechtigen Sprachfeatures ersetzen kann rueckt in den Vordergrund. Dieser Talk beleuchtet verschiedene Konzepte, die sich in Sprachen wie C# 3.0, Scala, Ruby, Groovy, Fortress und Erlang finden, darunter funktionale Programmierung, Metaprogrammierung, DSLs und Concurrency mittels Message Passing.


    23.04.2008 | JAX 2008 | PDF | Abstract
    M. Voelter

    20 Grundkonzepte der Softwarearchitektur

    Hypes: Eine neue Technologie wird als Allheilmittel angepriesen. Dabei aendert sich an den zugrundeliegenden Konzepten recht wenig! In diesem Talk werde ich 20 grundlegende Konzepte der Softwarearchitektur vorstellen und erlaeutern, wie diese in verschiedenen (alten und neuen) Technologien und Sprachen zum Einsatz kommen, und wie man damit als Architekt Systeme baut und reviewt.


    23.04.2008 | JAX 2008 | PDF | Abstract
    M. Voelter

    DSL Interpreter mit oAW und Scala

    This session looks at the alternative to code generation in the context of external DSLs: Interpretation. We will briefly construct a textual DSL and then write a nice interpreter for the DSL. The interpreter will be written in Scala. We will also use a model transformation to transform between different languages.


    25.01.2008 | OOP 2008 | PDF | Abstract
    M. Voelter

    Modellgetriebenes Produktlinien-Engineering

    Die Implementierung von Produktlinien mittels Modellgetriebener Softwareentwicklung bietet eine Reihe von Vorteilen gegenueber klassischen Implementierungstechniken. In dieser Session erlaeutere ich diese Vorteile und gehe auf Mechanismen und Techniken ein, um PLE auf Modellebene umzusetzen. Im Mittelpunkt steht dabei die Erstellung von Varianten von Modellen, Transformationen und Generatoren, und die Integration mit Variantenmanagement-Werkzeugen. Ich illustriere die Techniken anhand eines durchgehenden Beispiels mit Tools basierend auf Eclipse und openArchitectureWare.


    25.01.2008 | OOP 2008 | PDF | Abstract
    M. Voelter

    Implementierungstechniken fuer DSLs

    Domaenenspezifische Sprachen sind derzeit ja in aller Munde. Es gibt dabei die verschiedensten Arten von DSLs – eingebettet in Hostsprachen, eigenstaendige Sprachen, compilierte oder interpretierte, solche mit grafische und solche mit textueller Syntax. In dieser Session gehe ich auf diese verschiedenen Arten von DSLs ein und zeige die Vor- und Nachteile der entsprechenden Implementierungstechniken ein.


    25.01.2008 | OOP 2008 | PDF | Abstract
    M. Voelter, Henk Kolk

    Intentional Software - Democratizing Software Creation

    Intentional Software offers a software approach that separates business knowledge from software engineering. Business experts directly contribute using their customary domain knowledge and notation. Capgemini is building a new Pension Workbench that allows pension experts to express their knowledge using a Pension Domain Language that follows closely their customary format and nomenclature. The corresponding applications are generated from generators built by programmers. Programmers concentrate on the job they do the best: creating a clean, reusable and reliable program. Innovation is accelerated as everyone in the creative team has the effective means of expressing their intentions.


    25.09.2007 | JAOO 2007 | PDF | Abstract
    M. Voelter

    Writing Adaptable Software - Mechanisms for Implementing Variabilities in Code and Models

    Managing variability is a major challenge in product line engineering. The commonalities and differences between products must be described accurately, both in the problem space as well as in the solution space. It is also critical to be able to trace variability in the problem space to implementation decisions used to implement that variability in the code. In this session I will illustrate how model-driven and aspect oriented software development help addressing these challenges. Both the problem space and the solution space are described by models, using a model-to-model transformation to map problem space variability to solution space variability. Since models are less detailed than code, it is much easier to implement the variability in solution space models. Tracing can be done between model elements rather than between artifacts. The following techniques will be illustrated: (-) combining modelling languages for customization and configuration (-) using model-to-model transformations to formally describe the mapping from problem space to solution space (-) integrating runtime variability based on models (-) handling traceability on model-level (-) the importance of a powerful platform as a basis for the product line (-) developing families of code generators and model transformations (-) aspect-oriented modelling as a way of defining variants of models (-) using aspect-oriented programming to adapt product code for unexpected variability The approach shown in the tutorial is based on a concrete case study and completely example-driven. Concepts are illustrated with a running example using tools based on Eclipse and openArchitectureWare


    25.06.2007 | TOOLS Europe 2007 | PDF | Abstract
    M. Voelter

    Writing Adaptable Software - Mechanisms for Implementing Variabilities in Code and Models

    Today, a software system is often a member of a system family. Members have many things in common and differ in a set of well-defined respects. These differences are called variabilities and must be implemented in the software system. This tutorial provides an overview over techniques available for implementing such variabilities. Various alternatives exist in programming languages such as preprocessors (as in C/C++), static metaprogramming (e.g. C++ templates), aspect-oriented programming (e.g. AspectJ and CaesarJ), polymorhpism and design patterns (such as Bridge, Strategy or Interceptor), reflection and dynamic metaprogramming (as in Ruby). In addition, variabilities can also be handled in models in the context of model-driven development, for example by connecting structural models with varability models, model weaving and AO techniques for model-to-model and model-to-code transformations. The first part of the tutorial is a discussion of the different kinds of variability as well as notations for describing each form. The second part part will take a look at the different implementation techniques for variabilities in code and in models.


    21.05.2007 | CodeGeneration 2007 | PDF | Abstract
    M. Voelter

    MDSD with Eclipse and oAW

    This session will provide a brief overview of the openArchitectureWare MDSD tool and related Eclipse-based modelling infrastructure such as EMF and GMF. We will look at model verification, code generation as well as model-to-model transformation. Advanced topics, such as building textual and graphical editors, aspect-oriented modelling and variant management on generator level will also be covered. openArchitectureWare is a complete, industry-strength solution for model-driven development. oAW integrates a number of tool components for all aspects of MDSD into a coherent framework. Where possible, it integrates components from other Eclipse-based, MDD-related projects. The evolution of oAW is driven by the needs of developers implementing MDD in actual projects.


    28.05.2007 | INFWEST DSM | PDF | Abstract
    M. Voelter

    Introduction to Model-Driven Software Development

    Model-Driven Software Development is about automatically building software from formal models. In this session I will introduce the topic and motivate why it is necessary. I will show a number of examples and discuss the potential benefits of the approach.


    29.05.2007 | INFWEST DSM | PDF | Abstract
    M. Voelter

    Model-Driven Software Development Best Practices

    This session covers a set of best practices for MDSD exracted from a number of projects in different domains over the last years. This includes topics such as how to integrate generated and manually written code, the role of model-2-model trans- formations, multi-viewpoint modeling an different kinds of concrete syntax.


    06.03.2007 | EclipseCon 2007 | Abstract
    M. Voelter

    Model-to-model transformations using Eclipse tools

    Generating code from a model is a proven technology, and many projects apply it successfully. It is however often useful to transform models in a separate step before the actual generation, e.g. to adapt a single model to one or more existing cartridges at a lower, more technical level of abstraction. This session presents the concepts of model-to-model transformations and introduces xTend, ATL and QVT as existing transformation languages that are part of Eclipse Modeling Project, EMP. XTend is a transformation language provided by the openArchitectureWare code generator framework, ATL is a language which is available in the Model2Model component of the EMP. QVT is a specification created by the OMG. An implementation will also be available in the Model2Model component. Based on an example, we will compare the different languages and their respective strengths and features.


    26.04.2007 | JAX 2007 | PDF | Abstract
    M. Voelter

    Implementierungstechniken fuer domaenenspezifische Sprachen

    Domaenenspezifische Sprachen werden in immer mehr Bereichen eingesetzt. Es gibt dabei eine ganze Bandbreite an Wegen, wie man DSLs implementieren kann. Das reicht von Modellen und Transformatoren ueber Metaprogrammierung zur Compile-Zeit bis zu dynamischer Metaprogrammierung bspw. in Ruby. In dieser Session zeige ich die verschiedenen Ansaetze und erlaeutere Vor- und Nachteile sowie Anwendungsgebiete.


    26.04.2007 | JAX 2007 | PDF | Abstract
    M. Voelter

    Hope Belief and Wizardry - ein zynischer Blick aufs Projektmanagement

    Projektmanagement ist ja so eine Sache. Irgendwie kann's ja jeder, (fast) keiner kann's so richtig. Ich kann es vermutlich auch nicht - aber ich habe viele Projektmanagementversuche miterleben und -erleiden duerfen. In dieser Session habe ich die besten (Anti-)Patterns in dieser Hinsicht zu einer konsistenten Pattern Language zusammengefasst, mit der sich Projekte zielsicher ruinieren lassen.


    26.04.2007 | JAX 2007 | PDF | Abstract
    M. Voelter, Arno Haase, Sven Efftinge

    Textuelle domaenenspezifische Sprachen (DSLs)

    Bei der MDA wird fuer die Erstellung einer Domaenen-spezifischen Sprache (DSL) UML 2 empfohlen. Grafische Modellierungssprachen bringen jedoch eine Reihe von Schwierigkeiten mit sich (z.B. parallele Bearbeitung). Diese Session stellt die verschiedenen Vorteile textueller DSLs vor. Es wird außerdem gezeigt, wie eine textuellen Sprache inklusive Eclipse-Editor erstellt und verwendet werden kann.


    26.04.2007 | JAX 2007 | PDF | Abstract
    M. Voelter

    Funktional Objektorientiert - Einfuehrung in Scala

    Scala ist eine (relativ) neue Programmiersprache, die an der EPFL (Ecole Polytechnique Fédérale de Lausanne) entwickelt wurde. Der Clou ist, dass die Konzepte aus den objektorientierten und funktionalen Welten verbindet. Außerdem laeuft die Sprache auf der JVM und ist weitgehend Java-kompatibel. In dieser Session werde ich die wichtigsten Konzepte von Scala einfuehren und dabei vor allem auf die funktionalen Aspekte eingehen.


    09.10.2006 | DSL Workshop TU Muenchen (Prof. Broy) | PDF | Abstract
    M. Voelter

    Best Practices for DSLs illustrated with Eclipse Tools

    Domain-Specific Languages (DSLs) are an important aspect of Model-Driven Software Developemt, MDA and Product Line Engineering. Since DSLs are specific to a certain domain, it is the domain architect's task to define and implemnet DSLs so that application developers can use the DSLs to configure or otherwise describe systems. Over the years, a number of best practices have evolved with regards to building DSLs. Some of them are relevant for domain architects when defining their DSLs and when building the necessary support infrastructure, some of the best practices concern the people who build the actual frameworks for building DSLs. In this talk I will illustrate a number of these best practices and illustrate them with Open Source tools from Eclipse.org, namely the Eclipse Modeling Framework (EMF), the Graphical Modeling Framework (GMF) and openArchitectureWare. The best practices look at the definition of meta models, model verification, the creation of a textual and graphical concrete syntaxes, model transformation as well as code generation and the integration of generated and non-generated code.


    06.11.2006 | W-JAX 2006 | PDF | Abstract
    M. Voelter, Arno Haase, Sven Efftinge

    Textuelle Domaenen-spezifische Sprachen (DSLs)

    Bei der MDA wird fuer die Erstellung einer Domaenen-spezifischen Sprache (DSL) UML 2 empfohlen. Grafische Modellierungssprachen bringen jedoch eine Reihe von Schwierigkeiten mit sich (z.B. parallele Bearbeitung). Diese Session stellt die verschiedenen Vorteile textueller DSLs vor. Es wird außerdem gezeigt, wie eine textuellen Sprache inklusive Eclipse-Editor erstellt und verwendet werden kann.


    07.11.2006 | W-JAX 2006 | PDF | Abstract
    M. Voelter, Arno Haase, Sven Efftinge

    Modell-Transformationen in der Praxis (Teil 1 und 2)

    Codegenerierung als Mittel fuer modellgetriebene Entwicklung kommt inzwischen in vielen Projekten erfolgreich zum Einsatz. Oft ist es zusaetzlich nuetzlich, Modelle vor der Generierung zunaechst zu transformieren, zum Beispiel um sie an vorhandene Templates anzupassen. Dieser erste Teil der Session stellt die Konzepte vor und fuehrt in QVT und xTend als konkrete Transformationssprachen ein. Nachdem der erste Teil die allgemeinen Grundlagen zu Modelltransformationen gelegt hat, vergleichen wir im zweiten Teil die unterschiedlichen Transformationssprachen anhand eines konkreten Beispiels. Dabei zeigen wir, welche Sprachfeatures in welchen Situationen sinnvoll sind und fuer welche Probleme die jeweilige Sprache sinnvoll ist. Teil 2 setzt den Besuch von Teil 1 nicht zwingend voraus.


    08.11.2006 | W-JAX 2006 | PDF | Abstract
    M. Voelter

    Warum SOA erst mit MDSD richtig Sinn macht

    SOA - wieder eine Technologie, die einfach alle Enterprise-Software-Probleme loest. Wie ueblich ist das in der Praxis aber nicht so einfach ... Aus meiner Sicht und Erfahrung lassen sich die Vorteile von SOA (Integrierbarkeit, Rekombinierbarkeit, Skalierbarkeit) erst mit Model Driven Software Development so richtig verwirklichen. In dieser Session moechte ich diese Zusammenhaenge aufzeigen.


    20.01.2007 | OOP 2007 | PDF | Abstract
    M. Voelter

    SOA und MDSD

    SOA - wieder eine Technologie, die einfach alle Enterprise-Software-Probleme loest. Wie ueblich ist das in der Praxis aber nicht so einfach ... Aus meiner Sicht und Erfahrung lassen sich die Vorteile von SOA (Integrierbarkeit, Rekombinierbarkeit, Skalierbarkeit) erst mit Modellgetriebener Entwicklung so richtig realisieren. In dieser Session moechte ich diese Zusammenhaenge aufzeigen - und dabei helfen, SOA etwas klarer zu definieren. Verschiedene Best Practices im Zusammenhang mit SOAs werden erlaeutert. Außerdem werde ich kurz auf den neuen SOA-Standard SCA (Service Component Architecture) eingehen, da dieser einige der erlaeuterten Ideen umsetzt.


    20.01.2007 | OOP 2007 | PDF | Abstract
    M. Voelter

    Modellgetriebene Entwicklung von Eingebetteten Systemen

    Modellgetriebene Entwicklung ist in eingebetteten Systemen nichts revolutionaer Neues. Zustandsautomaten oder Regelungsalgorithmen werden bereits seit einiger Zeit modellbasiert implementiert. In der juengeren Vergangenheit wird MDSD aber immer mehr zum zentralen Eckpfeiler der Entwicklung eingebetteter Systeme. In diesem Talk gebe ich einen ueberblick, warum sich MDSD ins- besondere fuer die Entwicklung komplexer eingebetteter Systeme eignet. Ein zentraler Gesichtspunkt ist dabei, dass man mittels MDSD zusaetzliche Abstraktionsschichten einziehen kann, ohne dass dies zu Laufzeitoverhead fuehrt. Weiterhin gehe ich auf die Synergien von MDSD und komponentenbasierten Systemen, auf die Analyse und Abbildung von Variabilitaeten, sowie auf die anwendungsspezifische Anpassung von technischen Infrastrukturen ein. Die Konzepte werden anhand verschiedener Beispiele unter anderem aus der Automobilindustrie illustriert.


    20.01.2007 | OOP 2007 | PDF | Abstract
    M. Voelter

    Generieren vs. Interpretieren – Die andere Seite von MDSD

    Unter Modellgetriebener Softwareentwicklung (MDSD) versteht man heutzutage hauptsaechlich die Erzeugung von Quellcode aus Modellen. Alternativ oder auch ergaenzend zum reinen Generieren von Artefakten laesst sich das Modell – oder ein Teil davon – aber auch zur Laufzeit interpretieren. Der Vortrag zeigt wann welcher Ansatz sinnvoll ist und wie sich die beiden Alternativen kombinieren lassen. Beispiele aus der Projektpraxis illustrieren die Konzepte.


    20.01.2007 | OOP 2007 | PDF | Abstract
    M. Voelter

    Podcasting 101 – Eine uebersicht aus Sicht von Hoerer und Produzent

    Podcasting, also die Publikation von MP3s mittels RSS-Feeds, hat in den vergangenen 18 Monaten deutlich an Bedeutung gewonnen. Podcasts gibt es zu den verschiedensten Themen, und es werden teils bereits signifikante Zuhoererzahlen erreicht. In dieser Session gebe ich einen ueberblick ueber das Thema aus Sicht des Hoerers und des Produzenten. Hoerer-Themen sind: welche Podcasts gibt es? Wie finde ich sie? Welche Tools brauche ich? Themen fuer Produzenten sind u.a.: Aufnahme, Hardware, Lizensierung und Copyright, Editing sowie Hosting


    19.10.2006 | Model-Driven Development and Product Lines - Synergies and Experience | PDF | Abstract
    M. Voelter

    Steigerung der Softwarequalitaet durch modellgetriebene Entwicklung

    Neben der Steigerung der Entwicklungseffizienz hat die modellgetriebene Entwicklung (Model Driven Software Development, kurz MDSD) insbesondere positive Auswirkungen auf die Qualitaet des entwickelten Systems. Dabei wirken sich verschiedene Effekte aus. Um Generatoren bauen zu koennen, muss die Architektur des zu erstellenden Systems klar definiert sein, sonst wird der Generator zu komplex. Der Vorgang des Generatorbauens zwingt einen also dazu, wichtige Architekturentscheidungen systematisch anzugehen. Durch die automatisierte Implementierung großer Codeanteile verringert sich die Anzahl der Zufallsfehler im Code (ein Generator macht etwas entweder immer richtig oder immer falsch). Durch die stets gleiche Umsetzung bestimmter Konstrukte im Code lassen sich Aussagen ueber Wartbarkeit, Performanz oder Skalierbarkeit leichter einhalten. In großen Teams laesst sich mit MDSD die Umsetzung der Architektur steuern und kontrollieren. Architektur wird zum ausfuehrbaren Artefakt und nicht nur zur Dokumentation und Vorgabe. Der Vortrag greift diese Punkte auf und konkretisiert sie anhand von komponentenbasierter und serviceorientierter Architekturen.


    12.10.2006 | Eclipse Summit 2006 | Abstract
    M. Voelter, Ed Merks, Rich Gronback, Bernd Kolb

    What's new in Eclipse Modeling

    The Eclipse Modeling Project focuses on the evolution and promotion of model-based development technologies within the Eclipse community by providing a unified set of modeling frameworks, tooling, and standards implementations. This presentation will explore the content and future plan for this project and its components, with a particular focus on GMF. The Eclipse Graphical Modeling Framework (GMF) provides a generative component and runtime infrastructure for developing graphical editors based on EMF and GEF. An overview of this project?s history, current release, and future plans will be presented, along with a demonstration of how GMF will be bringing UML2 diagramming to Eclipse. The Eclipse Modeling Framework (EMF) provides Ecore as a model for describing models. Other model forms such as XML Schema, UML2, and annotated Java can be mapped to Ecore and vice versa, concretely demonstrating that all these model forms are effectively equivalent, not just at an abstract level, but in a real and very useful sense. During the Callisto development cycle, EMF introduced an exporter framework to compliment the existing importer framework so that additional model conversions can be plugged in. EMF also improved its XML Schema -> Ecore mapping and its Ecore -> XML Schema mapping, so that it's now the case that Ecore -> XML Schema -> Ecore, Ecore -> UML2 -> Ecore, and Ecore -> Java -> Ecore are all round trips. This allows clients to focus on whichever model form they prefer or have available as their as their primary model and allows multiple model forms to be used interchangeably since any one can be generated from any other with Ecore acting as the hub. This presentation will focus primarily on demonstrating the tools in action to give a flavor for how EMF can be used in your day to day development work. Modeling isn't just for modelers anymore. The Eclipse Modeling Project also contains a Model-to-Text generator component. An initial contribution to this component will be openArchitectureWare (oAW), a toolkit for model-driven development currently hosted as part of the Eclipse GMT project. In this talk, Bernd and Markus will introduce openArchitectureWare with a particular focus on the code generation aspect of the tool. We will also take a brief look at other parts of oAW, namely, the model transformation language, the extension facility, constraint checks, the workflow engine and the recipe framework.


    04.10.2006 | JAOO 2006 | PDF | Abstract
    M. Voelter

    Best Practices for Building DSLs illustrated with Eclipse Tools

    Domain-Specific Languages (DSLs) are an important aspect of Model-Driven Software Developemt, MDA and Product Line Engineering. Since DSLs are specific to a certain domain, it is the domain architect's task to define and implemnet DSLs so that application developers can use the DSLs to configure or otherwise describe systems. Over the years, a number of best practices have evolved with regards to building DSLs. Some of them are relevant for domain architects when defining their DSLs and when building the necessary support infrastructure, some of the best practices concern the people who build the actual frameworks for building DSLs. In this talk I will illustrate a number of these best practices and illustrate them with Open Source tools from Eclipse.org, namely the Eclipse Modeling Framework (EMF), the Graphical Modeling Framework (GMF) and openArchitectureWare. The best practices look at the definition of meta models, model verification, the creation of a textual and graphical concrete syntaxes, model transformation as well as code generation and the integration of generated and non-generated code.


    09.05.2006 | Fraunhofer Workshop IT-Produktivitaet | Abstract
    M. Voelter

    Softwarequalitaetssteigerung durch Einsatz Modellgetriebener Entwickung

    Neben der Steigerung der Entwicklungseffizienz hat Modellgetriebene Entwicklung insbesondere positive Auswirkungen auf die Qualitaet des entwickelten Systems. Dabei wirken sich verschiedene Effekte aus. Um Generatoren bauen zu koennen, muss die Architektur des zu erstellenden Systems klar definiert sein, sonst wird der Generator zu komplex. Der Vorgang des Generatorbauens zwingt einen also dazu, wichtige Architekturentscheidungen systematisch anzugehen. Durch automatisierte Implementierung großer Codeanteile verringert sich die Anzahl der Zufallsfehler im Code (ein Generator macht etwas entweder immer richtig oder immer falsch) Durch die immer gleiche Umsetzung bestimmter Konstrukte im Code lassen sich Aussagen ueber Wartbarkeit, Performanz oder Skalierbar- keit leichter einhalten. In großen Teams laesst sich mit MDSD die Umsetzung der Architektur steuern und kontrollieren. Architektur wird zum ausfuehrbaren Artefakt und nicht nur zur Dokumentation und Vorgabe. In diesem Talk moechte ich auf diese Punkte eingehen und anhand von Komponentenbasierten und Serviceorientierten Architekturen konkretisieren.


    18.04.2006 | ASQF | Abstract
    M. Voelter, Arno Haase, Sven Efftinge

    Modellgetriebene Softwareentwicklung mit openArchitectureWare 4

    Modellgetriebene Softwareentwicklung (MDSD) nimmt in der Praxis einen immer groeßeren Stellenwert ein - es verlaesst die Nische des Besonderen langsam aber sicher. Dazu tragen insbesondere auch die immer ausgereifteren Werk- zeuge bei. Eines davon ist sicherlich openArchitectureWare. In diesem Vortrag moechte ich kurz auf das Prinzip von MDSD eingehen und dann zeigen wie es mit openArchitectureWare umgesetzt wird. Dabei werde ich auf Metamodellierung, Modellvalidierung, Modell-zu-Modelltransformation und Codegenerierung eingehen.


    10.05.2006 | Eclipse Forum Europe 2006 | PDF | Abstract
    M. Voelter, Sven Efftinge, Bernd Kolb

    Model-Driven Development - From Frontend to Code

    Model Driven Development is not just about code generation. In fact, coming up with good graphical or textual editors for your DSL is a major challenge. However, using tools such the Eclipse Graphical Modelling Framework as well as the openArchitectureWare textual editor generator this is now changing. This session shows these two components in action. After developing an editor for a DSL we will now extend this example by developing transformers and code generators for the models built using the editors. We will also add live validation functionality to the editors. This closes the chain from frontend to code; an example for a complete Open Source MDSD tool chain.


    10.05.2006 | JAX 2006 | PDF | Abstract
    M. Voelter

    Warum SOA erst mit Model Driven Development richtig Sinn macht

    SOA - wieder eine Technologie, die einfach alle Enterprise-Software-Probleme loest. Wie ueblich ist das in der Praxis aber nicht so einfach ... Aus meiner Sicht und Erfahrung lassen sich die Vorteile von SOA (Integrierbarkeit, Rekombinierbarkeit, Skalierbarkeit) erst mit Model Driven Development so richtig verwirklichen. In dieser Session moechte ich diese Zusammenhaenge aufzeigen - und dabei helfen, SOA etwas klarer zu definieren. Außerdem werde ich auf den neuen SOA-Standard SCA (Service Component Architecture) eingehen.


    10.05.2006 | JAX 2006 | PDF | Abstract
    M. Voelter

    Abbildung von Variabilitaeten in Softwaresystemen

    Beim Bau von Softwaresystemfamilien, Produktlinien oder Frameworks werden Komponenten fast nie eins zu eins wiederverwendet, sondern in leicht abgewandelter Form. Diese Variabilitaeten muessen im System (also letztlich im Quellcode) vernuenftig abgebildet werden. In dieser Session werden verschiedene Moeglichkeiten aufgezeigt, wie man dies bewerkstelligt, vom einfachen Praeprozessor ueber Patterns bis hin zu AOP (AspectJ und CAESAR/J).


    10.10.2005 | Java User Group Switzerland | PDF | Abstract
    M. Voelter

    MDSD - Some Best Practices

    Die Verwendung von MDA wie sie im Buche steht ist heutzutage mangels Tools noch nicht so ohne weiteres moeglich. Diese Session wird daher basierend auf der Erfahrung mehrerer Projekte in verschiedenen Domaenen eine kleine Sammlung essentieller Do's and Don'ts vorstellen, die die praktische Arbeit mit MDA ermoeglichen. Dazu zaehlen u.a. kaskadierende Domaenenarchitekturen, Aspektorientierte Modellierung, Arbeit im Team und Versionierung sowie einige Aspekte der Toolauswahl.


    19.01.2006 | OOP 2006 | PDF | Abstract
    M. Voelter

    MDSD Advanced – Fortgeschrittene Aspekte der Modellgetriebenen Entwicklung

    Die Grundlagen modellgetriebener Softwareentwicklung sind inzwischen weithin bekannt und diskutiert. Ich moechte daher in dieser Session auf einige weiterfuehrende Themen eingehen. Diese umfassen: Architekturmetamodellierung und kaskadierte MDSD, Modell-zu-Modell-Transformationen, MDSD und AOSD, Variantenmanagement in MDSD Projekten, Anbindung von Nicht-UML-Editoren sowie die Beziehung von MDSD zu modernen Plattformen wie z.B. Spring. Die Themen werden anhand von praktischen, aus Projekten extrahierten Beispielen illustriert.


    18.01.2006 | OOP 2006 | PDF | Abstract
    M. Voelter

    Languages, Models, Factories - wie das alles zusammenpasst

    In der letzten Zeit haben sich alle moeglichen neuen Ansaetze zur Softwareentwicklung entwickelt; dazu zaehlen: Modellgetriebene Softwareentwicklung und MDA, Domain-Specific Languages (DSLs), Language-Oriented Programming (LOP), Software Factories und – schon etwas laenger her – Generative Programmierung und Domain- Specific Modeling. All diese Ansaetze haben eine ganze Menge gemeinsam, aber auch einige – teils wichtige – Unterschiede in Fokus, Scope und Ansatz. In dieser Session werde ich die gemeinsamen Grundkonzepte erlaeutern und dann fuer jeden der betreffenden Ansaetze die spezifischen Merkmale erlaeutern.


    18.11.2005 | W-JAX 2005 | Abstract
    M. Voelter

    Modellgetriebene Entwicklung von A-Z

    Im Rahmen modellgetriebener Projekte sieht man sich einer ganzen Reihe weiterer Herausforderungen als der reinen Frage ausgesetzt, welchen Generator man wie verwendet. Wir wollen in dieser Session auf diese Themen eingehen, und zwar basierend auf konkreten Fragen aus dem Publikum. Um die Erlaeuterung der Antworten besser vorbereiten zu koennen, bitten wir die Teilnehmer, uns die Fragen vorher zukommen zu lassen.


    18.11.2005 | W-JAX 2005 | PDF | Abstract
    M. Voelter

    Modellgetriebene Softwareentwicklung als Architekturkatalysator in Projekten

    Modellgetriebene Entwicklung hat einen sehr willkommenen Nebeneffekt - naemlich den, die Architektur eines Systems zu verbessern, weil man gezwungen wird, explizit darueber nachzudenken, Metamodelle zu definieren, und außerdem durch Generatoren die Umsetzung vereinfacht wird. Diese Session zeigt - u.a. anhand von Erfahrungsberichten - wie MDSD helfen kann, das Thema Architektur greifbar zu machen.


    18.11.2005 | W-JAX 2005 | PDF | Abstract
    M. Voelter

    Eine Kritische Betrachtung von Softwarearchitektur

    Softwarearchitektur ist heute ueberall, jeder Entwickler ist ein Architekt. Der J2EE-Technologieexperte ist der J2EE Architect, der Zustaendige fuer Security der Security Architect. Systeme haben eine J2EE-Archiektur und MDA will sogar Architekturen aus Modellen erstellen ... Was ist denn nun Softwarearchitektur wirklich? Auf was kommt es denn tatsaechlich an? Ist die Aussage, dass man J2EE verwendet, ausreichend, um die Architektur zu beschreiben? Diesen und aehnlichen Fragen soll sich diese Session widmen: Was macht gute Softwarearchitekturen aus? Wie kommt man zu einer fuer ein System passenden Architektur? Wie haelt man technologische Aspekte so lange als moeglich heraus? Was ist die Rolle von Modellen im Kontext von Softwarearchitekturen? Wie wichtig (oder wie schaedlich) sind Standards im Rahmen des Softwarearchitektur? Schlussendlich wird diese Session Hinweise darauf geben, wie man eine Softwarearchitektur im Projektalltag am Leben haelt.


    25.09.2005 | JAOO 2005 | PDF | Abstract
    M. Voelter

    The Role of Patterns in Modern Software Engineering

    Patterns have been a hype a while ago - nowadays they are simply a powerful tool developers use without making a fuss about it. However, even in today's hypes, patterns play an important role! Classic Design Patterns are used to help implementing some of the newer technologies such as MDSD or AOSD and the pattern form is used to describe best practices in working with such technologies. Software Architecture and Frameworks also have strong connections to patterns - patterns for distributed systems, component architectures describe complete middleware approaches in an accessible way. Modelling tools provide wizards that implement patterns. Mainstream technologies are described using the pattern form (at Sun and Microsoft, for example). This session provides insights into how patterns relate to other technologies, the role they play in today's software engineering landscape and why your should start writing patterns in your own organisation.


    15.06.2005 | iX Eclipse Konferenz 2005 | PDF | Abstract
    M. Voelter

    Modellgetriebene Entwickung mit Eclipse

    Modellgetriebene Entwicklung ist ein in der Praxis immer wichtiger werdendes Thema. Es geht darum, aus domaenenspezifischen Modellen lauffaehige Soft- ware zu erstellen. Dazu sind verschiedene Tools - Generatoren, Transformatoren, Editoren - notwendig. Im Rahmen des Eclipse Projektes gibt es verschiedene Projekte die sich in diesem Umfeld bewegen; diese Session gibt einen ueberblick ueber diese. Dabei gehe ich unter anderem auf EMF, GEF, MDDi, GMF, GMT und openArchitectureWare ein, ordne die Projekte in einen Gesamtzusammenhang und beleuchte deren Praxistauglichkeit.


    27.09.2005 | JAOO 2005 | PDF | Abstract
    M. Voelter

    Using DSLs in Practice - Benefits and Challenges

    Domain Specific Languages (DSLs) form an integral part of many current and upcoming software development para- digms such as Model-Driven Software Development, MDA, Software Factories, Generative Programming and Language- Oriented Programming. DSLs are use to express domain concepts, structures and behaviour in a much more concise and effective manner that general purpose languages could. While DSLs are a powerful tool for the software developer, using them in practice also poses a set of challenges with regards to editor availability, language integration and evolution, team skill and project organization. This session introduces DSLs in general, shows a couple of real-world examples and explaines when DSLs are appropriate to use. The session also looks at the stuff around DSLs that is needed to use them efficiently, namely patterns and frameworks. Finally, we explore the advantages and challenges associated with using DSLs. This includes technical as well as non-technical issues, such as those mentioned above.


    07.06.2005 | OMG Information Days (Frankfurt) | PDF | Abstract
    M. Voelter

    Real-World MDA Distilled - Best Practices

    Die Verwendung von MDA wie sie im Buche steht ist heutzutage mangels Tools noch nicht so ohne weiteres moeglich. Diese Session wird daher basierend auf der Erfahrung mehrerer Projekte in verschiedenen Domaenen eine kleine Sammlung essentieller Do's and Don'ts vorstellen, die die praktische Arbeit mit MDA ermoeglichen. Dazu zaehlen u.a. kaskadierende Domaenenarchitekturen, Aspektorientierte Modellierung, Arbeit im Team und Versionierung sowie einige Aspekte der Toolauswahl.


    09.06.2005 | OMG Information Days (Muenchen) | PDF | Abstract
    M. Voelter

    Real-World MDA Distilled - Best Practices

    Die Verwendung von MDA wie sie im Buche steht ist heutzutage mangels Tools noch nicht so ohne weiteres moeglich. Diese Session wird daher basierend auf der Erfahrung mehrerer Projekte in verschiedenen Domaenen eine kleine Sammlung essentieller Do's and Don'ts vorstellen, die die praktische Arbeit mit MDA ermoeglichen. Dazu zaehlen u.a. kaskadierende Domaenenarchitekturen, Aspektorientierte Modellierung, Arbeit im Team und Versionierung sowie einige Aspekte der Toolauswahl.


    17.06.2005 | ObjektForum Entwicklertag | PDF | Abstract
    M. Voelter

    Modellgetriebene Softwareentwicklung - ein paar Tips fuer die Praxis

    Die Verwendung von MDA wie sie im Buche steht ist heutzutage mangels Tools noch nicht so ohne weiteres moeglich. Diese Session wird daher basierend auf der Erfahrung mehrerer Projekte in verschiedenen Domaenen eine kleine Sammlung essentieller Do's and Don'ts vorstellen, die die praktische Arbeit mit MDA ermoeglichen. Dazu zaehlen u.a. kaskadierende Domaenenarchitekturen, Aspektorientierte Modellierung, Arbeit im Team und Versionierung sowie einige Aspekte der Toolauswahl.


    09.10.2005 | ICALEPCS 2005 | PDF | Abstract
    M. Voelter

    Model-Driven Development of Distributed Systems

    Distributed Systems are becoming more and more complex, many are distributed systems using various networking or bus technologies. Often developed in the context of software system families, they capture lots of domain and architectural knowledge. To manage the complexity of such systems, software architecture – specifically, middleware – gets more and more important. Model-Driven Software Development (MDSD) provides a means to develop distribution middleware that efficiently uses memory, bandwidth and performance resource while at the same time making development more effective, and supporting a consistent family architecture. This tutorial provides a pragmatic introduction to MDSD and shows how it can be applied to distributed systems. An introduction, a set of best practices as well as a case study form the main parts of the tutorial.


    10.05.2005 | JAX 2005 | PDF | Abstract
    M. Voelter, Bernd Kolb

    Generierung grafischer Eclipse-Editoren mit GEF

    Das Eclipse Graphical Editing Framework (GEF) ist ein Framework fuer zweidimensionale Graphen wie z.B. UML-Diagramme oder Statecharts, mit dem sich nach dem MVC Pattern Editoren erstellen lassen. Allerdings sind diese Editoren ohne weitere Abstraktion relativ aufwendig zu erstellen. Mithilfe von modellgetriebener Softwareentwicklung lassen sich solche Editoren sehr einfach generieren.


    10.05.2005 | JAX 2005 | PDF | Abstract
    M. Voelter

    Modelle und Aspekte - MDSD und AOP gemeinsam verwenden

    Modellgetriebene Entwicklung und aspektorientierte Programmierung sind zwei Ansaetze, die in den letzen Jahren an Bedeutung gewonnen haben, aufgrund der guten Tool-Unterstuetzung vor allem im Java-Umfeld. Viele Entwickler fragen sich, wann man MDSD und wann man AOP verwenden sollte. Diese Session liefert die dazu noetigen Informationen. Zunaechst werden die grundlegenden Gemeinsamkeiten sowie die entscheidenden Unterschiede zwischen MDSD und AOP beleuchtet sowie die jeweiligen Vor- und Nachteile in bestimmten Anwendungsfaellen herausgearbeitet. In einem zweiten Teil wird erlaeutert, wie MDSD und AOP sinnvoll gemeinsam verwendet werden koennen: Es werden Best Practices vorgestellt, inwiefern AOP in MDSD-Projekten eine sinnvolle Ergaenzung sein kann.


    10.05.2005 | JAX 2005 | PDF | Abstract
    M. Voelter

    Modellgetriebene Entwicklung - Fortgeschrittene Konzepte

    Die Grundideen modellgetriebener Softwareentwicklung haben sich in den letzten Jahren bewaehrt und etabliert. Darauf aufbauend zeigt diese Session fortgeschrittenere Konzepte, die in der Praxis in groeßeren modellgetriebenen Projekten zum Einsatz kommen. Dazu zaehlen die Generierung aus mehreren Modellen (aspektorientierte Modellierung), Partitionierung der Modelle in Teilmodelle, Verwendung von Nicht-UML-Modellen als Eingabesprache, Aufbau von Generator-Familien, Integration von AOP in MDSD, Trennung von Aspekten im Metamodell, einfache Modelltransformationen. Saemtliche Ansaetze werden anhand des Open-Source-Tools openArchitectureWare praktisch gezeigt.


    10.05.2005 | JAX 2005 | PDF | Abstract
    M. Voelter

    Eine Kritische Betrachtung von Softwarearchitektur

    Softwarearchitektur ist heute ueberall, jeder Entwickler ist ein Architekt. Der J2EE-Technologieexperte ist der J2EE Architect, der Zustaendige fuer Security der Security Architect. Systeme haben eine J2EE-Archiektur und MDA will sogar Architekturen aus Modellen erstellen ... Was ist denn nun Softwarearchitektur wirklich? Auf was kommt es denn tatsaechlich an? Ist die Aussage, dass man J2EE verwendet, ausreichend, um die Architektur zu beschreiben? Diesen und aehnlichen Fragen soll sich diese Session widmen: Was macht gute Softwarearchitekturen aus? Wie kommt man zu einer fuer ein System passenden Architektur? Wie haelt man technologische Aspekte so lange als moeglich heraus? Was ist die Rolle von Modellen im Kontext von Softwarearchitekturen? Wie wichtig (oder wie schaedlich) sind Standards im Rahmen des Softwarearchitektur? Schlussendlich wird diese Session Hinweise darauf geben, wie man eine Softwarearchitektur im Projektalltag am Leben haelt.


    01.03.2005 | EclipseCon 2005 | PDF | Abstract
    M. Voelter, Michael Rudorfer

    Domain-specific IDEs in embedded automotive software

    This session outlines how Eclipse is used by BMW Car IT for prototyping of embedded, component based software. Based on the AUTOSAR middleware standard, Eclipse is used for building models (using GEF), for managing modules and dependencies as well as for editing, debugging and generating code for the OSEK target platform.


    30.11.2004 | openArchitecture 2004 | PDF | Abstract
    M. Voelter

    Best Practices Modellgetriebener Softwareentwicklung

    Die Ideen der MDA sind ja durchaus derart revolutionaer, dass es noch eine ganze Weile dauern wird, bis MDA in voller Pracht zur Verfuegung steht. Man kann aber durchaus heutzutage schon modellgetrieben Software entwickeln. Um Entwicklern den Start zu erleichtern, erlaeutert diese Session eine Reihe von Best Practices fuer Modellgetriebene Softwareentwicklung. Sie geht dabei auf Prozessthemen, Tools, Domaenenmodellierung, Multi-Modell-Modellierung sowie Design- /Generierungstechniken, Testen und Versionierung ein. Abgerundet wird die Session durch eine Einordnung und Vergleich der verschiedenen Geschmacksrichtungen modellgetriebener Entwicklung.


    27.01.2005 | OOP 2005 | PDF | Abstract
    M. Voelter

    Best Practices Modellgetriebener Softwareentwicklung

    MDD und insbesondere MDA ist ja ein noch recht junges Thema. Nichts desto trotz liegt aus verschiedenen Projekten bereits eine ganze Menge Erfahrung vor. Dieser Talk moechte einen Teil dieser Erfahrung in Form von Best Practices weitergeben, um den Einstieg in das Thema zu erleichtern und Anfaengerfehler vermeiden zu helfen. Ich gehe dabei auf die folgenden Aspekte ein: Entwicklungsprozess, Toolerstellung/-auswahl, Domaenenarchitektur und DSL-Erstellung, Codegenerierung, Multi-Modell-Modellierung sowie Testen und Versionierung. Die erl?uterten Konzepte werden mittels Open Source Werkzeugen illustriert.


    25.01.2005 | OOP 2005 | PDF | Abstract
    M. Voelter

    MDSD - Einfuehrung und Ueberblick

    Modellgetriebene Entwicklung ist in aller Munde. Allerdings gibt es verschiedenste Vorstellung davon was sich hinter dem Begriff verbirgt. Diese Session soll das Begriffschaos etwas lichten, Begriffe definieren und Vorurteile beseitigen. Neben der Erlaeuterung zentraler Konzepte wie Domaenenspezifischer Sprachen und Metamodellierung werde ich auf die Rolle von Codegenerierung, UML, Frameworks, Middleware und Komponentenorientierung sowie Aspektorientierung eingehen. Um einen Ueberblick ueber den MDD Track zu geben, werde ich bei den entsprechenden Themen auf weitere Talks dieses Tracks hinweisen.


    21.09.2004 | JAOO 2004 | PDF | Abstract
    M. Voelter

    Introduction to Domain-Driven Development Track


    21.09.2004 | JAOO 2004 | PDF | Abstract
    M. Voelter

    Model-Driven Software Development - Best Practices

    Model-Driven Software Development (MDSD) aims at generating code from models defined in a domain-specific (modelling) language. While this approach is far from mainstream, it has been used very successfully in many instances. This talk presents a collection of best practices for MDSD. These cover development process aspects, development and integration of tools, as well as general tips and tricks for successful MDSD.


    15.06.2004 | iX Eclipse Konferenz | Abstract
    M. Voelter

    Geschaeftsanwendungen im Automotive-Bereich

    Im Rahmen eines Projekts im Automotive-Bereich kam Eclipse 2.1 als Basis fuer den Rich Client einer J2EE-Anwendung zum Einsatz. Dieser Praxisbericht skizziert die technischen, organisatorischen und politischen Erfahrungen, die die 25 Entwickler in diesem fuer den Kunden aeusserst wichtigen Projekt mit Eclipse machten.


    13.05.2004 | JAX 2004 | Abstract
    M. Voelter

    Best Practices Modellgetriebener Softwareentwicklung

    Die Ideen der MDA sind ja durchaus derart revolutionaer, dass es noch eine ganze Weile dauern wird, bis MDA in voller Pracht zur Verfuegung steht. Man kann aber durchaus heutzutage schon sehr modellgetrieben Software entwickeln. Um Entwicklern den Start zu erleichtern, erlaeutert diese Session eine Reihe von Best Practices fuer Modellgetriebener Softwareentwicklung. Sie geht dabei auf Prozessthemen, Tools, Domaenenmodellierung, Multi-Modell-Modellierung sowie Design-/Generierungstechniken, Testen und Versionierung ein. Abgerundet wird die Session durch eine Einordnung und Vergleich der verschiedenen Geschmacksrichtungen Modellgetriebener Entwicklung.


    13.05.2004 | JAX 2004 | PDF | Abstract
    M. Voelter, Uwe Zdun

    Patterns fuer Remoting-Infrastrukturen

    Remoting Middleware stellt den Backbone vieler Anwendungen in den verschiedensten Einsatz- gebieten dar. Es gibt eine gro?e Anzahl verschiedenster Implementierungen, wie z.B. DCE-RPC, Java RMI, CORBA, DCOM, .NET Remoting, Webservices, etc. Allerdings bauen alle diese Systeme auf denselben Patterns auf. Diese Session zeigt die grundlegenden Patterns von Remoting-Middleware auf. Beleuchtet werden die grundlegenden Bausteine, Erweiterungsmoeglichkeiten, Lifecycle-Management und Asynchrone Aufrufe. Teil 2 der Session erlaeutert Beispiele fuer die Patterns aus den Bereichen CORBA, .NET Remoting und Webservices.


    01.07.2004 | SIEMENS Workshop on Product-Line Engineering | PDF | Abstract
    M. Voelter

    Model-Driven Development - Best Practices

    Modellgetriebene Softwareentwicklung ist zwar nichts grundsaetzlich Neues, hat aber durch die MDA Initiative der OMG schlagartig an Bekanntheit gewonnen. Im Kern geht es dabei darum, basierend auf domaenenspezifischen Modellen moeglichst automatisiert Anwendungen im Rahmen einer Softwaresystemfamilie zu erstellen. Die dazu noetigen Techniken umfassen Metamodellierung und Modellierung, Codegenerierung, Modelltransformationen sowie Produktlinienarchitekturen. Nicht alle diese Techniken sind aber heute schon in zufrieden stellendem Umfang in der Praxis einsetzbar pragmatische Ansaetze sind gefragt. Dieser Vortrag geht auf einige Best Practices modellgetriebener Softwareentwicklung ein. Adressiert werden dabei vier Bereiche: Softwareentwicklungsprozess, Domaenenmodellierung, Tools sowie allgemeine Techniken. Der Vortrag stuetzt sich dabei auf eine in Arbeit befindliche Pattern-Sammlung.


    22.01.2004 | OOP 2004 | PDF | Abstract
    M. Voelter

    GUI Entwicklung mit Eclipse

    Die Eclipse Plattform stellt eine gute Basis fuer die Entwicklung von Rich-Clients dar. Dabei kann es sich nicht nur um IDE-artige Clients handeln sondern um beliebige Anwendungen. Im Rahmen der Session wird sowohl auf die Programmierung mit der SWT Bibliothek eingegangen als auch auf die Programmierung von Eclipse-Plugins. Weiterhin wird verdeutlicht, wie einige der GoF Design Patterns die Oberflaechenentwicklung deutlich vereinfachen koennen. Ein kleines GUI Framework implementiert diese Patterns fuer die Eclipse-Plattform. Auch auf das Testen von GUI-Anwendungen wird im Rahmen der Session eingegangen.


    22.01.2004 | OOP 2004 | PDF | Abstract
    M. Voelter

    Metamodellierung

    Im Rahmen modellgetriebener Entwicklung und der MDA spielt die Metamodellierung eine entscheidende Rolle. Metamodellierung beschreibt die Modellierung von Modellierungssprachen. Sie ist damit die Grundlage fuer effektive, domaenenspezifische Modellierung, architekturzentrierte Entwicklung Modellvalidierung sowie Codegenerierung. Diese Session erl?utert die grundlegenden Konzepte hinter der Metamodellierung, beschreibt, wie diese mit UML umgesetzt werden kann und gibt au?erdem konkrete Ratschl?ge, wie metamodellbasierte Modellvalidierung und Codegenerierung umgesetzt werden kann.


    22.01.2004 | OOP 2004 | PDF | Abstract
    M. Voelter, Nicolai Josuttis, Jutta Eckstein, Frank Westphal

    Fit, Agil und Eclipse ? Ein Erfolgsbericht


    30.09.2003 | OMG Web Days | Abstract
    M. Voelter

    J2EE und .NET - ein Vergleich


    23.09.2003 | ICWS'03 | PDF | Abstract
    M. Voelter, Uwe Zdun, Michael Kircher

    Design and Implementation of an Asynchronous Invocation Framework for Web Services


    13.05.2003 | JAX 2003 | PDF | Abstract
    M. Voelter

    Codegenerierung mit Java

    Einen wichtiger Teil modellgetriebener Softwareentwicklung stellt die Generierung von Quellcode, ueblicherweise aus Modellen, dar. Diese Session gibt einen Ueberblick ueber die verschiedenen Ansaetze, Techniken und Tools die dem Java Programmierer zur Generierung von Quellcode zur Verfuegung stehen.


    19.11.2002 | IIR Software Technology Forum 2002 | PDF | Abstract
    M. Voelter

    Einsatz offener Standards im ALMA Projekt

    In Vertretung fuer Heiko Sommer habe ich beim IIR Technologie Forum den Praxisvortrag ueber ALMA gehalten.


    26.01.2003 | OOP 2003 | PDF | Abstract
    M. Voelter

    Components, Remoting Middleware and Webservices - how it all fits together

    Webservices will revolutionize the way software is developed, tradional middleware is dead - Webservices, next-generation components. You can hear these and similar phrases all over the place. However, it's not that simple. All these technologies have - and will keep - their merits and areas of applicability. This session will classify the different technologies, show strengths and limitations, implications on system architecture, and how the different technologies can be used together as part of a consistent conceptual framework.


    25.01.2003 | OOP 2003 | PDF | Abstract
    M. Voelter

    Common architectural variations for J2EE applications

    J2EE provides an implementation technology for each part of a multi-tier enterprise system. However, it is not always easy to determine which technology to use, and how: for example, smaller real-world applications have been built using only Servlets and JDBC, however large-scale enterprise applications might use several J2EE elements, like JSPs/Servlets, different EJB types, and back-end integration by means of CORBA, JMS or Connectors. This session explores different architectural alternatives when working with J2EE, outlines strenghts and weaknesses, and gives examples where they have been successfully used.


    11.07.2002 | CDUF 2002 | PDF | Abstract
    M. Voelter

    Component Infrastructures for embedded systems

    Component infrastructures such as EJB, COM+ or CCM have become the de-facto standard architecture for enterprise systems, providing significant benefits in terms of reuse for the functional, and especially the technical aspects of application systems. In the area of embedded systems, such component infrastructures could be used to provide some of the same benefits. This session shows the benefits of using components in the embedded domain, explores design and implementation options based on generative programming techniques and provides concrete examples from the automotive domain.


    10.07.2002 | dot.net Konferenz 2002 | PDF | Abstract
    M. Voelter

    .NET Remoting - Patterns und Beispiele


    05.11.2002 | IIR Software Technology Forum 2002 | PDF | Abstract
    M. Voelter

    Softwarearchitekturen heute


    05.11.2002 | IIR Software Technology Forum 2002 | PDF | Abstract
    M. Voelter, Jutta Eckstein, Nico Josuttis

    Gro?e J2EE-Projekte erfolgreich managen


    28.06.2002 | Java Forum Stuttgart 2002 | PDF | Abstract
    M. Voelter

    Metaprogrammierung und Reflection


    05.06.2002 | XML ONE and Webservices 2002 | Abstract
    M. Voelter, Christian Weyer

    Backend architectures for Webservices


    12.05.2002 | JAX 2002 | PDF | Abstract
    M. Voelter

    Metaprogrammierung in Java und Enterprise Systemen


    12.05.2002 | JAX 2002 | PDF | Abstract
    M. Voelter

    Small Components - Ein Komponentenmodell fuer Kleingeraete


    12.05.2002 | JAX 2002 | PDF | Abstract
    M. Voelter

    Moderne Softwareentwiclungsmethoden - GP, AOP, MDSOC und IP


    03.03.2002 | MATHEMA Mini CAMPUS | PDF | Abstract
    M. Voelter

    Ueberblick ueber OMG's MDA


    05.02.2002 | Java User Group Stuttgart | Abstract
    M. Voelter

    Komponenten fuer Kleingeraete


    05.02.2002 | ACCU 2002 | PDF | Abstract
    M. Voelter, Michael Stal

    Comparing J2EE with .NET


    05.02.2002 | ACCU 2002 | PDF | Abstract
    M. Voelter, Michael Stal

    Patterns in .NET


    05.02.2002 | Borland Enterprise Essentials 2002 | PDF | Abstract
    M. Voelter

    Patterns for Building fast and scalable EJB applications


    01.02.2002 | Arbeitskreis OOT Hannover | Abstract
    M. Voelter

    Komponenten in embedded Systemene


    24.01.2002 | OOP 2002 | PDF | Abstract
    M. Voelter

    Patterns for Building fast and scalable EJB applications


    24.01.2002 | OOP 2002 | PDF | Abstract
    M. Voelter

    XML in der Objektorientierten Programmierung


    30.06.2001 | Java Forum Stuttgart 2001 | PDF | Abstract
    M. Voelter

    Component Patterns


    04.06.2001 | CDUF 2001 | PDF | Abstract
    M. Voelter

    Evolution in Software Engineering


    04.04.2001 | JAX 2001 | PDF | Abstract
    M. Voelter

    Constraints in Java


    04.04.2001 | JAX 2001 | PDF | Abstract
    M. Voelter

    Component Patterns - EJB, CCM, COM+


 
 

Tutorials

    28.09.2013 | Models 2013 | PDF | Abstract
    M. Voelter

    DSL Engineering

    Domain Specific Languages play an increasingly important role in model-driven software development. As the tasks addressed with DSLs become more complex, DSLs must become more sophisticated and the language workbenches more powerful. In particular, they have to support composition and extension of languages, DSL debugging as well as the flexible combination of textual, tabular and graphical notations. In this tutorial I will provide a thorough introduction to DSLs based on my book DSL Engineering. I will cover the two main parts of the book, namely the design of DSLs and their implementation. In the design part, I will discuss some design considerations from seven design dimensions: expressivity, coverage, semantics, separation of concerns, complete-ness, language modularization and syntax. The design trade-ofs are illustrated based on real-world case studies. The implementation part, I will discuss the various concerns relevant for implementing DSLs, including abstract and concrete syntax, type systems, code generation and/or interpretation, IDE support and debugging. These will be illustrated with examples based on several language workbenches including Xtext, Spoofax and MPS. Participants will gain a thorough understanding of how to design and build DSLs, and of the capabilities of today's language workbenches.


    28.02.2013 | SE 2013 | Abstract
    M. Voelter, Bernd Kolb, Dan Ratiu

    Spracherweiterungen und Verifikation - C Entwicklung fuer das 21. Jahrhundert mit mbeddr

    Was waere, wenn sich Sprachen genauso leicht erweitern ließen wie Programme? Entwickler koennten sich dann domaenenspezifische Erweiterungen fuer Programmiersprachen bauen, was zu hoeherer Produktivitaet (durch weniger Code) und besserer Softwarequalitaet (durch bessere Analysierbarkeit) fuehrt. In diesem Tutorial demonstrieren wir diesen Ansatz basierend auf mbeddr, einer erweiterbaren Version von C die auf der JetBrains MPS Language Workbench beruht. mbeddr C kommt bereits mit einer Reihe von modularen Erweiterungen, darunter Komponenten, Zustandsmaschinen und Datentypen mit Maßeinheiten. Formale Verifikation mittels Model Checking und SMT Solving wird direkt unterstuetzt. Im Tutorial erlaeutern wir die Idee und die Konzepte hinter inkrementeller Spracherweiterung und zeigen diese am Beispiel eingebetteter Softwareentwicklung mit mbeddr. Des Weiteren erstellen wir eine einfache Erweiterung um das Vorgehen zu illustrieren. Sowohl mbeddr als auch die Basistechnologie JetBrains MPS sind Open Source Software, sodass die Teilnehmer selbst mit dem System experimentieren koennen.


    03.09.2012 | Herbstcampus 2012 | Abstract
    M. Voelter, Bernd Kolb

    Massgeschneidert - Language Engineering mit MPS

    Was waere, wenn sich eine Sprache genauso einfach weiterentwickeln und erweitern ließe wie wir das von Bibliotheken schon lange gewohnt sind? In diesem Tutorium wird erklaert, wie dies mit der JetBrains MPS Language Workbench moeglich ist. Nach einer generellen Einfuehrung in die Konzepte von MPS wird gemeinsam mit den Teilnehmern Java und C mit eigenen Sprachkonstrukten angereichert. So wird an konkreten Use Cases gezeigt, wie APIs vereinfacht und Programme typsicherer werden, Requirements sich als Teil des Entwicklungsprozesses zusammen mit dem Code entwickeln und Fachexperten direkt in die Entwicklung mit einbezogen werden koennen. Dabei wird auch gezeigt, wie nicht-textuelle Notationen (tabellarisch oder mathematische Symbole) diesen Prozess unterstuetzen.


    03.12.2012 | ESE Kongress 2012 | PDF | Abstract
    M. Voelter, Bernd Kolb

    C - Spracherweiterung und formale Methoden

    Das mbeddr Open Source Projekt erlaubt es, die Programmiersprache C inkrementell mit domaenenspezifischen Konzepten zu erweitern. Die dadurch erreichbaren semantisch reicheren Abstraktionen erlauben es, den Implementierungscode automatisch zu generieren und die Programme leicht mittels formalen Methoden zu analysieren. mbeddr wurde ueber die letzten zwei Jahre im Rahmen des LW-ES Forschungsprojektes entwickelt und wurde jetzt in ersten Anwendungen eingesetzt. In diesem Vortrag berichten wir ueber die Erfahrungen in diesen Projekten. Dabei gehen wir zum einen auf die existierenden Erweiterungen (Komponenten, Zustandsmaschinen, physikalischen Einheiten) sowie die Anwendung der Analyseverfahren ein. Zum anderen berichten wir ueber Anwendungsszenarien fuer den Bau eigener, projektspezifischer Spracherweiterungen. Letzteres ist ein wesentlicher Aspekt von mbeddr, und es ist wichtig, dass die Aufwaende dafuer niedrig bleiben. Wir runden den Vortrag mit konkreten Zahlen bzgl. Aufwaenden ab.


    05.11.2012 | W-JAX 2012 | Abstract
    M. Voelter

    Make this YOUR Java

    Was waere, wenn sich Java als Sprache genauso einfach weiterentwickeln und erweitern ließe wie wir das von Bibliotheken schon lange gewohnt sind? In dieser Session erklaeren wir wie dies mit MPS moeglich ist. Nach einer generellen Einfuehrung in die Konzepte von MPS reichern wir gemeinsam mit den Teilnehmern Java mit eigenen Sprachkonstrukten an. So zeigen wir an konkreten Use Cases wie APIs vereinfacht werden, Programme typsicherer werden, Requirements als Teil des Entwicklungsprozesses sich zusammen mit dem Code entwickeln und Fachexperten direkt in die Entwicklung mit einbezogen werden koennen. Dabei zeigen wir auch, wie weitere Notationen (tabellarisch oder mathematische Symbole) diesen Prozess unterstuetzen. Anforderungen: WIN- oder OSX-Laptop (kein Linux), Java >=6 sollte installiert sein.


    05.06.2012 | ICSE 2012 | PDF | Abstract
    M. Voelter

    Domain-Specific Language Design

    Domain Specific Languages are languages with high expressivity for a specific, narrow problem domain. They are a powerful tool for software engineering, because they can be tailor-made for a specific class of problems. However, because of the large degree of freedom in designing DSLs, and because they are supposed to cover the right domain, completely, and at the right abstraction level, DSL design is also hard. In this tutorial I present a framework for describing, characterizing and guiding the design of external domain specific languages. I identify eight design dimensions that span the space within which DSLs are designed: expressivity, coverage, semantics, separation of concerns, completeness, reusable paradigms, language modularization and syntax. I illustrate design alternatives along each of these dimensions with examples from four case studies and discuss the drivers that lead to particular design decisions. The case studies are: a component architecture DSL, a DSL for describing refrigerator cooling algorithms, a pension plan specification language and a suite of domain-specific extensions to C. The tutorial will be slides, demos, and (hopefully a lot of) discussion.


    01.10.2012 | MODELS 2012 | PDF | Abstract
    M. Voelter

    Language Workbenches, Embedded Software and Formal Verification

    Domain Specific Languages play an increasingly important role in model-driven software development. As the tasks addressed with DSLs become more complex, DSLs must become more sophisticated and the language workbenches more pow-erful. In particular, they have to support composition and extension of languages, DSL debugging as well as the exible combination of textual, tabular and graph-ical notations. In this tutorial we show how the open source JetBrains MPS language work-bench addresses these challenges based on mbeddr, an open source, extensible IDE for embedded software development. mbeddr supports modular, incremental extension of C, debugging of extensions on DSL level, graphical visualizations as well as formal program analysis. To this end, mbeddr integrates an SMT solver and a model checker directly into the IDE. By extending C with suitable abstractions, programs become analyzable with these tools. The tutorial is mostly based on demos, we will use only few slides. Partic-ipants will be inspired regarding the power of language workbenches as well as the usefulness of language engineering for building rich development envi-ronments and for incrementally integrating formal analyses in the development process. Although this tutorial uses embedded software as the example domain, the tutorial is nottargetted to embedded software developers.


    22.08.2011 | SPLC 2011 | PDF | Abstract
    M. Voelter

    DSLs for Product Lines - Approaches, Tools, Experiences

    The goal of this turorial is to show how Domain-Specific Languages fit into the over PLE approach, and how they relate to and integrate with feature models. Domain-Specific Languages are languages narrowly focused on a particular problem domain. Compared to feature models they are more expressive, but possibly not as easy to use. Compared to source code, they are usually simpler, more targeted and hence easier to use - although not quite as flexible. DSLs can play an important role in PLE, filling the gap between configuration via feature models and low-level programming. In this tutorial I will cover approaches, tools and experiences of using DSLs in PLE. I will start with briefly introducing DSLs and their role in PLE. We will then look at a real-world DSL that has been used to describe a product line of electrical devices. Next we will spend some time extending a DSL built with Eclipse Xtext to get a feel for the tool and the involved effort. After that we will look at and extend a DSL for robot control, that integrates nicely with the C programming language and feature models. This example is based on JetBrains MPS.


    11.10.2011 | ICALEPCS 2011 | Abstract
    M. Voelter

    Implementing DSLs with Xtext and MPS

    This tutorial is an introduction to development of domain-specific languages, based on the 'Trends in Programming Languages' talk in Tuesday morning. I show a couple of example DSLs used in various technical domains. Then I provide details on two language workbenches: Eclipse Xtext and JetBrains MPS. Both are Java-based Open Source products that support the rapid development od DSLs, but they use radically different approaches: Xtext is parser-based, MPS is a projectional editor. The goal of the tutorial is to illustrate the usefulness of DSLs, showcase the productivity of language workbenches for developing languages, and give participants a head start in using Xtext and MPS. The tutorial is mostly example-based: I will demonstrate the implementation of a small DSL in each of the tools.


    10.12.2010 | JAX on TOUR 2010 | PDF | Abstract
    M. Voelter

    Dokumentation von Softwarearchitekturen

    Dokumentation ist laestig und ueberfluessig...; naja, nicht wirklich. Vor allem fuer Architekturen, die ueber eine laengere Zeit verwendet werden sollen, ist eine brauchbare und trotzdem nicht zu aufwaendige Dokumentation essentiell. In dieser Session moechte ich auf eine Reihe von Best Practices zur Architekturdokumentation eingehen: Dazu zaehlen strukturierte Glossare, Patterns, Tutorials und FAQs, Diagramme und Modellierung, einige stilistische Aspekte sowie die Verwendung alternativer Kanaele wie Audio und Video.


    10.12.2010 | JAX on TOUR 2010 | PDF | Abstract
    M. Voelter

    DSLs, Modelle und Softwarearchitektur

    Softwarearchitektur beschreibt Konzepte, Konventionen und Vorgehensweisen, die in einem System konsistent umgesetzt werden muessen. Die Erreichung dieser Konsistenz ist in großen Systemen nicht leicht. Domaenenspezifische Architektursprachen, Modelle, Valdierung, Codegenerierung und die Integration mit Codeanalysewerkzeugen versprechen Besserung. Dieser Workshop erlaeutert, wann und wie DSLs, Modelle und Codegenerierung sinnvoll und pragmatisch eingesetzt werden koennen.


    10.10.2010 | GPCE 2010 | PDF | Abstract
    M. Voelter

    Language Definition and Extension with MPS

    Language definition and extension is a hot topic. Using modular languages, where a program can use concepts from different language modules as needed, promises significantly increased language usability as well as an integration between general purpose (programming) and domain-specific (modeling) concepts and tools. JetBrains MPS is an open source language workbench that uses projectional editing as opposed to parsing techniques. In MPS, languages are defined via structure, projection rules, transformation rules and type systems. In this tutorial I will provide a brief overview about how MPS works and what you can do with it. I will show how to build an external DSL, how to integrate the external DSL with Java, and how to extend an existing programming language with a new statement. To round it off, I will demo a non-trivial set of languages for embedded software development. 90% of the tutorial will be live demos. Note that even if you don't plan to work with MPS specifically, this tutorial will provide a good overview of projectional editing.


    18.10.2010 | SPLASH 2010 | PDF | Abstract
    M. Voelter, Eelco Visser

    Language Composition and Extension with Language Workbenches

    Domain Specific Languages are becoming increasingly important - in the modeling community as well as in the programming community. Textual DSLs in particular promise to remove the difference between programming and modeling in the first place treating general purpose languages and domain-specific languages in the same way. Language Workbenches are the tools that make this approach possible. This tutorial provides a solid introduction to the state of the art in textual DSLs and language workbenches. We will introduce the two main approaches for language definition: parser-based and projectional. The parser-based approach will be illustrated with the Spoofax language workbench, based on the SDF/Stratego tool chain developed by Delft University. The projectional approach will be demonstrated with JetBrains MPS. Both tools are Open Source and will be made available to the participants with the examples used in the tutorial. The tutorial will contain a very brief recap of DSLs and language workbenches, argue why the unification of programming and modeling is a good thing and show how it can be achieved. Then the benefits and drawbacks of the two approaches (parser-based and projectional) are illustrated based on real-world languages for web development and embedded system development. Finally we will show how to build and/or extend languages with the two kinds of tools, further illustrating how the tools work. The tutorial will be 40% slides and 60% demos and discussion.


    18.06.2010 | CodeGeneration 2010 | Abstract
    M. Voelter, Konstantin Solomatov

    Language Extension with MPS

    Jetbrains MPS is an Open Source language workbench, supporting the creation and combination of arbitrary DSLs. Since it also comes with an implementation of Java, it also supports incremental extension of Java (and other general purpose languages for which an implementation in MPS is available).


    03.05.2010 | JAX 2010 | Abstract
    M. Voelter, Arno Haase, Heiko Seeberger

    Durchstarten mit Scala

    Immer mehr Projekte setzen auf Scala. Und das zu Recht, denn Scala ist nicht nur einfacher, sondern auch fortschrittlicher als Java. Kaum Glue Code, ein knapper und praegnanter Programmierstil sowie neue Moeglichkeiten durch funktionale Programmierung lassen Entwicklerherzen hoeher schlagen. Aber Scala bietet nicht nur hohe Produktivitaet, sondern auch Flexibilitaet, denn die Sprache ist skalierbar und laesst sich auf individuelle Beduerfnisse anpassen. Besonders hervorzuheben ist auch die volle Interoperabilitaet mit Java, sodass sich Scala bestens in die bestehende Java-Welt integriert. In diesem praxisorientierten Workshop, der sich an erfahrene Entwickler richtet, erlernen Sie die Grundlagen von Scala anhand von zahlreichen praktischen uebungen. Bitte bringen Sie daher Ihr Notebook mit.


    22.02.2010 | SE 2010 | PDF | Abstract
    M. Voelter, Peter Friese

    Software Engineering mit Domaenenspezifischen Sprachen und Language Workbenches

    Als Softwareentwickler sind wir daran gewoehnt, uns mithilfe existierender Programmiersprachen auszudruecken, also die Fachlichkeit des zu erstellenden Systems mittels objektorientierter, funktionaler, oder andere Ausdrucksmittel der Implementierungssprache zu beschreiben. In den letzten Jahren haben sich allerdings Werkzeuge entwickelt, mit denen es moeglich ist, eigene Sprachen zu bauen beziehungsweise existierende Sprachen zu erweitern. In diesem Tutorium gehen wir darauf ein, wie sich Softwareentwicklung aendert wenn man die Moeglichkeit hat die Sprache an die Domaene anzupassen, und nicht gezwungen ist, sich im Rahmen existierender Programmiersprache zu bewegen. Im ersten Teil des Tutoriums erlaeutern wir Grundlagen zu domaenenspezifischen Sprachen und Spracherweiterungen und erlaeutern einige wichtige Anwendungsfaelle fuer diese Technologien. Im zweiten Teil werden wir zwei Werkzeuge zeigen mit denen Sprachbau mit vertretbarem Aufwand moeglich ist (Eclipse Xtext, JetBrains MPS). Der zweite Teil besteht zum Grossteil aus praktischen uebungen.


    27.10.2009 | Eclipse Summit Europe 2009 | Abstract
    M. Voelter, Karsten Thoms, Sebastian Zarnekow, Jan Koehnlein

    DSLs with Eclipse Modeling

    Domain-specific languages (DSLs) are a popular technique in software to eliminate redundancy, reduce syntactic noise, separate concerns and introduce abstractions the target language cannot offer. In this tutorial we present a complete chain of Eclipse Modeling tools to define, process and execute external DSLs. We start with the definition of the abstract and the concrete textual syntax using an Xtext grammar. From that, we use Xtext to automatically create a DSL workbench, including an Ecore model for the abstract syntax, a parser and a text editor with syntax highlighting code completion and navigation. We show how to customize the editor and use it to define models. Finally, we orchestrate the model processing components with MWE and write code-generation templates in Xpand to generate artifacts for our target platform. The participants will be introduced to the fundamentals of all these technologies and gather hands-on experience. They will learn how easy working with DSLs can be and how well it fits into modern agile software development.


    25.08.2009 | SPLC 2009 | PDF | Abstract
    M. Voelter

    Using Domain-Specific Languages for Product Line Engineering

    Domain specific languages, together with code generation or interpreters (a.k.a. model-driven development), are becoming more and more important. Since there is a certain overhead involved in building languages and processors, this approach is especially useful in environments where a spe-cific set of languages and generators can be reused many times. Product lines are such an environment. Consequently, the use of domain specific languages (DSLs) for Software Product Line Engi-neering (SPLE) is becoming more relevant. However, exploiting DSLs in the context of product lines involves more than just defining and using languages. This tutorial explains the differences as well as commonalities between model-driven development (MDD) and SPLE and shows how the two approaches can be combined. In this tutorial we will first recap/introduce feature modeling and model-driven development. We then build a simple textual DSL and a code generator based on Eclipse openArchitectureWare (oAW). Based on this language we’ll discuss the kinds of variability expressible via DSLs versus those expressible via feature modeling, leading to a discussion about ways to combine the two. In the next demo slot we’ll do just that: we’ll annotate a model with feature dependencies. When generating code, the elements whose features are not selected will be removed, and hence no code will be generated. Finally we’ll discuss and demo the integration feature dependencies into code generators to con-figure the kind of code generated from the model.


    25.08.2009 | MODELS 2009 | Abstract
    M. Voelter, Eelco Visser

    Textual Modeling and Language Composition

    Textual languages are becoming more mainstream in MDD. They have a couple of advantages: developers know how to efficiently work with text, and there is a lot of existing infrastructure for text artifacts. However, they also have their challenges. Traditional parser technology limits composability of language fragments. And structural, cause-effect or timing relationships are often best shown graphically. In this tutorial we will provide an overview of the state of the art of textual DSLs. We will explain the challenges above and how they are resolved by a representative sample of existing (open source) tools: Eclipse TMF, the Syntax Definition Formalism SDF, and JetBrains' MPS. Attendees will be able to judge for themselves which technology is best for their context. TMF plays the role of a traditional, parser based framework that is productionready, integrated with a mature platform and easy to use. SDF represents leading edge parser technology and showcase language modularization based on parsers. MPS represents projectional/syntax directed editing where no parsing is necessary and hence language modularization is simple. We will also briefly address the topic of visualization, i.e. generating graphical views of textual models using renderers like Graphviz, Eclipse ZEST, XMind and Ubigraph.


    19.10.2008 | OOPSLA 2008 | Abstract
    M. Voelter

    Textual DSLs and Code Generators

    In this tutorial, we will capitalize on the DSL we have built in the Textual DSLs - Concepts and Tooling tutorial and show various ways to process the models that can be created with this DSL. Domain Specific Languages are becoming important ingredients of software developers' tool chests. The mainstream is divided into two camps: external graphical DSLs (aka Modeling) and internal textual DSLs (via meta programming in languages like Ruby). As experience shows however, a sweet spot for DSLs is textual external DSLs: you can define any grammar you want, you can have domain specific constraint checks and error messages, and processing models is straight forward: generate code or interpret them based on the AST derived from the grammar. Another advantage - especially compared to graphical DSLs - is that they integrate natively with today's development infrastructure (CVS/SVN diff/merge). The goal of this tutorial is to provide with an understanding of how MDSD code generators work as well as give you a hands-on experience of how to create MDSD model processors that validate, transform and interpret formalized (textual) models in a way that is efficient enough for practical project reality. Please bring your Windows laptop - the tutorial includes hands-on work for you, the participant!


    19.10.2008 | OOPSLA 2008 | Abstract
    M. Voelter

    Textual DSLs - Concepts and Tooling

    Domain Specific Languages are becoming important ingredients of software developers' tool chests. The mainstream is divided into two camps: external graphical DSLs (aka Modeling) and internal textual DSLs (via meta programming in languages like Ruby). As experience shows however, a sweet spot for DSLs is textual external DSLs: you can define any grammar you want, you can have domain specific constraint checks and error messages, and processing models is straight forward: generate code or interpret them based on the AST derived from the grammar. Another advantage - especially compared to graphical DSLs - is that they integrate natively with today's development infrastructure (CVS/SVN diff/merge). In this tutorial, I introduce DSLs in general, talk about advantages of textual external DSLs and explain how the Eclipse Xtext tool is used to develop editors for your custom DSLs that resemble modern IDEs with features such as syntax coloring, code completion, real-time constraint checking, customized outlines and inter-file navigation. I will also discuss how to process the models created with the editor. The goal is to provide you with all the concepts, tooling and pointers you need to build your own textual DSLs in a way that is efficient enough for practical project reality.


    19.10.2008 | OOPSLA 2008 | PDF | Abstract
    M. Voelter

    Architecture As Language

    Software Architecture is often either imprecise and hard to grasp or technology specific. What you really want is a succinct, precise, technology-independent and tool-processable description of an architecture. In this tutorial we illustrate how textual DSLs can be used to this end. The core idea is to actually develop an architecture language as you understand the architecture, formalizing the growing intuitive understanding into a formal language. This removes ambiguity from the discussion, requires answers to arising questions and results in a more consistent and (re-)usable architecture. The tutorial has three parts: we start with a role play where we showcase how an architecture DSL is developed as part of a discussion about a system's architecture. We actually build an example DSL in real time. In part two we look at some of the concepts, rationales and benefits of the approach, and briefly point to tools that can be used to build languages and associated tooling. The third part looks at how to use the approach for product lines: how to express variability in the architectural descriptions, and how to integrate the DSL with feature-modeling based variability management. The tutorial is for practitioners, by practitioners. It is guaranteed to contain only practice-oriented material.


    03.10.2008 | JAOO 2008 | PDF | Abstract
    M. Voelter

    Architecture As Language

    Architecture is typically either a very non-tangible, conceptual aspect of a software system that can primarily be found in Word documents, or it is entirely driven by technology (we use an XML architecture). Both are bad: the former makes it hard to work with, and the latter hides architectural concepts behind technology hype. What can be done? As you develop the architecture, evolve a language that allows you to describe systems based on this architecture. Based on my experience in a number of real-world projects, this makes the architecture tangible and provides an unambiguous description of the architectural building blocks as well as the concrete system while still staying away from technology decisions (which then can be made consciously in a separate step). This tutorial comes in two parts: The first part of this paper illustrates the idea using a real-world story, executed as a role play between an architect and a consultant. The second part summarizes the key points of the approach using slides and discussions.


    20.10.2008 | OOPSLA 2008 | PDF | Abstract
    M. Voelter

    Architecture As Language

    Software Architecture is often either imprecise and hard to grasp or technology specific. What you really want is a succinct, precise, technology-independent and tool-processable description of an architecture. In this tutorial we illustrate how textual DSLs can be used for this. The core idea is to actually develop the architecture language as you understand the architecture, formalizing the growing intuitive understanding into a formal language. This removes ambiguity from the discussion, requires answers to arising questions and results in a more consistent and (re-)usable architecture. The tutorial has three parts: we start with a role play where we showcase how an architecture DSL is developed as part of a discussion about a system’s architecture. We actually build an example DSL in real time. In part two we look at some of the concepts, rationales and benefits of the approach, and briefly point to tools that can be used to do these things. The third part looks at how to use the approach for product lines: how to express variability in the architectural descriptions, and how to integrate the DSL with feature-modeling based variability management. The tutorial is for practitioners, by practitioners. It is guaranteed to contain only practice-oriented material.


    11.03.2008 | QCon London 2008 | PDF | Abstract
    M. Voelter

    Hands-On DSLs with Eclipse Tools

    In this tutorial I will provide a hands-on introduction to building textual DSLs with Eclipse tools (and yes, you can follow along on your own machine, if you like). I will start with a very short introduction to DSLs and will explain where and how the tutorial content fits into the grand scheme of DSLs in general. I will continue with a brief introduction to Eclipse Modeling in general and provide an overview over the capabilities of Eclipse-based DSL tooling (to let you know about all of the stuff we cannot cover in the tutorial because there isn't enough time). The last part of the theoretical introduction will cover some important best practices regarding DSLs. We will then spend the majority of the tutorial time building an external textual DSL. The created tooling will include a convenient editor with syntax coloring, code completion and error checking. In the next step we will build a code generator to create executable artefacts from the DSL programs. We will also look at how to build an interpreter as an alternative means of execution. The goal of this full-day tutorial is to ensure you are able to build your own DSLs (including tools to process the programs) in a reasonable amount of time. This will make developing your own DSLs in real-life projects a practical reality.


    17.03.2008 | EclipseCon 2008 | Abstract
    M. Voelter, Bernd Kolb

    An introduction to Model-driven-development using Eclipse Tools

    In the first part of this series of tutorials, we will give an introduction to the topic and explain various fundamentals (such as the workflow of the generation process and the general interplay between metamodel, editors, constraints, transformations and code generation). We also provide a short introduction and motivation for the example. We will then define the meta model we'll use throughout the series of tutorials. Finally, we will start to define some constraints for this metamodel to be able to validate the models we are going to create. In a next step we will have a look at the the Graphical Modeling Framework. We will start explaining its purpose and how to use it.


    17.03.2008 | EclipseCon 2008 | Abstract
    M. Voelter, Bernd Kolb, Radomil Dvorak, Tatiana Fesenko

    Using GMF and M2M for Model-driven-development

    In this second tutorial, we will continue building a graphical editor using GMF for our example. We will look at the different GMF-models and explain how GMF is used: the GMF graph model for defining the graphical notation, the GMF tool model to define the palette and the GMF map model to bind the domain meta model to the graphical and tooling models. The GMF part will be finished with the integration of our previously defined constraints with the generated editor. Now you will be able to see constraint violation in your models immediately in the editor. Additionally we will have a look at model transformation languages. You will see how you can benefit from transformation languages as opposed to writing transformations in Java. We will show you how to enhance an existing model or how to transform your model to another model.


    17.03.2008 | EclipseCon 2008 | Abstract
    M. Voelter, Bernd Kolb

    Using M2T and TMF for Model-driven-development

    In this last part of the series on modeling you will get in learn to use code generation based on M2T’s Xpand language, as well as some best practices to manage the complexity inherent in building code generators. We will also show a mechanism to add derived properties to your meta model to simplify code generation. In a final step we will illustrate how easy it is to build textual DSLs using the Textual Modeling Framework (TMF). We are going to use TMF’s Xtext for that purpose and build an editor with syntax highlighting, code-completion and other useful facilities from a simple EBNF-based grammar. We will integrate model validation capabilities here as well. Finally, we will also look at the intersection between model-driven software development and product line engineering by introducing variability management for MDD tool chains, including the AO features for code generators.


    22.10.2007 | OOPSLA 2007 | PDF | Abstract
    M. Voelter

    Software Architecture Documentation in the Real World

    Documentation is a relatively unpopular aspect of software development and its importance is much debated. However, if you want to develop software architectures that should last for a long time - e.g. for platforms or product lines - documenting these architectures is essential. And done right, it can even be rewarding and fun! In this tutorial we will introduce best practices for documenting software architectures in real projects. These best practices include (-) Using the pattern form as a vehicle to write compelling explanations and capturing rationales (-) Using pattern languages to describe complex, multi-aspect architectures (-) Using tutorials and walk-throughs to describe the programming model to application developers (-) Using Structured Glossaries as a way of defining the meaning of terms and the relationships between terms (-) Using architectural diagrams (Visio/Powerpoint, UML Class Diagrams, Sequence Diagrams) to illustrate architectures (-) Using architecture meta models for formally describe software architectures We will also talk a little bit about which channel (e.g. paper, online, video) is best suited for the various kinds of documentation, as well as about some best practices for typesetting and document layout. The toolbox provided by this session makes architecture documentation much more productive.


    21.10.2007 | OOPSLA 2007 | PDF | Abstract
    M. Voelter

    Best Practices for Model-Driven Development

    Model-Driven Development is well on its way into the mainstream of software development. Many developers have used DSLs, models and code generators to simplify recurring development tasks. However, fully exploiting the power of DSLs and MDSD requires more that just using a generator. Specifically, many of the benefits will only materialize if development teams build their own languages and generators for their particular domain. This tutorial presents a set of best practices extracted from a number of MDD projects, among them (-) When and how to use custom meta models instead of general purpose meta models such as UML (-) Various techniques of annotating, extending and specializing models (-) Trade offs between textual and graphical DSLs (-) When to use code generation, and when to use interpreters (-) Pragmatic use of model-to-model transformations (-) Handling variants in models, generators and transformations (-) How to sensibly integrate generated code with manually written code (-) Multiple viewpoint meta models (-) modelling behavioural aspects of a system This tutorial is aimed at real developers working in real projects. The concepts will be illustrated with examples from my projects in the last year, based on tools from the Eclipse Modeling Project and openArchitectureWare.


    22.10.2007 | OOPSLA 2007 | PDF | Abstract
    M. Voelter

    Writing Adaptable Software - Mechanisms for Implementing Variabilities in Code and Models

    Today, a software system is often a member of a system family. Members have many things in common and differ in a set of well-defined respects. These differences are called variabilities and must be implemented in the software system. This tutorial provides an overview over techniques available for implementing such variabilities. Various alternatives exist in programming languages such as preprocessors (as in C/C++), static metaprogramming (e.g. C++ templates), aspect-oriented programming (e.g. AspectJ and CaesarJ), polymorhpism and design patterns (such as Bridge, Strategy or Interceptor), reflection and dynamic metaprogramming (as in Ruby). In addition, variabilities can also be handled in models in the context of model-driven development, for example by connecting structural models with varability models, model weaving and AO techniques for model-to-model and model-to-code transformations. The first part of the tutorial is a discussion of the different kinds of variability as well as notations for describing each form (feature modelling, graph-based models). We will then show examples for each of the implementation alternatives listed above and discuss which of them are capable of handling structural and/or non-structural variabilities. Finally, we will elaborate on the tradeoffs with regards to performance, flexibility and complexity of each alternative.


    26.06.2007 | TOOLS 2007 | Abstract
    M. Voelter

    MDD-TIF07 Model-Driven Development Tool Implementers Forum

    Today, a software system is often a member of a system family. Members have many things in common and differ in a set of well-defined respects. These differences are called variabilities and must be implemented in the software system. This tutorial provides an overview over techniques available for implementing such variabilities. Various alternatives exist in programming languages such as preprocessors (as in C/C++), static metaprogramming (e.g. C++ templates), aspect-oriented programming (e.g. AspectJ and CaesarJ), polymorhpism and design patterns (such as Bridge, Strategy or Interceptor), reflection and dynamic metaprogramming (as in Ruby). In addition, variabilities can also be handled in models in the context of model-driven development, for example by connecting structural models with varability models, model weaving and AO techniques for model-to-model and model-to-code transformations. The first part of the tutorial is a discussion of the different kinds of variability as well as notations for describing each form. The second part part will take a look at the different implementation techniques for variabilities. These include the classic techniques mentioned above, as well as the more advanced techniques of Model-Driven Product Line Engineering.


    06.03.2007 | EclipseCon 2007 | Abstract
    M. Voelter

    MDSD from Frontend to Code using Eclipse Modeling Technologies

    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.


    01.10.2006 | Models 2006 | PDF | Abstract
    M. Voelter, Doug Schmidt

    Model-Driven Engineering of Distributed Systems

    Despite advances in standard middleware platforms, it is hard to develop software for distributed systems, such as airplanes, power grids, and patient monitors. For example, developers still use ad hoc means to develop, configure, and deploy applications and middleware, due to the lack of analyzable and verifiable building block components. Model-Driven Engineering (MDE) has emerged as a promising means to address these issues by combining domain-specific modeling languages (DSMLs) with generators that analyze certain aspects of models and then synthesize various artifacts, such as source code, simulation inputs, XML deployment descriptions, or alternative model representations. This tutorial provides an overview over MDE for distributed systems, focusing on • Fundamental concepts of MDE • How MDE tools and metamodeling typically work • The role of code generation and model-to-model transformation • Frameworks and DSMLs, which are two sides of the same coin • How MDE can be used to improve and manage software architecture • Applying MDE to component-based distributed systems • Deploying and configuring middleware and applications using MDE Many of the topics mentioned above will be introduced using examples and case studies from production distributed systems. Wherever possible, we will show live demos of using MDE tools in the tutorial.


    04.10.2006 | JAOO 2006 | Abstract
    M. Voelter

    Building Domain Specific Languages with Eclipse

    DSLs are an important aspect of Model-Driven Software Developemt, MDA and Product Line Engineering. Since DSLs are specific to a certain domain, it is the domain architect's task to define and implemnet DSLs so that application developers can use the DSLs to configure or otherwise describe systems. In this tutorial, participants will learn how to define metamodels that form the basis for a DSL, how to define a graphical and textual syntax for the DSL, how to verify the correctness of models wrt. to the metamodel that underlies them and how to write transformations that transform models into executable code. To do all this, we will use tools and technologies from the Eclipse platform. These include EMF for metamodelling, GMF for building graphical editors as well as openArchitectureWare for verifying and transforming models.


    22.10.2006 | GPCE 2006 | PDF | Abstract
    M. Voelter, Arno Haase

    Building Domain Specific Languages with Eclipse and openArchitectureWare

    DSLs are an important aspect of Model-Driven Software Development. Since DSLs are specific to a certain domain, it is the domain architect’s task to define and implement DSLs so that application developers can use the DSLs to configure or otherwise describe systems. In this tutorial, participants will learn how to define metamodels that form the basis for a DSL, how to define a graphical syntax for the DSL, how to verify the correctness of models wrt. to the metamodel that underlies them, aas well as how to Write transformations that transform models into executable code. To do all this, we will use tools and technologies from the Eclipse platform. These include EMF for metamodelling, GMF for building graphical editors as well as openArchitectureWare for verifying and transforming models, and to generate code. The focus will be on the graphical editor and code generation. The tutorial will be highly interactive with only a minimum of slides, many live presentations show the tools at work.


    23.10.2006 | OOPSLA 2006 | PDF | Abstract
    M. Voelter, Doug Schmidt

    Model-Driven Development of Distributed Systems

    Despite advances in standard middleware platforms, it is hard to develop software for distributed systems, such as airplanes, power grids, and patient monitors. For example, developers still use ad hoc means to develop, configure, and deploy applications and middleware, due to the lack of analyzable and verifiable building block components. Model-Driven Development (MDD) has emerged as a promising means to address these issues by combining domain-specific modeling languages (DSMLs) with generators that analyze certain aspects of models and then synthesize various artifacts, such as source code, simulation inputs, XML deployment descriptions, or alternative model representations. This tutorial provides an overview over MDD for distributed systems, focusing on Fundamental concepts of MDD, How MDD tools and metamodeling typically work , The role of code generation and model-to-model transformation, Frameworks and DSMLs, which are two sides of the same coin, How MDD can be used to improve and manage software architecture, Applying MDD to component-based distributed systems and Deploying and configuring middleware and applications using MDD. Many of the topics mentioned above will be introduced using examples and case studies from production distributed systems. Wherever possible, we'll show live demos of using MDD tools in the tutorial.


    10.05.2006 | JAX 2006 | Abstract
    M. Voelter

    Modellgetriebene Entwicklung mit openArchitectureWare 4

    In diesem Workshop fuehren wir in die Modellgetriebene Softwareentwicklung mit dem openArchitectureWare Generator ein. Dabei kommen die neuen Features von Version 4 zum Einsatz; darunter die Workflow Engine zur Steuerung des Generierungsvorganges, die neue Template Engine mit den verbesserten Editoren, Modell-zu-Modelltransformationen mit Wombat, die Verwendung des Recipe Frameworks zur Kontrolle manuell geschriebenen Codes sowie die Integration mit EMF. Die Teilnehmer sollten ein grundlegendes Verstaendnis von modellgetriebener Softwareentwicklung mitbringen (Idee, Begrifflichkeiten). Nach dem Workshop werden sie in der Lage sein, diese Dinge mit oAW in die Praxis umzusetzen.


    20.03.2006 | AOSD 06 | PDF | Abstract
    M. Voelter

    Models and Aspects - Handling Cross-Cutting Concerns in Model-Driven Software Development

    Aspect Oriented Software Development (AOSD) as well as Model-Driven Software Development (MSDD) are both becoming more and more important in modern software engineering. Both approaches attack important problems of traditional software development. AOSD addresses the modularization (and thus, reuse) of cross-cutting concerns (CCC). MDSD allows developers to express structures and algorithms in a more problem-domain oriented language, and automates many of the tedious aspects of software development. But how do the two approaches relate? And how, if at all, can they be used together? This tutorial looks at both of these questions. The first one – how AOSD and MDSD relate – is discussed in the first part of the tutorial. The second, and main part of the tutorial introduces six patterns of how MDSD and AOSD can be used together. These range from using code generation templates as a simple means to separate concerns to using aspect-oriented modeling concepts to separate concerns in the models. All the patterns are illustrated with practical real-world examples taken from various model-driven software development projects.


    16.01.2006 | OOP 2006 | PDF | Abstract
    M. Voelter, Tom Stahl, Doug Schmidt

    Model-Driven Development - State of the Art

    This tutorial provides an overview over the current state of the art in model-driven development. It is structured into three parts: the first part explains commonalities and differences between the various acronyms and approaches such as MDSD, MDA, MIC (Model-Integrated Computing), LOP (Language-Oriented Programming) and SF (Software Factories). Part two then illuminates a number of industry best practices illustrated with various open source tools. Finally, the third part shows typical usage scenarios and example projects where a model-driven approach has been used successfully.


    18.11.2005 | W-JAX 2005 | Abstract
    M. Voelter

    Einstieg in die Modellgetriebene Softwareentwicklung

    Modellgetriebene Softwareentwicklung ist inzwischen ein wichtiger Bestandteil des Handwerkszeugs des Softwareentwicklers geworden. Dieser Workshop moechte Ihnen als Entwickler einen Einstieg geben. Dazu werden zunaechst einige wenige theoretische Grundlagen erlaeutert, bevor wir dann in die praktische Einfuehrung in MDSD einsteigen. Die praktischen Beispiele koennen von den Teilnehmern direkt auf dem eigenen Notebook nachvollzogen werden. Die Beispiele werden mittels des openArchitectureWare Generators durchgefuehrt, einem der fuehrenden OpenSource MDSD Werkzeuge. Im Rahmen des Workshops werden wir unter anderem die folgenden Themen behandeln: Metamodellierung, Modellierung mit UML sowie XML, einfache Modell-zu-Modell Transformationen, und Codegenerierung. Um die uebungen selbst mitzumachen, bringen Sie bitte Ihren Notebook mit. Eine Vorinstallation von Software ist nicht noetig.


    20.10.2005 | OOPSLA 2005 | PDF | Abstract
    M. Voelter, Martin Lippert

    Models and Aspects - How to use MDSD and AOSD together

    Aspect Oriented Software Development (AOSD) as well as Model-Driven Software Development (MSDD) are both becoming more and more important in modern software engineering. Both approaches attack important problems of traditional software development. AOSD addresses the modularization (and thus, reuse) of cross-cutting concerns (CCC). MDSD allows developers to express structures and algorithms in a more problem-domain oriented language, and automates many of the tedious aspects of software development. But how do the two approaches relate? And how, if at all, can they be used together? This tutorial looks at both of these questions. The first one – how AOSD and MDSD relate – is discussed in the first part of the tutorial. The second, and main part of the tutorial introduces six patterns of how MDSD and AOSD can be used together. These range from using code generation templates as a simple means to separate concerns to using aspect-oriented modeling concepts to separate concerns in the models. All the patterns are illustrated with practical real-world examples taken from various model-driven software development projects.


    08.11.2005 | ECMDA-FA 2005 | PDF | Abstract
    M. Voelter

    Models and Aspects - How to use MDSD and AOSD together

    Aspect Oriented Software Development (AOSD) as well as Model-Driven Software Development (MSDD) are both becoming more and more important in modern software engineering. Both approaches attack important problems of traditional software development. AOSD addresses the modularization (and thus, reuse) of cross-cutting concerns (CCC). MDSD allows developers to express structures and algorithms in a more problem-domain oriented language, and automates many of the tedious aspects of software development. But how do the two approaches relate? And how, if at all, can they be used together? This tutorial looks at both of these questions. The first one – how AOSD and MDSD relate – is discussed in the first part of the tutorial. The second, and main part of the tutorial introduces six patterns of how MDSD and AOSD can be used together. These range from using code generation templates as a simple means to separate concerns to using aspect-oriented modeling concepts to separate concerns in the models. All the patterns are illustrated with practical real-world examples taken from various modeldriven software development projects.


    10.05.2005 | JAX 2005 | Abstract
    M. Voelter

    Modellgetriebene Softwareentwicklung - Quick Start

    Modellgetriebene Softwareentwicklung ist inzwischen ein wichtiger Bestandteil des Handwerkszeugs des Softwareentwicklers geworden. Dieser Workshop moechte Ihnen als Entwickler einen Einstieg geben. Dazu werden zunaechst einige wenige theoretische Grundlagen erlaeutert, bevor wir dann in die praktische Einfuehrung in MDSD einsteigen. Die praktischen Beispiele koennen von den Teilnehmern direkt auf dem eigenen Notebook nachvollzogen werden. Die Beispiele werden mittels des openArchitectureWare Generators durchgefuehrt, einem der fuehrenden OpenSource MDSD Werkzeuge. Im Rahmen des Workshops werden wir unter anderem die folgenden Themen behandeln: Metamodellierung, Modellierung mit UML sowie XML, einfache Modell-zu-Modell Transformationen, und Codegenerierung. Um die uebungen selbst mitzumachen, bringen Sie bitte Ihren Notebook mit. Eine Vorinstallation von Software ist nicht noetig.


    24.10.2004 | OOPSLA 2004 | PDF | Abstract
    M. Voelter, Jorn Bettin

    Model-Driven Software Development - Introduction and Best Practices

    In today's complex world model-driven approaches are becoming more and more important - OMG's MDA initiative being the most well-known but by no means only flavour of this approach. To select the most suitable flavour of MDSD it is necessary to understand the basic approach and differences among the flavours. Adopting a model-driven approach to software development today also requires architects to understand the implications of such an approach on process, techniques and tooling. This tutorial consists of three parts: Introduction: Explains basic principles and core building blocks, such as meta modelling, model transformation, and code generation. Flavours: Shows different flavours of model-driven development and connections to related topics (Domain-Driven Design, Domain-Specific Modelling, Generative Programming) Best Practices: best practices for process, meta modelling, tool construction and application infrastructure development. Attendees will understand the concepts behind MDSD and will be able to distinguish facts from fiction with regards to MDSD and MDA. Based on the presenter's experience, a realistic picture of today's state of the art will be drawn. The best practices will make sure attendees will not make typical beginner's mistakes when adopting the approach in their projects.


    14.06.2004 | iX Eclipse Konferenz | Abstract
    M. Voelter

    Desktop-Anwendungen entwickeln auf Basis der Rich-Client-Plattform


    20.04.2004 | OMG Days, Muenchen | Abstract
    M. Voelter

    Modellgetriebene Softwareentwicklung - Einfuehrung und Best Practices

    Aufgrund der immer weiter steigenden Komplexit?t und und der sich rapide weiter entwickelnden Technologien im Rahmen Softwareentwicklungsprojekten setzen sich modellgetriebene Entwicklungsmethoden immer st?rker durch. Die MDA-Initiative der OMG ist dabei sicherlich der bekannteste Ansatz, aber bei weiten nicht der einzige. Um den am besten geeigneten Ansatz auszuw?hlen, ist es noetig, die verschiedenen Ans?tze und deren Unterschiede zu kennen. Die Einfuehrung modellgetriebener Entwicklungsmethoden erfordert auch, dass Architekten und Entwickler sich ueber die Konsequenzen bzgl. Technologie, Tools und Prozess bewusst sind. Dieses Tutorial enthaelt daher drei Teile. Teil 1 erl?utert die Prinzipien von Modellgetriebener Softwareentwickung: Metamodellierung, Modelltrans- formationen und Codegenerierung sind dabei wichtige Konzepte. Teil zwei zeigt die verschiedenen Geschmacksrichtungen Modellgetriebener Entwicklung, darunter Architekturzentrierte MDSD, MDA und GP. Um die ersten Gehversuche zu erleichtern, enth?lt der dritte Teil des Tutorials eine Reihe von Best Practices fuer die Bereiche Tools, Dom?nenmodellierung, PLattform- und Generator- entwicklung und Prozess. Aufgrund der starken Praxisfokussierung werden die Teilnehmer eine ganze Reihe praktisch nuetzlicher Aspekte mitnehmen.


    10.05.2004 | JAX 2004 | Abstract
    M. Voelter

    Modellgetriebene Softwareentwicklung in der Praxis

    Modellgetriebene Softwareentwicklung ist zwar prinzipiell nichts neues, hat aber in den letzten Monaten vor allem aufgrund der MDA-Initiative der OMG erheblich an Bedeutung gewonnen. Dabei ist MDA zwar die bekannsteste Geschmacksrichtung modellgetriebener Softwareentwicklung, aber bei weitem nicht die einzige. Dieser Power Workshop erlaeutert die grundlegenden Konzepte modellgetriebener Entwicklung und zeigt die vor diesem Hintergrund die spezifischen Eigenschaften der MDA und anderer Variationen auf. Er geht dabei ausfuehrlich auf Meta-Modellierung, die Defininition von (grafischen und textuellen) Domaenenspezifischen Sprachen (DSL), sowie Codegenerierung ein. Abgerundet wird der Workshop durch die Vorstellung von Best Practices fuer Modellgetriebene Entwicklung und Beispielen aus der Praxis.


    14.05.2004 | JAX 2004 | Abstract
    M. Voelter

    Rich Client GUI Entwicklung mit Eclipse

    Die Eclipse Plattform stellt eine gute ? Basis fuer die Entwicklung von Rich-Clients dar. Dabei kann es sich nicht nur um IDE-artige Clients handeln sondern um beliebige Anwendungen. Dieser Powerworkshop vermittelt die dazu noetigen Grundkenntnisse: Erstellung von Plugins, Grundlagen der SWT Bibliothek, Wegkonfigurieren unnoetige GUI-Elemente. Weiterhin wird verdeutlicht, wie einige der GoF Design Patterns die Oberflaechenentwicklung deutlich vereinfachen koennen. Ein kleines GUI Framework implementiert diese Patterns fuer die Eclipse-Plattform und erleichtert damit die Erstellung typischer Eingabemasken, Treeviews und berechtigungsabh?ngiger GUIs. Auch auf das automatisierte Testen von GUI-Anwendungen mittels des vorgestellten Frameworks wird im Rahmen der Session eingegangen.


    28.01.2004 | LTT OMG Briefing 2004 | PDF | Abstract
    M. Voelter

    Code Generations - Techniques and Concepts

    Program Generation as a means for software development has been used for a long time in enterprise and embedded systems. However, because of the proliferation of generative programming, product line engineering and OMG's Model Driven Architecture in particular, program generation techniques are getting more and more important these days. This tutorial covers the most important kinds of code generation such as Model Transformations, Source Code Generation, Source Code Transformation, Byte Code Rewriting and Reflection. A a strong focus is put on the second item: generating source code from models. We will introduce different generation technologies (such as template-based generators, frame technology, aspect weaving and AST-based approaches), show their use cases, discuss benefits and drawbacks and look at representative tools for each of these categories.


    05.11.2003 | W-JAX 2003 | PDF | Abstract
    M. Voelter

    MDA praktisch (mit Hands-On Session)


    25.10.2003 | OOPSLA 2003 | PDF | Abstract
    M. Voelter

    Code Generation - Techniques and Concepts

    Program Generation as a means for software development has been used for a long time in enterprise and embedded systems. However, because of the proliferation of generative programming, product line engineering and OMG's Model Driven Architecture in particular, program generation techniques are getting more and more important these days. This tutorial covers the most important kinds of code generation such as Model Transformations, Source Code Generation, Source Code Transformation, Byte Code Rewriting and Reflection. A a strong focus is put on the second item: generating source code from models. We will introduce different generation technologies (such as template-based generators, frame technology, aspect weaving and AST-based approaches), show their use cases, discuss benefits and drawbacks and look at representative tools for each of these categories.


    10.11.2003 | OOPSLA 2003 | Abstract
    M. Voelter, Arne Koschel

    J2EE in practice - Architectural variations in the context of enterprise systems


    25.09.2003 | JAOO 2003 | Abstract
    M. Voelter

    Common architectural variations for J2EE applications


    25.09.2003 | JAOO 2003 | Abstract
    M. Voelter

    Component Patterns


    15.09.2003 | openMDA 2003 | PDF | Abstract
    M. Voelter

    Einfuehrung in MDA


    15.09.2003 | openMDA 2003 | PDF | Abstract
    M. Voelter

    Codegenerierung - entzaubert!


    14.05.2003 | JAX 2003 | PDF | Abstract
    M. Voelter

    Real-Life MDA - Modellgetriebene Java Entwicklung

    Modellgetriebene Softwareentwicklung hat durch die MDA-Initiative der OMG schlagartig an Bedeutung gewonnen. Ziel ist es dabei, aus Modellen ausfuehrbaren Code zu generieren. Im Rahmen der MDA sind die Modelle typischerweise UML Diagramme. Der Workshop erlaeutert die wichtigsten Konzepte modellgetriebener Entwicklung und der MDA, zeigt wo und wie man modellgetriebene Entwicklung wirtschaftlich und technisch sinnvoll einsetzen kann und welche Vorteile ein solches Vorgehen haben kann. An Beispielen aus der Enterprise und der Embedded Welt werden die Dinge verdeutlich. Der Workshop geht auch auf gaengige Konzepte zur Codegenerierung ein, praktische Uebungen runden die Theorie ab und verfestigen das gelernte.


    20.07.2003 | ECOOP 2003 | PDF | Abstract
    M. Voelter

    Source Code Generation - Concepts, Techniques and Tools

    Program Generation as a means for software development has been used for a long time in enterprise and embedded systems. However, because of the proliferation of generative programming, product line engineering and OMG's Model Driven Architecture in particular, program generation techniques are getting more and more important these days. This tutorial covers the most important kinds of code generation such as Model Transformations, Source Code Generation, Source Code Transformation, Byte Code Rewriting and Reflection. A a strong focus is put on the second item: generating source code from models. We will introduce different generation technologies (such as template-based generators, frame technology, aspect weaving and AST-based approaches), show their use cases, discuss benefits and drawbacks and look at representative tools for each of these categories.


    07.10.2002 | Net.ObjectDays 2002 | PDF | Abstract
    M. Voelter

    OO Remoting Foundations of OO remote procedure call middleware

    OO Remoting frameworks play a vital role in the IT industry. They come in different flavours, most prominently CORBA, DCOM, .NET Remoting and, most recently, XML webservices. While each of these technologies use different APIs, protocols or implementation techniques, they are all based on the same patterns. From a high-level view, they all implement the Broker pattern described in the POSA1 book. However, a closer view on the subject reveals several finer grained patterns around the areas of quality of services, remoting framework design, asynchronous invocations, and more. This tutorial presents a collection of about 40 patterns describing how these oo remoting middlewares work. It also provides real-life examples using CORBA, .NET remoting and webservices. The tutorial will introduce the patterns one by one, and illustrate them using examples from the mentioned technologies. This provides a step-by-step introduction to the internals of the full-fledged remoting frameworks in use today.


    06.11.2002 | CDUF 2002 | PDF | Abstract
    M. Voelter

    Component containers as a foundation for software system families

    Component architectures like EJB, CCM or COM+ are widely used today in enterprise applications. However, most people just know the APIs of the component model they use. The basic principles and building blocks are usually not so well known. To be able to use such infrastructures efficiently, however, the developers must know these basics. In addition, there are situations when a component-based approach comes in handy, but you cannot use the mainstream implementations - you have to design your own, specialized component infrastructure while employing the same basics. This tutorial introduces the principles and patterns on which component architectures are based using a pattern language. The tutorial will also provide concrete examples for these patterns from using rather different implementations: EJB as an example of an enterprise component model, and examples from the Small Components project, focussing on defining a component infrastructure for mobile and embedded systems. In addition, I would like to discuss with the participants, where they consider using a proprietary component-infrastructure, and show how the patterns could help there.


    05.11.2002 | IIR Software Technology Forum 2002 | PDF | Abstract
    M. Voelter

    J2EE und .NET im Vergleich


    10.06.2002 | ECOOP 2002 | PDF | Abstract
    M. Voelter

    Patterns for building Component Infrastructures


    24.01.2002 | OOP 2002 | Abstract
    M. Voelter, Ulrich Eisenecker

    Tutorial zu Generative Programming


    04.11.2001 | IIR Software Technology Forum 2001 | PDF | Abstract
    M. Voelter

    Moderne Softwareentwicklungsmethoden - AOP, GP, IP und MDSOC


    10.09.2001 | NetObjectDays 2001 | Abstract
    M. Voelter, Alexander Schmid

    Component Patterns



CONTACT
webvoelter.de
e-mailvoelter@acm.org
skype  schogglad
twitter markusvoelter
g++MarkusVölter
fb/markus.voelter
githubmarkusvoelter
xingMarkus_Voelter
Linkedin 0/377/a31
Physical Impressum/Imprint

 
RELATED SITES
omega tau, my science podcast
mbeddr, the project I work on
DSL Engineering, my most recent book
(c) 2005 - 2014 Markus Voelter   |   Impressum/Imprint   |   Created with Jekyll and Bootstrap   |   Last regenerated at 2016-04-23 14:34:32 +0200