Andreas Polzer

Model-driven support for product line evolution on feature level

Highlights? We model the evolution of a product line on feature model level. ? Our approach supports both modeling of historic evolution and proactively planning of future evolution. ? The initial evolution model can be derived automatically from a given sequence of feature model versions. ? After planning future evolution using the evolution model, the resulting feature models can be generated automatically. ? The evolution model provides a foundation for automated analyses and interactive tools. Software Product Lines (SPL) are an engineering technique to efficiently derive a set of similar products from a set of shared assets. In particular in conjunction with model-driven engineering, SPL engineering promises high productivity benefits. There is however, a lack of support for systematic management of SPL evolution, which is an important success factor as a product line often represents a long term investment. In this article, we present a model-driven approach for managing SPL evolution on feature level. To reduce complexity we use model fragments to cluster related elements. The relationships between these fragments are specified using feature model concepts itself leading to a specific kind of feature model called EvoFM. A configuration of EvoFM represents an evolution step and can be transformed to a concrete instance of the product line (i.e., a feature model for the corresponding point in time). Similarly, automatic transformations allow the derivation of an EvoFM from a given set of feature models. This enables retrospective analysis of historic evolution and serves as a starting point for introduction of EvoFM, e.g., to plan future evolution steps.

Applying software product line techniques in model-based embedded systems engineering

This paper addresses variability in the domain of software-based control systems. When designing product lines of such systems, varying sensors and actuators have to be used and parameterized, which in turn requires adaptations in the behavior of the microcontroller. For efficient engineering these adaptations should be performed in an systematic and straightforward manner. We tackle these challenges by using a Rapid Control Prototyping (RCP) system in combination with model-based development techniques. In particular, we modularize the parametrization of components into a separate configuration, which is isolated from the model that defines the controller behavior. Hence, during adaptations the model can often remain unchanged, which significantly reduces the turnaround time during design iterations. The approach is illustrated and evaluated with a parking assistant application, which is tested on our experimental vehicle, where it performs automatic parking maneuvers.

Managing complexity and variability of a model-based embedded software product line

This paper presents a framework for model-based product lines of embedded systems. We show how to integrate model-based product line techniques into a consistent framework that can deal with large product lines as they are common in industry. The framework demonstrates the strengths of model-based techniques like abstraction, support for customised representations, and a high degree of automation. In particular, we provide the following contributions: (1) to shift existing product lines towards a model-based approach, we support the (semi-) automated extraction of models from existing requirement, test, and implementation artefacts; (2) to cope with the complexity of artefacts and their interrelations in industrial product lines, we support the generation of context-specific views. These views support developers, e.g., in analysing complex dependencies between different artefacts; (3) finally, we support automated product derivation based on an integrated hardware abstraction layer. Most of the presented concepts have been inspired by challenges arising in the industrial application of product line techniques in the model-based engineering of embedded systems. We report on experiences gathered during the application of the techniques to a prototypical product line (on a rapid prototyping platform in the university lab) and to industrial sample cases (at the industry partner).

Using higher-order transformations to derive variability mechanism for embedded systems

The complexity of embedded systems can partly be handled by models and domain-specific languages (DSLs) like Matlab/Simulink. If we want to apply such techniques to families of similar systems, we have to describe their variability, i.e., commonalities and differences between the similar systems. Here, approaches from Software Product Lines (SPL) and variability modeling can be helpful. In this paper, we discuss three challenges which arise in this context: (1) We have to integrate mechanisms for describing variability into the DSL. (2) To efficiently derive products, we require techniques and tool-support that allow us to configure a particular product and resolve variability in the DSL. (3) When resolving variability, we have to take into account dependencies between elements, e.g., when removing Simulink blocks we have to remove the signals between these blocks as well. The approach presented here uses higher-order transformations (HOT), which derive the variability mechanisms (as a generated model transformation) from the meta-model of a DSL.

Experiences of applying model-based analysis to support the development of automotive software product lines

In embedded systems in general and in automotive systems in particular the systematic reuse of existing assets is crucial. Moreover, companies in these domains often offer whole families of similar products. Hence, the application of product line engineering seems to be an obvious option. However, current products have reached a complexity level where management of products within a product line cannot be handled with current techniques and tools (e.g. Matlab/Simulink) alone. To sustain an efficient engineering process and to reach the required quality levels of the products, additional techniques are required. In this paper we report on a prototypical framework for the analysis of embedded systems product lines. The techniques and tools offered by the framework were developed to support engineers in typical tasks, which occur during design, implementation, and maintenance of embedded software product lines. The techniques allow to analyse product line artefacts by transforming them into models, which are then used in an analysis process based on model transformation languages.

Mapping Requirement Models to Mathematical Models in Control System Development

When developing control systems software, mathematically based modelling tools such as Matlab/Simulink are used for design, simulation, and implementation. Thus, a continuous model-based approach does not need to map requirements to, for example, UML class diagrams but to this mathematical representation. In this paper, we build on previous work that has applied the requirements formalism i* to the development of control systems software and present a mapping from i* models to Matlab/Simulink models. During a first manual transformation step, design alternatives are resolved. The second, automated step generates a Matlab/Simulink skeleton model from the i* model. Finally, an interactive step allows incorporating existing hardware and platform components into the skeleton. As a running example, we consider the development of a parking assistant.

View-supported rollout and evolution of model-based ECU applications

When applying model-based techniques to the engineering of embedded application software, a typical challenge is the complexity of dependencies between application elements. In many situations, e.g., during rollout of products or in the evolution of product lines, the understanding of these dependencies is a key capability. In this paper, we discuss how model-based techniques, in particular, model transformations can help to reduce the complexity of such analysis tasks. To this end, we realised a representation of Simulink models based on the Eclipse Modeling Framework (EMF). The resulting integration allows us to apply various model-based frameworks from the Eclipse ecosystem. On this basis we developed a view that increases the visibility of functional dependencies, which otherwise would have been hidden due to a lack of abstraction in the native Simulink representation. The provided analysis framework comes in handy, when such a model has to be modified. Consequently, the developer is supported in reusing existing models and avoiding errors. The concepts and techniques are illustrated with a running example, which is derived from a real industry model from Automotive Software Engineering.