{ Publications //

 
 

Journal Papers

    31.08.2015 | Computer Languages, Systems and Structures tbd | PDF | Abstract
    S. Erdweg, T. van der Storma, M. Völter, L. Tratt et al.

    Evaluating and Comparing Language Workbenches - Existing Results and Benchmarks for the Future

    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 | IEEE Software tbd | PDF | Abstract
    M. Voelter, B. Kolb, J. Warmer

    Projecting a Modular Future

    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 | Journal of Automated Software Engineering | PDF | Abstract
    M. Voelter, Daniel Ratiu, Bernd Kolb, Bernhard Schaetz

    mbeddr -- Instantiating a Language Workbench in the Embedded Software Domain

    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 | IEEE Software March/April 2010 | PDF | Abstract
    M. Voelter

    Architecture As Language

    Architecture is typically either a very non-tangible, conceptual aspect of a software system that can primarily be found in Word documents, or it is entirely driven by technology (“we use an XML architecture”). Both are bad: the former makes it hard to work with, and the latter hides architectural concepts behind technology hype. What can be done? As you develop the architecture, evolve a language that allows you to describe systems based on this architecture. Based on my experience in a number of real-world projects, this makes the architecture tangible and provides an unambiguous description of the architectural building blocks as well as the concrete system while still staying away from technology decisions (which then can be made consciously in a separate step).


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

    Aspect-Oriented Model-Driven Software Development

    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 | International Journal on Webservice Research 2004-05 | PDF | Abstract
    Uwe Zdun, Michael Kircher, M. Voelter

    Pattern-Based Design of an Asynchronous Invocation Framework for Web Services

    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

    28.09.2016 | ASE 2016 | Paper PDF | Abstract
    T. Szabo, S. Alperovich, M. Voelter, S. Erdweg

    An Extensible Framework for Variable-Precision Data-Flow Analyses in MPS

    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 | ASE 2016 | Paper PDF | Abstract
    T. Szabo, S. Erdweg, M. Voelter

    IncA - A DSL for the Definition of Incremental Program Analyses

    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 | FSE 2016 | Paper PDF | Abstract
    T. Berger, M. Voelter, H.-P. Jensen, T. Dangprasert, J. Siegmund

    Efficiency of Projectional Editing - A Controlled Experiment

    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 | OOPSLA 2015 | Paper PDF | Slides PDF | Abstract
    M. Voelter, A. van Deursen, B. Kolb, S. Eberle

    Using C Language Extensions for Developing Embedded Software - A Case Study

    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 | Ada Europe 2015 | Paper PDF | Abstract
    D. Pavletic, M. Voelter, S. A. Raza, B. Kolb, T Kehrer

    Extensible Debuggers for Extensible Languages

    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 | ASE 2014 | Paper PDF | Abstract
    Z. Molotnikov, M. Voelter, D. Ratiu

    Automated Domain-Specific C Verification with mbeddr

    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 | SLE 2014 | Paper PDF | Slides PDF | Abstract
    M. Voelter, J. Siegmund, T. Berger, B. Kolb

    Towards User-Friendly Projectional Editors

    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 | REFSQ'14 | Paper PDF | Abstract
    F. Kneer, E. Kamsties, M. Voelter

    Feedback-aware Requirements Documents for Smart Devices

    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 | SLE 2013 | Paper PDF | Abstract
    T. v. d. Storm, S. Erdweg, M. Voelter + 19 tool developers

    The State of the Art in Language Workbenches - Conclusions from the LWC

    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 | Principles and Practice of Programming in Java, 2013 | Paper PDF | Abstract
    V. Pech, A. Shatalin, M. Voelter

    JetBrains MPS as a Tool for Extending Java

    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 | NASA Formal Methods Symposium 2013 | Paper PDF | Abstract
    D. Ratiu, M. Voelter, B. Kolb, B. Schaetz

    Using Language Engineering to Lift Languages and Analyses at the Domain Level

    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 | Wavefront/SPLASH 2012 | Paper PDF | Abstract
    M. Voelter, D. Ratiu, B. Kolb, B. Schaetz

    mbeddr - an Extensible C-based Programming Language and IDE for Embedded Systems

    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 | SLE 2013
    L. Bettini, D. Stoll, M. Voelter, S. Colameo

    Approaches and Tools for Implementing Type Systems in Xtext


    05.07.2011 | GTTSE 2011 | Paper PDF | Abstract
    M. Voelter

    Language and IDE Development, Modularization and Composition with MPS

    JetBrains MPS is an Open Source language workbench. It uses projectional editing, which means that no parser is involved, and textual, tabular and graphical notations are handled with the same approach. As a consequence, it is an ideal language and IDE development environment. This tutorial has three parts: In part one, I will give a very short introduction to projectional editing. Part two provides examples of existing (modular) languages developed with MPS, showcasing the benefits of the tool and its 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 | SPLC 2011 | Paper PDF | Abstract
    M. Voelter, E. Visser

    Product Line Engineering using Domain-Specific Languages

    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 | Models 2010 | Paper PDF | Abstract
    M. Voelter

    Embedded Software Development with Projectional Language Workbenches

    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 | ERTS 2010 | Paper PDF | Abstract
    M. Voelter, Andreas Graf

    Integrating the AUTOSAR tool chain with Eclipse based model transformations


    05.05.2007 | SPLC 2007 | Paper PDF | Abstract
    M. Voelter, Iris Groher

    Product Line Implementation using Aspect-Oriented and Model-Driven Software Development

    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 | SPIE 2004 | Paper PDF | Abstract
    M. Voelter, Heiko Sommer, Gianluca Chiozzi, Klemen Zaga

    Container-component model and XML in ALMA ACS

    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 | ICWS-Europe'03 | Paper PDF | Abstract
    M. Voelter, Uwe Zdun, Michael Kircher

    Design and Implementation of an Asynchronous Invocation Framework for Web Services

    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 | XP 2002 | Paper PDF | Abstract
    M. Voelter

    Human Aspects in Software Processes - A collection of former Pedagogical Patterns

    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 | Net.ObjectDays 2001 | Paper PDF | Abstract
    M. Voelter, Jutta Eckstein

    Learning to teach - Learning to learn

    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

 
 

Workshop Papers

    14.05.2016 | Automation of Software Test (AST 2016) at ICSE 2016 | Paper PDF | Abstract
    D. Ratiu, M. Voelter

    Automated Testing of DSL Implementations

    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 | The 15th Workshop on Domain-Specific Modeling at SPLASH 2015 | Paper PDF | Slides PDF | Abstract
    M. Voelter, Z. Molotnikov, B. Kolb

    Improving Software Security using Language Engineering and mbeddr C

    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 | GEMOC 2014 at MODELS 2014 | Paper PDF | Slides PDF | Abstract
    M. Voelter, S. Lisson

    Supporting Diverse Notations with MPS' Projectional Editor

    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 | MBEES 2014 at | Paper PDF | Abstract
    M. Voelter

    Preliminary Experience of using mbeddr for Developing Embedded Software

    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 | MPM'13 at MoDELS 2013 | Paper PDF | Abstract
    M. Voelter

    Integrating Prose as a First-Class Citizen with Models and Code

    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 | GI/ACM WS on Software Reengineering, 2013 at -- | Paper PDF | Abstract
    M. Voelter, D. Pavletic, A. S. Raza, B. Kolb, T. Kehrer

    Extensible Debuggers for Extensible Languages

    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 | MiSE 2013 at ICSE 2013 | Paper PDF | Abstract
    M. Voelter, F. Tomassetti, A. Vetro, M. Torchiano, B. Kolb

    A Model-Based Approach to Language Integration

    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 | MBEES 2013 at MBEES 2013 | Paper PDF | Abstract
    M. Voelter, Federico Tomassetti

    Requirements as First Class Citizens

    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.


    20.04.2013 | MiSE 2013 at ICSE 2013 | Paper PDF | Abstract
    M. Voelter, Federico Tomassetti, Antonio Vetro, Marco Torchiano, Bernd Kolb

    A Model-Based Approach to Language Integration

    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 crosslanguage 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.


    08.10.2012 | Modevva 2012 at MoDELS 2012 | Paper PDF | Abstract
    M. Voelter, Daniel Ratiu, Zaur Molotnikov, Bernhard Schaetz

    Implementing Modular Domain Specific Languages and Analyses

    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 | FormSERA 2012 at ICSE 2012 | Paper PDF | Abstract
    M. Voelter, Daniel Ratiu, Bernhard Schaetz, Bernd Kolb

    Language Engineering as an Enabler for Incrementally Defined Formal Analyses

    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 | MBEES 2012 at MBEES 2012 | Paper PDF | Abstract
    M. Voelter

    Towards an Extensible C for Embedded Programming

    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 Modeling (DSM) 2010 at SPLASH 2010 | Paper PDF | Abstract
    M. Voelter, Bernhard Merkle

    Domain Specific - a Binary Decision ?

    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 | Domain Specific Modeling (DSM) 2010 at SPLASH 2010 | Paper PDF | Abstract
    M. Voelter, Bernhard Merkle

    Implementing Feature Variability for Models and Code with Projectional Language Workbenches

    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 | Feature Oriented Software Development (FOSD) 2010 at GPCE 2010 | Paper PDF | Abstract
    M. Voelter

    Projectional Language Workbenches as a Foundation for Product Line Engineering

    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 | Domain-Specific Modeling 2008 at OOPSLA 2008 | Paper PDF | Abstract
    M. Voelter

    A Family of Languages for Architecture Description

    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 at Model-Driven Development in the Real World | Paper PDF | Abstract
    M. Voelter

    Model-Driven Development in the Real World


    21.10.2007 | Domain Specific Modeling 2007 at OOPSLA 2007 | Paper PDF | Abstract
    M. Voelter, Iris Groher

    Handling Variability in Model Transformations and Generators

    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 | Managing Variability for Software Product Lines at SPLC 2007 | Paper PDF | Abstract
    M. Voelter, Iris Groher

    Expressing Feature-Based Variability in Structural Models

    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 | MDD Tool Implementers Forum at TOOLS Europe 2007 | Paper PDF | Abstract
    M. Voelter, Bernd Kolb, Sven Efftinge, Arno Haase

    Introduction to openArchitectureWare 4.1.x

    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 | SIG MDSE Workshop on MDSD in Embedded Systems at | Paper PDF | Abstract
    M. Voelter, Iris Groher, Bernd Kolb

    Mechanisms for Expressing Variability in Models and MDD Tool Chains

    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 | Aspect Oriented Modelling Workshop 2007 at AOSD 2007 | Paper PDF | Abstract
    M. Voelter, Iris Groher

    XWeave - Models and Aspects in Concert

    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 | Modeling Symposium at Eclipse Summit 2006 | Paper PDF | Abstract
    M. Voelter

    oAW xText - A framework for textual DSLs

    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 | Modeling Symposium at Eclipse Summit 2006 | Paper PDF | Abstract
    M. Voelter

    Best Practices for Model-to-Text Transformations

    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 | Eclipse Technology Exchange at ECOOP 06 | Paper PDF | Abstract
    M. Voelter

    openArchitectureWare, a flexible Open Source platform for model-driven software development

    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 | Dagstuhl Workshop Model-Based Development of Embedded Systems at Dagstuhl Workshop Model-Based Development of Embedded Systems | Paper PDF | Abstract
    M. Voelter

    Model-Driven Development of Component Infrastructures for Embedded Systems

    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 | Automotive Software Engineering at GI Jahrestagung | Paper PDF | Abstract
    M. Voelter

    Model-based Middleware for Embedded Systems

    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 | Focus Group on Resource Management Patterns at EuroPLoP 2002 | Paper PDF | Abstract
    M. Voelter

    Some Resource Management Patterns

    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 | Generative Programming at OOPSLA 2001 | Paper PDF | Abstract
    M. Voelter

    Jenerator – Generative Programming for Java

    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 | Designing a 3 Tier Pattern Language at EuroPLoP 2001 | Paper PDF | Abstract
    M. Voelter

    3-Tier Pattern Language

    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 at OOPSLA 2000 | Paper PDF | Abstract
    M. Voelter

    Pattern Refactoring

    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 | Frameworks at OOPSLA 2000 | Paper PDF | Abstract
    M. Voelter

    Methods and Tools for OO-Framework Development and Specialization

    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 at OOPSLA 2000 | Paper PDF | Abstract
    M. Voelter

    Mining Pedagogical Patterns

    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

    07.07.2009 | EuroPLoP 2009 | PDF | Abstract
    M. Voelter

    Variability Patterns

    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 | EuroPLoP 2006 | PDF | Abstract
    M. Voelter

    Software Architecture Patterns

    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 | EuroPLoP 2005 | PDF | Abstract
    M. Voelter

    Models and Aspects

    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 | EuroPLoP 2004 | PDF | Abstract
    M. Voelter, Michael Kircher

    Command Revisited

    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 | EuroPLoP 2004 | PDF | Abstract
    M. Voelter, Michael Kircher, Christa Schwanninger, Klaus Jank

    Broker Revisited

    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 | EuroPLoP 2004 | PDF | Abstract
    M. Voelter, Jorn Bettin

    Patterns for Model-Driven Development

    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 | EuroPLoP 2003 | PDF | Abstract
    M. Voelter, Uwe Zdun, Michael Kircher, Michael Englbrecht

    Patterns for Asynchronous Invocations in Distributed Object Frameworks

    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 | EuroPLoP 2003 | PDF | Abstract
    M. Voelter

    A collection of Patterns for Program Generation

    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 | VikingPLoP 2002 | PDF | Abstract
    M. Voelter

    Object-Oriened Remoting - A Pattern Language

    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 | EuroPLoP 2002 | PDF | Abstract
    M. Voelter

    Hope, Belief and Wizardry - Three different perspectives on project management

    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 | PLoP 2002 | PDF | Abstract
    M. Voelter, Alexander Schmid, Eberhard Wolff

    Building EJB Applications - A Collection of Patterns

    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 | EuroPLoP 2001 | PDF | Abstract
    M. Voelter, Jutta Eckstein, Klaus Marquardt

    Patterns for Experential Learning

    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 | EuroPLoP 2001 | PDF | Abstract
    M. Voelter

    Server-Side Components - A Pattern Language

    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 | EuroPLoP 2000 | PDF | Abstract
    M. Voelter, Astrid Fricke

    SEMINARS - A Pedagogical Pattern Language on how to teach seminars effectively

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


    01.07.1999 | EuroPLoP 2000 | PDF | Abstract
    M. Voelter

    The Metacommand Pattern

    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 | EuroPLoP 1999 | PDF | Abstract
    M. Voelter

    Pluggable Component - A Pattern for Interactive System Configuration

    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.


 
 

Magazin Articles

    20.07.2012 | heise developer online | Read Online | Abstract
    M. Voelter

    mbeddr - Embedded-Entwicklung mit erweiterbarem C

    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 | my own webiste March 2011 | PDF | Abstract
    M. Voelter

    MD* Best Practices

    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 | IEEE Software Nov/Dec 2011 | PDF | Read Online | Abstract
    M. Voelter

    From Programming To Modeling – and back again

    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 | InfoQ 2011 | Read Online | Abstract
    M. Voelter

    Xtext/TS - a Typesystem Framework for Xtext

    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 Control Europe 2010 | PDF | Read Online | Abstract
    M. Voelter

    Embedded Software Development with MPS


    01.06.2010 | Cutter Executive Update Vol 11, Issue 9 | PDF | Abstract
    M. Voelter

    The Model Craftsman

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


    01.09.2009 | JOT - Journal of Object Technology 2009-09 | PDF | Abstract
    M. Voelter

    MD* Best Practices

    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 | DotNetMagazin 03/2009 | PDF | Abstract
    M. Voelter, Lars Corneliussen

    Domänenspezifische Sprachen und Microsoft Oslo

    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 | DotNetPro 04/2009 | PDF | Abstract
    M. Voelter, Lars Corneliussen

    Kurze Rede Langer Sinn

    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 | DotNetPro 05/2009 | PDF | Abstract
    M. Voelter, Lars Corneliussen

    Carpe Diem - Xtext für .NET

    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 | Heise Developer Channel 03/2009 | PDF | Read Online | Abstract
    M. Voelter

    Werkzeuge zur Erstellung und Verarbeitung von DSLs

    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 | JavaMagazin 03/2009 | PDF | Abstract
    M. Voelter

    Java-Spracherweiterung mit JetBrains MPS

    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 | JavaMagazin 01/2009 | PDF | Abstract
    M. Voelter

    Public Beta von Jetbrains’ Meta Programming System (MPS)

    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 | voelter.de 12/2008 | PDF | Abstract
    M. Voelter

    MD* Best Practices

    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 | MDSD Today 2008 Proceeding 09/2008 | PDF | Read Online | Abstract
    M. Voelter

    Forword Proceedings MDSD Today 2008


    01.03.2008 | InfoQ 01/2008 | PDF | Read Online | Abstract
    M. Voelter

    Architecture As Language

    Architecture is typically either a very non-tangible, conceptual aspect of a software system that can primarily be found in Word documents, or it is entirely driven by technology (“we use an XML architecture”). Both are bad: the former makes it hard to work with, and the latter hides architectural concepts behind technology hype. What can be done? As you develop the architecture, evolve a language that allows you to describe systems based on this architecture. Based on my experience in a number of real-world projects, this makes the architecture tangible and provides an unambiguous description of the architectural building blocks as well as the concrete system while still staying away from technology decisions (which then can be made consciously in a separate step). 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 | voelter.de 05/2008 | PDF | Abstract
    M. Voelter

    Architecture As Language, Part 2

    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 | ObjektSpektrum 01/2008 | PDF | Abstract
    M. Voelter

    Trends bei Sprachen

    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 | IEEE Software 07/08 2007 | PDF | Abstract
    M. Voelter, Michael Kircher

    Guest Editorial Software Patterns

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


    01.04.2007 | Eclipse Magazine 03/2007 | PDF | Abstract
    M. Voelter

    openArchitectureWare 4.1 An introduction

    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 | JavaSpektrum 01/2007 | PDF | Abstract
    M. Voelter, Iris Groher

    Modelltransformationen in der Praxis

    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 | TheServerSide.com | Read Online | Abstract
    M. Voelter, Arno Haase, Sven Efftinge, Bernd Kolb

    The Pragmatic Code Generator Programmer

    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 | ix 12/2006 und 01/2007 | PDF | Abstract
    M. Voelter, Arno Haase, Sven Efftinge, Bernd Kolb

    GMF Tutorial

    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 | Eclipse.org | Read Online | Abstract
    M. Voelter, Arno Haase, Sven Efftinge, Bernd Kolb

    From Frontend To Code - MDSD In Practice

    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 | iX 09/2006 | PDF | Abstract
    M. Voelter

    Sprachen, Modelle, Fabriken

    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 | iX 01/2011 | PDF | Abstract
    M. Voelter

    Embedded-Entwicklung mit MPS

    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 | codegeneration.net | PDF | Read Online | Abstract
    M. Voelter

    Interview on codegeneration.net

    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 | ObjektSpektrum 2006-5 | PDF | Abstract
    M. Voelter

    Services, Komponenten, Modelle

    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 | JavaMagazin 2005-10 | PDF | Abstract
    M. Voelter, Arno Haase

    Textuelle DSLs – Programmiersprachen zum selbermachen

    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 | JavaMagazin 10 | PDF | Abstract
    M. Voelter

    Architektur ohne Hype

    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 | JavaMagazin 10 | PDF | Abstract
    M. Voelter

    Architektur ohne Hype - Beispiel

    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 | JavaMagazin 10 | PDF | Abstract
    M. Voelter

    Modellgetriebene, Komponentbasierte Softwareentwicklung, Teil 1

    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 | JavaMagazin 11 | PDF | Abstract
    M. Voelter

    Modellgetriebene, Komponentbasierte Softwareentwicklung, Teil 2

    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 | | PDF | Abstract
    M. Voelter

    Variantenmanagement im Kontext von MDSD

    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 | JavaMagazin 2005-07 | PDF | Abstract
    M. Voelter, Eberhard Wolff, Pter Friese

    Spring und modellgetriebenes Vorgehen - Gegensatz oder Ergänzung?

    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 | JavaSpektrum 05/2005 | PDF | Abstract
    M. Voelter

    Kaskadierung von MDSD und Modelltransformationen

    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 | DatenbankSpektrum 2005-?? | PDF | Abstract
    M. Voelter

    Modellgetriebene Softwareentwicklung

    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 | ObjektSpektrum 2005-03 | PDF | Abstract
    M. Voelter

    Domain-Driven Development; die Zukunft

    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 | Eclipse Magazin 2005-07 | PDF | Abstract
    M. Voelter, Bernd Kolb

    openArchitectureWare und Eclipse

    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 | Java Spektrum 2005-07 | PDF | Abstract
    M. Voelter, Bernd Kolb

    Generierung von GEF Editoren für Modellgetriebene Entwicklung

    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 Magazin 2005-01 | PDF | Abstract
    M. Voelter

    Eclipse zur Domänenspezifischen Entwicklung

    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 | Java Spektrum 2005-02 | PDF | Abstract
    M. Voelter

    MDSD und/oder AOSD?

    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 | Java Magazin Eclipe Special 2004-09 | PDF | Abstract
    M. Voelter, Martin Lippert

    Rich Client Anwendungen mit Eclipse 3

    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 | IEEE Internet special issue on middleware, 2004-05 | PDF | Abstract
    M. Voelter, Uwe Zdun, Michael Kircher

    Remoting Patterns - A Systematic Approach for Design Reuse of Distributed Object Middleware Solutions

    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 | JavaSpektrum 2004-04 | PDF | Abstract
    M. Voelter

    Parsen und Verarbeiten textueller Spezifikationen

    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 | JavaSpektrum 2004-10 | PDF | Abstract
    M. Voelter

    Sommerloch

    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 | JavaSpektrum 2004-03 | PDF | Abstract
    M. Voelter

    Lebendige Architekturen

    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 | JavaSpektrum 2002-06 | PDF | Abstract
    M. Voelter, Klaus Marquardt

    Plug-Ins - Applikationsspezifische Komponenten

    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 | ObjektSpektrum 2004-07 | PDF | Abstract
    M. Voelter

    Model Driven Software Development

    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 | JavaSpektrum 2004-04 | PDF | Abstract
    M. Voelter, Martin Lippert

    Die 5 Leben des AspectJ

    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 | JavaSpektrum 2004-02 | PDF | Abstract
    M. Voelter

    Eigene Aspekte in EJB

    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 | JavaSpektrum 2003-08 | PDF | Abstract
    M. Voelter

    Eclipse-GUIs einmal anders

    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 | JavaSpektrum 2003-08 | PDF | Abstract
    M. Voelter

    Metamodellbasierte Codegenerierung in Java

    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 | | PDF | Abstract
    M. Voelter

    Handling Cross-Cutting Conerns - AOP and beyond

    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 | Java Magazin 2003-07 | PDF | Abstract
    M. Voelter

    Codegenerierung - ein Ueberblick

    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 | iX 2003-01 | PDF | Abstract
    M. Voelter, Thomas Stahl

    Architektur und Generierung

    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 | ObjektSpektrum 2002-08 | PDF | Abstract
    M. Voelter, Thomas Stahl, Nicolai Josuttis

    J2EE im kommerziellen Grossprojekt

    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 | Java Magazin 2002-12 | PDF | Abstract
    M. Voelter, Eberhard Wolff, Alexander Schmid

    Komponenteninfrastrukturen


    01.08.2003 | JOT - Journal of Object Technology 2003-08 | PDF | Abstract
    M. Voelter

    A Taxonomy for Components

    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 | Wiley Software Focus 2002-01 | PDF | Abstract
    M. Voelter, Jutta Eckstein, Mary-Lynn Manns

    Pedagogical patterns - capturing best practices in teaching object technology

    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 | JavaReport 1999-12 | PDF | Abstract
    M. Voelter

    Aspect Oriented Programming in Java

    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 | iX 2002-08 | PDF | Abstract
    M. Voelter

    Mobil Orientiert

    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 | computerwoche extra 2002-05 | PDF | Abstract
    M. Voelter, Eberhard Wolff

    Die Model Driven Architecture

    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 | JavaSpektrum 2002-03 | PDF | Abstract
    M. Voelter

    Java Komponenteninfrastrukturenv - Grundlagen und Beispiele

    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 | ObjektSpektrum 2002-01 | PDF | Abstract
    M. Voelter, Thomas Quas

    P2P und Komponenten - Eigenschaften, Unterschiede, Ergaenzungsmoeglichkeiten

    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 | iX 2001-08 | PDF | Abstract
    M. Voelter

    Spontanes Netz

    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 | sw-development 2001-03 | PDF | Abstract
    M. Voelter

    Flexible Erzeugung von Value Objects

    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 | Java Spektrum 2001-01 | PDF | Abstract
    M. Voelter

    Vor- und Nachbedingungen in Java

    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 | sw-development 2000-01 | PDF | Abstract
    M. Voelter

    Frameworks und Komponenten - Widerspruch oder Ergaenzung

    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 | JavaMagazin 2000-12 | PDF | Abstract
    M. Voelter

    Ein Scheduler basierend auf Commands und Strategien

    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 | JavaMagazin 2000-11 | PDF | Abstract
    M. Voelter

    Transaktionen basierend auf Commands und Mementos

    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 | JavaMagazin 2000-10 | PDF | Abstract
    M. Voelter

    Mementos basierend auf Java's Serialisierungsmechanismus

    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 | JavaMagazin 2000-09 | PDF | Abstract
    M. Voelter

    Bidirektionale Assoziationen in Java

    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 | iX 1999-10 | PDF | Abstract
    M. Voelter

    Dr. med. CORBA

    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 | iX 1998-11 | PDF | Abstract
    M. Voelter

    Better test

    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.



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

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