Florian Heidenreich

FeatureMapper: mapping features to models

Variability modelling with feature models is one key technique for specifying the problem space of Software Product Lines (SPLs). To allow for the automatic derivation of a concrete product based on a given variant configuration, a mapping between features in the problem space and their realisations in the solution space is required. It is crucial to support the developer in the complex task of defining such mappings. These mappings can also be used to provide visualisations of the variant space that allow to reason over variability in SPLs. In this paper we present FeatureMapper, a tool that allows for defining mappings of features to model elements specifying feature realisations. These feature realisations can be defined in arbitrary Ecore-based languages. Furthermore, the tool supports different visualisation techniques that can help developers understand the complex designs of SPLs.

Derivation and Refinement of Textual Syntax for Models

Textual Syntax (TS) as a form of model representation has made its way to the Model-Driven Software Development community and is considered a viable alternative to graphical representations. To support the design and implementation of text editing facilities many concrete syntax and model mapping tools have emerged. Despite the maturity of these tools, users still spend considerable effort to specify syntaxes and generate editors even for simple metamodels. To reduce this effort, we propose to refine a specification that is automatically derived from a given metamodel. We argue that defaults in a customisable setting enable developers to quickly realise text-based editors for models. In particular in settings where metamodels evolve, such a procedure is beneficial. To evaluate this idea we present EMFText [1], an EMF/Eclipse integrated tool for agile Textual Syntax (TS) development. We show how default syntax can easily be tailored and refined to obtain a custom text editor for EMF models and demonstrate our approach by two examples.

Closing the gap between modelling and java

Model-Driven Software Development is based on standardised models that are refined, transformed and eventually translated into executable code using code generators. However, creating plain text from well-structured models creates a gap that implies several drawbacks: Developers cannot continue to use their model-based tool machinery, relations between model elements and code fragments are hard to track and there is no easy way to rebuild models from their respective code. This paper presents an approach to bridge this gap for the Java programming language. It defines a full metamodel and text syntax specification for Java, from which a parser and a printer are generated. Through this, Java code can be handled like any other model. The implementation is validated with large test sets, example applications are shown, and future directions of research are discussed.

On Language-Independent Model Modularisation

As model-driven software development covers additional parts of the development process, the complexity of software models increases as well. At the same time, however, many modelling languages do not provide adequate support for modularising models. For this reason, there has been an increasing interest in the topic of model modularisation, often under the heading of aspect-oriented modelling (AOM). The approaches range from techniques that closely mimic concepts from aspect-oriented programming (AOP), such as AspectJ, to very powerful composition techniques for specific types of models--for example, state machines. We believe that AOM is more than just copying the concepts of AOP at the modelling level and should rightly include a large number of other model-composition techniques. However, developing model composition techniques and tooling is costly. To minimise the effort required, this paper presents a generic technique for model composition. The technique is based on invasive software composition and our Reuseware tooling and can be used with arbitrary modelling languages. The basic technique itself is language independent, but it can be adapted to construct language- and purpose-specific composition techniques for specific modelling languages and situations. Hence, it can be used both as a tool for developing specific model-modularisation techniques and as an instrument of research for studying basic properties and concepts of model modularisation. The paper gives a detailed description of our approach and evaluates it using a number of examples.

Relating feature models to other models of a software product line: a comparative study of featuremapper and VML

Software product lines using feature models often require the relation between feature models in problem space and the models used to describe the details of the product line to be expressed explicitly. This is particularly important, where automatic product derivation is required. Different approaches for modelling this mapping have been proposed in the literature. However, a discussion of their relative benefits and drawbacks is currently missing. As a first step towards a better understanding of this field, this paper applies two of these approaches-- FeatureMapper as a representative of declarative approaches and VML* as a representative of operational approaches--to the case study. We show in detail how the case study can be expressed using these approaches and discuss strengths and weaknesses of the two approaches with regard to the case study.

A Framework for Generating Query Language Code from OCL Invariants

The semantical integrity of business data is of great importance for the implementation of business applications. Model-Driven Software Development (MDSD) allows for specifying the relevant domain concepts, their interrelations and their concise semantics using a plethora of modelling languages. Since model transformations enable an automatic mapping of platform independent models (PIMs) to platform specific models (PSMs) and code, it is reasonable to utilise them to derive data schemas and integrity rules for business applications. Most current approaches only focus on transforming structural descriptions of software systems while semantical specifications are neglected. However, to preserve also the semantical integrity rules we propose a Query Code Generation Framework that enables Model-Driven Integrity Engineering. This framework allows for mapping UML models to arbitrary data schemas and for mapping OCL invariants to sentences in corresponding declarative query languages, enforcing semantical data integrity on implementation level. This supersedes the manual translation of integrity constraints and, thus, decreases development costs while increasing software quality.

Co-evolution of models and feature mapping in software product lines

Software Product Lines (SPLs) are a successful approach to software reuse in the large. Even though tools exist to create SPLs, their evolution is widely unexplored. Evolving an SPL manually is tedious and error-prone as it is hard to avoid unintended side-effects that may harm the consistency of the SPL. The main contribution of this paper is the conceptual basis of a system for the evolution of model-based SPLs, which maintains consistency of models and feature mapping. As further contribution, a novel classification is introduced that distinguishes evolutions by their potential to harm the mapping of an SPL. In addition, multiple remapping operators are presented that can remedy the negative side-effects of evolutions in order to co-evolve the feature mapping. Finally, an implementation of the evolution system in the SPL tool FeatureMapper is provided to demonstrate the capabilities of the presented approach when co-evolving models and feature mapping of an SPL.

Extending grammars and metamodels for reuse: the Reuseware approach

The trend toward domain-specific languages leads to an ever-growing plethora of highly specialized languages. Developers of such languages focus on their specific domains rather than on technical challenges of language design. Generic features of languages are rarely included in special-purpose languages. One very important feature is the ability to formulate partial programs in separate encapsulated entities, which can be composed into complete programs in a well-defined manner. This paper presents a language-independent approach for adding useful constructs for defining components. We discuss the underlying concepts and describe a composition environment and tool supporting these ideas ‐ the Reuseware Composition Framework. To evaluate our approach we enrich the (Semantic) Web query language Xcerpt with an additional useful reuse concept—modules.

Validation of families of business processes

A Software Product Line (SPL) is a set of programs that are developed as a whole and share a set of common features. Product lines variability is typically specified using problem space models (i.e., feature models), solution space models that specify the realization of functionality and mapping models that link problem and solution space artifacts. In this paper, we consider this concept in the scope of families of business processes, whose specificity is that the solution space is defined with business process models. Solution space models are typically specified as model templates, and thus in the rest of the paper we will refer to business process model templates. While the previous research tackled the concepts of families of business processes, there have been very limited research on their validation.

Model-Based Language Engineering with EMFText

Model-based techniques are in wide-spread use for the design and implementation of domain specific languages (DSLs) and their tooling. The Eclipse Modeling Framework (EMF) is a frequently used environment for model-based language engineering. With its underlying modelling language Ecore, its XML serialisation support and its versatile extensibility it provides a solid grounding for many task-specific language development tools. In this tutorial, we give an introduction to model-based language engineering using EMFText, which allows users to develop powerful textual editors for Ecore-based DSLs that are tightly integrated with the EMF.