Publications


Journal Papers

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

  • 18.05.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
    SOSYM Online; Issue TBA | 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.

  • 14.10.2017 | Automated Testing of DSL Implementations - Experiences from Building mbeddr
    D. Ratiu, M. Völter, D. Pavletic
    SQJ Online; Issue TBA | PDF

    Domain-specific languages promise to improve productivity and quality of software development by providing problem-adequate abstractions to developers. Projectional language workbenches, in turn, allow the definition of modular and extensible domain specific languages, generators, and development environments. While recent advances in language engineering have enabled the definition of DSLs and tooling in a modular and cost-effective way, the quality assurance of their implementation is still challenging. In this paper, we discuss our work on testing different aspects of the implementation of domain specific languages and associated tools, and present several approaches to increase the automation of language testing. We illustrate these approaches with the Jetbrains MPS language workbench and our experience with testing mbeddr, a set of domain specific languages and tools on top of C tailored to embedded software development. Based on the experience gained from the mbeddr project, we extract generic lessons for practitioners as well as challenges which need more research.

  • 09.01.2017 | Lessons Learned from Developing mbeddr - A Case Study in Language Engineering with MPS
    M. Völter, B. Kolb, T. Szabo, D. Ratiu, A. van Deursen
    SOSYM Online; Issue TBA | PDF

    Language workbenches are touted as a promising technol- ogy to engineer languages for use in a wide range of do- mains, from programming to science to business. However, not many real-world case studies exist that evaluate the suit- ability of language workbench technology for this task. This paper contains such a case study. In particular, we evaluate the development of mbeddr, a collection of integrated languages and language extensions built with the Jetbrains MPS language workbench. mbeddr consists of 81 languages, with their IDE support, 34 of them C extensions. The mbeddr languages use a wide va- riety 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 10 person years so far, and the tool is used in practice and continues to be devel- oped. This makes mbeddr a meaningful case study of non- trivial size and complexity. The evaluation is centered around five research questions: language modularity, notational freedom and projectional editing, mechanisms for managing complexity, performance and scalability issues and the consequences for the develop- ment process.

  • 31.08.2015 | Evaluating and Comparing Language Workbenches - Existing Results and Benchmarks for the Future
    S. Erdweg, T. van der Storma, M. Völter, L. Tratt et al.
    Computer Languages, Systems and Structures tbd | PDF

    Language workbenches are environments for simplifying the creation and use of com- puter languages. The annual Language Workbench Challenge (LWC) was launched in 2011 to allow the many academic and industrial researchers in this area an opportunity to quantitatively and qualitatively compare their approaches. We first describe all four LWCs to date, before focussing on the approaches used, and results generated, during the third LWC. We give various empirical data for ten approaches from the third LWC. We present a generic feature model within which the approaches can be understood and contrasted. Finally, based on our experiences of the existing LWCs, we propose a number of benchmark problems for future LWCs.

  • 12.07.2014 | Projecting a Modular Future
    M. Voelter, B. Kolb, J. Warmer
    IEEE Software tbd | PDF

    We describe two innovations in programming languages: modularity and projectional editing. Language modularity refers to the ability to combine independently developed languages without changing their respective definitions. A language is not anymore a fixed quantity, instead it can be extended with domain-specific constructs as needed. Projectional editing refers to a technique of building editors and IDEs that avoid the need for parsers. They support a wide range of tightly integrated notations including textual, symbolic, tabular and graphical. In addition, by avoiding parsers, the well-known limitations of grammar composition are avoided as well. The article illustrates the consequences of these two innovations for the design of (programming) languages with three examples. First, we discuss a set of modular extensions of C for embedded programming that enables efficient code generation and formal analysis. Second, we discuss a language for requirements engineering that flexibly combines structured and unstructured (prose) data. Third, we illustrate a language for defining insurance rules that makes use of mathematical notations. All examples rely on the open source JetBrains MPS language workbench.

  • 01.12.2013 | mbeddr -- Instantiating a Language Workbench in the Embedded Software Domain
    M. Voelter, Daniel Ratiu, Bernd Kolb, Bernhard Schaetz
    Journal of Automated Software Engineering | PDF

    Tools can boost software developer productivity, but building custom tools is prohibitively expensive, especially for small organizations. For example, embedded programmers often have to use low-level C with limited IDE support, and integrated into an off-the-shelf tool chain in an ad-hoc way. To address these challenges, we have built mbeddr, an extensible language and IDE for embedded software development based on C. mbeddr is a large- scale instantiation of the Jetbrains MPS language workbench. Exploiting its capabilities for language modularization and composition, projectional editing and multi-stage transformation, mbeddr is an open and modular framework that lets third parties add extensions to C with minimal effort and without invasive changes. End users can combine extensions in programs as needed. To illustrate the approach, in this paper we discuss mbeddr's support for state machines, components, decision tables, requirements tracing, product line variability and program verification and outline their implementation. We also present our experience with building mbeddr, which shows that relying on language workbenches dramatically reduces the effort of building customized, modular and extensible languages and IDEs to the point where this is affordable by small organizations. Finally, we report on the experience of using mbeddr in a commercial project, which illustrates the benefits to end users.

  • 15.05.2010 | Architecture As Language
    M. Voelter
    IEEE Software March/April 2010 | 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).

  • 31.12.2009 | Aspect-Oriented Model-Driven Software Development
    I. Groher, M. Voelter
    Transactions on Aspect-Oriented Software Development VI | PDF

    Software product line engineering aims to reduce develop- ment time, effort, cost, and complexity by taking advantage of the com- monality within a portfolio of similar products. The effectiveness of a software product line approach directly depends on how well feature variability within the portfolio is implemented and managed through- out the development lifecycle, from early analysis through maintenance and evolution. This article presents an approach that facilitates vari- ability implementation, management, and tracing by integrating model- driven and aspect-oriented software development. Features are separated in models and composed by aspect-oriented composition techniques on model level. Model transformations support the transition from problem to solution space models. Aspect-oriented techniques enable the explicit expression and modularization of variability on model, template, and code level. The presented concepts are illustrated with a case study of a home automation system.

  • 01.06.2004 | Pattern-Based Design of an Asynchronous Invocation Framework for Web Services
    Uwe Zdun, Michael Kircher, M. Voelter
    International Journal on Webservice Research 2004-05 | PDF

    Asynchronous invocations are needed in the context of distributed object frameworks to prevent clients from blocking during remote invocations. Popular Web Service frameworks offer only synchronous invocations (over HTTP). An alternative are messaging protocols but these implement a different communication paradigm. When client asynchrony is not supported, client developers have to build asynchronous invocations on top of the synchronous invocation facility. But this is tedious, error-prone, and might result in different remote invocation styles used within the same application. We present a number of patterns for asynchronous invocations and explain how these patterns can be used to build asynchronous invocation facilities for Web Service frameworks. We exemplify this approach by explaining the design and implementation of an asynchronous invocation framework for Apache Axis.

 
 

Conference Papers

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

  • 10.10.2021 | Programming vs. That Thing Subject Matter Experts Do
    M. Voelter
    | PDF

    Allowing subject matter experts to directly contribute their domain knowledge and expertise to software through DSLs and automation is a promising way to increase overall software development efficiency and the quality of the product. However, there are doubts of whether this will force subject matter experts to become programmers. In this paper I answer this question with 'no'. But at the same time, subject matter experts have to learn how to communicate clearly and unambiguously to a computer, and this requires some aspects of what is traditionally called programming. The main part of this paper discusses what these aspects are and why learning these does not make people programmers.

  • 20.10.2018 | Shadow Models - Incremental Transformations for MPS
    M. Voelter, K. Birken, S. Lisson, A. Rimer
    | PDF

    Shadow Models is an incremental transformation framework for MPS. The name is motivated by the realization that many analyses are easier to do on an model whose structure is different from what the user edits. To be able to run such analyses interactively in an IDE, these “shadows” of the user- facing model must be maintained in realtime, and incremen- tality can deliver the needed short response times. Shadow Models is an incremental model transformation engine for MPS. In the paper we motivate the system through example use cases, and outline the transformation framework.

  • 06.11.2018 | Fusing Modeling and Programming into Language-Oriented Programming
    M. Voelter
    | 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.

  • 06.11.2018 | Incrementalizing Lattice-Based Program Analyses in Datalog
    T. Szabo, G. Bergmann, S. Erdweg, M. Voelter
    | PDF

    Program analyses detect errors in code but have to trade off precision, recall, and performance. However, when code changes frequently as in an IDE, repeated re-analysis from-scratch is unnecessary and leads to poor performance. Incremental program analysis promises to deliver fast feedback after a code change by deriving a new analysis result from the previous one, and prior work has shown that order-of-magnitude performance improvements are possible. However, existing frameworks for incremental program analysis are limited in expressive power because they only consider the powerset lattice as the representation of the analysis result. This is also true for prior approaches for incremental Datalog evaluation because relations encoded by Datalog rules also compute sets of tuples. This is a problem because many practically relevant analyses build on custom lattices and aggregation over lattice values. To solve this problem, we take our existing IncA incremental program analysis framework that supports relational analyses, and we extend it with lattice-based computations. Our extension is based on a novel algorithm that enables the incremental maintenance of recursive lattice-value aggregation, which occurs when analyzing code with cyclic control flow by fixpoint iteration. To demonstrate our approach, we realized strong-update points-to analysis and string analyses for Java in IncA and present performance measurements that demonstrate incremental analysis updates within milliseconds.

  • 25.06.2018 | The Design, Evolution and Use of KernelF [invited paper]
    M. Voelter
    | 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.

  • 30.10.2017 | Robust Projectional Editing
    F. Steimann, M. Frenkel, M. Voelter
    | PDF

    While contemporary projectional editors make sure that the edited programs conform to the programming language's metamodel, they do not enforce that they are also well-formed, that is, that they obey the well-formedness rules defined for the language. We show how, based on a constraint-based capture of well-formedness, projectional editors can be empowered to enforce well-formedness in much the same way they enforce conformance with the metamodel. The resulting robust edits may be more complex than ordinary, well-formedness breaking edits, and hence may require more user involvement; yet, maintaining well-formedness at all times ensures that necessary corrections of a program are linked to the edit that necessitated them, and that the projectional editor's services are never compromised by inconsistent programs. Robust projectional editing is not a straitjacket, however: If a programmer prefers to work without it, its constraint-based capture of well-formedness will still catch all introduced errors --- unlike many other editor services, well-formedness checking and robust editing are based on the same implementation, and are hence guaranteed to behave consistently.

  • 02.11.2016 | Efficient Development of Consistent Projectional Editors using Grammar Cells
    M. Voelter, T. Szabo, S. Lisson, B. Kolb, S. Erdweg, T. Berger
    | PDF

    The definition of a projectional editor does not just specify the notation of a language, but also how users interact with the notation. Because of that it is easy to end up with different interaction styles within one and between multiple languages. The resulting inconsistencies have proven to be a major usability problem. To address this problem, we introduce grammar cells, an approach for declaratively specifying textual notations and their interactions for projectional editors. In the paper we motivate the problem, give a formal definition of grammar cells, and define their mapping to low-level editor behaviors. Our evaluation based on project experience shows that grammar cells improve editing experience by providing a consistent and intuitive ``text editor-like'' user experience for textual notations. At the same time they do not limit language composability and the use of non-textual notations, the primary benefits of projectional editors. We have implemented grammar cells for Jetbrains MPS, but they can also be used with other projectional editors.

  • 10.10.2016 | Modeling and Optimizing Automotive Electric/Electronic (E/E) Architectures - Towards Making Clafer Accessible to Practitioners
    E. Khalilov, M. Ross, M. Antkievicz, M. Voelter, K. Czarnecki
    | PDF

    The definition of a projectional editor does not just specify the notation of a language, but also how users interact with the notation. Because of that it is easy to end up with different interaction styles within one and between multiple languages. The resulting inconsistencies have proven to be a major usability problem. To address this problem, we introduce grammar cells, an approach for declaratively specifying textual notations and their interactions for projectional editors. In the paper we motivate the problem, give a formal definition of grammar cells, and define their mapping to low-level editor behaviors. Our evaluation based on project experience shows that grammar cells improve editing experience by providing a consistent and intuitive ``text editor-like'' user experience for textual notations. At the same time they do not limit language composability and the use of non-textual notations, the primary benefits of projectional editors. We have implemented grammar cells for Jetbrains MPS, but they can also be used with other projectional editors.

  • 28.09.2016 | An Extensible Framework for Variable-Precision Data-Flow Analyses in MPS
    T. Szabo, S. Alperovich, M. Voelter, S. Erdweg
    | PDF

    Data-flow analyses are used as part of many software engineering tasks: they are the foundations of program understanding, refactorings and optimized code generation. Similar to general-purpose languages (GPLs), state-of-the-art domain-specific languages (DSLs) also require sophisticated data-flow analyses. However, as a consequence of the different economies of DSL development and their typically relatively fast evolution, the effort for developing and evolving such analyses must be lowered compared to GPLs. This tension can be resolved with dedicated support for data-flow analyses in language workbenches. In this tool paper we present MPS-Dataflow, which is the component in the MPS language workbench that supports the definition of data-flow analyses for DSLs. Language developers can define data-flow graph builders declaratively as part of a language definition and compute analysis results efficiently based on these data-flow graphs. MPS-Dataflow is extensible such that it does not compromise the support for language composition in MPS. Additionally, clients of MPS-Dataflow analyses can run the analyses with variable precision thus trading off precision for performance. This allows clients to tailor an analysis to a particular use case.

  • 28.09.2016 | IncA - A DSL for the Definition of Incremental Program Analyses
    T. Szabo, S. Erdweg, M. Voelter
    | PDF

    Program analyses support software developers, for example, through error detection, code-quality assurance, and by enabling compiler optimizations and refactorings. To provide real-time feedback to developers within IDEs, an analysis must run efficiently even if the analyzed code base is large. To achieve this goal, we present a domain-specific language called IncA for the definition of efficient incremental program analyses that update their result as the program changes. IncA compiles analyses into graph patterns and relies on existing incremental matching algorithms. To scale IncA analyses to large programs, we describe optimizations that reduce caching and prune change propagation. Using IncA, we have developed incremental control flow and points-to analysis for C, well-formedness checks for DSLs, and 10 FindBugs checks for Java. Our evaluation demonstrates significant speedups for all analyses compared to their non-incremental counterparts.

  • 13.11.2016 | Efficiency of Projectional Editing - A Controlled Experiment
    T. Berger, M. Voelter, H.-P. Jensen, T. Dangprasert, J. Siegmund
    | PDF

    Projectional editors are editors where a user's editing actions directly change the abstract syntax tree without using a parser. They promise essentially unrestricted language composition as well as flexible notations, which supports aligning languages with their respective domain and constitutes an essential ingredient of model-driven development. Such editors have existed since the 1980s and gained widespread attention with the Intentional Programming paradigm, which used projectional editing at its core. However, despite the benefits, programming still mainly relies on editing textual code, where projectional editors imply a very different---typically perceived as worse---editing experience, often seen as the main challenge prohibiting their widespread adoption. We present an experiment of code-editing activities in a projectional editor, conducted with 19 graduate computer-science students and industrial developers. We investigate the effects of projectional editing on editing efficiency, editing strategies, and error rates---each of which we also compare to conventional, parser-based editing. We observe that editing is efficient for basic-editing tasks, but that editing strategies and typical errors differ. More complex tasks require substantial experience and a better understanding of the abstract-syntax-tree structure---then, projectional editing is also efficient. We also witness a tradeoff between fewer typing mistakes and an increased complexity of code editing.

  • 28.10.2015 | Using C Language Extensions for Developing Embedded Software - A Case Study
    M. Voelter, A. van Deursen, B. Kolb, S. Eberle
    | PDF

    We report on an industrial case study on developing the embedded software for a smart meter using the C programming language and domain-specific extensions of C such as components, physical units, state machines, registers and interrupts. We find that the extensions help significantly with managing the complexity of the software. They improve testability mainly by supporting hardware-independent testing, as illustrated by low integration efforts. The extensions also do not incur significant overhead regarding memory consumption and performance. Our case study relies on mbeddr, an extensible version of C. mbeddr, in turn, builds on the MPS language workbench which supports modular extension of languages and IDEs.

  • 21.02.2015 | Extensible Debuggers for Extensible Languages
    D. Pavletic, M. Voelter, S. A. Raza, B. Kolb, T Kehrer
    | PDF

    Language extension enables integration of new language constructs without invasive changes to a base language (e. g., C). Such extensions help to build more reliable software by using proper domain-specific abstractions. Language workbenches significantly reduce the effort for building such extensible languages by synthesizing a fully-fledged IDE from language definitions. However, in contemporary tools, this synthesis does not include interactive debugging for programs written with the base language or its extensions. This paper describes a generic framework for extensible debuggers that enables debugging of the language extensions by definig mappings between the base language and the language extensions. The architecture is designed for extensibility, so debug support for future extensions can be contributed with little effort. We show an implementation of our approach for mbeddr, which is an extensible version of the C programming language. We also discuss the debugger implementation for non-trivial C extensions such as components. Finally, the paper discusses the extent to which the approach can be used with other base languages, debugger backends and language workbenches.

  • 20.09.2014 | Automated Domain-Specific C Verification with mbeddr
    Z. Molotnikov, M. Voelter, D. Ratiu
    | PDF

    When verifying C code, two major problems must be addressed. One is the specification of the verification conditions, the other one is the construction of the verification environment. Neither C itself, nor existing C verification tools, offer the means to efficiently specify application domain-level verification conditions and environments. These two shortcomings hamper the usability of C verification, and limit its adoption in practice. In this paper we introduce an approach that addresses both problems and results in user-friendly and practically usable C verification. The novelty of the approach is the combination of domain-specific language engineering and C verification. We apply the approach in the domain of state-based software, using mbeddr and CBMC. We validate the implementation with an example from the Pacemaker Challenge, developing a functionally verified, lightweight, and deployable cardiac pulse generator. The approach itself is domain-independent.

  • 20.09.2014 | Towards User-Friendly Projectional Editors
    M. Voelter, J. Siegmund, T. Berger, B. Kolb
    | PDF

    Today's challenges for language development include language extension and composition, as well as the use of diverse notations. A promising approach is projectional editing, a technique to directly manipulate the abstract syntax tree of a program, without relying on parsers. Its potential lies in the ability to combine diverse notational styles -- such as text, symbols, tables, and graphics -- and the support for a wide range of composition techniques. However, projectional editing is often perceived as problematic for developers. Expressed drawbacks include the unfamiliar editing experience and challenges in the integration with existing infrastructure. In this paper we investigate the usability of projectional editors. We systematically identify usability issues resulting from the architecture. We use JetBrains Meta Programming System (MPS) as a case study. The case study discusses the concepts that MPS incorporates to address the identified issues, evaluates effectiveness of these concepts by surveying professional developers, and reports industrial experiences from realizing large-scale systems. Our results show that the benefits of flexible language composition and diverse notations come at the cost of serious usability issues -- which, however, can be effectively mitigated with facilities that emulate editing experience of parser-based editors.

  • 16.12.2013 | Feedback-aware Requirements Documents for Smart Devices
    F. Kneer, E. Kamsties, M. Voelter
    | PDF

    A smart device is a software-intensive sys-tem, which operates autonomously and interacts to some degree with other systems over wireless connections (e.g., a iRobot Roomba vacuum cleaner). These systems are often faced with uncertainty in the environment. Runtime representations of requirements have recently gained more interested to deal with this challenge and the term requirements at runtime was coined. These representations allow to reason about the requirements at runtime and to adapt the configuration of a system according to changes in the environment. The research question is how the results of online monitoring of requirements and the system's decisions about changes in the configuration are communicated to the requirements engineer to better understand the environment. There is a gap between the written requirements document and the dynamic requirements model inside the system. This problem is exacerbated by the fact that a requirements document are mostly informal while the dynamic requirements model is formal. This paper introduces an approach to bridge the gap between development time and runtime representations in order to keep them consistent and to facilitate a better understanding. We suggest to weave the feedback from the runtime system into requirements documents using a domain-specific language which keeps the informal nature of requirements. An annotated requirements document helps get a better understanding of the system's actual behavior in a given environment. The approach is implemented using mbeddr, a novel domain-specific language for developing embedded systems, and illustrated in a case study

  • 01.07.2013 | The State of the Art in Language Workbenches - Conclusions from the LWC
    T. v. d. Storm, S. Erdweg, M. Voelter + 19 tool developers
    | PDF

    Abstract.Language workbenches are tools that provide high-level mechanisms for the implementation of (domain-specific) languages. Language workbenches are an active area of research that also receives many contributions from industry. To compare and discuss existing language workbenches, the annual Language Workbench Challenge was launched in 2011. Each year, participants are challenged to realize a given domain-specific language with their workbenches as a basis for discussion and comparison. In this paper, we describe the state of the art of language workbenches as observed in the previous editions of the Language Workbench Challenge. In particular, we capture the design space of language workbenches in a feature model and show where in this design space the participants of the 2013 Language Workbench Challenge reside. We compare these workbenches based on a DSL for questionnaires that was realized in all workbenches.

  • 01.08.2013 | JetBrains MPS as a Tool for Extending Java
    V. Pech, A. Shatalin, M. Voelter
    | PDF

    JetBrains MPS is an integrated environment for language engineering. It allows language designers to define new programming languages, both general-purpose and domain-specific, either as standalone entities or as modular extensions of already existing ones. Since MPS leverages the concept of projectional editing, non-textual and non-parseable syntactic forms are possible, including tables or mathematical symbols. This tool paper introduces MPS and shows how its novel approach can be applied to Java development. Special attention will be paid to the ability to modularize and compose languages.

  • 01.05.2013 | Using Language Engineering to Lift Languages and Analyses at the Domain Level
    D. Ratiu, M. Voelter, B. Kolb, B. Schaetz
    | PDF

    Developers who use C model checkers have to overcome three usability challenges: First, it is difficult to express application level properties as C-level verification conditions, due to the abstraction gap. Second, without advanced IDE support, it is difficult to interpret the counterexamples produced by the model checker and understand what went wrong in terms of application level properties. Third, most C model checkers support only a subset of C and it is easy for developers to inadvertently use C constructs outside this subset. In this paper we report on our preliminary experience with using the MPS language workbench to integrate the CBMC model checker with a set of domain-specific extensions of C for developing embedded software. Higher level language constructs such as components and decision tables makes it easier for end users to bridge the abstraction gap, to write verification conditions and to interpret the analysis results. Furthermore, the use of language workbenches allows the definition of analyzable language subsets, making the implementation of analyses simpler and their use more predictable.

  • 01.11.2012 | mbeddr - an Extensible C-based Programming Language and IDE for Embedded Systems
    M. Voelter, D. Ratiu, B. Kolb, B. Schaetz
    | PDF

    While the C programming language provides very good support for writing efficient, low-level code, it does not offer adequate means for defining higher-level abstractions relevant to embedded software. In this paper we present the mbeddr technology stack that supports extension of C with constructs adequate for embedded systems. In mbeddr, efficient low-level programs can be written using the well-known concepts from C. Higher-level domain-specific abstractions can be seamlessly integrated into C by means of modular language extension regarding syntax, type system, semantics and IDE. In the paper we show how language extension can address the challenges of embedded software development and report on our experience in building these extensions. We show that language workbenches deliver on the promise of significantly reducing the effort of language engineering and the construction of corresponding IDEs. mbeddr is built on top of the JetBrains MPS language workbench. Both MPS and mbeddr are open source software.

  • 01.09.2013 | Approaches and Tools for Implementing Type Systems in Xtext
    L. Bettini, D. Stoll, M. Voelter, S. Colameo




  • 05.07.2011 | Language and IDE Development, Modularization and Composition with MPS
    M. Voelter
    | 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 possibilities. 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.

  • 25.08.2011 | Product Line Engineering using Domain-Specific Languages
    M. Voelter, E. Visser
    | PDF

    This paper investigates the application of domainspecific languages in product line engineering (PLE). We start by analyzing the limits of expressivity of feature models. Feature models correspond to context-free grammars without recursion, which prevents the expression of multiple instances and references. We then show how domain-specific languages (DSLs) can serve as a middle ground between feature modeling and programming. They can be used in cases where feature models are too limited, while keeping the separation between problem space and solution space provided by feature models. We then categorize useful combinations between configuration with feature model and construction with DSLs and provide an integration of DSLs into the conceptual framework of PLE. Finally we show how use of a consistent, unified formalism for models, code, and configuration can yield important benefits for managing variability and traceability. We illustrate the concepts with several examples from industrial case studies.

  • 06.10.2010 | Embedded Software Development with Projectional Language Workbenches
    M. Voelter
    | PDF

    This paper describes a novel approach to embedded software development. Instead of using a combination of C code and modeling tools, we propose an approach where modeling and programming is unified using projectional language workbenches. These allow the incremental, domain-specific extension of C and a seamless integration between the various concerns of an embedded system. The paper does not propose specific extensions to C in the hope that everybody will use them; rather, the paper illustrates the benefits of domain specific extension using projectional editors. In the paper we describe the problems with the traditional approach to embedded software development and how the proposed approach can solve them. The main part of the paper describes our modular embedded language, a proof-of-concept implementation of the approach based on JetBrains MPS. We implemented a set of language extensions for embedded programming, such as state machines, tasks, type system extensions as well as a domain specific language (DSL) for robot control. The language modules are seamlessly integrated, leading to a very efficient way for implementing embedded software.

  • 15.05.2010 | Integrating the AUTOSAR tool chain with Eclipse based model transformations
    M. Voelter, Andreas Graf
    | PDF



  • 05.05.2007 | Product Line Implementation using Aspect-Oriented and Model-Driven Software Development
    M. Voelter, Iris Groher
    | PDF

    Software product line engineering aims to reduce development time, effort, cost, and complexity by taking advantage of the commonality within a portfolio of similar products. The effectiveness of a software product line approach directly depends on how well feature variability within the portfolio is implemented and managed throughout the development lifecycle, from early analysis through maintenance and evolution. This paper presents an approach that facilitates variability implementation, management and tracing by integrating model-driven and aspect-oriented software development. Features are separated in models and composed by aspect-oriented composition techniques on model level. Model transformations support the transition from problem to solution domain. Aspect-oriented techniques enable the explicit expression and modularization of variability on model, code, and template level. The presented concepts are illustrated with a case study of a home automation system.

  • 26.9.2003 | Container-component model and XML in ALMA ACS
    M. Voelter, Heiko Sommer, Gianluca Chiozzi, Klemen Zaga
    | PDF

    ALMA software, from high-level data °ow applications down to instrument control, is built using the ACS framework. To meet the challenges of developing distributed software in distributed teams, ACS o®ers a con- tainer/component model that integrates the use of XML transfer objects. ACS containers are built on top of CORBA and are available for C++, Java, and Python, so that ALMA software can be written as components in any of these languages. The containers perform technical aspects of the software system, while components can focus on the implementation of functional requirements. Like Web services, components can use XML to exchange structured data by value. For Java components, the container seamlessly integrates the use of XML binding classes, which are Java classes that encapsulate access to XML data through type-safe methods. Binding classes are generated from XML schemas, allowing the Java compiler to enforce compliance of application code with the XML schemas. This presentation will explain the capabilities of the ACS container/component model, and how it relates to other middleware technologies that are popular in industry.

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

    Asynchronous invocations are an important functionality in the context of distributed object frameworks, because in many situations clients should not block dur-ing remote invocations. There should be a loose coupling between clients and remote services. Popular web service frameworks, such as Apache Axis, offer only synchronous invocations (over HTTP). An alternative are messaging protocols but these implement a different communication paradigm. When client asynchrony is not supported, client developers have to build asynchronous invocations on top of the synchronous invocation facility. But this is tedious, error-prone, and might result in different remote invocation styles used within the same application. In this paper we build a framework using pat-terns for asynchronous invocation of web services. The framework design is based on the asynchrony patterns and other patterns from the same pattern language.

  • 01.04.2002 | Human Aspects in Software Processes - A collection of former Pedagogical Patterns
    M. Voelter
    | PDF

    A software project can only be successful if the developer team and its leaders form a working group. In small project teams, these human issues usually happen automatically if some preconditions are met. In larger projects however, these human aspects have to be explicitly facilitated. This situation is similar to teaching a group of people. This can also only work if the human aspects are taken into accout. This paper presents a set of pedagogical patterns rewritten in the context of project management to provide evidence for the assumption, that both domains share many common problems and solutions and that therefore the two disciplines should cooperate more closely.

  • 01.09.2001 | Learning to teach - Learning to learn
    M. Voelter, Jutta Eckstein
    | PDF

    Pedagogical Patterns capture successful experiences of learning and teaching OT, from industry or academia, in a homogeneous, easily accessible format. The Pedagogical Patterns Project started during OOPSLA '95, made its first public appearances at ECOOP '96 and then TOOLS USA '96; the first workshop was held at OOPSLA '96. Many sessions have been held at numerous conferences in America and Europe and more then 50 teaching techniques written in pattern format have been collected. The patterns themselves have proved to be useful, and have helped educators to explore and exchange their teaching experiences.

 
 

Book Chapters

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

  • 28.06.2021 | FASTEN - An Extensible Platform to Experiment with Rigorous Modeling of Safety-Critical Systems
    D. Ratiu, A. Nordmann, P. Munk, C. Carlan, M. Voelter
    PDF


    The increasing complexity of safety critical systems and the shorter time- to-market requires a high degree of automation during all development phases from requirements specification to design, implementation, verification and safety assur- ance. To make this feasible, we need to describe different system aspects using appropriate models that are semantically rich and, whenever possible, formally de- fined such that they are verifiable by automated methods. At the same time they must be easy to understand by practitioners and allow them to capture the domain concepts with minimal encoding bias. In this chapter, we describe FASTEN, an open source research environment for model-based specification and design of safety crit- ical systems using domain specific languages. FASTEN enables the experimentation with modeling abstractions at different levels of rigor and their integration in today’s development processes. We present an overview of the currently available domain specific languages (DSLs) used to formally specify requirements, system designs and assurance arguments. These DSLs have been developed and used in technology transfer projects by researchers from different organizations – Siemens, Bosch, for- tiss and itemis. Last but not least, we discuss lessons learned from implementing the languages and interacting with practitioners and discuss the language engineering features of MPS that enabled our approach and its open challenges.

  • 28.06.2021 | A Domain-Specific Language for Payroll Calculations - an Experience Report from DATEV
    M. Voelter, S. Koscejev, M. Riedel, A. Deitsch and A. Hinkelmann
    PDF


    We review our experience developing a domain-specific language at DATEV, a large payroll service provider. The language enables business programmers to efficiently implement, test, and validate payroll calculations independent of downstream deployment considerations. It is fundamentally functional and addresses core domain challenges such as versioning of cal- culation rules and data and the processing temporal data. We evaluate the language regarding reduction of complexity in payroll programs, the impact on quality, its suitability for use by domain experts as well as the integration into the IT infrastructure. The chapter concludes with general learnings about building business DSLs.

  • 10.10.2011 | Model-Driven Engineering Support for PLE
    M. Voelter, C. Elsner, L. Fiege, I. Groher





  • 10.09.2009 | Architecture As Language
    M. Voelter





  • 10.09.2009 | Model-Driven, Aspect-Oriented Product Line Engineering - an Industrial Case Study
    M. Voelter, C. Schwanninger, I. Groher





  • 10.06.2007 | Services, Komponenten, Modelle
    M. Voelter
    PDF




  • 10.05.2005 | Model Driven Software Development in the Context of Embedded Component Infrastructures
    M. Voelter, C. Salzmann, M. Kircher
    PDF




  • 10.05.2004 | Framework-basierte GUI Entwicklung
    M. Voelter
    PDF




 
 

Workshop Papers

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

  • 14.05.2016 | Automated Testing of DSL Implementations
    D. Ratiu, M. Voelter
    Automation of Software Test (AST 2016) at ICSE 2016 | Paper PDF

    Domain specific languages promise to improve productivity and quality of software by providing problem-adequate abstractions to developers. Projectional language workbenches like JetBrains MPS allow the definition of modular and extensible domain specific languages, generators and development environments. While recent advances in language engineering have enabled the definition of DSLs and tooling in a modular and cost-effective manner, the quality assurance of their implementation is still challenging. In this paper we present our work on testing the implementation of domain specific languages and associated tools, and discuss different approaches to increase the automation of language testing. We illustrate this based on MPS and our experience with testing mbeddr, a set of domain specific languages and tools on top of C tailored to embedded software development.

  • 10.10.2014 | Improving Software Security using Language Engineering and mbeddr C
    M. Voelter, Z. Molotnikov, B. Kolb
    The 15th Workshop on Domain-Specific Modeling at SPLASH 2015 | Paper PDF | Slides PDF

    Software security refers to the security proper- ties of a software system’s implementation. Various program- ming techniques as well as process practices can help with building a secure implementation. In this paper we explore the contribution of language engineering to solving this challenge. Language engineering refers to building, extend- ing and composing languages using a principled approach, based on language workbenches. Specifically, in this paper we illustrate how modular extension of the C programming language can help with technical and process-related aspects of software security. To this end we rely on mbeddr, an extensible version of C developed with the JetBrains MPS language workbench. We close the paper with a discussion of the potential drawbacks of the approach and how these can be solved in the future.

  • 30.09.2014 | Supporting Diverse Notations with MPS' Projectional Editor
    M. Voelter, S. Lisson
    GEMOC 2014 at MODELS 2014 | Paper PDF | Slides PDF

    To be able to build effective DSLs, these DSLs must not just use language concepts that are aligned with their respective domain, but also use notations that correspond closely to established domain notations -- and those are often not purely textual or graphical. The underlying language workbench must support these notations, and combining different notations in a single editor must be supported as well in order to support the coherent definitions of systems that use several DSLs. In this paper we provide an overview over the notations supported by JetBrains MPS. MPS is a language workbench that uses a projectional editor, which, by its very nature, can deal with many different notational styles, including text, prose, math tables and graphics. The various supported notations are illustrated with examples from real-world systems.

  • 08.04.2014 | Preliminary Experience of using mbeddr for Developing Embedded Software
    M. Voelter
    MBEES 2014 at | Paper PDF

    Over the last years, as part of the LW-ES KMU Innovativ research project, a team of developers at itemis and fortiss have developed the mbeddr system, which relies on language engineering to build a new class of environment for embedded soft- ware development. In essence, mbeddr consists of a set of extensions to C (such as state machines, units, interfaces and components) as well as a few additional languages for requirements engineering, documentation and product line engineering. mbeddr is still new, but a number of systems have been built with mbeddr. In this paper I sum- marize some preliminary experience with using mbeddr’s default extensions to build embedded systems based on a set of case studies. The ability for mbeddr to be ex- tended is not discussed in this paper, even though this has proven very useful as well.

  • 08.10.2013 | Integrating Prose as a First-Class Citizen with Models and Code
    M. Voelter
    MPM'13 at MoDELS 2013 | Paper PDF

    In programming and modeling we strive to express structures and behaviors as formally as possible to support tool-based processing. However, some aspects of systems cannot be described in a way that is suitable for tool-based consistency checking and analysis. Examples include code comments, requirements and software design documents. Consequently, they are often out-of-sync with the code and do not reflect the current state of the system. This paper demonstrates how language engineering based on language workbenches can help solve this problem by seamlessly mixing prose and program nodes. These program nodes can range from simple references to other elements over variables and formulas to embedded program fragments. The paper briefly explains the language engineering techniques behind the approach as well as a number of prose-code integrated languages that are part of mbeddr, an integrated language and tool stack for embedded software engineering.

  • 08.10.2013 | Extensible Debuggers for Extensible Languages
    M. Voelter, D. Pavletic, A. S. Raza, B. Kolb, T. Kehrer
    GI/ACM WS on Software Reengineering, 2013 at -- | Paper PDF

    Language workbenches significantly reduce the effort for building extensible languages. However, they do not facilitate programmers with built-in debugging support for language extensions. This paper presents an extensible debugger architecture that enables debugging of language extensions. This is established by defining mappings between the base language and the language extensions. We show an implementation of our approach for the mbeddr language workbench.

  • 01.08.2013 | A Model-Based Approach to Language Integration
    M. Voelter, F. Tomassetti, A. Vetro, M. Torchiano, B. Kolb
    MiSE 2013 at ICSE 2013 | Paper PDF

    The interactions of several languages within a software system pose a number of problems. There is several anecdotal and empirical evidence supporting such concerns. This paper presents a solution to achieve proper language integration in the context of language workbenches and with limited effort. A simple example is presented to show how cross-language constraints can be addressed and the quality of the support attainable, which covers error-checking and refactoring. A research agenda is then presented, to support future work in the area of language integration, taking advantage of modern language workbenches features.

  • 25.04.2013 | Requirements as First Class Citizens
    M. Voelter, Federico Tomassetti
    MBEES 2013 at MBEES 2013 | Paper PDF

    Requirements often play second fiddle in software development projects. The tools for managing requirements often just support ”numbered lists of prose paragraphs”, and they don’t integrate well with the tools used for implementing the system. This leads to all kinds of challenges in terms of versioning and traceability. Moreover, because they are mainly prose text, they cannot easily be checked for consistency and completeness, limiting their usefulness. In this paper we describe an alternative approach, where requirements are (at least partially) formalized to support consistency checking, where parts of requirements can be used directly as the implementation, and where requirements are managed with the same tools that are used for system development. The approach is illustrated with the mbeddr system, a comprehensive IDE for embedded software development based on an extensible version of C and domain-specific languages.

  • 08.10.2012 | Implementing Modular Domain Specific Languages and Analyses
    M. Voelter, Daniel Ratiu, Zaur Molotnikov, Bernhard Schaetz
    Modevva 2012 at MoDELS 2012 | Paper PDF

    Domain specific languages allow users to directly express domain concepts in their programs and thereby eliminate the accidental complexity resulting from implementation details irrelevant to the domain. Cleaner programs, written in DSLs are much easier to analyze formally. However, domain specific analyses need to be implemented over and over again for each new domain specific language. In this paper we show that the use of language engineering techniques for modu-larizing languages can drastically improve on this situation. Language fragments (aka. language modules) together with a set of analyses defined for them can be reused between different DSLs, making the implementation of analyses significantly easier. This paper presents our approach for using the Meta-Programming System to implement domain specific languages and analyses both as extensions of C and in the domain of intelligent buildings. The main lesson learned is that modularization at language and analysis level allows rapid instantiation of advanced DSLs and their correspond-ing analyses.

  • 08.06.2012 | Language Engineering as an Enabler for Incrementally Defined Formal Analyses
    M. Voelter, Daniel Ratiu, Bernhard Schaetz, Bernd Kolb
    FormSERA 2012 at ICSE 2012 | Paper PDF

    There is a big semantic gap between today's general purpose programming languages on the one hand and the input languages of formal verification tools on the other hand. This makes integrating formal analyses into the daily development practice artificially complex. In this paper we advocate that the use of language engineering techniques can substantially improve this situation along three dimensions. First, more abstract and thus more analyzable domain specific languages can be defined, avoiding the need for abstraction recovery from programs written in general purpose languages. Second, restrictions on the use of existing languages can be imposed and thereby more analyzable code can be obtained and analyses can be incrementally defined. Third, by expressing verification conditions and the verification results at the domain level, they are easier to define and the results of analyses are easier to interpret by end users. We exemplify our approach with three domain specific language fragments integrated into the C programming language, together with a set of analyses: completeness and consistency of decision tables, model-checking-based analyses for a dialect of state machines and consistency of feature models. The examples are based on the mbeddr stack, an extensible C language and IDE for embedded software development.

  • 08.02.2012 | Towards an Extensible C for Embedded Programming
    M. Voelter
    MBEES 2012 at MBEES 2012 | Paper PDF

    Abstract.Embedded software development suffers from inadequate lan-guages and tools. The C programming language does not provide means for defining adequate abstractions. Furthermore, modeling tools and their languages are typically closed and cannot be adapted to particular do-mains. In this paper we present the current state of an extensible lan-guage based on C that combines the best of both worlds. The mbeddr C language is developed as part of the LWES KMU Innovativ research project run by fortiss, itemis, Lear and Sick.

  • 20.10.2010 | Domain Specific - a Binary Decision ?
    M. Voelter, Bernhard Merkle
    Domain Specific Modeling (DSM) 2010 at SPLASH 2010 | Paper PDF

    It is often considered a binary decision whether something is domain specific or not. Consequently, there are domain specific languages (DSL) and general purpose languages (GPL), there are domain specific and non-domain specific modeling tools, there are domain specific and non-domain specific methodologies etc. In this paper we argue, that domain specificity is not a hard decision, but rather one extreme on a continuum. We also argue that many systems can be more efficiently described with a mix of domain specific and non-domain specific abstractions. This view of the world has consequences for languages, tools and methodologies, specifically the ability to modularize and compose languages. Additionally we outline these consequences and provide an extensive example based on embedded systems.

  • 10.10.2010 | Implementing Feature Variability for Models and Code with Projectional Language Workbenches
    M. Voelter, Bernhard Merkle
    Domain Specific Modeling (DSM) 2010 at SPLASH 2010 | Paper PDF

    It is often considered a binary decision whether something is domain specific or not. Consequently, there are domain specific languages (DSL) and general purpose languages (GPL), there are domain specific and non-domain specific modeling tools, there are domain specific and non-domain specific methodologies etc. In this paper we argue, that domain specificity is not a hard decision, but rather one extreme on a continuum. We also argue that many systems can be more efficiently described with a mix of domain specific and non-domain specific abstractions. This view of the world has consequences for languages, tools and methodologies, specifically the ability to modularize and compose languages. Additionally we outline these consequences and provide an extensive example based on embedded systems.

  • 23.02.2010 | Projectional Language Workbenches as a Foundation for Product Line Engineering
    M. Voelter
    Feature Oriented Software Development (FOSD) 2010 at GPCE 2010 | Paper PDF

    Product line engineering deals with managing and implementing the variability among a set of related products. We distinguish between two kinds of variability: configuration and customiza-tion. Customization variability can be described using program-ming language code or creative construction DSLs, whereas configuration variability is described using configuration based approaches, such as feature models. Many product lines have both kinds of variability, and they need to be integrated efficiently. This paper describes an approach for product line engineering using projectional language workbenches. These represent code and models with the same fundamental technology, enabling the mixing of models and code. They make the tight integration be-tween several domain-specific languages possible and simple. Since they can store arbitrary information in models, it is possible to overlay configuration variability over customization variability (i.e. apply feature model-based configuration to code and models). Because of the projectional approach to editing, programs can be shown with or without the dependencies on feature models, they can even be rendered (and edited) for a specific variant. This ap-proach leads to highly integrated and productive tools for product line development. The paper explains the approach, outlines the implementation of a prototype tool based on Jetbrains MPS and illustrates the benefits using a small product line for embedded systems.

  • 21.10.2008 | A Family of Languages for Architecture Description
    M. Voelter
    Domain-Specific Modeling 2008 at OOPSLA 2008 | Paper PDF

    In this paper I describe how product line engineering and variant management can be applied to domain-specific languages. I introduce concepts and a tool prototype for describing a family of DSLs used for architecture description. I want to make two points in this paper: First, I want to introduce the idea of product line engineering for domain-specific languages, and second, I want to illustrate why and how this approach is especially useful for DSLs that describe software architectures. The paper is based on practical experience and not on academic research.

  • 21.07.2008 | Model-Driven Development in the Real World
  • 21.10.2007 | Handling Variability in Model Transformations and Generators
    M. Voelter, Iris Groher
    Domain Specific Modeling 2007 at OOPSLA 2007 | Paper PDF

    Software product line engineering aims to reduce development time, effort, cost, and complexity by taking advantage of the commonality within a portfolio of similar products. The effectiveness of a software product line approach directly depends on how well feature variability within the portfolio is implemented and managed throughout the development lifecycle, from early analysis through maintenance and evolution. Using DSLs and AO to implement product lines can yield significant advantages, since the variabilities can be implemented in higher level, less detailed models. This paper illustrates how variabilities can be implemented in model-to-model transformations and code generators. The backbone of the presented approach is to use aspect-oriented techniques for transformations and generators. These techniques are important ingredients for the model-driven product line engineering approach.

  • 10.09.2007 | Expressing Feature-Based Variability in Structural Models
    M. Voelter, Iris Groher
    Managing Variability for Software Product Lines at SPLC 2007 | Paper PDF

    Software product line engineering aims at reducing development time, effort, cost, and complexity by taking advantage of the commonality within a portfolio of similar products. The effectiveness of a software product line approach directly depends on how well feature variability within the portfolio is implemented and managed throughout the development lifecycle, from early analysis through maintenance and evolution. This paper presents a tool-supported approach that improves variability management and tracing by providing means to express feature-based variability on model level. Features are separated in models and automatically composed. The approach supports both positive variability, i.e. adding optional parts to a model, as well as negative variability, i.e. removing parts from a model. Tools are provided that implement the presented concepts. The approach is illustrated with a case study of a home automation system.

  • 05.05.2007 | Introduction to openArchitectureWare 4.1.x
    M. Voelter, Bernd Kolb, Sven Efftinge, Arno Haase
    MDD Tool Implementers Forum at TOOLS Europe 2007 | Paper PDF

    OpenArchitectureware is an open source tool set for defining and processing models. It provides building blocks for the entire tool chain. It focuses on modularity, making the building blocks usable in other contexts and – more importantly – making it possible to integrate tools that originate outside of oAW.

  • 05.05.2007 | Mechanisms for Expressing Variability in Models and MDD Tool Chains
    M. Voelter, Iris Groher, Bernd Kolb
    SIG MDSE Workshop on MDSD in Embedded Systems at | Paper PDF

    Building embedded systems using model-driven development is highly desirable for a number of reasons, among them performance, penalty free abstraction, architecture enforcement, and global constraint evaluation. However, embedded systems are often built in several variants. It is thus essential to be able to express variations of systems in a coherent way, even when the system is built using model-driven development. In this paper, we describe a number of mechanisms for expressing variability in the context of MDD. This includes the expression of model variants, extending models with additional information, as well as describing variants of code generators.

  • 15.03.2007 | XWeave - Models and Aspects in Concert
    M. Voelter, Iris Groher
    Aspect Oriented Modelling Workshop 2007 at AOSD 2007 | Paper PDF

    Model-driven software development improves the way software is developed by capturing key features of the system in models which are developed and refined as the system is created. During the system’s lifecycle models are combined and transformed between different levels of abstraction and viewpoints. Aspectoriented techniques improve software development by providing modularization constructs for the encapsulation of crosscutting concerns. While the two approaches are different in many ways – model-driven software development adds domain specific abstractions and aspect-oriented software development offers concerns modularization and composition mechanisms – they also have many things in common. Existing research has already investigated many ways of combining the two paradigms. This paper contributes by presenting XWeave, a model weaver that supports weaving of both models and meta models. The concepts are illustrated with an example of a home automation system.

  • 11.10.2006 | oAW xText - A framework for textual DSLs
    M. Voelter
    Modeling Symposium at Eclipse Summit 2006 | Paper PDF

    xText is part of the openArchitectureWare project (which is in turn part of Eclipse GMT). oAW provides a set of tools to develop MDSD infrastructures; it helps with meta modeling, constraint checking, code generation and model transformation. More recently a framework has been developed that supports the creation of textual domain-specifc languages (DSL), xText

  • 11.10.2006 | Best Practices for Model-to-Text Transformations
    M. Voelter
    Modeling Symposium at Eclipse Summit 2006 | Paper PDF

    In Model-Driven Software Development, the generation of textual artifacts – often source code – plays an important role. However, often, code generation is seen as the “less important brother” of model-to-model transformations and is consequently treated as a second-class citizen. However, most developers come into MDSD through “simple” code generation and in most cases, the last step of a transformation chain is actually a code generator. It is therefore important that the generator is up to the challenge of generating non-trivial software systems. In this paper, we will report on best practices for code generation. The authors are part of the openArchitectureWare team and have significant experience wrt. code generation, from the perspectives of the tool builder, as well as from the perspective of the tool user (i.e. generator developer).

  • 03.07.2006 | openArchitectureWare, a flexible Open Source platform for model-driven software development
    M. Voelter
    Eclipse Technology Exchange at ECOOP 06 | Paper PDF

    openArchitectureWare (oAW) is a suite of tools and components assisting with model driven software development built upon a modular MDA/MDD generator framework implemented in Java supporting arbitrary import (model) formats, meta models, and output (code) formats. Supportive tools (such as editors and model browsers) are based on the Eclipse platform. openArchitectureWare is a tool for building MDSD/MDA tools. At the core there is a workflow engine allowing the definition of transformation workflows as well as a number of prebuilt workflow components that can be used for reading and instantiating models, checking them for constraint violations, transforming them into other models and then finally, for generating code.

  • 01.01.2005 | Model-Driven Development of Component Infrastructures for Embedded Systems
    M. Voelter
    Dagstuhl Workshop Model-Based Development of Embedded Systems at Dagstuhl Workshop Model-Based Development of Embedded Systems | Paper PDF

    Component infrastructures such as Enterprise JavaBeans, Micorosoft’s COM+ and CORBA Components have become a de-facto standard for enterprise applications. Reasons for this success are the clean separation of technical and functional concerns, COTS containers (applications servers), and the resulting well-defined programming model and standardization. To benefit from these advantages in the domain of embedded systems, the same concepts can be used, but a different implementation strategy is required: monolithic application servers are not suitable because of the limited resources regarding computing power, memory, etc. on the device. An alternative can be based on using a family of code-generated containers. The container is generated from models that specify interfaces, components, system topologies and deployments. In addition to motivating the problem and looking at related work, this paper gives general guidelines for the design and implementation of such infrastructures and describes a prototype implementation that has been implemented recently. We also look at the advantages of using such an approach for the electronic control units in vehicles and the benefits the approach could have with regards to vehicle diagnostics.

  • 01.04.2004 | Model-based Middleware for Embedded Systems
    M. Voelter
    Automotive Software Engineering at GI Jahrestagung | Paper PDF

    In this paper we describe the advantages of a model based middleware concept with components for embedded systems. Component infrastructures such as Enterprise JavaBeans, Micorosoft’s COM+ and CORBA Components have become a defacto standard for enterprise applications. One reason for this success are the clean separation of technical and functional concerns, COTS containers (applications servers), and the resulting well-defined programming model and standardization. To benefit from these advantages in the domain of embedded systems, the same concepts can be used, but a different implementation strategy is required. After describing the characteristics of automotive software and reasoning why the concepts from the enterprise IT can not be simply applied in the automotive domain we give a general outline of the design and implementation of such a middleware concept and describe prototype implementation that has been implemented recently.

  • 01.7.2002 | Some Resource Management Patterns
    M. Voelter
    Focus Group on Resource Management Patterns at EuroPLoP 2002 | Paper PDF

    This little paper suggests a set of patterns in the area of resouce management in local or distributed systems. Please note that some of the patterns might overlap with material that is already written. This paper is just a suggestion – don’t consider the stuff as full-fledged patterns!

  • 01.10.2001 | Jenerator – Generative Programming for Java
    M. Voelter
    Generative Programming at OOPSLA 2001 | Paper PDF

    Generative Programming aims at creating software components, which, after suitable configuration, generate systems or other components. This allows to build families of products (or product lines) out of which several concrete systems can be created. Compared to frameworks, this has the advantage that the configuration takes place before runtime, enhancing runtime performance. This paper introduces a tool called Jenerator, an extensible code generator for Java. By using its extension mechanisms, complete high-level, product-line-specific generators can be build, enabling the automated creation of systems on source-code basis.

  • 01.07.2001 | 3-Tier Pattern Language
    M. Voelter
    Designing a 3 Tier Pattern Language at EuroPLoP 2001 | Paper PDF

    This position paper contains two parts. In the first part, I want to point out that three tiers are a more or less arbitrary (or at least, coarse-grained) number of tiers. In reality, there are usually more than three. The second part presents a couple of design pattern thumbnails for some potential patterns.

  • 01.10.2000 | Pattern Refactoring
    M. Voelter
    Pattern Refactoring at OOPSLA 2000 | Paper PDF

    This paper is a submission to the OOPSLA 2000 workshop Pattern Refactoring. It briefly describes some of the problems of the current state of the Pedagogical Pattern Project, and describes why and how pattern refactoring can be applied to the patterns in the project. In particular, it describes an alternative form for pedagogical patterns, it tries to formalize a schema for categorization of the patterns and the relationships among them, and it defines an XML based notation for the patterns. The proposed solution is general enough to be used for other patterns (or PLs) outside the PPP.

  • 01.10.2000 | Methods and Tools for OO-Framework Development and Specialization
    M. Voelter
    Frameworks at OOPSLA 2000 | Paper PDF

    This paper is a submission to the OOPSLA 2000 workshop on Methods and Tools for OO-Framework Development and Specialization. It presents an approach to framework configuration using the explicit variability metaphor. The approach presented in this paper will be verified in a research project within MATHEMA software during the next months.

  • 01.10.2000 | Mining Pedagogical Patterns
    M. Voelter
    Mining Pedagogical Patterns at OOPSLA 2000 | Paper PDF

    This paper is a submission to the OOPSLA 2000 workshop Mining Pedagogical Patterns. It briefly describes some of the problems of the current state of the PPP and tries to give some proposals as to how to improve the situation. In particular, it describes an alternative form for pedagogical patterns, it tries to formalize a schema for categorization of the patterns and the relationships among them, and it defines an XML based notation for the patterns.

 
 

Pattern Papers

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

  • 07.07.2009 | Variability Patterns
    M. Voelter
    EuroPLoP 2009 | PDF

    Traditionally, in software engineering, development happens for single products. This is a very inefficient approach in cases where groups of products are related. Software product line engineering is about systematically developing families of related products together, as a product line. The products within a product line usually have many things in common, but also significant differences. Managing and implementing these differences can become complex because in realistic product lines, variability abounds, and it is often a cross-cutting concern. Hence, to exploit the benefits of product line engineering, it is important to systematically manage the variability between the products. Variability denotes differences between related products in a product line. Typically one talks about variation points, where, to define a product, you need to bind each variation point. There are different ways to bind a variation point: setting a value, selecting an option or implementing a program fragment or model (we’ll talk about this in the patterns below). For each variation point, you’ll also have to define the binding time: at design time, load time, runtime, etc. This paper is a collection of patterns for handling variability in software systems. It contains patterns for managing variability, introduces different kinds of variability, and illustrates realization of variability in implementation artifacts such as models or source code. The patterns are intended as a contribution to a more comprehensive pattern language on product line engineering. The paper is intended to be read by architects who want to get a better grasp on managing and implementing variability. The paper does not address requirements and product management. I assume the requirements that drive the variability are known.

  • 10.03.2005 | Software Architecture Patterns
    M. Voelter
    EuroPLoP 2006 | PDF

    Recently, the business of software architecture has become one of technology hypes and technology geeks. An architecture often defines itself by the primary technology it is built upon. Developers are given a J2EE book and then let loose. And then the project fails, although we used an industry standard ... How come? The craft of defining an architecture – independent of buzzwords – has gone out of fashion. Designing architectures on a conceptual level is not something people learn, or read books about (there aren't many books on this topic!). The view for the essential aspects of an architecture is obstructed by all the technology crap. This paper outlines a couple of best practices that I consider essential when building a real-world software architecture. It could be called an architectural process if you wish…

  • 24.12.2004 | Models and Aspects
    M. Voelter
    EuroPLoP 2005 | PDF

    Aspect Oriented Software Development as well as Model-Driven Software Development 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 paper looks at both of these questions. The first one – how AOSD and MDSD relate – is briefly discussed in the first paragraphs. How AOSD and MDSD can be used together is the subject of the main discussion, where the paper presents six patterns of how MDSD and AOSD can be used in conjunction.

  • 31.03.2004 | Command Revisited
    M. Voelter, Michael Kircher
    EuroPLoP 2004 | PDF

    The Command Revisited pattern packages a piece of application functionality as well as its parameterization in an object in order to make it usable in another context, such as later in time or in a different thread.

  • 31.04.2004 | Broker Revisited
    M. Voelter, Michael Kircher, Christa Schwanninger, Klaus Jank
    EuroPLoP 2004 | PDF

    The Broker Revisited pattern connects clients with remote objects by mediating invocations from clients to remote objects while encapsulating the details of network communication.

  • 30.05.2004 | Patterns for Model-Driven Development
    M. Voelter, Jorn Bettin
    EuroPLoP 2004 | PDF

    The patterns in this paper consititute a set of basics for model-driven development; there are patterns for process, tool building, techniques and domain modelling. This paper is still very much work in progress!

  • 01.07.2003 | Patterns for Asynchronous Invocations in Distributed Object Frameworks
    M. Voelter, Uwe Zdun, Michael Kircher, Michael Englbrecht
    EuroPLoP 2003 | PDF

    The patterns in this paper introduce the four most commonly used techniques for providing client-side asynchrony in dis-tributed object frameworks. FIRE AND FORGET describes best-effort delivery semantics for asynchronous operations that have void return types. SYNC WITH SERVER notifies the client only in case the delivery of the invocation to the server application fails. POLL OBJECTS provide clients with means to query the distributed object framework whether an asyn-chronous response for the request has arrived yet, and if so, to obtain the return value. RESULT CALLBACK actively notifies the requesting client of the returning result.

  • 01.05.2003 | A collection of Patterns for Program Generation
    M. Voelter
    EuroPLoP 2003 | PDF

    Generation of source code is becoming a more and more important tool for software engineering, especially in the context of model drien development and MDA. While it is possible in theory to „gen-erate code“ just using printf, this approach is insufficient in all but the most trivial cases. However, there are several alternatives. This paper introduces a set of patterns that describe the most commonly used source code generation techniques. That can be used for model transformations, model-to-source generation or source code trans-formation. It also contains large amount of examples that show how different tools realize the patterns.

  • 01.10.2002 | Object-Oriened Remoting - A Pattern Language
    M. Voelter
    VikingPLoP 2002 | PDF

    This pattern language describes the building blocks of typical remoting frameworks as they are used in Java, CORBA or .NET. This is still very much work in progress - but you can have a look at the current version.

  • 01.07.2002 | Hope, Belief and Wizardry - Three different perspectives on project management
    M. Voelter
    EuroPLoP 2002 | PDF

    Normally, I'm not too much into project management. However, over the last couple of years, I have come across several projects that use hope, belief and wizardry as their primary management tools. You will probably not have heard about these specific projects - and you probably never will. They have gone out of existence, maybe because of too successful management techniques. However, if you're a consultant or a developer, I'm sure you have experienced your own hope/belief/wizardry project and you can probably tell the same story.

  • 01.09.2002 | Building EJB Applications - A Collection of Patterns
    M. Voelter, Alexander Schmid, Eberhard Wolff
    PLoP 2002 | PDF

    Although Enterprise JavaBeans provide simple APIs for relatively complex tasks, designing and implementing a scalable, maintainable and reasonably fast application based on EJB is not trivial. Over time, a set of proven patterns has emerged – this paper presents some of them. The patterns will be part of a book about EJB architecture and application patterns which is currently being written by the authors of this paper. We do not address other parts of J2EE such as servlets or JMS, we solely focus on the “middle tier” made up of EJBs.

  • 01.07.2001 | Patterns for Experential Learning
    M. Voelter, Jutta Eckstein, Klaus Marquardt
    EuroPLoP 2001 | PDF

    In general, teaching is about flexibility. Every teacher should have a set of techniques to create an effective teaching and learning experience. A teacher should collect these effective techniques over time, perhaps creating a personal pattern language or finding new patterns to add to this pattern language. This pattern language, which is work in progress, collects proven techniques for teaching effectively. For professional educators, these patterns might seem obvious, even trivial, because they have used them so often. But for those newer to teaching, these patterns offer a way for experienced teachers to pass on their tried and true techniques. However, patterns are not step by step recipes. These patterns offer a format and a process for sharing successful teaching practices, and can be used by a variety of people in many different ways.

  • 01.07.2001 | Server-Side Components - A Pattern Language
    M. Voelter
    EuroPLoP 2001 | PDF

    Enterprise-level component-based development is an important topic in today's software industry. Several technologies for components on the server exist, among them EJB, CCM and COM+. Although these technologies have significant differences, they are all built on the same core concepts. This paper captures these concepts in the form of a pattern language in Alexandrian style. The patterns are useful for people who have to understand the concepts behind these technologies in order to develop better applications, to develop their own component architectures, or to evaluate the three competing architectures on the market today.

  • 01.07.2000 | SEMINARS - A Pedagogical Pattern Language on how to teach seminars effectively
    M. Voelter, Astrid Fricke
    EuroPLoP 2000 | PDF

    This pattern language is intended for those instructors in the industry, who are not studied educators.

  • 01.07.1999 | The Metacommand Pattern
    M. Voelter
    EuroPLoP 2000 | PDF

    Metacommand enhances the Command pattern by providing a facility to enhance or modify the common behaviour of the command classes used in a system at any time without modifying the command classes themselves.

  • 01.07.1999 | Pluggable Component - A Pattern for Interactive System Configuration
    M. Voelter
    EuroPLoP 1999 | PDF

    PluggableComponent is a pattern for runtime component exchange. It allows to change parts of a software system and lets the user configure these parts interactively. It also provides for registration and storage of these components. It is especially interesting for framework developers. The Pattern has been presented and reviewed at the EuroPLOP 99 conference, July 7-10, 1999, Irsee, Germany.

 
 

Magazine Articles

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

  • 08.08.2023 | AI-based Prose Programming for Subject Matter Experts: Will this work?
    M. Voelter
    InfoQ online | Read Online

    In this article, I discuss the future of programming using Large Language Model (LLM) tools like ChatGPT and GitHub’s Copilot for prose-to-code generation.

  • 10.12.2020 | Why DSLs? A Collection of Anecdotes
    M. Voelter
    InfoQ online | Read Online

    In this article I discuss a number of example DSLs that are used successfully in real-world applications. I have personally been involved in the development of many of them, the others have been developed by people I know and trust. In this article I use short essays to discuss the languages. The essays are fictional in their composition and some details, but are faithful to what happened in the real projects. For several of the languages, more extensive and more systematic papers have been published, and I refer the reader to those papers at the end of each anecdote.

  • 20.07.2012 | mbeddr - Embedded-Entwicklung mit erweiterbarem C
    M. Voelter
    heise developer online | Read Online

    Was wäre, wenn Sprachen genau so einfach erweiterbar wären wie Programme? Der Artikel zeigt im Kontext eingebetteter Systeme, wie sich mit der IDE mbeddr die Programmiersprache C erweitern lässt.

  • 28.03.2011 | MD* Best Practices
    M. Voelter
    my own webiste March 2011 | PDF

    This is an update of the original best practices article/paper I wrote in 2008. It looks at what has changed in the meantime, from my perspective. Here is the original abstract: This article covers a collection of best practices for model-driven development and DSLs. They cover language design, generation, transformation and interpretation, as well as a couple of best practices regarding organizational issues.

  • 01.08.2011 | From Programming To Modeling – and back again
    M. Voelter
    IEEE Software Nov/Dec 2011 | PDF | Read Online

    So, what's the difference between programming and modeling? And should there even be one? A long time ago I started programming using the usual general-purpose languages of the time: Pascal, C++, Java. In the last couple of years I turned to domain specific languages and model driven development, building my own languages and compilers specific to certain technical and application domains, usually driven by a broad range of customer from various fields. However, modeling is a world different from programming – at least regarding tools. So as I think more about this, I came to the conclusion that there should be no difference between programming and modeling. What we really need is a set of composable language modules that each express different concerns of a software system, some application domain specific, others more related to technical concerns, and hence more general and reusable. In this article I explore this idea. Of course the idea isn't really new. However, as the necessary tools are maturing, the time is right to discuss this idea again.

  • 10.02.2011 | Xtext/TS - a Typesystem Framework for Xtext
    M. Voelter
    InfoQ 2011 | Read Online

    Starting with version 1.0, it has become feasible to build complex languages in Xtext. One common aspect of a complex language is support for expressions. Expressions require recursive grammar definitions, for which assignment actions in Xtext provide reasonable support. However, once you have expressions, you typically also need a type system. Whilst it can be argued that type checks are nothing more than constraints, building a reasonably-sized type system is a lot of work that can offer additional support over plain constraint checks. This article describes a framework for specifying type systems for (expression) languages built with Xtext.

  • 15.10.2010 | Embedded Software Development with MPS
    M. Voelter
    Embedded Control Europe 2010 | PDF | Read Online



  • 01.06.2010 | The Model Craftsman
    M. Voelter
    Cutter Executive Update Vol 11, Issue 9 | PDF

    An article that dicusses DSLs and product lines in the context of agile development and software craftsmanship.

  • 01.09.2009 | MD* Best Practices
    M. Voelter
    JOT - Journal of Object Technology 2009-09 | PDF

    This article covers a collection of best practices for model-driven development and DSLs. They cover language design, generation, transformation and interpretation, as well as a couple of best practices regarding organizational issues.

  • 30.03.2009 | Domänenspezifische Sprachen und Microsoft Oslo
    M. Voelter, Lars Corneliussen
    DotNetMagazin 03/2009 | PDF

    Auf der PDC letzten Herbst hat Microsoft eine neue Plattform vorgestellt: Oslo. Dabei handelt es sich um Frameworks und Tools zur Arbeit mit Modellen und der Erstellung von domänenspezifischen Sprachen. In diesem Artikel möchten wir einen Überblick über Oslo geben, und es in das Umfeld der modellgetriebenen Softwareentwicklung und der DSLs

  • 15.04.2009 | Kurze Rede Langer Sinn
    M. Voelter, Lars Corneliussen
    DotNetPro 04/2009 | PDF

    Die Anforderungen an Software wachsen stetig. Steigende, tatsächliche Komplexität spiegelt sich häufig in einer großen, undurchdringlichen Codebasis wieder. Kein Wunder, dass der Ruf nach Abstraktion, nach Ausdrucksstärke lauter wird. Mit wenigen Worten mehr sagen; das ist das Ziel einer guten domänenspezifischen Sprache.

  • 15.05.2009 | Carpe Diem - Xtext für .NET
    M. Voelter, Lars Corneliussen
    DotNetPro 05/2009 | PDF

    Nutze den Tag. Domänenspezifische Sprachen sind eines der vielen Mittel zur Industrialisierung von Software. In anderen Branchen ist die Automatisierung längst Alltag. Praxisnah zeigt dieser Artikel eine DSL für den Import von Mainframe-Exporten ? mit Eclipse Xtext in Szene gesetzt.

  • 30.03.2009 | Werkzeuge zur Erstellung und Verarbeitung von DSLs
    M. Voelter
    Heise Developer Channel 03/2009 | PDF | Read Online

    Domänenspezifische Sprachen werden als Teil der modernen Softwareentwicklung immer wichtiger, die dazugehörige Toollandschaft entwickelt sich spürbar weiter. Die neuesten Kandidaten in diesem Umfeld sind Microsofts Oslo sowie MPS von Jetbrains. In diesem Artikel möchte ich auf den aktuellen State-of-the-Art eingehen und erläutern, welche Tools derzeit verfügbar sind, wie sie sich voneinander unterscheiden und wie reif sie für den Einsatz in der Praxis sind. Dem Leser soll damit der Überblick über das weite und unübersichtliche Feld erleichtert und ggfs. eine Entscheidung für oder gegen das eine oder andere Tool ermöglicht werden. In dem Artikel betrachte ich Eclipse Modeling und openArchitectureWare, Microsoft DSL Tools, MetaEdit+, Jetbrains' MPS sowie Microsoft Oslo.

  • 20.12.2008 | Java-Spracherweiterung mit JetBrains MPS
    M. Voelter
    JavaMagazin 03/2009 | PDF

    Jetbrains, der Hersteller von IntelliJ IDEA, Resharper und anderen Entwicklungwerkzeugen haben am 10. Dezember die Beta-Version von MPS, dem Meta Programming System, veröffentlicht. In einem früheren Artikel hatte ich bereits kurz darüber geschrieben. MPS ist ein System zur sprachorientierten Programmierung (Language Oriented Programming). Mit MPS lassen sich effizient domänenspezifische Sprachen erstellen, kombinieren und verwenden. In diesem Artikel zeige ich, wie man mit MPS Java um eigene Sprachkonzepte erweitert: ein neues Schlüsselwort, um einfacher mit Java 5 Locks zu arbeiten. MPS ist kein klassischer Texteditor, weswegen einige Editieroperationen nicht in gewohnter Weise funktionieren. Dies ist in einem Artikel wie diesem sehr schwer zu beschreiben, weswegen ich es erst gar nicht versuche, sondern begleitende Screencasts erstellt habe.

  • 20.12.2008 | Public Beta von Jetbrains’ Meta Programming System (MPS)
    M. Voelter
    JavaMagazin 01/2009 | PDF

    Jetbrains, der Hersteller von IntelliJ IDEA, Resharper und anderen Entwicklungwerkzeugen haben am 10. Dezember die Beta-Version von MPS, dem Meta Programming System, veröffentlicht. MPS ist ein System zur sprachorientierten Programmierung (Language Oriented Programming). Mit MPS lassen sich effizient domänenspezifische Sprachen erstellen, kombinieren und verwenden (siehe auch hier: [http://www.it-republik.de/jaxenter/news/046601|Jaxenter]

  • 10.12.2008 | MD* Best Practices
    M. Voelter
    voelter.de 12/2008 | PDF

    In this article I describe best practices I learned over the years using DSLs for developing software. Before we start, let me outline the context. I exclusively cover external domain specific languages (DSLs), languages that are custom-defined to describe aspects of a software system. These languages can be textual or graphical, the models created with the language can be used as input for code generation, validation, simulation or interpretation. The DSLs can be intended for use by developers and architects (covering mainly architectural/technical aspects of software systems), but also by domain experts, i.e. people from the business domain who are not classically considered developers.

  • 15.10.2008 | Forword Proceedings MDSD Today 2008
    M. Voelter
    MDSD Today 2008 Proceeding 09/2008 | PDF | Read Online



  • 01.03.2008 | Architecture As Language
    M. Voelter
    InfoQ 01/2008 | PDF | Read Online

    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). The first part of this paper illustrates the idea using a real-world story. The second part summarizes the key points of the approach.

  • 01.05.2008 | Architecture As Language, Part 2
    M. Voelter
    voelter.de 05/2008 | PDF

    This second part of the Architecture As Language series looks at implementing variability in the DSL. This open up the Architecture As Language approach as a foundation for product line architectures. We explain how to express positive and negative variability in the DSL and how integrate it with feature modeling. Like in the first paper, we look at the story, the concepts, and – in the last section – the necessary tooling.

  • 09.12.2007 | Trends bei Sprachen
    M. Voelter
    ObjektSpektrum 01/2008 | PDF

    Bei den Programmiersprachen tut sich was: der Sprachenmarkt ist wieder in Bewegung gekommen. Das gilt zum Einen für die Weiterentwicklung der Mainstream-Sprachen Java und C#, zum Anderen aber auch generell für die Sprachvielfalt. Generell scheint die Erkenntnis, dass man auch mit noch so guten Frameworks keine mächtigen Sprachfeatures ersetzen kann wieder in den Vordergrund zu rücken. In diesem Artikel möchte ich daher einige aktuelle Trends bei Programmiersprachen beleuchten. Ziel ist es, Sie als Leser auf diese (mehr oder weniger) neuen Trends aufmerksam zu machen und ihnen einige Hintergrundinformationen zu bieten. Dabei geht es auch darum, ein bischen über den Tellerrand hinauszuschauen – selbst wenn es die betreffenden Features in der Sprache in der man arbeitet nicht gibt, so kann man doch seinen Programmierstil von diesen Features inspirieren lassen.

  • 10.07.2007 | Guest Editorial Software Patterns
    M. Voelter, Michael Kircher
    IEEE Software 07/08 2007 | PDF

    This is the editorial for Software Patterns special issue of IEEE Software that I wrote together with Michael Kircher.

  • 01.04.2007 | openArchitectureWare 4.1 An introduction
    M. Voelter
    Eclipse Magazine 03/2007 | PDF

    openArchitectureWare is a suite of tools and components assisting with model driven software development, more precisely it is a tool for building MDSD/MDA tools. It is built upon a modular MDSD generator framework and is implemented in Java. The suite supports arbitrary import (model) formats, meta models, and output (code) formats, especially Eclipse EMF. The tooling (such as editors and model browsers) is based on the Eclipse platform. The core of openArchitectureWare comprises of a workflow engine that allows the user to define transformation workflows as well as a number of prebuilt workflow components that can be used for reading and instantiating models, checking them for constraint violations, transforming them into other models and then finally, for generating code. openArchitectureWare is open source and part of the Eclipse GMT project.

  • 10.01.2007 | Modelltransformationen in der Praxis
    M. Voelter, Iris Groher
    JavaSpektrum 01/2007 | PDF

    Die Bedeutung von Modell-zu-Modell Transformationen in der Praxis steigt derzeit rapide an. In diesem Artikel möchten wir daher – basierend auf der Theorie die Arno im vorigen Artikel eingeführt hat – einige Beispiele für Modelltransformationen zeigen. Wir implementieren diese Beispiele mit der Sprache Xtend, einem Teil des openArchitectureWare Frameworks.

  • 01.12.2006 | The Pragmatic Code Generator Programmer
    M. Voelter, Arno Haase, Sven Efftinge, Bernd Kolb
    TheServerSide.com | Read Online

    In this article we will reimplement an exercise taken from the best-selling book The Pragmatic Programmer written by Andy Hunt and Dave Thomas. In the third chapter The Basic Tools the authors motivate the reader to learn a text manipulation language (like Perl or Ruby) in order to be able to develop little code generators. The proposed exercise is very simple and code-centric and we will show how it can be implemented with today's generator development tools and languages.

  • 01.09.2006 | GMF Tutorial
    M. Voelter, Arno Haase, Sven Efftinge, Bernd Kolb
    ix 12/2006 und 01/2007 | PDF

    Seit nunmehr knapp einem Jahr gibt es unter Eclipse.org das Graphical Modeling Framework, kurz GMF. Seit einigen Wochen hat GMF innerhalb des Callisto-Release-Trains seine Version 1.0 veröffentlicht. Dies wollen wir zum Anlass nehmen uns dieses Framework genauer anzusehen.

  • 15.04.2006 | From Frontend To Code - MDSD In Practice
    M. Voelter, Arno Haase, Sven Efftinge, Bernd Kolb
    Eclipse.org | Read Online

    Model-Driven Software Development 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 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 generator. In this article we show how to tackle all these challenges today, based on a collection of Open Source tools. These are Eclipse, EMF, GMF as well as openArchitectureWare. We believe that this tool chain provides a proven and stable stack for making MDSD a practical reality.

  • 15.04.2006 | Sprachen, Modelle, Fabriken
    M. Voelter
    iX 09/2006 | PDF

    In an interview on codegeneration.net I talk about model-driven software development and openArchitectureWare. I explain some of the history of the tool, typical steps you need to go through when using openArchitectureWare, how to use openArchitectureWare in legacy migration project, places where openArchitectureWare is used and generally, about the challenges of introducing MDSD into a development organization.

  • 10.01.2011 | Embedded-Entwicklung mit MPS
    M. Voelter
    iX 01/2011 | PDF

    Dieser Vortrag (und dieses Paper) beschreiben einen neuartigen Ansatz für die Entwicklung eingebetteter Systeme. Die Idee ist, die Programmiersprache C inkrementell so zu erweitern, dass sie besser für die Entwicklung eingebetteter Systeme in einer bestimmten Domäne geeignet ist. Technologisch wird dies durch die Verwendung von projizierenden Editoren - konkret: JetBrains MPS - umgesetzt, die es erlauben, Sprachen zu erweitern, und zu modularisieren

  • 15.04.2006 | Interview on codegeneration.net
    M. Voelter
    codegeneration.net | PDF | Read Online

    In an interview on codegeneration.net I talk about model-driven software development and openArchitectureWare. I explain some of the history of the tool, typical steps you need to go through when using openArchitectureWare, how to use openArchitectureWare in legacy migration project, places where openArchitectureWare is used and generally, about the challenges of introducing MDSD into a development organization.

  • 22.03.2006 | Services, Komponenten, Modelle
    M. Voelter
    ObjektSpektrum 2006-5 | PDF

    Service Oriented Architecture (SOA) ist zu einem der Hype-Themen geworden. Mehrere meiner Kunden stellen ihre Architekturen derzeit auf „SOA“ um oder planen dies zu tun. Interessanterweise machen diese Kunden alle mehr oder weniger unterschiedliche Sachen. Dies deutet darauf hin, dass SOA sehr viele verschiedene Bedeutungen haben kann und ein nicht wirklich scharf definierter Begriff ist. In diesem Artikel möchte ich daher gar nicht erst versuchen, SOA allgemeingültig zu definieren. Stattdessen möchte ich auf einige wichtige Merkmale und Lessons-Learned eingehen. Dabei spielen Komponententechnologien und Modellgetriebene Softwareentwicklung eine zentrale Rolle.

  • 21.09.2005 | Textuelle DSLs – Programmiersprachen zum selbermachen
    M. Voelter, Arno Haase
    JavaMagazin 2005-10 | PDF

    Die meisten Softwaresysteme sind so groß, dass ein einzelner Entwickler sie nicht mehr überall in den Implementierungsdetails überblickt. Deshalb brauchen Entwickler ein abstrakteres Vokabular als den Quelltext, um über das System reden zu können. Diese Kernabstraktionen können in UML-Diagrammen oder z.B. in XP-Projekten als „Metapher“ vorliegen, sie können präzise oder informell definiert sein, aber sie sind notwendig, damit ein System änderbar ist. Ohne dieses gemeinsame Vokabular birgt jedes Gespräch über das System die große Gefahr von unbemerkten Missverständnissen, und die Qualität und Änderbarkeit leidet dem entsprechend. Modellgetriebene Softwareentwicklung hat das Ziel, solche Abstraktionen explizit zu machen, z.B. indem man auf Architekturebene Bausteine und ihr Zusammenspiel beschreibt. Meist denkt man dabei nur an UML-Klassendiagramme, aus denen Infrastrukturcode für das Zusammenspiel von Komponenten generiert wird. Dieser Artikel beschreibt dagegen, wie man das Verhalten von Komponenten durch textuelle Sprachen beschreiben kann und dabei diese Art von Abstraktionen explizit macht. Der Artikel gliedert sich grob in drei Teile. Zunächst beschreibt er anhand eines Beispiels, wie man mit Hilfe textueller DSLs das Verhalten eines Systems beschreiben kann. Auf der Basis dieses Beispiels folgt eine Diskussion der Vor- und Nachteile sowie der sinnvollen Einsatzgebiete textueller DSLs, und der Artikel schließt mit einer Reihe von Best Practices.

  • 20.08.2005 | Architektur ohne Hype
    M. Voelter
    JavaMagazin 10 | PDF

    Softwarearchitektur ist heutzutage ein sehr stark von Hypes und Technologien geprägtes Thema. Man redet von „Java EE Architekturen“ oder „Webservice-Architekturen“. Dies hat jedoch eine ganze Reihe von Nachteilen. In diesem Artikel möchten wir diese Nachteile aufzeigen und einen Ansatz vorstellen, der das Thema Softwarearchitektur etwas systematischer und konzeptioneller und weniger technologiezentriert angeht

  • 20.08.2005 | Architektur ohne Hype - Beispiel
    M. Voelter
    JavaMagazin 10 | PDF

    Dieses ist das aus meiner Mustersprache Software Architecture Patterns extrahierte Beispiel und dient zur Illustration des Artikels Architektur ohne Hype im Java Magazin.

  • 05.07.2005 | Modellgetriebene, Komponentbasierte Softwareentwicklung, Teil 1
    M. Voelter
    JavaMagazin 10 | PDF

    Komponentenbasierte Entwicklung und Modellgetriebene Entwicklung passen sehr gut zueinander – dies hat sich im Laufe der letzen paar Projekte in den verschiedensten Domänen gezeigt. In diesem zweiteiligen Artikel möchte ich darauf eingehen, wie man konkret Modellgetrieben und Komponentenbasiert entwickeln kann in dem ich als zentralen Aspekt ein Metamodell vorstelle, welches CBD aus den drei wichtigsten Perspektiven beleuchtet. Im zweiten Teil des Artikels zeige ich dann typische Variationen dieses Metamodells auf.

  • 05.07.2005 | Modellgetriebene, Komponentbasierte Softwareentwicklung, Teil 2
    M. Voelter
    JavaMagazin 11 | PDF

    Komponentenbasierte Entwicklung und Modellgetriebene Entwicklung passen sehr gut zueinander – dies hat sich im Laufe der letzen paar Projekte in den verschiedensten Domänen gezeigt. In diesem zweiteiligen Artikel möchte ich darauf eingehen, wie man konkret Modellgetrieben und Komponentenbasiert entwickelt. Teil eins hat ein konkretes Metamodell vorgestellt, welches CBD aus den drei wichtigsten Perspektiven beleuchtet. Im zweiten Teil des Artikels möchte ich auf einige typische Variationen dieses Metamodells eingehen, darunter Asynchronität, Events, Layering, und dynamische Verdrahtung.

  • 17.06.2005 | Variantenmanagement im Kontext von MDSD
    M. Voelter
    | PDF

    Product-Line Engineering, also das Bestreben, Familien von Softwaresystemen zu erstellen erfordert kontrolliertes Verwalten von Variabilitäten zwischen den verschiedenen Produkten der Produktlinie. Wie kann man nun Variantenbildung (beschrieben bspw. durch Featuremodelle) sinnvoll mit klassischen Modellgetriebenen Ansätzen verbinden? Wie beschreibt man Varianten von Modellen? Dieser Artikel soll dazu einige theoretische Anregungen geben, und auch zeigen wie man das Problem praktisch angehen könnte.

  • 21.06.2005 | Spring und modellgetriebenes Vorgehen - Gegensatz oder Ergänzung?
    M. Voelter, Eberhard Wolff, Pter Friese
    JavaMagazin 2005-07 | PDF

    Die leidvollen Erfahrungen mit komplexen Plattformen wie J2EE oder CORBA haben zur Entstehung zweier neuer Strömungen im Bereich des Software Engineering geführt: Auf der einen Seite sprießen leichtgewichtige Frameworks – allen voran Spring – aus dem Boden. Gleichzeitig erfreuen sich Modellgetriebene Konzepte wie MDA oder MDSD wachsender Beliebtheit, deren Anspruch aber über das Erleichtern des Umgangs mit einer komplexen Plattform weit hinausgehen. Beide Strömungen nehmen allerdings für sich in Anspruch, die Entwicklung von Anwendungen deutlich zu vereinfachen. So stellt sich die Frage, ob beide Ansätze komplementär einsetzbar sind oder ob sie Gegensätze darstellen.

  • 15.05.2005 | Kaskadierung von MDSD und Modelltransformationen
    M. Voelter
    JavaSpektrum 05/2005 | PDF

    Die Grundlagen Modellgetriebene Softwareentwicklung (MDSD) sind ja zwischenzeitlich hinreichend oft beschrieben worden. Auch der Einsatz der grundlegenden MDSD Techniken ist heutzutage keine Seltenheit mehr. Zeit also, die etwas fortgeschrittenen Konzepte zu beleuchten. In diesem Artikel möchte ich auf zwei fortgeschrittene Themen eingehen: Zum einen die sogenannte kaskadierte MDSD und zum anderen Modelltransformationen. Beides ist in größeren MDSD Projekten essentiell, um die Komplexität des Ansatzes in Grenzen zu halten.

  • 15.06.2005 | Modellgetriebene Softwareentwicklung
    M. Voelter
    DatenbankSpektrum 2005-?? | PDF

    Modellgetriebene Entwicklung (MDSD ) und MDA sind in aller Munde. Dieser Artikel stellt MDSD-Kernkonzepte vor und zeigt, wie sich modellgetriebene Softwareentwicklung im Allgemeinen von MDA (als Spezialisierung von MDSD) unterscheidet. Des Weiteren möchte der Autor Konsequenzen für den Entwicklungsprozess aufzeigen sowie darauf eingehen. Aus Platzgründen kann nicht auf alle Details und Aspekte eingegangen werden.

  • 15.02.2005 | Domain-Driven Development; die Zukunft
    M. Voelter
    ObjektSpektrum 2005-03 | PDF

    Domain-Driven Development und Modellgetriebene Ansätze werden in der Zukunft massiv an Bedeutung gewinnen. Dieser Artikel beleuchtet diese Entwicklung kurz und knapp auf zwei Seiten.

  • 21.03.2005 | openArchitectureWare und Eclipse
    M. Voelter, Bernd Kolb
    Eclipse Magazin 2005-07 | PDF

    openArchitectureWare ist ein Framework zur Modellgetriebenen Entwicklung mit einer ganzen Reihe interessanter Features. Ich möchte in diesem Artikel kurz auf die Eclipse-Integration des Generators eingehen, also die Unterstützung bei der Generator-Entwicklung sowie die Generierung GEF-basierter DSL-Editoren.

  • 21.03.2005 | Generierung von GEF Editoren für Modellgetriebene Entwicklung
    M. Voelter, Bernd Kolb
    Java Spektrum 2005-07 | PDF

    Das Eclipse Graphical Editing Framework (GEF) ist ein Framework für 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.

  • 15.01.2005 | Eclipse zur Domänenspezifischen Entwicklung
    M. Voelter
    Eclipse Magazin 2005-01 | PDF

    Eclipse ist nicht nur eine gute, mit „coolen“ Plugins erweiterbare Java IDE. Aufgrund der offenen Architektur und der zwar umfangreichen, aber gut strukturierten API ist es eine ideale Plattform, um domänen- oder projektspezifisch erweitert zu werden.

  • 15.01.2005 | MDSD und/oder AOSD?
    M. Voelter
    Java Spektrum 2005-02 | PDF

    Modellgetriebene Softwareentwicklung (MDSD) und Aspektorientierte Softwareentwicklung (AOSD) werden beide immer wichtiger im Rahmen der praktischen Softwareentwicklung – vor allem auch, weil die Werkzeugunterstützung immer besser wird. Ich mache im Rahmen meiner Arbeit allerdings immer wieder die Erfahrung, dass es vielen Entwicklern nicht klar ist, in welchem Verhältnis MDSD und AOSD stehen. Dabei gibt es zwei Aspekte: Zum einen stellt sich die Frage, wie die beiden prinzipiell (also mehr oder weniger theoretisch) zusammen passen. Andererseits stellt sich die vollkommen praktische Frage, ob und wie man beide Ansätze zusammen verwenden sollte. Ich möchte in diesem Artikel auf beide Themen kurz eingehen.

  • 01.09.2004 | Rich Client Anwendungen mit Eclipse 3
    M. Voelter, Martin Lippert
    Java Magazin Eclipe Special 2004-09 | PDF

    Viele assoziieren mit Eclipse eine umfangreiche integrierte Entwicklungsumgebung fuer Java, die sich durch Plugins flexibel erweitern laesst. Doch Eclipse ist weit mehr als nur eine erweiterbare IDE – weitaus mehr. Mit der Version 3.0 etabliert sich Eclipse als Plattform fuer die Entwicklung von Rich-Client-Anwendungen und zeigt eindrucksvoll, dass sich Java-basierte Client-Anwendungen nicht zu verstecken brauchen.

  • 01.08.2004 | Remoting Patterns - A Systematic Approach for Design Reuse of Distributed Object Middleware Solutions
    M. Voelter, Uwe Zdun, Michael Kircher
    IEEE Internet special issue on middleware, 2004-05 | PDF

    In many situations the developers or architects of a distributed system require a deep understanding of the middleware products they use. We argue that patterns and pattern languages are a practical and useful means to convey this knowledge. Unfortunately, a comprehensive pattern language, explaining how to effectively use, extend, integrate, customize, or build distributed object middleware solutions was missing. Therefore, we propose a pattern language of remoting patterns as a systematic way to reuse software models, designs, and implementations in the area of distributed object middleware. This pattern language has rich interactions with other patterns and pattern languages from related domains, such as networking, concurrency, resource management, server components, security, availability, scalability, fault tolerance, and aspect-orientation.

  • 01.05.2004 | Parsen und Verarbeiten textueller Spezifikationen
    M. Voelter
    JavaSpektrum 2004-04 | PDF

    Im Zusammenhang mit Modellgetriebener Softwareentwicklung ist das Parsen von Modellen und deren Weiterverarbeitung (insbesondere zwecks Codegenerierung) sehr wichtig. Oft verwendet man grafische, UML basierte Modelle als Spezifikation. In vielen Fällen sind textuelle Spezifikationen aber mindestens genauso nuetzlich. Auch wenn man nicht komplett modellgetrieben arbeitet, macht es oft Sinn, sich fuer bestimmte Aspekte kleine, textuelle Sprachen zu bauen; man denke nur an CORBA IDL. Ich moechte in diesem Artikel zeigen, wie man mit Parsergeneratoren - hier am Beispiel von JavaCC - arbeitet. Aus eigener Erfahrung weiss ich, dass diese Art von Tools fuer viele Leute schwer zugaenglich ist, fuer allem fuer nicht-Informatiker (bin selbst Ingenieur). Zum Zwecke der Illustration werden wir dann aus dem Modell Code generieren. Dazu verwenden wir den openArchitectureWare Codegenerator, der bereits im Rahmen eines frueheren Artikels in dieser Kolumne eingefuehrt wurde.

  • 01.05.2004 | Sommerloch
    M. Voelter
    JavaSpektrum 2004-10 | PDF

    Diese Kolumne adressiert praktisch relevante (Der Praktiker) technologisch interessante Themen. Dies bedingt, dass die interessanten Themen auch tatsaechlich in der Praxis eingesetzt wurden. Nun habe ich diesen Sommer aber gluecklicherweise auch Urlaub gehabt und deshalb nichts interessantes praktisches getan (abgesehen von Segelfliegen in den Schweizer Alpen, wofuer sich im Rahmen dieser Kolumne aber wahrscheinlich niemand interessiert). Ich werde daher in diesem Artikel etwas tun, was ich schon lange einmal vorhatte: Auf interessante Buecher hinweisen, die ich in der letzten Zeit gelesen habe.

  • 01.07.2004 | Lebendige Architekturen
    M. Voelter
    JavaSpektrum 2004-03 | PDF

    Dass die Architektur eines Softwaresystems massgeblich ueber dessen Qualität und Wartbarkeit entscheidet ist wohlbekannt. Wie eine gute Softwarearchitektur aussieht ist (spaetestens nach Ende des Projektes) meist auch klar. Wie man aber im Laufe eines – meist unter Zeitdruck stehenden – Projektes dafuer sorgen kann, dass eine Architektur konsequent umgesetzt wird, und wie man die Architektur eines Systems im Laufe der Entwicklung praktisch weiterentwickelt ist nicht so klar. Dieser Artikel soll einige Anregungen in dieser Hinsicht geben.

  • 01.07.2004 | Plug-Ins - Applikationsspezifische Komponenten
    M. Voelter, Klaus Marquardt
    JavaSpektrum 2002-06 | PDF

    Erweiterbarkeit ist eines der grossen Themen in der Software-Architektur. Moderne Systeme schmuecken sich gerne mit diesem Attribut - und meinen damit oft ganz unterschiedliche Dinge. Tatsaechlich wird Erweiterbarkeit vom Benutzer fast nie als zentrale Eigenschaft eines Systems wahrgenommen. Doch gibt es Anwendungsbereiche, in denen eine gezielte Erweiterbarkeit den essentiellen Beduerfnissen der Kunden entspricht. Diese Kunden verlangen gleichzeitig nach einer hohen, nahtlosen Integration ihrer Anwendungen, um aus dem Zusammensetzen verschiedener Funktionen Vorteile zu ziehen. Fuer den Spagat zwischen Flexibilitaet durch getrennt entwickelte Erweiterungen und nahtloser Integration in eine gemeinsame Applikation gibt es eine - gelegentlich uebersehene - Art der Komponentenarchitektur: Plug-Ins.

  • 01.07.2004 | Model Driven Software Development
    M. Voelter
    ObjektSpektrum 2004-07 | PDF

    Bei Modellgetriebener Softwareentwicklung (MDSD) geht es um die Erstellung von Software aus Modellen. Modelle - in welcher Notation auch immer sie erstellt werden - spielen also die Rolle der Quellen im Softwareentwicklungsprozess, die im Rahmen traditioneller Entwicklung ueblicherweise von einer 3GL Programmiersprache ausgefuellt wird. Dabei sollen die Modelle so exakt und so ausdrucksstark wie moeglich die durch die Software zu erbringende Funktionalität beschreiben. Dazu braucht man eine passende Modellierungssprache, eine DSL (Domain-Specific Language). Um dann letztendlich Software zu erhalten, die auf der entsprechenden Zielplattform lauffähig ist, muessen die Modelle durch Transformationen bzw. Codegenerierung in ausfuehrbaren Code ueberfuehrt werden. Dafuer sind Tools notwendig, die fuer die entsprechende DSL erstellt und weiterentwickelt werden muessen. Wie dieser kurze Abriss zeigt, sind einige der von MDSD verwendeten Konzepte doch etwas anders als im Rahmen traditioneller Softwareentwicklung. Die Übersetzung von abstrakten Spezifikationen in eine weniger abstrakte, ausfuehrbare Implementierung ist zwar nichts neues (Compiler machen nichts anderes!), allerdings obliegt es nun dem Entwicklungsteam die Sprache und den Übersetzer zu definieren und zu Implementieren - man entwickelt also nicht nur Software, sondern auch Software Fabriken: Infrastrukturen, um Software zu entwickeln. Dieser Artikel soll einige MDSD-Kernkonzepte vorstellen, Konsequenzen auf den Entwicklungsprozess aufzeigen sowie darauf eingehen, wie MDA, AOP, IP und andere Techniken mit MDSD in Bezug stehen. Aus Platzgruenden kann nicht auf alle Details und Aspekte eingegangen werden, der Artikel soll ausdruecklich einen moeglichst breiten Ueberblick ueber das Gebietes geben.

  • 01.04.2004 | Die 5 Leben des AspectJ
    M. Voelter, Martin Lippert
    JavaSpektrum 2004-04 | PDF

    Bei Modellgetriebener Softwareentwicklung (MDSD) geht es um die Erstellung von Software aus Modellen. Modelle - in welcher Notation auch immer sie erstellt werden - spielen also die Rolle der Quellen im Softwareentwicklungsprozess, die im Rahmen traditioneller Entwicklung ueblicherweise von einer 3GL Programmiersprache ausgefuellt wird. Dabei sollen die Modelle so exakt und so ausdrucksstark wie moeglich die durch die Software zu erbringende Funktionalität beschreiben. Dazu braucht man eine passende Modellierungssprache, eine DSL (Domain-Specific Language). Um dann letztendlich Software zu erhalten, die auf der entsprechenden Zielplattform lauffähig ist, muessen die Modelle durch Transformationen bzw. Codegenerierung in ausfuehrbaren Code ueberfuehrt werden. Dafuer sind Tools notwendig, die fuer die entsprechende DSL erstellt und weiterentwickelt werden muessen. Wie dieser kurze Abriss zeigt, sind einige der von MDSD verwendeten Konzepte doch etwas anders als im Rahmen traditioneller Softwareentwicklung. Die Übersetzung von abstrakten Spezifikationen in eine weniger abstrakte, ausfuehrbare Implementierung ist zwar nichts neues (Compiler machen nichts anderes!), allerdings obliegt es nun dem Entwicklungsteam die Sprache und den Übersetzer zu definieren und zu Implementieren - man entwickelt also nicht nur Software, sondern auch Software Fabriken: Infrastrukturen, um Software zu entwickeln. Dieser Artikel soll einige MDSD-Kernkonzepte vorstellen, Konsequenzen auf den Entwicklungsprozess aufzeigen sowie darauf eingehen, wie MDA, AOP, IP und andere Techniken mit MDSD in Bezug stehen. Aus Platzgruenden kann nicht auf alle Details und Aspekte eingegangen werden, der Artikel soll ausdruecklich einen moeglichst breiten Ueberblick ueber das Gebietes geben.

  • 01.02.2004 | Eigene Aspekte in EJB
    M. Voelter
    JavaSpektrum 2004-02 | PDF

    Das primaere Ziel serverseitiger Komponentenarchitekturen wie EJB ist die Herausfaktorisierung technischer Belange aus Anwendungscode. Der Container kuemmert sich um die technischen Belange, der Entwickler schreibt Komponenten in deren Implementierung er sich nicht um die technischen Aspekte kuemmern muss. Er muss den Container lediglich steuern (mittels des Deployment Descriptors). Wenn man Komponenteninfrastrukturen unter diesem Licht betrachtet sind sie eine Form der Aspektorientierung. AOP hat zum Ziel querliegende Belange (crosscutting concerns) aus einem System herauszuziehen und in einem Aspekt zu lokalisieren. Dies erlaubt ein leichteres Verstaendnis des Programms und erlaubt des weiteren, bestimmte Aspekte „einoder auszuschalten“. Außerdem foerdert diese Art von Vorgehen die Wiederverwendbarkeit: Kernlogik und Aspekte koennen (bei gutem Design) separat wiederverwendet werden. Der offensichtliche Nachteil von EJB wenn man es als AOP Framework betrachtet ist, daß die Anzahl und Art der Concerns auf die von der EJB Spezifikation beschriebenen (Persistenz, Transaktionen, Security, ...) beschraenkt ist. Der vorliegende Artikel erlaeutert, wie man sich ein einfaches Framework bauen kann, welches es erlaubt, bei Beans beliebige Aspekte an bestimmten Stellen (Joinpoints) einzunklinken.

  • 01.08.2003 | Eclipse-GUIs einmal anders
    M. Voelter
    JavaSpektrum 2003-08 | PDF

    Wie schafft man es, einheitliche, flexible und gut testbare grafische Oberflaechen mit minimalem Zeitaufwand zu erstellen und das auch noch ohne dass sich der Anwendungsprogramierer um die zugrunde liegende Oberflaechenbibliothek kuemmern muss? Dieser Artikel beschaeftigt sich mit einem GUI-Framework, welches entwickelt wurde um genau dies zu ermoeglichen. Der Artikel will dabei nicht Werbung fuer dieses spezifische Framework machen, sondern anregen, auf diese Art und Weise Oberflaechen zu erstellen. Das Framework welches hier beschrieben wird wurde zunaechst fuer SWT entwickelt, mittlerweile aber ebenfalls nach Swing portiert. Wir wollen uns in diesem Artikel mit der SWT-Version des Frameworks beschaeftigen.

  • 01.08.2003 | Metamodellbasierte Codegenerierung in Java
    M. Voelter
    JavaSpektrum 2003-08 | PDF

    Codegenerierung bezeichnet die automatische Erstellung von Quelltext aus ueblicherweise abstraktereren, oft domaenenspezifischen Modellen. Ueblicherweise sollen damit Ziele erreicht werden wie Vermeidung des Schreibens von immer gleichem Code, Architekturkonformität, Performanzsteigerung, oder eben die Moeglichkeit, Dinge auf Ebene eines Modelles spezifizieren zu koennen und sich um die Details der Implementierung nicht kuemmern zu muessen. Dieser Artikel geht nun nicht auf das Fuer und wider von Codegenerierung, Integration von generiertem und nicht-generiertem Code ein. Er enthaelt auch keinen Ueberblick ueber die verschiedenen technischen Moeglichkeiten wie Code generiert werden kann. Vielmehr soll dieser Artikel eine sehr effiziente Art der Generierung von Code aus Modellen erlaeutern, die sogenannte metamodellbasierte Codegenererierung.

  • 01.08.2003 | Handling Cross-Cutting Conerns - AOP and beyond
    M. Voelter
    | PDF

    With the rise of aspect-oriented programming techniques and tools the issue of cross-cutting concerns and their efficient handling is becoming more and more prominent. AspectJ is the most well-known example of aspect-oriented programming. I have come across many discussions about what constitutes “real” AOP and what doesn’t. While I certainly don’t have the goal of settling this discussion once and for all, but I want to widen the scope of the discussion a little bit: AOP is basically a way to efficiently handle cross-cutting concerns on language-level. However, there are ways to handle cross-cutting concerns differently, on other levels, such as design or architecture. While I don’t want to formally define AO-Design or AO-Architecture, I want to provide a couple of examples how cross-cutting concerns can be handled without AO language tools.

  • 01.07.2003 | Codegenerierung - ein Ueberblick
    M. Voelter
    Java Magazin 2003-07 | PDF

    Codegenerierung ist ein wichtiges Mittel die Effizienz von Softwareentwicklungsprojekten zu steigern. Im Rahmen von Modellgeriebener Entwicklung und MDA nimmt die Generierung von Code aus Modellen einen wichtigen Stellenwert ein. Dieser Artikel soll im Zusammenhang mit Codegenerierung die folgenden drei Aspekte betrachten: Wann ist es sinnvoll, Codegenerierung einzusetzen, Wie integriert man generierten und nicht-generierten Code sinnvoll, Welche Arten von Codegenerierung werden genutzt, und welche Tools sind dafuer vorhanden.

  • 01.01.2003 | Architektur und Generierung
    M. Voelter, Thomas Stahl
    iX 2003-01 | PDF

    Generierung von Quellcode im Rahmen von Software-Entwicklungsprojekten gilt heutzutage als akzeptiertes Konzept zur Effizienzsteigerung, nicht zuletzt durch die zunehmende Verbreitung generativer Programmiertechniken und der Model-Driven Architecture der OMG. Mittlerweile gibt es auch die ersten praxistauglichen Tools, die flexibel und ausgereift genug sind, die genannten Konzepte zu unterstuetzen. Allerdings ist dabei wie immer zu beachten, dass nicht die Tool-Frage im Vordergrund stehen sollte sondern die Anforderungen. Ein Werkzeug ist eben dann geeignet, wenn es die Anforderungen erfuellt. In diesem Artikel untersuchen wir die Voraussetzungen fuer den effektiven Einsatz von Codegenerierung und Ansaetze, die sich daraus ableiten lassen.

  • 01.08.2002 | J2EE im kommerziellen Grossprojekt
    M. Voelter, Thomas Stahl, Nicolai Josuttis
    ObjektSpektrum 2002-08 | PDF

    J2EE bietet eine Standard-Architektur fuer große kommerzielle Systeme. Doch wie in jedem Projekt muss man auch bei J2EE-Projekten bei der Umsetzung die besonderen Anforderungen und Randbedingungen beruecksichtigen. Wir berichten hier von einem erfolgreichen Grossprojekt im Bankenumfeld, bei dem J2EE etwas anders als sonst eingesetzt wurde. Diese Besonderheiten betrachten wir als Folge der Projektgroesse und der Forderung nach einer einfachen, handhabbaren, und skalierbaren Architektur. Insofern stellen wir die im folgenden vorgrstellte Architektur als eine typische, praktische Umsetzung des J2EE-Ansatzes zur Diskussion.

  • 01.12.2002 | Komponenteninfrastrukturen
    M. Voelter, Eberhard Wolff, Alexander Schmid
    Java Magazin 2002-12 | PDF



  • 01.08.2003 | A Taxonomy for Components
    M. Voelter
    JOT - Journal of Object Technology 2003-08 | PDF

    The notion of a component is not really well defined for practical purposes. This is, because the term is used to denote many different things. So, instead of defining the term once and for all, we present a taxonomy that shows the different features of a component.

  • 01.01.2002 | Pedagogical patterns - capturing best practices in teaching object technology
    M. Voelter, Jutta Eckstein, Mary-Lynn Manns
    Wiley Software Focus 2002-01 | PDF

    The Pedagogical Patterns Project began at OOPSLA '95 and started holding workshops in 1996 at the ECOOP, TOOLS and OOPSLA conferences. The aim of the project has been to capture successful experiences in teaching and learning object technology, from industry or academia, in a homogeneous, easily-accessible format. Patterns have been regarded as an effective method for achieving this. Since 1996, many other sessions have been held at numerous conferences in America and Europe, resulting in the collection of more than 50 teaching techniques written in pattern format. As this present collection is now being refined and expanded, educators are discovering the effectiveness of sharing their teaching experiences in the form of pedagogical patterns.

  • 01.12.1999 | Aspect Oriented Programming in Java
    M. Voelter
    JavaReport 1999-12 | PDF

    Object oriented programming has become mainstream over the last years, having almost completely replaced the procedural approach. One of the biggest advantages of object orientation is that a software system can be seen as being built of a collection of discrete classes. Each of these classes has a well defined task, its responsibilities are clearly defined. In an OO application, those classes collaborate to achieve the application's overall goal. However, there are parts of a system that cannot be viewed as being the responsibility of only one class, they cross-cut the complete system and affect parts of many classes. Examples might be locking in a distributed application, exception handling, or logging method calls. Of course, the code that handles these parts can be added to each class separately, but that would violate the principle that each class has well-defined responsibilities. This is where AOP comes into play: AOP defines a new program construct, called an aspect, which is used to capture cross-cutting aspects of a software system in separate program entities. The application classes keep their well-defined resonsibilities. Additionally, each aspect captures cross-cutting behaviour.

  • 01.08.2002 | Mobil Orientiert
    M. Voelter
    iX 2002-08 | PDF

    Um OO-Konzepte in der Embedded-Welt zu realisieren, bedarf es leichtgewichtiger Komponentenmodelle. Das Beispiel eines in Java, unter Verwendung generativer Entwicklungsmethoden implementierten Prototypen, zeigt worauf in diesem Umfeld besonders zu achten ist.

  • 01.05.2002 | Die Model Driven Architecture
    M. Voelter, Eberhard Wolff
    computerwoche extra 2002-05 | PDF

    Um OO-Konzepte in der Embedded-Welt zu realisieren, bedarf es leichtgewichtiger Komponentenmodelle. Das Beispiel eines in Java, unter Verwendung generativer Entwicklungsmethoden implementierten Prototypen, zeigt worauf in diesem Umfeld besonders zu achten ist.

  • 01.03.2002 | Java Komponenteninfrastrukturenv - Grundlagen und Beispiele
    M. Voelter
    JavaSpektrum 2002-03 | PDF

    Diesers Artikel soll die grundlegenden Prinzipien aufzeigen, die Komponenteninfrastrukturen zugrunde liegen, mit speziellem Fokus auf Java. Dazu werden zunaechst einige der Grundlagen erlaeutert, und dann zwei verschiedene Realisierungen betrachtet: Zum einen Enterprise JavaBeans, und zum anderen ein Prototyp eines Komponentenmodells fuer Embedded Systeme - einer Domaene, wo kompontenbasierte Ansaetze nicht alltaeglich sind. Der Artikel fuehrt nicht in EJB ein, Kenntnisse der Funktionsweise werden vorausgesetzt.

  • 01.01.2002 | P2P und Komponenten - Eigenschaften, Unterschiede, Ergaenzungsmoeglichkeiten
    M. Voelter, Thomas Quas
    ObjektSpektrum 2002-01 | PDF

    Peer-to-Peer (P2P) ist in aller Munde. Neben Webservices ist es ganz klar der neueste Hype (es gibt sogar schon eine Konferenz dazu!). Da fragt sich der etwas traditioneller veranlagte Softwareentwickler, der gerade erst den Komponentenhype verdaut hat: Muss ich jetzt alles wegwerfen und wieder was neues lernen? Keine Sorge, ganz so schlimm kommt es wohl nicht. Der vorliegende Artikel beleuchtet Komponententechnologien und P2P Systeme, zeigt ihre Unterschiede und Anwendungsgebiete, und versucht, Anwendungsfaelle zu erlaeutern, wo sich beide Technologien ergaenzen koennen.

  • 01.08.2001 | Spontanes Netz
    M. Voelter
    iX 2001-08 | PDF

    Enterprise JavaBeans, CORBA und .Net sind nicht alles in der vernetzten Welt. Mit mobilem Code, Agenten oder den durch Napster et cetera ge-hype-ten Peer-to-Peer-Systemen (P2P) existieren Softwareansaetze, die fuer die Zukunft anderes als Client/Server-Anwendungen versprechen.

  • 01.03.2001 | Flexible Erzeugung von Value Objects
    M. Voelter
    sw-development 2001-03 | PDF

    ValueObjects sind Datentypen, die bei der Kommunikation mit entfernten Komponenten eingesetzt werden um die Kommunikation mit diesen effizienter zu gestalten. Das Problem ist, dass immer wenn (aufgrund eines neues Use Cases) ein neues ValueObject noetig ist, eine neue Value Object Klasse und eine entsprechenden Operation im Interface der Komponenten noetig ist. Die dadurch auftretenden Aenderungen an der Komponentenimplementierung sind allerdings laestig und fehleranfaellig und sollten daher vermieden werden. Der Artikel zeigt, wie.

  • 01.01.2001 | Vor- und Nachbedingungen in Java
    M. Voelter
    Java Spektrum 2001-01 | PDF

    Die Schnittstelle einer Klassen soll einen Vertrag zwischen der Klasse selbst und ihren Benutzerklassen definieren, der die Leistungen die die Lieferantenklasse anbietet (also deren Operationen) beschreibt. Leider definiert eine solche Schnittstelle nur die Syntax der Operationen, die Semantik bleibt undefiniert. Dem kann mit Constraints (Einschraenkungen) Abhilfe geschafft werden. In Java werden Constraints zwar nicht direkt unterstuetzt, jedoch lassen sie sich recht einfach nachbauen. Dieser Artikels zeigt eine Moeglichkeit, wie dies ohne neue Sprachfeatures oder spezielle Precompiler geschehen kann.

  • 01.01.2000 | Frameworks und Komponenten - Widerspruch oder Ergaenzung
    M. Voelter
    sw-development 2000-01 | PDF

    Diese Technologie ist die Zukunft der Softwareentwicklung. Ein Satz den man dieser Tage regelmaessig nicht nur bei den Marketingabteilungen der Toolhersteller hoert, sondern auch auf konzeptionellem Niveau. Ein Kandidat ist zum Beispiel komponentenbasierte Softwareentwicklung. Ein anderer sind Frameworks. Auf den ersten Blick scheinen die beiden Bereiche nichts viel gemeinsam zu haben, vielleicht widersprechen sie sich sogar scheinbar. Bei naeherer Betrachtung laesst sich diese These aber nicht halten. Der vorliegende Artikel soll die Gemeinsamkeiten und Ergaenzungsmoeglichkeiten von Komponenten und Frameworks naeher beleuchten.

  • 01.12.2000 | Ein Scheduler basierend auf Commands und Strategien
    M. Voelter
    JavaMagazin 2000-12 | PDF

    Eine gaengige Anforderung an Anwendungsprogramme ist, dass bestimmte Aktionen regelmaeßig und wiederholt ablaufen sollen. Verschiedene Aktionen koennen in verschiedenen Abstaenden, etc. ablaufen. Zu diesem Zweck kann ein Scheduler eingesetzt werden, dem die auszufuehrenden Aktionen uebergeben werden, und der sich dann darum kuemmert, dass sie zu den richtigen Zeiten ausgefuehrt werden. Ein solcher Scheduler, der auf dem Command- und dem Strategie-Muster beruht, soll in diesem Artikel vorgestellt werden.

  • 01.11.2000 | Transaktionen basierend auf Commands und Mementos
    M. Voelter
    JavaMagazin 2000-11 | PDF

    In vielen Anwendungen wird Transaktionssemantik benoetigt. Um diese zu implementieren, gibt es verschiedene Hilfsmittel, darunter Transaktionsmonitore bzw. die Interfaces und Klassen im Package javax.jta. Jedoch ist dies fuer viele Anwendungen zuviel des Guten. Beispielsweise hat auch das Rueckgaengigmachen von Gruppen von Kommandos einige Aspekte mit Transaktionen gemeinsam. Im Rahmen dieses Artikels soll aufgezeigt werden, wie sich derartige Transaktionen implementieren lassen.

  • 01.10.2000 | Mementos basierend auf Java's Serialisierungsmechanismus
    M. Voelter
    JavaMagazin 2000-10 | PDF

    Das Mementomuster aus dem Buch der Gang of Four dient dazu, den Zustand eines Objektes zu externalisieren und einem anderen Objekt zur Aufbewahrung zu ueberlassen, ohne dass die Kapselung des Objektes aufgebrochen wird. Java bietet mittels der Serialisierung einen einfachen Mechanismus, um generisch verwendbare Mementos zu erzeugen.

  • 01.09.2000 | Bidirektionale Assoziationen in Java
    M. Voelter
    JavaMagazin 2000-09 | PDF

    Bidirektionale Assozationen sind jedem Programmierer bekannt da sie in praktisch allen Softwareentwicklungsprojekten vorkommen. Da sie von den gaengigen Programmiersprache, so auch Java, nicht unterstuetz werden, werden sie in der Regel mit Hilfe von zwei einzelnen, unidirektionalen Assoziationen nachgebildet. Dies hat jedoch verschiedene Nachteile. Die in diesem Artikel vorgestellten Hilfsklassen koennen da Abhilfe schaffen.

  • 01.10.1999 | Dr. med. CORBA
    M. Voelter
    iX 1999-10 | PDF

    Neben globalen Diensten wie Naming oder Transaction spezifiziert die OMG im Rahmen von CORBA anwendungsspezifische Services. Das Beispiel CORBAMed zeigt, wie ein solcher Dienst die Branchensoftware verschiedener Hersteller unter einen Hut bringen kann.

  • 01.10.1999 | Better test
    M. Voelter
    iX 1998-11 | PDF

    Bei der Arbeit mit Servlets kommt man recht schnell an den Punkt, an dem man Servlets vernuenftig testen oder debuggen will. Mit Hilfe des hier erlaeuterten Verfahrens lassen sich Servlets als normale Java-Anwendungen verwenden und in der gewohnten IDE debuggen.