Talks & Slides


Keynotes

(click on the titles to get to abstract and download)

  • 17.09.2019 | Envisioning the Future of Language Workbenches
    M. Voelter
    MDETools Workshop at MODELS 2019 | PDF

    Over the last couple of years, I have used MPS successfully to build interesting (modeling and programming) languages in a wide variety of domains, targeting both business users and engineers. I’ve used MPS because it is currently the most powerful language workbench, lots of things are good about iz, in particular, its support for a multitude of notations and language modularity. But it is also obvious that MPS is not going to be viable for the medium to long term future; the most obvious reason for this statement is that it is not web/cloud-based. In this keynote, I will quickly recap why and how we have been successful with MPS, and point out how language workbenches could look like in the future; I will outline challenges, opportunities and research problems. I hope to spawn discussions for the remainder of the workshop.

  • 29.03.2019 | New Developments in the MPS Ecosystem
    M. Voelter
    MPS Day Eindhoven 2019 | PDF

    As you might know, we have developed lots of different DSLs over the last ten years based on MPS and factored reusable assets into what is called the mbeddr.platform. In this talk, we will provide an overview over some of the recent development in this context. This includes the use of MPS-based DSLs in safety-critical contexts, the functional base language KernelF and its tools for debugging, testing and coverage measurement, our work-in-progress incremental transformation framework called “shadow models”, as well as a few other reusable assets around systems engineering.

  • 12.09.2018 | DSLs in Software Product Lines -- Why and How
    M. Voelter
    SPLC 2018 | PDF

    Traditionally, software product lines rely on a configurative approach, where feature models or other variability modeling formalisms determine the presence or absence of parts of a product, as well as some (usually limited) aspects of the parts’ behaviors. However, for many systems, the expressiveness of a configurative approach is too limited. For example, while one can use configuration to tailor an existing life insurance product for a particular customer, it is not expressive enough to design new, innovative insurance products from scratch; you can’t sensibly pre-design all possible product ideas and put them into a feature model. However, programming these products “manually” is too expensive and error-prone. A middle ground between programming and configuration is needed. Domain-specific languages are that middle-ground: they are more expressive than pure configuration languages, yet can be tailored to the core abstractions of a particular domain to improve productivity. They can be designed to be usable by non-programmers, allowing product definition by those who really know about the domain. In this keynote, I will briefly motivate the idea of DSLs, put them into the context of product line engineering and variability and then show a number of recent examples of real-world DSLs, some of them combining DSLs with configurative approaches. I will conclude the talk with a look at the meta level: modern language development tools support modularity of the language definition itself, supporting the construction of product lines of DSLs for related domains.

  • 25.06.2018 | The Design, Evolution and Use of KernelF
    M. Voelter
    ICMT 2018 | PDF

    KernelF is a functional language built on top of MPS. It is designed to be highly extensible and embeddable in order to support its use at the core of domain-specific languages, realising an approach we sometimes call Funclerative Programming. 'Funclerative' is of course a mash-up of 'functional' and 'declarative' and refers to the idea of using functional programming in the small, and declarative language constructs for the larger-scale, often domain-specific, structures in a program. We have used KernelF in a wide range of languages including health and medicine, insurance contract definition, security analysis, salary calculations, smart contracts and language-definition. In this keynote, I illustrate the evolution of KernelF over the last two years. I discuss requirements on the language, and how those drove design decisions. I showcase a couple of the DSLs we built on top of KernelF to explain how MPS was used to enable the necessary language modularity. I demonstrate how we have integrated the Z3 solver to verify some aspects of programs. I present the architecture we have used to use KernelF-based DSLs in safety-critical environments. I close the keynote with an outlook on how KernelF might evolve in the future, and point out a few challenges for which we don't yet have good solutions.

  • 21.02.2018 | Sustainable Systems through DSLs
  • 30.10.2016 | Lessons learned about language engineering from the development of mbeddr
    M. Voelter
    ITSLE 2016 | PDF

    Over the last five years we have built mbeddr, a collection of integrated languages and language extensions built with the Jetbrains MPS language workbench. mbeddr consists of 81 languages, incl. IDE support, 34 of them C extensions. The mbeddr languages use a wide variety of notations – textual, tabular, symbolic and graphical – and the C extensions are modular; new extensions can be added without changing the existing implementation of C. mbeddr’s development has spanned roughly 15 person years so far, and the tool is used in practice and continues to be developed. This makes mbeddr a case study in language engineering of non-trivial size and complexity. In this keynote, I look back at mbeddr’s development to identify what worked well and what are still challenges in language engineering with a modern language workbench. I will address five areas: language modularity, notational freedom and projectional editing, mechanisms for managing complexity, performance and scalability issues and the consequences for the development process. I will close by highlighting a set of issues which need further research and engineering.

  • 28.09.2014 | The State of the Art in Language Workbenches
  • 15.10.2014 | Introducing Language-Oriented Business Applications
    M. Voelter
    JAXLondon 2014 | PDF

    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 | Language Workbenches - Opportunities and Challenges for V&V
    M. Voelter
    MoDeVVa 2014 Workshop | PDF

    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 | Language Shapes (Architectural) Thought
    M. Voelter
    European Conference on Software Architecture (ECSA) | PDF

    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 | Architecting Domain-Specific Languages
    M. Voelter
    DADA 2014 Workshop | PDF

    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 | Generic Tools, Specific Languages
    M. Voelter
    SDA 2013 | PDF

    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 | Domain-Specific Language Design - A conceptual framework for building good DSLs
    M. Voelter
    CodeGeneration 2012 | PDF



  • 06.10.2011 | Language Workbenches als Basis fuer integrierte Sprachentwicklung
  • 28.02.2011 | DSLs and Product Lines
    M. Voelter
    VAMOS 2011 Workshop | PDF



  • 27.03.2011 | The state of the art in (external) DSLs
    M. Voelter
    WGT 2011 Workshop | PDF

    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 | DSLs - Examples, Tools, Practices
    M. Voelter
    3rd RiSE International Summer School (RISS) | PDF

    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 | Modellierung und Programmierung - Zwei Welten?
    M. Voelter
    Insight 2009 | PDF

    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 | Language Workbenches and Software Product Lines
    M. Voelter
    Practical Product Lines 2009 | PDF

    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 | (Part 1) MDD, The Good, The Bad and The Ugly
    M. Voelter, Steven Kelly
    CodeGeneration 2009 | PDF

    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 | (Part 2) MDD, The Best, The Worst and The Ugliest
    M. Voelter, Steven Kelly
    CodeGeneration 2009 | PDF

    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 Keynote
    M. Voelter
    MDD und PLE Konferenz | PDF

    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 | Keynote ELEPES Workshop
    M. Voelter
    ELEPES Workshop 2008 | PDF



 
 

Invited Talks

(click on the titles to get to abstract and download)

  • 16.07.2019 | The future of DSLs - functions and formal methods
    M. Voelter
    Curry On 2019 | PDF

    I have used domain-specific languages to empower non-programmers in healthcare, finance, aerospace, automotive and public administration for years. My approach relies on growing the DSL from a functional programming core, combining the flexibility and power of an algorithmic language with domain-specific constructs that range from temporal data types, state machines and data models to polymorphic dispatch between versions of calculation rules. I rely on the open source MPS workbench to define the languages and their IDE. I am looking to incremental model transformations to desugar domain-specific constructs back to a minimal core language in realtime. That core language will have an interpreter for in-IDE execution and a compiler for deployment. The language will be integrated with formal methods to verify properties of programs, enabling advanced analyses for DSL users. In this talk, I will demo some existing DSLs, provide an illustration of how they are built, and demo prototypes of the future approach while discussing their integration with formal methods.

  • 06.11.2018 | Fusing Modeling and Programming into Language-Oriented Programming
    M. Voelter
    ISoLA 2018, UVMP Track | PDF

    Modeling in general is of course different from programming (think: climate models). However, when we consider the role of models in the context of “model-driven”, i.e., when they are used to automati- cally construct software, it is much less clear that modeling is different from programming. In this paper, I argue that the two are conceptually indistinguishable, even though in practice they traditionally emphasize different aspects of the (conceptually indistinguishable) common approach. The paper discusses and illustrates language-oriented programming, the approach to {modeling| programming} we have successfully used over the last 7 years to build a range of innovative systems in domains such as insurance, healthcare, tax, engineering and consumer electronics. It relies on domain-specific languages, modular language extension, mixed notations, and in particular, the Jetbrains MPS language workbench.

  • 17.10.2018 | Modeling of Business Logic to enhance Business Agility
  • 20.02.2018 | Why Modeling Suck Sucks
    M. Voelter
    Java User Group Ostfalen | PDF

    Kürzlich ist es mal wieder passiert: jemand hat vertwittert, welche Thesen und Probleme im Rahmen eines akademischen Workshop zum Thema 'Model-Driven' diskutiert wurden. Darunter Perlen wie: Passen Agil + Modellierung zusammen? Alle Modellierungswerkzeuge sind schlecht! Modellieren kann man auch mit Papier und Bleistift. Gibt es Wege aus der Modellierungskrise? Modellierungssprachen müssen nicht grafisch sein. Codegenerierung ist nicht der einzige Zweck von Modellen. Diese Diskussionen machen mich wahnsinnig. Denn die (industrielle) Model-Driven Community hat alle diese Fragen schon beanwortet (Ja, Nein, Nein, Keine Krise!, Echt?, Genau!) Die obigen Behauptungen oben kommen in aller Regel aus uninformierten (nicht nur akademischen) Kreisen, die in ihrem Verständnis von Sprachen, Modellen und Werkzeugen irgendwann vor 10 oder 15 Jahren stehengeblieben sind. In diesem Vortrag hoffe ich, mit diesen Vorurteilen aufzuräumen. End of Rant! Aber ernsthaft. Was wir heute in diesem Umfeld tun ist nicht mit UML Tools + Konsorten zu vergleichen. Auf Basis der Vorurteile oben diskutiere ich ein modernes Verständnis von Modellen und Modellierungssprachen, illustriere anhand von Jetbrains MPS aktuelle Werkzeuge und illustriere den Nutzen des ganzen anhand konkreter Beispiele aus unserer industriellen Praxis. Der eine oder andere berechtigte kritische Punkt kommt dabei auch zur Sprache.

  • 07.11.2014 | How Domains Shape Languages
    M. Voelter
    SPLASH 2016, Industry/Inspring/Invited Track | PDF

    Depending on the purpose of a language, its design will be completely different: the syntax may be textual, graphical, tabular, or a mix of those. It may be highly expressive, allowing users to define their own abstractions, or restricted, simplifying the language for non-programmer end users. The degree of formality may be different, depending on the domain for which the language is built and the assurances one must be able to make about the correctness of programs. Depending on performance requirements, a simple AST interpreter may be good enough for executing programs, or one may need an optimizing generator. I this talk, I revisit a number of languages we have built over the last five years. For each of them, I discuss the core design decisions as well as the drivers in the domain that led to those decisions. The talk includes languages for embedded software, insurance product definition, security analysis, health algorithms, engine control and system engineering. All of the languages discussed have been designed with and for industrial customers and have been implemented on the basis of the open source Jetbrains MPS language workbench.

  • 07.10.2014 | KernelF - Designing an extensible and embeddable functional language
    M. Voelter
    IFIP WG 2.16 Meeting, Lausanne | PDF

    Expressions and simple functional abstractions are at the core of almost every DSL we have been building over the last years, in domains ranging from embedded software to medical systems to insurance contracts. To avoid reimplementing this functional core over and over again, we have built KernelF, an extensible and embeddable functional language. It is built based on JetBrains MPS, which facilitates extension and embedding. Because of the focus on embedding and the reliance on a language workbench, the design decisions driving KernelF are quite different from other functional languages. In this talk I give an overview over the language, describe the design goals and the resulting design decisions and use a set of four case studies to evaluate the degree to which KernelF achieves the design goals.

  • 29.10.2015 | Language-Oriented Business Applications - Helping End Users become Programmers
    M. Voelter
    SPLASH 2015, Industry Track | PDF

    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 | Die Rolle von Modellen im Embedded Software Engineering
    M. Voelter
    Modeling of Embedded Systems Conference | PDF

    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 | Thoughts on the Collaboration between Software Engineers and Domain Experts (Dinner Speech)
    M. Voelter
    European Conference of Software Engineering Education 2014 | PDF

    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 | mbeddr's Support for Variability - features and challenges
    M. Voelter
    FOSD'14 Workshop | PDF

    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 | DSL Design
  • 07.12.2012 | mbeddr Language Design
    M. Voelter
    IFIP WG 2.16 Meeting, Austin



  • 14.12.2012 | Modeling and Progamming - isn't it all the same?
    M. Voelter
    CHOOSE Forum 2012 | PDF

    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 | Models, DSLs and Code Generation
    M. Voelter
    CERN Computing Seminar | PDF

    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 | Trends in Programming Languages
    M. Voelter
    ICALEPCS 2011

    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 | Language and IDE Development, Modularization and Composition with MPS
    M. Voelter
    GTTSE 2011 | PDF

    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 | Textual DSLs in Practice
    M. Voelter
    Modellierung 2011



  • 22.08.2011 | Thoughts on DSLs und PLE
  • 29.03.2011 | Domain-Specific Languages for Requirements
    M. Voelter
    RefSQ 2011 | PDF

    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 | Practical textual DSLs with Xtext and MPS
    M. Voelter
    Workshop on OCL and Textual Modelling

    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

(click on the titles to get to abstract and download)

  • 22.03.2019 | What's Missing
    M. Voelter
    Langdev 2019 | PDF

    In this talk I will present a number of issues that we run against in our work of building DSLs for and with customers, mostly on top of MPS. This is not an MPS wishlist, but rather the attempt at identifying general areas where tool support or even the conceptual approach are not yet as mature as for the basics of language engineering: syntax, type systems, generators and basic IDE support. An ideal outcome of this session would be the formation of groups of people who will work on some of these issues in the future. These issues include the construction of debuggers for various language paradigms, realtime incremental transformations of models, interactive guidance for end users (clippy for DSLs :-)), a practically-usable formalism for defining semantics from which interpreters and generators can be derived, as well as the more diffuse requirement for more “liveness” in DSLs of non-trivial complexity and model sizes.

  • 10.02.2019 | Using Language Workbenches and Domain-Specific Languages for Safety-Critical Software Development
    M. Voelter
    SE 2019 | PDF



  • 23.01.2019 | Accelerating Software Development in Digital Therapeutics
    M. Voelter, P. Alff
    OOP 2019 | PDF

    Mobile phones drive innovation in digital therapeutics by supporting patients during treatments. In this talk we discuss Voluntis' approach to accelerating software development by integrating healthcare professionals directly into the development process while at the same time complying with quality and process constraints imposed by regulatory bodies. We discuss the motivation, the business case and the technical approach. We conclude by explaining why the approach can be used in other safety-critical domains as well.

  • 18.10.2018 | Using language workbenches and domain-specific languages for safety-critical software development
    M. Voelter, B. Kolb, K. Birken, F. Tomassetti, P. Alff, L. Wiart, A. Wortmann, A. Nordmann
    Models 2018 (SOSYM First Presentation) | PDF

    Language workbenches support the efficient creation, integration, and use of domain-specific languages. Typically, they execute models by code generation to programming language code. This can lead to increased productivity and higher quality. However, in safety-/mission-critical environments, generated code may not be considered trustworthy, because of the lack of trust in the generation mechanisms. This makes it harder to justify the use of language workbenches in such an environment. In this paper, we demonstrate an approach to use such tools in critical environments. We argue that models created with domain-specific languages are easier to validate and that the additional risk resulting from the transformation to code can be mitigated by a suitably designed transformation and verification architecture. We validate the approach with an industrial case study from the healthcare domain. We also discuss the degree to which the approach is appropriate for critical software in space, automotive, and robotics systems.

  • 04.07.2018 | Deklarative Smart Contractss
    M. Voelter
    Java Forum Stuttgart 2018 | PDF

    Smart Contracts sind in aller Munde. Auf Basis von Blockchains soll die Ausführung von Verträgen zwischen mehreren Parteien (die sich nicht zwangsläufig vertrauen müssen) automatisiert werden. Blockchains stellen sicher, dass die im Vertrag definierten Regeln auch zwangsläufig eingehalten werden. Allerdings ist es mit existierenden Sprachen (wie bspw. Solidity) nicht so einfach, Veträge so zu implementieren, dass alle beteiligten Parteien (insbesondere auch nicht-Programmierer) verstehen welche Regeln denn nun in dem Vertrag definiert sind. Solidity ist letztendlich eine General-Purpose Programmiersprache, die typischen Muster für Mehr-Parteien-Verträge werden nicht direkt unterstützt. In diesem Vortrag zeige ich anhand konkreter Code-Beispiele, wie man kollaborative Verträge so beschreiben kann, dass das Verhalten leichter verständlich und leichter auf Korrektheit prüfbar ist. Dabei kommen unter anderem Zustandsmaschinen, deklarative Entscheidungsstrategien und Mechanismen zur Vermeidung spieltheoretischer Angriffe zum Einsatz. Die Implementierung beruht auf KernelF, einer funktionalen Sprache die wir über die letzten Jahre entwickelt haben um als Basis für domänenspezifische Sprachen zum Einsatz zu kommen. Da die Sprache mittels Jetbrains MPS entwickelt ist, lässt sie sich modular erweitern. Die Abstraktionen für Smart Contracts sind ein Beispiel für solcheErweiterungen. Der Talk dient damit auch als Illustration der Mächtigkeit funktionaler Sprachen sowie für Sprachbau mittels MPS.

  • 19.06.2018 | Build your own Language - Why and How?
    M. Voelter
    GOTO Amsterdam 2018 | PDF

    Are you responsible for developing satellite on-board software? Are you the Dutch government and you have to efficiently implement the public benefits law? Are you a healthcare startup, developing companion apps that help patients through a treatment? Are you an insurance company struggling to create new, and evolve existing products quickly to keep up with the market? These are all examples of organisations who have built their own domain-specific programming language to streamline the development of applications that have a non-trivial algorithmic core. All have built their languages with Jetbrains MPS, an open source language development tool optimized for ecosystems of collaborating languages with mixed graphical, textual, tabular and mathematical notations. This talk has four parts. I start by motivating the need for DSLs based on real-world examples, including the ones above. I will then present a few high-level design practices that guide our language development work. Third, I will develop a simple language extension to give you a feel for how MPS works. And finally, I will point you to things you can read to get you started with your own language development practice.

  • 08.06.2018 | Testing languages, generators and runtimes for a safety-critical system
    M. Voelter
    German Testing Days 2018 | PDF

    The use of domain-specific languages and custom code generators is often seen as incompatible with the requirements of software development in safety-critical contexts. This is mainly because the DSLs and custom generators are by definition no proven-in-use, and formally proving them correct is also hopeless. I this talk I will present an architecture that uses systematic testing and redundant execution to work around this problem. We validate the approach with a case study from the medical domain, where the approach was used successfully to develop mobile phone apps for prescriptions of medicine and monitoring of side-effects in chemotherapies. The case study relies on Jetbrains MPS, but the approach works for any DSL/generator technology.

  • 26.04.2018 | Funktionale Programmierung seziert - Interna einer funktionalen Sprache
    M. Voelter
    JAX 2018

    Die Grundlagen funktionaler Programmierung, also Funktionen, unveränderbare Daten, und Assign-once-Variablen sind einfach zu verstehen. Schwieriger wird es für fortgeschrittene Konzepte. Dazu zählen unter anderem Higher-Order-Funktionen, Currying, Effekt-Tracking und Caching von Funktionsaufrufen sowie der systematische Umgang mit veränderbaren Daten oder zustandsbehaftetem Verhalten. In dieser Session erkläre ich diese Techniken auf Basis einer minimalen funktionalen Sprache. Über die letzten Jahre habe ich eine eigene funktionale Programmiersprache gebaut, die als Kern von DSLs zum Einsatz kommt. Die Struktur und das Typsystem der Sprache sind in MPS entwickelt, die Semantik ist durch einen in Java implementierten Interpreter definiert. Alle Interna der Sprache sind also weitgehend deklarativ oder mittels Java-Code realisiert und eignen sich dadurch hervorragend zur Erläuterung der Konzepte. Die Session hat nicht zum Ziel, MPS als Language Workbench zu erklären. MPS ist nur didaktisches Werkzeug, um die Implementierung der interessanten Konzepte einer funktionalen Sprache zu erläutern. Die Session besteht zum Großteil aus Demo und Live Coding; keine Folien!

  • 25.04.2018 | Let’s build Fachlogik like they build Rockets!
    M. Voelter, B. Kolb
    JAX 2018 | PDF

    Immer mehr Geschäftsprozesse werden digitalisiert. Softwaresysteme werden komplizierter, sowohl was den Kern der Geschäftslogik angeht als auch bezüglich querschnittlicher Aspekte wie Variabilität und Individualisierung. Die Änderungs- oder Anpassungshäufigkeit steigt, die Time-to-Market sinkt. Effiziente Entwicklungsmethoden sind also mehr denn je entscheidend für den langfristigen Erfolg eines Unternehmens, um agil auf geänderte Anforderungen reagieren zu können. Aber gerade die Entwicklung der Fachlogik für Rechenkerne von Verträgen (Versicherung, Logistik), Tarifen (Telekommunikation, Transport), Diagnose (Medizin) oder Behörden (Steuern, Gebühren, Sozialkassen) folgt immer noch einem sehr dokumentenorientierten Ansatz. Fortschritte im Prozess, beispielsweise durch den Einsatz von Scrum, helfen nur bedingt weiter. In diesem Vortrag zeigen wir eine Möglichkeit auf, den Entwicklungsprozess für Fachlogik massiv zu beschleunigen. Der Ansatz stützt sich auf domänenspezifische (Programmier-)Sprachen, die von Fachexperten direkt einsetzbar sind, um die Fachlogik zu beschreiben. Dazu nutzen sie gemischte Notationen aus Text, Prosa, Tabellen, Diagrammen und mathematischen Ausdrücken. Auch Szenariosimulationen und fachliche Tests werden direkt von den Fachlern 'programmiert'. Der Vortrag besteht zum großen Teil aus Beispielen, in denen wir den Ansatz in der Praxis erfolgreich eingesetzt haben. Wir gehen auch kurz auf die (Open-Source-)Werkzeuge ein, mit denen wir die Sprachen entwickelt haben. Let’s build Fachlogik like they build rockets!

  • 17.04.2018 | Using DSLs for Implementing Variability
    M. Voelter
    VariantWorld 2018 | PDF



  • 19.04.2018 | Impressions of MPS DSLs
    M. Voelter
    Jetbrains MPS Intro Event 2018 | PDF

    MPS is unique among language workbenches in its support for a wide variety of notations and its real-world support for language modularity. In this talk, we present a survey of languages we have built for customers in a wide range of domains, including insurance, tax/salary, public benefits, automotive, space engineering and healthcare. For each language, we briefly outline our customer’s motivation for building the language as well as the particular features of MPS that made each of them successful.

  • 19.04.2018 | Interesting Tidbits around MPS
    M. Voelter
    Jetbrains MPS Community Meetup | PDF

    As you probably know, we have developed lots of different DSLs over the last ten years based on MPS and factored reusable assets into what is called the mbeddr.platform. In this talk, we will provide an overview over some of the recent development in this context. This includes the use of MPS-based DSLs in safety-critical contexts, the functional base language KernelF, the integration of an SMT solver with KernelF, as well as a few other reusable assets around systems engineering. We will conclude the talk with an introduction of the MPS Extensions project, where the stable parts of the platform will be maintained and evolved together with JetBrains.

  • 06.02.2018 | Formale Methoden in der Praxis - SMT Solver und Model Checker
    M. Voelter, D. Ratiu
    OOP 2018 | PDF

    Formale Analyse und Verifikation von Modellen und Programmen werden von vielen Praktikern als 'zu kompliziert' oder 'praxisuntauglich' verschmäht. Für manche Ansätze mag das stimmen, für andere definitiv nicht. Dieser Vortrag gibt einen Überblick über zwei Verifikationsansätze, die wir in der Praxis verwenden: SMT Solver und Model Checker. Wir illustrieren, wo und wie man sie auf Modellen und Code einsetzen kann, und dass sie eine für Praktiker sinnvolle Ergänzung zum Testen sein können.

  • 09.11.2017 | Sichere(re) Software durch bessere Abstraktion und statische Analyse
    M. Voelter, B. Kolb
    WJAX 2017 | PDF

    Neben einem geschärften Bewusstsein für Softwaresicherheit und der Schaffung von organisatorischen Randbedingungen, die eine sichere Entwicklung zulassen, sind auch die Sprachen und Werkzeuge, die wir zur Softwareentwicklung einsetzen, ein relevanter Faktor. Auch heute entstehen viele Sicherheitslücken immer noch aufgrund von Problemen wie Buffer Overruns, kaputter Zeigerarithmetik oder unvollständigen Verzweigungen oder Switch Fallthroughs. Um hier Fortschritte zu machen, sind bessere Abstraktionen der Schlüssel. In modernen Sprachen und VMs helfen sie, sicherheitsrelevante Fehler wie Buffer Overruns gar nicht erst entstehen zu lassen. Programmannotationen können für die statische Programmanalyse verwendet und ausgewertet werden. Passende Abstraktionen helfen aber auch dabei, die Programmlogik für Fachanwender besser verständlich zu machen. Dadurch wird die Software leichter reviewbar, und Teile der Implementierung können durch Generierung oder Interpretation automatisiert werden, was wiederum hilft, Low-level-Fehler zu vermeiden. In diesem Vortrag zeigen wir einige Beispiele, wie man mit diesen Mitteln Software robuster und damit sicherer entwickeln kann. Dabei kommen einige Konzepte aus der theoretischen Informatik zur Sprache (bspw. SMT Solver oder Model Checker), wir illustrieren alles aber mit konkreten Beispielen aus der Praxis. Damit sollte der Vortrag für jeden Softwareingenieur nachvollziehbar sein. Wir sprechen beispielhaft Werkzeuge wie Z3, MPS oder Xtext an, betonen aber die konzeptionellen Aspekte.

  • 06.09.2017 | DSLs für Fachexperten
    M. Voelter
    Solutions Hamburg 2017 | PDF

    DSLs erlauben den Fachexperten im Projekt die Kernfunktionalität eines Systems ausführbar zu beschreiben, ohne sich mit zu viel Implementierungstechnologie zu beschäftigen. Domänennahe Notationen (Text, Tabellen, Diagramme), interaktive Ausführung und Fachliche Tests machen das möglich.

  • 02.02.2017 | Moderne Programmierung durch Spracherweiterung und DSLs
    M. Voelter
    OOP 2017 | PDF

    Programmieren heißt unter anderem, Abstraktionen zu schaffen, um ein Problem effizient zu adressieren. Programmiersprachen stellen dazu die Mittel zur Verfügung, je nach Sprache sind diese für eine bestimmte Problemklasse unterschiedlich gut geeignet. Alternativ kann man die Sprache selbst an die Problemklasse anpassen, mit Vorteilen bzgl. der Analysierbarkeit des Codes, der Qualität von Fehlermeldungen, möglichen Optimierungen, sowie der Syntax. In diesem Vortrag erläutere ich diese Alternative anhand von Beispielen aus der Praxis.

  • 13.10.2016 | Komplette Isolation der Fachlichkeit mittels DSLs
    M. Voelter
    Architecture Gathering 2016 | PDF

    Ein Eckpfeiler der Softwarearchitektur ist die Separation of Concerns, also die Idee, unterschiedliche Aspekte eines Systems separat voneinander zu implementieren. Ziel ist, die einzelnen Aspekte leichter wartbar oder austauschbar zu gestalten. Der aus meiner Sicht wichtigste herauszulösende Aspekt ist die Fachlichkeit: diese sollte idealerweise völlig unabhängig von technischen Belangen implementiert werden, denn dadurch kann diese unabhängig vom Hype-Cycle der Technologien weiterentwickelt werden. Und idealerweise können dann sogar die Fachexperten (also Nicht-Programmierer) direkt dazu beitragen. Der Schlüssel um dieses Ziel zu erreichen liegt in der Verwendung (und/oder dem Bau) von Sprachen, mit denen die Fachlichkeit in Ihrer Reinform ausgedrückt werden kann. In diesem Vortrag führe ich die Idee von fachlichen Sprachen ein, zeige einige erfolgreiche Beispiele, diskutiere die Integration der damit beschriebenen Fachlichkeit mit der Implementierungsplattform, gebe ein paar Hinweise zum effizienten Bau von Sprachen, und erläutere einige Best Practices, die ich über die letzten Jahre bzgl. dieses Ansatzes gelernt habe.

  • 20.04.2016 | Fachexperten als Programmierer - Erfahrung aus 10 Jahren Projektarbeit
    M. Voelter, B. Kolb
    JAX 2016 | PDF

    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 | Not your Daddy’s Language
    M. Voelter
    JAX 2016 | PDF

    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 | Wir sind aber keine Programmierer!! Oder doch?
    M. Voelter, B. Kolb
    OOP 2016 | PDF

    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 | Maintaining Business Knowledge with Language Workbenches
    M. Voelter
    JAX Finance 2015 | PDF

    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 | Sprachorientierte Geschäftsanwendungen
    M. Voelter
    Frankfurter Entwicklertag 2015 | PDF

    [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 | Language Workbenches - The State of the Art in 2015
    M. Voelter
    OOP 2015 | PDF

    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 | Building mbeddr - a Language Engineering Experiment
    M. Voelter
    GPCE 2014 | PDF

    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 | The art of building tools - A language engineering perspective
    M. Voelter
    Craft Conference 2014 | PDF

    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 | On the way to DSLs for non-programmers
    M. Voelter, B. Kolb, J. Warmer
    Code Generation 2014 | PDF

    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 | Sprache? Formular? IDE? Applikation?
    M. Voelter, B. Kolb
    OOP 2014

    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 | mbeddr - Extensible Languages for Embedded Software Engineering
    M. Voelter
    The Future of Programming | PDF

    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 | The Art of Building Tools - A Language Engineering Perspective
    M. Voelter
    Oredev 2013 | PDF

    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 | Simplifying Complex Embedded Development Processes with mbeddr
    M. Voelter, Stefan Schmierer
    EclipseCon Europe 2013

    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 | DSLs und ihre Tools -- State of the Art
    M. Voelter
    JAX 2013 | PDF

    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 | Working with Multiple Languages - Why and How
    M. Voelter
    CodeGeneration 2013 | PDF

    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 | Improving C code quality using language extension
    M. Voelter
    Bits and Chips Embedded Systems 2012

    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 | Modular Erweiterbare (domaenenspezifische) Sprachen
    M. Voelter
    OOP 2013 | PDF

    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 | Werkzeuge zur DSL Entwicklung - State of the Art
    M. Voelter
    IBM DeveloperWorks Day 2012



  • 22.01.2013 | mbeddr - C Entwicklung fuer das 21. Jahrhundert
    M. Voelter, Bernd Kolb
    OOP 2013

    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 | DSL-Design - Ueber den Bau von guten DSLs
    M. Voelter
    W-JAX 2012 | PDF

    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 | Language Engineering mit Language Workbenches
    M. Voelter
    Java Forum Stuttgart 2012 | PDF

    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 | DSLs im Kontext agiler Softwareentwicklung
    M. Voelter
    Karlsruher Entwicklertage 2012 | PDF

    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 | Robuster C Code durch Spracherweiterung und Model Checking
    M. Voelter
    Karlsruher Entwicklertage 2012 | PDF

    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 | Language Modularity with the MPS Language Workbench
    M. Voelter
    ICSE 2012

    (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 | mbeddr C - an extensible version of the C programming language
    M. Voelter
    CodeGeneration 2012 | PDF

    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 | Refrigerators and DSLs
    M. Voelter
    EclipseCon Europe 2011 | PDF

    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 | Eckpfeiler und Trends der Software-Architektur
    M. Voelter
    TAE Symposium Software Architektur | PDF

    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 | Modellgetriebene Entwicklung und Domain-Specific Languages am Beispiel eingebetteter Systeme
    M. Voelter
    TAE Symposium Software Architektur | PDF

    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 | Architekturdokumentation
    M. Voelter
    TAE Symposium Software Architektur | PDF

    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 | Entwicklung eingebetteter Systeme mit Language Workbenches
    M. Voelter
    itemis Vortragsreihe Stuttgart | PDF

    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 | DSL Design
    M. Voelter
    OOP 2012 | PDF

    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 | Testen von DSLs
    M. Voelter
    OOP 2012 | PDF

    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 | DSLs - State of the Art
    M. Voelter
    Jazoon 2011 | PDF

    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 | Erweiterbare Programmiersprachen fuer die Embedded-Entwicklung
  • 25.05.2011 | Type Systems for DSLs
    M. Voelter
    CodeGeneration 2011 | PDF

    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 | Introduction to MPS
    M. Voelter, Alexander Shatalin
    CodeGeneration 2011



  • 17.06.2010 | Language Workbenches, Product Lines and Lego
    M. Voelter, Alexander Bernauer, Bernhard Merkle
    CodeGeneration 2010

    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 | Do-it-yourself Java-Spracherweiterung mit MPS
    M. Voelter
    JAX 2010 | PDF

    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 | DSLs, Modelle und Softwarearchitektur
    M. Voelter
    JAX 2010 | PDF

    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 | Einfuehrung eines modellbasierten Entwicklungsprozesses mit Open-Source Tools
    M. Voelter
    Embedded Systems Kongress 2009 | PDF

    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 | Using Domain-Specific Languages in Product Line Engineering
    M. Voelter
    OOP 2010 | PDF

    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 | From Programming to Modeling – and Back Again
    M. Voelter
    OOP 2010 | PDF

    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 | Live Coding - Embedded Entwicklung und Spracherweiterung mit MPS
    M. Voelter
    OOP 2011 | PDF

    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 | DSLs, Modelle und Softwarearchitektur
    M. Voelter
    OOP 2011 | PDF

    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 Software Development with Projectional Language Workbenches
    M. Voelter
    Embedded World Conference 2011 | PDF

    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 | Modellgetriebene Entwicklung fuer eingebettete Systeme mit Eclipse Tools am Beispiel
    M. Voelter, Andreas Graf
    OOP 2010 | PDF

    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 | Lightweight Model-Driven Development for Embedded Systems with Eclipse Tools
    M. Voelter, Andreas Graf
    Eclipse Summit Europe 2009 | PDF

    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 | Trends in Languages 2009
    M. Voelter
    Telekom TechTalk | PDF

    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 | Verbindung von Modellierung und Programmierung ueber DSLs
    M. Voelter
    Java User Group Stuttgart | PDF

    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 | Verbindung von Modellierung und Programmierung ueber DSLs
    M. Voelter
    Java User Group Mannheim | PDF

    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 | The interplay between Models, Generators and Variants
    M. Voelter, Andreas Graf
    Eclipse Embedded Day Stuttgart | PDF

    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 | Textual DSLs and Code Generation with Eclipse Tools
    M. Voelter
    Microsoft DSL Devcon | PDF

    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 | Architektur als Sprache
    M. Voelter
    JAX 2009 | PDF

    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 | DSL/MDSD Best Practices
    M. Voelter
    JAX 2009 | PDF

    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 | Trends in Sprachen 2009
    M. Voelter
    JAX 2009 | PDF

    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 | Best Practices fuer Modellgetriebene Entwicklung und DSLs
    M. Voelter
    SET 2009 | PDF

    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 | Architektur als Sprache
    M. Voelter
    Embedded Software Engineering Kongress 2008 | PDF

    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 | Modellgetriebene Softwareentwicklung mit Eclipse und openArchitectureWare
    M. Voelter
    Embedded Software Engineering Kongress 2008 | PDF

    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 | Architektur als Sprache – Architekturmodellierung mittels textueller DSLs
    M. Voelter
    OOP 2009 | PDF

    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 | Architekturdokumentation in der Praxis
    M. Voelter
    OOP 2009 | PDF

    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 | Six Design Principles Illustrated
    M. Voelter
    JAOO 2008 | PDF

    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 | Architektur Als Sprache
    M. Voelter
    W-JAX 2008 | PDF

    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 | Textuelle DSLs mit Eclipse Xtext
    M. Voelter
    prio.conference 2008 | PDF

    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 | Architekturdokumentation in der Praxis
    M. Voelter
    prio.conference 2008 | PDF

    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 | Architektur Als Sprache
    M. Voelter
    prio.conference 2008 | PDF

    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 | Implementation Technqiues for Domain-Specific Languages
    M. Voelter
    CodeGeneration 2008 | PDF

    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 | Building Interpreters with EMF, Xtext and Scala
    M. Voelter
    CodeGeneration 2008 | PDF

    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 | External Textual DSLs Made Simple
    M. Voelter
    QCon London 2008 | PDF

    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 | Textual DSLs with Eclipse Modeling
    M. Voelter, Bernd Kolb
    EclipseCon 2008 | PDF

    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 | Code Generation with M2T Xpand
    M. Voelter, Bernd Kolb
    EclipseCon 2008

    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 | Trends in Sprachen 2008
    M. Voelter
    JAX 2008 | PDF

    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 | 20 Grundkonzepte der Softwarearchitektur
    M. Voelter
    JAX 2008 | PDF

    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 | DSL Interpreter mit oAW und Scala
    M. Voelter
    JAX 2008 | PDF

    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 | Modellgetriebenes Produktlinien-Engineering
    M. Voelter
    OOP 2008 | PDF

    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 | Implementierungstechniken fuer DSLs
    M. Voelter
    OOP 2008 | PDF

    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 | Intentional Software - Democratizing Software Creation
    M. Voelter, Henk Kolk
    OOP 2008 | PDF

    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 | Writing Adaptable Software - Mechanisms for Implementing Variabilities in Code and Models
    M. Voelter
    JAOO 2007 | PDF

    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 | Writing Adaptable Software - Mechanisms for Implementing Variabilities in Code and Models
    M. Voelter
    TOOLS Europe 2007 | PDF

    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 | MDSD with Eclipse and oAW
    M. Voelter
    CodeGeneration 2007 | PDF

    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 | Introduction to Model-Driven Software Development
    M. Voelter
    INFWEST DSM | PDF

    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 | Model-Driven Software Development Best Practices
    M. Voelter
    INFWEST DSM | PDF

    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 | Model-to-model transformations using Eclipse tools
    M. Voelter
    EclipseCon 2007

    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 | Implementierungstechniken fuer domaenenspezifische Sprachen
    M. Voelter
    JAX 2007 | PDF

    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 | Hope Belief and Wizardry - ein zynischer Blick aufs Projektmanagement
    M. Voelter
    JAX 2007 | PDF

    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 | Textuelle domaenenspezifische Sprachen (DSLs)
    M. Voelter, Arno Haase, Sven Efftinge
    JAX 2007 | PDF

    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 | Funktional Objektorientiert - Einfuehrung in Scala
    M. Voelter
    JAX 2007 | PDF

    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 | Best Practices for DSLs illustrated with Eclipse Tools
    M. Voelter
    DSL Workshop TU Muenchen (Prof. Broy) | PDF

    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 | Textuelle Domaenen-spezifische Sprachen (DSLs)
    M. Voelter, Arno Haase, Sven Efftinge
    W-JAX 2006 | PDF

    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 | Modell-Transformationen in der Praxis (Teil 1 und 2)
    M. Voelter, Arno Haase, Sven Efftinge
    W-JAX 2006 | PDF

    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 | Warum SOA erst mit MDSD richtig Sinn macht
    M. Voelter
    W-JAX 2006 | PDF

    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 | SOA und MDSD
    M. Voelter
    OOP 2007 | PDF

    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 | Modellgetriebene Entwicklung von Eingebetteten Systemen
    M. Voelter
    OOP 2007 | PDF

    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 | Generieren vs. Interpretieren – Die andere Seite von MDSD
    M. Voelter
    OOP 2007 | PDF

    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 | Podcasting 101 – Eine uebersicht aus Sicht von Hoerer und Produzent
    M. Voelter
    OOP 2007 | PDF

    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 | Steigerung der Softwarequalitaet durch modellgetriebene Entwicklung
    M. Voelter
    Model-Driven Development and Product Lines - Synergies and Experience | PDF

    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 | What's new in Eclipse Modeling
    M. Voelter, Ed Merks, Rich Gronback, Bernd Kolb
    Eclipse Summit 2006

    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 | Best Practices for Building DSLs illustrated with Eclipse Tools
    M. Voelter
    JAOO 2006 | PDF

    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 | Softwarequalitaetssteigerung durch Einsatz Modellgetriebener Entwickung
    M. Voelter
    Fraunhofer Workshop IT-Produktivitaet

    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 | Modellgetriebene Softwareentwicklung mit openArchitectureWare 4
    M. Voelter, Arno Haase, Sven Efftinge
    ASQF

    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 | Model-Driven Development - From Frontend to Code
    M. Voelter, Sven Efftinge, Bernd Kolb
    Eclipse Forum Europe 2006 | PDF

    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 | Warum SOA erst mit Model Driven Development richtig Sinn macht
    M. Voelter
    JAX 2006 | PDF

    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 | Abbildung von Variabilitaeten in Softwaresystemen
    M. Voelter
    JAX 2006 | PDF

    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 | MDSD - Some Best Practices
    M. Voelter
    Java User Group Switzerland | PDF

    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 | MDSD Advanced – Fortgeschrittene Aspekte der Modellgetriebenen Entwicklung
    M. Voelter
    OOP 2006 | PDF

    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 | Languages, Models, Factories - wie das alles zusammenpasst
    M. Voelter
    OOP 2006 | PDF

    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 | Modellgetriebene Entwicklung von A-Z
    M. Voelter
    W-JAX 2005

    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 | Modellgetriebene Softwareentwicklung als Architekturkatalysator in Projekten
    M. Voelter
    W-JAX 2005 | PDF

    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 | Eine Kritische Betrachtung von Softwarearchitektur
    M. Voelter
    W-JAX 2005 | PDF

    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 | The Role of Patterns in Modern Software Engineering
    M. Voelter
    JAOO 2005 | PDF

    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 | Modellgetriebene Entwickung mit Eclipse
    M. Voelter
    iX Eclipse Konferenz 2005 | PDF

    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 | Using DSLs in Practice - Benefits and Challenges
    M. Voelter
    JAOO 2005 | PDF

    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 | Real-World MDA Distilled - Best Practices
    M. Voelter
    OMG Information Days (Frankfurt) | PDF

    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 | Real-World MDA Distilled - Best Practices
    M. Voelter
    OMG Information Days (Muenchen) | PDF

    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 | Modellgetriebene Softwareentwicklung - ein paar Tips fuer die Praxis
    M. Voelter
    ObjektForum Entwicklertag | PDF

    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 | Model-Driven Development of Distributed Systems
    M. Voelter
    ICALEPCS 2005 | PDF

    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 | Generierung grafischer Eclipse-Editoren mit GEF
    M. Voelter, Bernd Kolb
    JAX 2005 | PDF

    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 | Modelle und Aspekte - MDSD und AOP gemeinsam verwenden
    M. Voelter
    JAX 2005 | PDF

    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 | Modellgetriebene Entwicklung - Fortgeschrittene Konzepte
    M. Voelter
    JAX 2005 | PDF

    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 | Eine Kritische Betrachtung von Softwarearchitektur
    M. Voelter
    JAX 2005 | PDF

    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 | Domain-specific IDEs in embedded automotive software
    M. Voelter, Michael Rudorfer
    EclipseCon 2005 | PDF

    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 | Best Practices Modellgetriebener Softwareentwicklung
    M. Voelter
    openArchitecture 2004 | PDF

    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 | Best Practices Modellgetriebener Softwareentwicklung
    M. Voelter
    OOP 2005 | PDF

    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 | MDSD - Einfuehrung und Ueberblick
    M. Voelter
    OOP 2005 | PDF

    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 | Introduction to Domain-Driven Development Track
    M. Voelter
    JAOO 2004 | PDF



  • 21.09.2004 | Model-Driven Software Development - Best Practices
    M. Voelter
    JAOO 2004 | PDF

    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 | Geschaeftsanwendungen im Automotive-Bereich
    M. Voelter
    iX Eclipse Konferenz

    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 | Best Practices Modellgetriebener Softwareentwicklung
    M. Voelter
    JAX 2004

    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 | Patterns fuer Remoting-Infrastrukturen
    M. Voelter, Uwe Zdun
    JAX 2004 | PDF

    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 | Model-Driven Development - Best Practices
    M. Voelter
    SIEMENS Workshop on Product-Line Engineering | PDF

    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 | GUI Entwicklung mit Eclipse
    M. Voelter
    OOP 2004 | PDF

    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 | Metamodellierung
    M. Voelter
    OOP 2004 | PDF

    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 | Fit, Agil und Eclipse ? Ein Erfolgsbericht
    M. Voelter, Nicolai Josuttis, Jutta Eckstein, Frank Westphal
    OOP 2004 | PDF



  • 30.09.2003 | J2EE und .NET - ein Vergleich
    M. Voelter
    OMG Web Days



  • 23.09.2003 | Design and Implementation of an Asynchronous Invocation Framework for Web Services
    M. Voelter, Uwe Zdun, Michael Kircher
    ICWS'03 | PDF



  • 13.05.2003 | Codegenerierung mit Java
    M. Voelter
    JAX 2003 | PDF

    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 | Einsatz offener Standards im ALMA Projekt
    M. Voelter
    IIR Software Technology Forum 2002 | PDF

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

  • 26.01.2003 | Components, Remoting Middleware and Webservices - how it all fits together
    M. Voelter
    OOP 2003 | PDF

    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 | Common architectural variations for J2EE applications
    M. Voelter
    OOP 2003 | PDF

    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 | Component Infrastructures for embedded systems
    M. Voelter
    CDUF 2002 | PDF

    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 | .NET Remoting - Patterns und Beispiele
  • 05.11.2002 | Softwarearchitekturen heute
    M. Voelter
    IIR Software Technology Forum 2002 | PDF



  • 05.11.2002 | Gro?e J2EE-Projekte erfolgreich managen
    M. Voelter, Jutta Eckstein, Nico Josuttis
    IIR Software Technology Forum 2002 | PDF



  • 28.06.2002 | Metaprogrammierung und Reflection
  • 05.06.2002 | Backend architectures for Webservices
    M. Voelter, Christian Weyer
    XML ONE and Webservices 2002



  • 12.05.2002 | Metaprogrammierung in Java und Enterprise Systemen
    M. Voelter
    JAX 2002 | PDF



  • 12.05.2002 | Small Components - Ein Komponentenmodell fuer Kleingeraete
    M. Voelter
    JAX 2002 | PDF



  • 12.05.2002 | Moderne Softwareentwiclungsmethoden - GP, AOP, MDSOC und IP
    M. Voelter
    JAX 2002 | PDF



  • 03.03.2002 | Ueberblick ueber OMG's MDA
    M. Voelter
    MATHEMA Mini CAMPUS | PDF



  • 05.02.2002 | Komponenten fuer Kleingeraete
    M. Voelter
    Java User Group Stuttgart



  • 05.02.2002 | Comparing J2EE with .NET
    M. Voelter, Michael Stal
    ACCU 2002 | PDF



  • 05.02.2002 | Patterns in .NET
    M. Voelter, Michael Stal
    ACCU 2002 | PDF



  • 05.02.2002 | Patterns for Building fast and scalable EJB applications
  • 01.02.2002 | Komponenten in embedded Systemene
    M. Voelter
    Arbeitskreis OOT Hannover



  • 24.01.2002 | Patterns for Building fast and scalable EJB applications
    M. Voelter
    OOP 2002 | PDF



  • 24.01.2002 | XML in der Objektorientierten Programmierung
    M. Voelter
    OOP 2002 | PDF



  • 30.06.2001 | Component Patterns
  • 04.06.2001 | Evolution in Software Engineering
    M. Voelter
    CDUF 2001 | PDF



  • 04.04.2001 | Constraints in Java
    M. Voelter
    JAX 2001 | PDF



  • 04.04.2001 | Component Patterns - EJB, CCM, COM+
    M. Voelter
    JAX 2001 | PDF



 
 

Tutorials

(click on the titles to get to abstract and download)

  • 04.12.2017 | Formale Methoden der Programm- und Modellanalyse
    M. Voelter, K. Birken
    ESE-Kongress 2017 | PDF

    Formale Methoden haben den Ruf, nicht praxistauglich zu sein. Das ändert sich aber gerade: Die Werkzeuge skalieren besser, die Usability steigt. Und aufgrund der steigenden Komplexität von Software bei gleichzeitig hohen Anforderungen an deren Zuverlässigkeit wächst der Bedarf für Garantien bzgl. Korrektheit. Dieser Vortrag ist eine pragmatische Einführung in formale Methoden: Wir erklären intuitiv, wie verschiedene Methoden funktionieren, und zeigen Einsatzszenarien und -grenzen auf. Dabei legen wir unsere eigenen Erfahrungen bei der Erarbeitung dieses Themenkomplexes über die letzen Jahren zugrunde. Vorkenntnisse in theoretischer Informatik sind nicht nötig. Im Vortrag gehen wir ein auf Datenflussanalyse, Discrete-Event-Simulation (zur Timinganalyse), SMT Solving (Verifikation von Ausdrücken und funktionalen Abstraktionen), und Modelchecking (Verifikation von zeitlich variablem Verhalten). Wir betrachten sowohl die Verifikation von C Code, als auch die von Modellen (UML/DSLs).

  • 28.09.2013 | DSL Engineering
    M. Voelter
    Models 2013 | PDF

    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 | Spracherweiterungen und Verifikation - C Entwicklung fuer das 21. Jahrhundert mit mbeddr
    M. Voelter, Bernd Kolb, Dan Ratiu
    SE 2013

    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 | Massgeschneidert - Language Engineering mit MPS
    M. Voelter, Bernd Kolb
    Herbstcampus 2012

    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 | C - Spracherweiterung und formale Methoden
    M. Voelter, Bernd Kolb
    ESE Kongress 2012 | PDF

    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 | Make this YOUR Java
    M. Voelter
    W-JAX 2012

    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 | Domain-Specific Language Design
    M. Voelter
    ICSE 2012 | PDF

    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 | Language Workbenches, Embedded Software and Formal Verification
    M. Voelter
    MODELS 2012 | PDF

    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 | DSLs for Product Lines - Approaches, Tools, Experiences
    M. Voelter
    SPLC 2011 | PDF

    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 | Implementing DSLs with Xtext and MPS
    M. Voelter
    ICALEPCS 2011

    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 | Dokumentation von Softwarearchitekturen
    M. Voelter
    JAX on TOUR 2010 | PDF

    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 | DSLs, Modelle und Softwarearchitektur
    M. Voelter
    JAX on TOUR 2010 | PDF

    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 | Language Definition and Extension with MPS
    M. Voelter
    GPCE 2010 | PDF

    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 | Language Composition and Extension with Language Workbenches
    M. Voelter, Eelco Visser
    SPLASH 2010 | PDF

    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 | Language Extension with MPS
    M. Voelter, Konstantin Solomatov
    CodeGeneration 2010

    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 | Durchstarten mit Scala
    M. Voelter, Arno Haase, Heiko Seeberger
    JAX 2010

    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 | Software Engineering mit Domaenenspezifischen Sprachen und Language Workbenches
    M. Voelter, Peter Friese
    SE 2010 | PDF

    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 | DSLs with Eclipse Modeling
    M. Voelter, Karsten Thoms, Sebastian Zarnekow, Jan Koehnlein
    Eclipse Summit Europe 2009

    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 | Using Domain-Specific Languages for Product Line Engineering
    M. Voelter
    SPLC 2009 | PDF

    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 | Textual Modeling and Language Composition
    M. Voelter, Eelco Visser
    MODELS 2009

    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 | Textual DSLs and Code Generators
    M. Voelter
    OOPSLA 2008

    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 | Textual DSLs - Concepts and Tooling
    M. Voelter
    OOPSLA 2008

    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 | Architecture As Language
    M. Voelter
    OOPSLA 2008 | PDF

    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 | Architecture As Language
    M. Voelter
    JAOO 2008 | PDF

    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 | Architecture As Language
    M. Voelter
    OOPSLA 2008 | PDF

    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 | Hands-On DSLs with Eclipse Tools
    M. Voelter
    QCon London 2008 | PDF

    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 | An introduction to Model-driven-development using Eclipse Tools
    M. Voelter, Bernd Kolb
    EclipseCon 2008

    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 | Using GMF and M2M for Model-driven-development
    M. Voelter, Bernd Kolb, Radomil Dvorak, Tatiana Fesenko
    EclipseCon 2008

    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 | Using M2T and TMF for Model-driven-development
    M. Voelter, Bernd Kolb
    EclipseCon 2008

    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 | Software Architecture Documentation in the Real World
    M. Voelter
    OOPSLA 2007 | PDF

    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 | Best Practices for Model-Driven Development
    M. Voelter
    OOPSLA 2007 | PDF

    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 | Writing Adaptable Software - Mechanisms for Implementing Variabilities in Code and Models
    M. Voelter
    OOPSLA 2007 | PDF

    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 | MDD-TIF07 Model-Driven Development Tool Implementers Forum
    M. Voelter
    TOOLS 2007

    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 | MDSD from Frontend to Code using Eclipse Modeling Technologies
    M. Voelter
    EclipseCon 2007

    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 | Model-Driven Engineering of Distributed Systems
    M. Voelter, Doug Schmidt
    Models 2006 | PDF

    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 | Building Domain Specific Languages with Eclipse
    M. Voelter
    JAOO 2006

    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 | Building Domain Specific Languages with Eclipse and openArchitectureWare
    M. Voelter, Arno Haase
    GPCE 2006 | PDF

    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 | Model-Driven Development of Distributed Systems
    M. Voelter, Doug Schmidt
    OOPSLA 2006 | PDF

    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 | Modellgetriebene Entwicklung mit openArchitectureWare 4
    M. Voelter
    JAX 2006

    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 | Models and Aspects - Handling Cross-Cutting Concerns in Model-Driven Software Development
    M. Voelter
    AOSD 06 | PDF

    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 | Model-Driven Development - State of the Art
    M. Voelter, Tom Stahl, Doug Schmidt
    OOP 2006 | PDF

    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 | Einstieg in die Modellgetriebene Softwareentwicklung
    M. Voelter
    W-JAX 2005

    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 | Models and Aspects - How to use MDSD and AOSD together
    M. Voelter, Martin Lippert
    OOPSLA 2005 | PDF

    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 | Models and Aspects - How to use MDSD and AOSD together
    M. Voelter
    ECMDA-FA 2005 | PDF

    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 | Modellgetriebene Softwareentwicklung - Quick Start
    M. Voelter
    JAX 2005

    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 | Model-Driven Software Development - Introduction and Best Practices
    M. Voelter, Jorn Bettin
    OOPSLA 2004 | PDF

    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 | Desktop-Anwendungen entwickeln auf Basis der Rich-Client-Plattform
  • 20.04.2004 | Modellgetriebene Softwareentwicklung - Einfuehrung und Best Practices
    M. Voelter
    OMG Days, Muenchen

    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 | Modellgetriebene Softwareentwicklung in der Praxis
    M. Voelter
    JAX 2004

    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 | Rich Client GUI Entwicklung mit Eclipse
    M. Voelter
    JAX 2004

    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 | Code Generations - Techniques and Concepts
    M. Voelter
    LTT OMG Briefing 2004 | PDF

    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 | MDA praktisch (mit Hands-On Session)
    M. Voelter
    W-JAX 2003 | PDF



  • 25.10.2003 | Code Generation - Techniques and Concepts
    M. Voelter
    OOPSLA 2003 | PDF

    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 | J2EE in practice - Architectural variations in the context of enterprise systems
    M. Voelter, Arne Koschel
    OOPSLA 2003



  • 25.09.2003 | Common architectural variations for J2EE applications
    M. Voelter
    JAOO 2003



  • 25.09.2003 | Component Patterns
    M. Voelter
    JAOO 2003



  • 15.09.2003 | Einfuehrung in MDA
    M. Voelter
    openMDA 2003 | PDF



  • 15.09.2003 | Codegenerierung - entzaubert!
    M. Voelter
    openMDA 2003 | PDF



  • 14.05.2003 | Real-Life MDA - Modellgetriebene Java Entwicklung
    M. Voelter
    JAX 2003 | PDF

    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 | Source Code Generation - Concepts, Techniques and Tools
    M. Voelter
    ECOOP 2003 | PDF

    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 | OO Remoting Foundations of OO remote procedure call middleware
    M. Voelter
    Net.ObjectDays 2002 | PDF

    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 | Component containers as a foundation for software system families
    M. Voelter
    CDUF 2002 | PDF

    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 | J2EE und .NET im Vergleich
    M. Voelter
    IIR Software Technology Forum 2002 | PDF



  • 10.06.2002 | Patterns for building Component Infrastructures
    M. Voelter
    ECOOP 2002 | PDF



  • 24.01.2002 | Tutorial zu Generative Programming
    M. Voelter, Ulrich Eisenecker
    OOP 2002



  • 04.11.2001 | Moderne Softwareentwicklungsmethoden - AOP, GP, IP und MDSOC
    M. Voelter
    IIR Software Technology Forum 2001 | PDF



  • 10.09.2001 | Component Patterns
    M. Voelter, Alexander Schmid
    NetObjectDays 2001