Thomas Buchmann

SuperMod — A model-driven tool that combines version control and software product line engineering

Version control (VC) and Software Product Line Engineering (SPLE) are two software engineering disciplines to manage variability in time and variability in space. In this paper, a thorough comparison of VC and SPLE is provided, showing that both disciplines imply a number of desirable properties. As a proof of concept for the combination of VC and SPLE, we present SuperMod, a tool realizes an existing conceptual framework that transfers the iterative VC editing model to SPLE. The tool allows to develop a software product line in a single-version workspace step by step, while variability management is completely automated. It offers familiar version control metaphors such as check-out and commit, and in addition uses the SPLE concepts of feature models and feature configuration the definition of logical variability and to define the logical scope of a change. SuperMod has been implemented in a model-driven way and primarily targets EMF models as software artifacts. We successfully apply the tool to a standard SPLE example.

The added value of programmed graph transformations --- a case study from software configuration management

Model-driven software engineering intends to increase the productivity of software engineers by replacing conventional programming with the development of executable models at a high level of abstraction. It is claimed that graph transformation rules contribute towards this goal since they provide a declarative, usually graphical specification of complex model transformations. Frequently, graph transformation rules are organized into even more complex model transformations with the help of control structures, resulting in full-fledged support for executable behavioral models. This paper examines the added value of programmed graph transformations with the help of a case study from software configuration management. To this end, a large model is analyzed which was developed in the MOD2-SCM project over a period of several years. The model was developed in Fujaba, which provides story diagrams for programming with graph transformations. Our analysis shows that the model exhibits a strongly procedural flavor. Graph transformation rules are heavily used, but typically consist of very small patterns. Furthermore, story diagrams provide fairly low level control structures. Altogether, these findings challenge the claim that programming with graph transformations is performed at a significantly higher level of abstraction than conventional programming.

MOD2-SCM: A model-driven product line for software configuration management systems

Context: Software Configuration Management (SCM) is the discipline of controlling the evolution of large and complex software systems. Over the years many different SCM systems sharing similar concepts have been implemented from scratch. Since these concepts usually are hard-wired into the respective program code, reuse is hardly possible. Objective: Our objective is to create a model-driven product line for SCM systems. By explicitly describing the different concepts using models, reuse can be performed on the modeling level. Since models are executable, the need for manual programming is eliminated. Furthermore, by providing a library of loosely coupled modules, we intend to support flexible composition of SCM systems. Method: We developed a method and a tool set for model-driven software product line engineering which we applied to the SCM domain. For domain analysis, we applied the FORM method, resulting in a layered feature model for SCM systems. Furthermore, we developed an executable object-oriented domain model which was annotated with features from the feature model. A specific SCM system is configured by selecting features from the feature model and elements of the domain model realizing these features. Results: Due to the orthogonality of both feature model and domain model, a very large number of SCM systems may be configured. We tested our approach by creating instances of the product line which mimic wide-spread systems such as CVS, GIT, Mercurial, and Subversion. Conclusion: The experiences gained from this project demonstrate the feasibility of our approach to model-driven software product line engineering. Furthermore, our work advances the state of the art in the domain of SCM systems since it support the modular composition of SCM systems at the model rather than the code level.

Mapping feature models onto domain models: ensuring consistency of configured domain models

We present an approach to model-driven software product line engineering which is based on feature models and domain models. A feature model describes both common and varying properties of the instances of a software product line. The domain model is composed of a structural model (package and class diagrams) and a behavioral model (story diagrams). Features are mapped onto the domain model by annotating elements of the domain model with features. An element of a domain model is specific to the features included in its feature annotation. An instance of the product line is defined by a set of selected features (a feature configuration). A configuration of the domain model is built by excluding all elements whose feature set is not included in the feature configuration. To ensure consistency of the configured domain model, we define constraints on the annotations of inter-dependent domain model elements. These constraints guarantee that a model element may be selected only when the model elements are also included on which it depends. Violations of dependency constraints may be removed automatically with the help of an error repair tool which propagates features to dependent model elements.

Ensuring well-formedness of configured domain models in model-driven product lines based on negative variability

Model-driven development is a well-known practice in modern software engineering. Many tools exist which allow developers to build software in a model-based or even model-driven way, but they do not provide dedicated support for software product line development. Only recently some approaches combined model-driven engineering and software product line engineering. In this paper we present an approach that allows for combining feature models and Ecore-based domain models and provides extensive support to keep the mapping between the involved models consistent. Our key contribution is a declarative textual language which allows to phrase domain-specific consistency constraints which are preserved during the configuration process in order to ensure context-sensitive syntactical correctness of derived domain models.

Towards tool support for agile modeling: sketching equals modeling

Model-driven development is a well-known practice in modern software engineering. A wide variety of different tools exist, which support model-driven development. Usually, these tools do not provide dedicated support for agile modeling, as they can be used with any development process. In this paper, we present an extension to our UML-based modeling tool Valkyrie which allows free-hand diagram sketching. Thus, it addresses agile modeling as whiteboards and papers can now be replaced with tablet computers or other touch-enabled (hand-held) devices.

Bidirectional transformations with QVT-R: A case study in round-trip engineering UML class models and java source code

Model-driven software engineering has become more and more important during the last few years. Model transformations constitute the core essence of model-driven development. Throughout the years, the concept of unidirectional model transformations and corresponding tool support has become mature and usable. Transformations of this kind are widely used in model-driven development, for forward or reverse engineering or mainly for code generation. Bidirectional transformations, on the other hand, aim to provide support for (incrementally) transforming one or more source models to one or more target models and vice versa from only one transformation description. However, they seem to be rarely used in model-driven software development although modelers need round-trip support between the different stages of development models. In this paper we present a QVT implementation of a bidirectional model transformation. Our case study keeps UML class diagrams consistent with a Java model during round-trip engineering and thereby shows a real world application. The results and experiences gained in this case study are discussed in detail.

Model-driven software engineering: concepts and tools for modeling-in-the-large with package diagrams

Model-driven software engineering intends to reduce development effort by generating executable code from high-level models. However, models for non-trivial problems are still very large and require sophisticated support for modeling-in-the-large—a challenge which has not yet gained sufficient attention in model-driven software engineering. In response to this need, we have developed a set of tools for modeling-in-the-large based on UML package diagrams. The tool set comprises a stand-alone tool, which serves as a graphical editor for package diagrams, an integration tool, which controls the consistency of the model with its architecture defined in the package diagram, and a metrics tool, which is used to measure the coupling of model packages. Our tools for modeling-in-the-large complement the functionality of an environment for model-driven software engineering which so far has focused on supporting modeling-in-the-small. The overall environment has been applied successfully in a project which is dedicated to model-driven engineering of a product line for software configuration management systems.

Model-Driven Software Development with Graph Transformations: A Comparative Case Study

Significant achievements have been made in the design and implementation of languages and tools for graph transformation systems. However, many other competing approaches have been developed for model-driven software development. We present a case study in which we applied different modeling approaches in the construction of a tool for software process management. We compare these approaches with respect to the respective levels of abstraction on which models are defined, the language concepts offered, and the resulting modeling effort. The case study identifies the benefits and shortcomings of the selected modeling approaches, and suggests areas of future improvement.

Using triple graph grammars to realise incremental round-trip engineering

Model-driven software engineering is supported with the help of model transformations. At present, the technology for defining and executing uni-directional batch transformations seems to be fairly well developed, while bidirectional and incremental transformations are more difficult to handle. In this study, the authors present a bidirectional and incremental transformation tool for round-trip engineering between class diagrams and Java source code. Unlike other approaches, the tool may work with arbitrary Java code rather than only with source code following specific coding conventions. For its realisation, they selected triple graph grammars (TGGs) because they allow to generate bidirectional incremental transformations from a single set of undirected rules. When applying TGGs, they observed several strengths and weaknesses which are also discussed in this study.