Michael Nieke

Context Aware Reconfiguration in Software Product Lines

Software Product Lines (SPLs) are a mechanism for large-scale reuse where families of related software systems are represented in terms of commonalities and variabilities, e.g., using Feature Models (FMs). While FMs define all possible configurations of the SPL, when considering dynamic SPLs not every possible configuration may be valid in all possible contexts. Unfortunately, common FMs can not capture this context dependence. In this paper, we remedy this problem by extending attributed FMs with Validity Formulas (VFs) that constrain the selection of a particular feature to a specific context and that are located directly within the FM. We provide a reconfiguration engine that checks if the active configuration is valid in the current context and, if not, computes how to reconfigure it. Furthermore, we present our implementation and demonstrate its feasibility within a case study derived from scenarios of our industry partner in the automotive domain.

Guaranteeing Configuration Validity in Evolving Software Product Lines

Software Product Lines (SPLs) are an approach to capture families of closely related software systems in terms of commonalities and variabilities where individual variants are defined by configurations of selected features. Specific (partial) configurations may be of particular importance to SPL manufacturers, e.g., if they are very popular or used by major customers. SPLs are subject to evolution, which may inadvertently break existing configurations, e.g., if a previously selected feature does no longer exist. This is problematic as it may delay or completely prevent creation of previously existing important variants causing monetary loss and customer dissatisfaction. In this paper, we present a method to lock specific configurations to ensure their validity during evolution of the SPL. For this, we present Temporal Feature Models (TFMs) and dedicated evolution operations as a semantic-enriched first-class notion for evolution of feature models, which we use to assess the impact on existing configurations. Using the presented method, it is possible to guarantee that locked configurations remain valid during SPL evolution and make statements on which part of the evolution would break the configurations.

DarwinSPL: an integrated tool suite for modeling evolving context-aware software product lines

Software Product Lines (SPLs) are an approach for large-scale reuse for software families by means of variabilities and commonalities. We consider three dimensions of variability representing sources of software systems to behave differently: configuration as spatial variability, dependence on surroundings as contextual variability and evolution as temporal variability. The three dimensions of variability strongly correlate: Contextual variability changes the set of possible configurations in spatial variability. Temporal variability captures changes of spatial and contextual variability over the course of time. However, currently, there is no tool support for integrated modeling of these three dimensions of variability. In this paper, we present DarwinSPL, a tool suite supporting integrated definition of spatial, contextual and temporal variability. With DarwinSPL, spatial variability is modeled as feature models with constraints. Additionally, we are able to capture the current context and its impact on functionality of the SPL. Moreover, by providing support for temporal variability, DarwinSPL supports performing arbitrary evolutionary changes to spatial and contextual variability and tracking of previous evolution and planning future evolution of SPLs. We show the feasibility of DarwinSPL by performing a case study adapted from our industrial partner in the automotive domain.

User Profiles for Context-Aware Reconfiguration in Software Product Lines

Software Product Lines (SPLs) are a mechanism to capture families of closely related software systems by modeling commonalities and variability. Although user customization has a growing importance in software systems and is a vital sales argument, SPLs currently only allow user customization at deploy-time. In this paper, we extend the notion of context-aware SPLs by means of user profiles, containing a linearly ordered set of preferences. Preferences have priorities, meaning that a low priority preference can be neglected in favor of a higher prioritized one. We present a reconfiguration engine checking the validity of the current configuration and, if necessary, reconfiguring the SPL while trying to fulfill the preferences of the active user profile. Thus, users can be assured about the reconfiguration engine providing the most suitable configuration for them. Moreover, we demonstrate the feasibility of our approach using a case study based on existing car customizability.

A toolchain for delta-oriented modeling of software product lines

Software is increasingly individualized to the needs of customers and may have to be adapted to changing contexts and environments after deployment. Therefore, individualized software adaptations may have to be performed. As a large number of variants for affected systems and domains may exist, the creation and deployment of the individualized software should be performed automatically based on the software’s configuration and context. In this paper, we present a toolchain to develop and deploy individualized software adaptations based on Software Product Line (SPL) engineering. In particular, we contribute a description and technical realization of a toolchain ranging from variability modeling over variability realization to variant derivation for the automated deployment of individualized software adaptations. To capture the variability within realization artifacts, we employ delta modeling, a transformational SPL implementation approach. As we aim to fulfill requirements of industrial practice, we employ model-driven engineering using statecharts as realization artifacts. Particular statechart variants are further processed by generating C/C++ code, linking to external code artifacts, compiling and deploying to the target device. To allow for flexible and parallel execution the toolchain is provided within a cloud environment. This way, required variants can automatically be created and deployed to target devices. We show the feasibility of our toolchain by developing the industry-related case of emergency response systems.

Proof-Carrying Apps: Contract-Based Deployment-Time Verification

For extensible software platforms in safety-critical domains, it is important that deployed plug-ins work as specified. This is especially true with the prospect of allowing third parties to add plug-ins. We propose a contract-based approach for deployment-time verification. Every plug-in guarantees its functional behavior under a specific set of assumptions towards its environment. With proof-carrying apps, we generalize proof-carrying code from proofs to artifacts that facilitate deployment-time verification, where the expected behavior is specified by the means of design-by-contract. With proof artifacts, the conformance of apps to environment assumptions is checked during deployment, even on resource-constrained devices. This procedure prevents unsafe operation by unintended programming mistakes as well as intended malicious behavior. We discuss which criteria a formal verification technique has to fulfill to be applicable to proof-carrying apps and evaluate the verification tools KeY and Soot for proof-carrying apps.

Anomaly Detection and Explanation in Context-Aware Software Product Lines

A software product line (SPL) uses a variability model, such as a feature model (FM), to describe the configuration options for a set of closely related software systems. Context-aware SPLs also consider possible environment conditions for their configuration options. Errors in modeling the FM and its context may lead to anomalies, such as dead features or a void feature model, which reduce if not negate the usefulness of the SPL. Detecting these anomalies is usually done by using Boolean satisfiability (SAT) that however are not expressive enough to detect anomalies when context is considered. In this paper, we describe HyVarRec: a tool that relies on Satisfiability Modulo Theory (SMT) to detect and explain anomalies for context-aware SPLs.

Back to the future: avoiding paradoxes in feature-model evolution

A Software Product Line (SPL) captures families of software products and its functionality is captured as features in a feature model. Similar to other software systems, SPLs and their feature models are subject to evolution. Temporal Feature Models (TFMs) are an extension to feature models that allow for engineers to model past feature-model evolution and plan future evolution. When planning future evolution of feature models, multiple evolution steps may be planned upfront but changed requirements may lead to retroactively introducing evolution steps into the planned evolution or changing already planned steps. As a consequence, inconsistencies, which we denote as evolution paradoxes, may arise leading to invalidity of already modeled future evolution steps. In this paper, we present first steps towards allowing to introduce intermediate evolution steps into planned evolution while preserving consistency of all future evolution steps. To this end, we outline a method to define and check model evolution consistency rules. Using this method, engineers are allowed to introduce intermediate feature-model evolution steps whenever these changes preserve the evolution consistency rules.

Context-aware reconfiguration in evolving software product lines

Abstract Software Product Lines (SPLs) are a mechanism for large-scale reuse where families of related software systems are represented in terms of commonalities and variabilities, e.g., using Feature Models (FMs). While FMs define all possible configurations of an SPL, when considering dynamic SPLs and environmental conditions, not every possible configuration may be valid in all possible contexts. A change in the environment may, therefore, require the reconfiguration of the SPL. With common modeling methodologies, it is not possible to capture the correlation of configuration options, contextual influences, user customizations, and evolution. In this paper, we remedy this problem by first defining a novel framework that allows modeling customizable evolving context-aware SPLs. We then provide a reconfiguration engine that computes how the current configuration needs to be reconfigured when the context is altered, the user preferences changed or the SPL artifacts are evolved and the configuration is adapted to reflect the evolved artifacts.

Anomaly analyses for feature-model evolution

Software Product Lines (SPLs) are a common technique to capture families of software products in terms of commonalities and variabilities. On a conceptual level, functionality of an SPL is modeled in terms of features in Feature Models (FMs). As other software systems, SPLs and their FMs are subject to evolution that may lead to the introduction of anomalies (e.g., non-selectable features). To fix such anomalies, developers need to understand the cause for them. However, for large evolution histories and large SPLs, explanations may become very long and, as a consequence, hard to understand. In this paper, we present a method for anomaly detection and explanation that, by encoding the entire evolution history, identifies the evolution step of anomaly introduction and explains which of the performed evolution operations lead to it. In our evaluation, we show that our method significantly reduces the complexity of generated explanations.