Felix Schwägerl

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.

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.

Model-based tool support for consistent three-way merging of EMF models

Inadequate version control has been identified as a major obstacle to the application of model-driven software engineering. In particular, sophisticated support for merging model versions is urgently needed. We present a tool for merging of EMF models which may be applied to instances of arbitrary Ecore models. The tool advances the state of the art by guaranteeing a consistent merge result. Furthermore, it detects and resolves not only context-free, but also context-sensitive conflicts. Our merge tool is model-based; it relies on EMF for its implementation. Initial experiences gained from its application confirm that the merge tool operates both accurately and efficiently.

Maintaining Workspace Consistency in Filtered Editing of Dynamically Evolving Model-driven Software Product Lines.

Model-driven software product line engineering is complicated: In addition to defining a variability model, developers must deal with a multi-variant domain model. To reduce complexity, filtered editing, inspired by version control, was recently transferred to software product line engineering. On check-out, a single-variant model is derived based on a configuration of its features. On commit, the representatively applied change is scoped with the features to which it is relevant. The here considered dynamic editing model involves different kinds of evolution: The variability model and the domain model are edited concurrently. Features, which define the workspace contents or the scope of the change, may be introduced or deleted. Furthermore, the scope of a change may be revised until commit. The dynamism of this filtered editing model raises consistency problems concerning the evolving relationships between the variability model, the specified configuration, and the scope of the change. This paper formalizes these constraints and presents consistency-preserving algorithms for the workspace operations check-out, commit, as well as a new operation, migrate. This way, the evolution of model-driven software product lines is managed automatically, non-disruptively, and consistently.

Realizing Multi-variant Model Transformations on Top of Reused ATL Specifications.

Model transformations are crucial in model-driven software engineering (MDSE). While combining MDSE and software product line engineering (SPLE) techniques, summarized as model-driven product line engineering (MDPLE), promises increased productivity by relying on organized reuse, the benefits are impeded by transformation specifications designed exclusively for single-variant models. Applying single-variant model transformations to multi-variant input models results in output models lacking the variability information. Multi-variant model transformations (MVMT), which preserve variability information, have only recently been understood as an explicit research problem. In this paper, we propose an a posteriori approach towards MVMT. Following the paradigm of organized reuse, we propose to employ single-variant model transformations without modifications in a first step, and to transfer variability information afterwards based on the artifacts provided by the single-variant transformation specification. In particular, we implemented this approach for the well-known model-to-model transformation language ATL. To deduce variability information, the execution artifacts (trace and execution model) are analyzed. Then, variability annotations are transfered to the target model automatically. The implementation is evaluated based on a practically example of a Graph product line. Results exhibit that our approach outperforms the conventional solution with respect to user effort, accuracy and performance.

SuperMod: tool support for collaborative filtered model-driven software product line engineering

The increase in productivity implied by model-driven software product line engineering is weakened by the complexity exposed to the user having to manage a multi-variant model. Recently, a new paradigm has emerged: filtered software product line engineering transfers the established check-out/modify/commit workflow from version control to variability management, allowing to iteratively develop the multi-variant model in a single-variant view. This paper demonstrates SuperMod, a tool that supports collaborative filtered model-driven product line engineering, implemented for and with the Eclipse Modeling Framework. Concerning variability management, the tool offers capabilities for editing feature models and specifying feature configurations, both being well-known formalisms in product line engineering. Furthermore, collaborative editing of product lines is provided through distributed version control. The accompanying video shows that SuperMod seamlessly integrates into existing tool landscapes, reduces the complexity of multi-variant editing, automates a large part of variability management, and ensures consistency. A tool demonstration video is available here: http://youtu.be/5XOk3x5kjFc.

Collaborative and Distributed Management of Versioned Model-driven Software Product Lines

Software Product Line Engineering promises a significant gain in productivity, yet with the addition of new challenges one of which is the increased complexity of collaborative development. This paper presents an approach to distributed and collaborative product line engineering based on a filtered editing framework that has been extended by multi-user support. Using filtered editing, the product line is developed in a single-version view in a local workspace and transparently organized in a local repository. The contributed conceptual extension orchestrates the evolution and synchronization of different copies of the repository. This way, local transactions realized by check-out and commit are complemented by remote transactions using the operations pull and push. The proposed approach has been implemented as an extension to the model-driven tool SuperMod backed by a REST-based web service, evolving the toolset to a distributed product line version control system. We discuss relevant design decisions and illustrate our contributions by several examples.

Filtered Model-Driven Product Line Engineering with SuperMod: The Home Automation Case

Software Product Line Engineering promises to increase the productivity of software development. In the literature, a plan-driven process has been established that is divided up into domain and application engineering. We argue that the strictly sequential order of its process activities implies several disadvantages such as increased complexity, late customer feedback, and duplicate maintenance. SuperMod is a novel model-driven tool based upon a filtered editing model oriented towards version control. The tool provides integrated support for domain and application engineering, offering an iterative and incremental style of development. In this paper, we apply SuperMod to a well-known case study, the Home Automation System product line. We learn that the tool supports a broad variety of iterative and incremental development processes, ranging from phase-structured to feature-driven. Furthermore, it can mitigate the disadvantages of the traditional software product line development process.

Realizing a Conceptual Framework to Integrate Model-Driven Engineering, Software Product Line Engineering, and Software Configuration Management

Software engineering is a highly integrative computer science discipline, combining a plethora of different techniques to increase the quality of software development as well as the resulting software. The three sub-disciplines Model-Driven Software Engineering (MDSE), Software Product Line Engineering (SPLE) and Software Configuration Management (SCM) are well-explored, but literature still lacks an integrated solution. In this paper, we present the realization of a conceptual framework that integrates those three sub-disciplines uniformly based on a filtered editing model. The framework combines the check-out/modify/commit workflow known from SCM with the formalism of feature models and feature configurations known from SPLE. The implementation is model-driven and extensible with respect to different product and version space models. Important design decisions are formalized by means of Ecore metamodels. Furthermore, we propose several optimizations that increase the scalability of the conceptual framework.

A graph-based algorithm for three-way merging of ordered collections in EMF models

Version control for models is not yet supported in an adequate way. In this paper, we address three-way merging of model versions. Based on a common base version b, two alternative versions a1 and a2 were developed by copying and modifying the base version. To reconcile these changes, a merged version m is to be created as a common successor of a1 and a2. We present a graph algorithm to solve an important subproblem which occurs in three-way model merging: merging of (linearly) ordered collections. To create the merged version, a generalized topological sort is performed. Conflicts occur if the order of elements cannot be deduced automatically; these conflicts are resolved either interactively or by default rules. We have implemented the merge algorithm in our tool BTMerge, which performs a consistency-preserving merge of versions of EMF models being instances of arbitrary Ecore models. By taking arbitrary move operations into account, the algorithm considerably goes beyond the functionality of contemporary merge tools which are based on common subsequences and thus cannot adequately handle move operations.