Separation of Concerns in Feature Modeling: Support and Applications

International audienceFeature models (FMs) are a popular formalism for describing the commonality and variability of software product lines (SPLs) in terms of features. SPL development increasingly involves manipulating many large FMs, and thus scalable modular techniques that support compositional development of complex SPLs are required. In this paper, we describe how a set of complementary operators (aggregate, merge, slice) provides practical support for separation of concerns in feature modeling. We show how the combination of these operators can assist in tedious and error prone tasks such as automated correction of FM anomalies, update and extraction of FM views, reconciliation of FMs and reasoning about properties of FMs. For each task, we report on practical applications in different domains. We also present a technique that can efficiently decompose FMs with thousands of features and report our experimental results

Lazy product discovery in huge configuration spaces

Highly-configurable software systems can have thousands of inter-dependent configuration options across different subsystems. In theresulting configuration space, discovering a valid product configu-ration for some selected options can be complex and error prone.The configuration space can be organized using a feature model,fragmented into smaller interdependent feature models reflectingthe configuration options of each subsystem.We propose a method for lazy product discovery in large frag-mented feature models with interdependent features. We formalizethe method and prove its soundness and completeness. The evalu-ation explores an industrial-size configuration space. The resultsshow that lazy product discovery has significant performance ben-efits compared to standard product discovery, which in contrastto our method requires all fragments to be composed to analyzethe feature model. Furthermore, the method succeeds when moreefficient, heuristics-based engines fail to find a valid configuration

Model Defects in Evolving Software Product Lines: A Review of Literature

Software products lines (SPLs) are long living systems that undergo several evolutions throughout their lifetime due to many reasons related to technology, strategy, business, etc. These evolutions can be the source of several defects that impact the different artefacts of SPLs, namely requirements, models, architecture and code. Many studies in the literature have dealt with the correction of defects in software product lines, but to our knowledge, no reviews have been carried out to provide an extensive overview of these studies. In this paper, we present a literature review of model defects in software product lines. The purpose of this review is to enumerate the different defects discussed in literature and to present the approaches proposed to detect and correct them. The findings of this review reveal new research leads to explore in this issue

Lazy Product Discovery in Huge Configuration Spaces

Highly-configurable software systems can have thousands of interdependent configuration options across different subsystems. In the resulting configuration space, discovering a valid product configuration for some selected options can be complex and error prone. The configuration space can be organized using a feature model, fragmented into smaller interdependent feature models reflecting the configuration options of each subsystem. We propose a method for lazy product discovery in large fragmented feature models with interdependent features. We formalize the method and prove its soundness and completeness. The evaluation explores an industrial-size configuration space. The results show that lazy product discovery has significant performance benefits compared to standard product discovery, which in contrast to our method requires all fragments to be composed to analyze the feature model. Furthermore, the method succeeds when more efficient, heuristics-based engines fail to find a valid configuration

Structuring the modeling space and supporting evolution in software product line engineering

The scale and complexity of product lines means that it is practically infeasible to develop a single model of the entire system, regardless of the languages or notations used. The dynamic nature of real-world systems means that product line models need to evolve continuously to meet new customer requirements and to reflect changes of product line artifacts. To address these challenges, product line engineers need to apply different strategies for structuring the modeling space to ease the creation and maintenance of models. This paper presents an approach that aims at reducing the maintenance effort by organizing product lines as a set of interrelated model fragments defining the variability of particular parts of the system. We provide support to semi-automatically merge fragments into complete product line models. We also provide support to automatically detect inconsistencies between product line artifacts and the models representing these artifacts after changes. Furthermore, our approach supports the co-evolution of models and their respective meta-models. We discuss strategies for structuring the modeling space and show the usefulness of our approach using real-world examples from our ongoing industry collaboration

Entwicklung und Modellierung von Evolutionsszenarien für Delta-orientierte Softwareproduktlinien: Projektarbeit

Softwareproduktlinien bieten aufgrund ihrer Variabilität eine hohe Variantenvielfalt an unterschiedlichen, resultierenden Produkten. Dies und das hohe Maß an Wiederverwendung von Softwarebausteinen innerhalb der Produktlinie sowie deren vielfältige Abhängigkeiten untereinander führen dazu, dass die Evolution von Softwareproduktlinien überaus komplex ist. Damit Inkonsistenzen und Fehler als Folge von Evolution weitestgehend vermieden werden können, müssen vorher die genauen Auswirkungen der geplanten Änderungen eingeschätzt werden können. Dies wird durch die eingehende Betrachtung und Untersuchung der Veränderungen in Form von Modellen erreicht. Daher sind Modellierungsmethoden notwendig, die eine übersichtliche und verständliche Darstellung bieten und gleichzeitig eine effiziente Analyse der Auswirkungen erlauben. Doch auch die vielzählig vorhandenen Ansätze, Evolution von Softwareproduktlinien zu modellieren, müssen ausgiebig erprobt und evaluiert werden, damit Fehler im Konzept ausgeschlossen werden können und eine zuverlässige und alltagstaugliche Anwendung nachgewiesen werden kann. Für diese Evaluation werden Fallstudien mit Evolutionshistorie im Kontext von Softwareproduktlinien benötigt, welche bisher allerdings nicht in ausreichendem Maß vorhanden sind. Daher werden in dieser Projektarbeit vier verschiedene Fallstudien vorgestellt, die Softwareproduktlinien beschreiben. Es handelt sich um einen Verkaufsautomaten, eine Scheibenwischanlage, eine Minenpumpanlage und ein Body Comfort System. Für diese Fallstudien werden Szenarien entwickelt, welche evolutionäre Veränderungen an den zugrundeliegenden Softwareproduktlinien illustrieren. Da es sich um delta-orientierte Fallstudien handelt, werden die Ansätze „Delta-Modellierung“ zur Darstellung von Variabilität und „Higher-Order Delta-Modellierung“ zur Modellierung von Evolution verwendet, um Modelle für die Fallstudien und Evolutionsszenarien zu erstellen. Die entwickelten Evolutionsszenarien werden in einem Eclipse-basierten Prototyp umgesetzt und in dieser Arbeit dokumentiert

Supporting the grow-and-prune model for evolving software product lines

207 p.Software Product Lines (SPLs) aim at supporting the development of a whole family of software products through a systematic reuse of shared assets. To this end, SPL development is separated into two interrelated processes: (1) domain engineering (DE), where the scope and variability of the system is defined and reusable core-assets are developed; and (2) application engineering (AE), where products are derived by selecting core assets and resolving variability. Evolution in SPLs is considered to be more challenging than in traditional systems, as both core-assets and products need to co-evolve. The so-called grow-and-prune model has proven great flexibility to incrementally evolve an SPL by letting the products grow, and later prune the product functionalities deemed useful by refactoring and merging them back to the reusable SPL core-asset base. This Thesis aims at supporting the grow-and-prune model as for initiating and enacting the pruning. Initiating the pruning requires SPL engineers to conduct customization analysis, i.e. analyzing how products have changed the core-assets. Customization analysis aims at identifying interesting product customizations to be ported to the core-asset base. However, existing tools do not fulfill engineers needs to conduct this practice. To address this issue, this Thesis elaborates on the SPL engineers' needs when conducting customization analysis, and proposes a data-warehouse approach to help SPL engineers on the analysis. Once the interesting customizations have been identified, the pruning needs to be enacted. This means that product code needs to be ported to the core-asset realm, while products are upgraded with newer functionalities and bug-fixes available in newer core-asset releases. Herein, synchronizing both parties through sync paths is required. However, the state of-the-art tools are not tailored to SPL sync paths, and this hinders synchronizing core-assets and products. To address this issue, this Thesis proposes to leverage existing Version Control Systems (i.e. git/Github) to provide sync operations as first-class construct

Composition des modèles de lignes de produits logiciels

Cette thèse s inscrit dans le cadre de la gestion des modèles de lignes de produits logiciels complexes. L ingénierie des lignes de produits logiciels a pour objectif de modéliser et développer une famille de produits logiciels présentant un ensemble de similarités plutôt que de modéliser et développer des produits logiciels individuels au cas par cas. La modélisation, cependant, peut se révéler une tâche difficile voir même infaisable quand il s agit de modéliser des lignes de produits logiciels complexes et à grande échelle. Pour résoudre un tel problème, la tâche de modélisation est distribuée sur différents intervenants. Les modèles développés séparément doivent alors être composés pour obtenir le modèle global de la ligne de produits logiciels. Toutefois, la composition des modèles de lignes de produits logiciels n est pas une tâche triviale car elle doit prendre en compte l information de variabilité des éléments de modèles, les contraintes de variabilité, la structure des modèles manipulés et la sémantique ciblée par la composition. L objectif de cette thèse est de fournir des mécanismes de composition des modèles de lignes de produits logiciels. Pour cela, deux mécanismes sont proposés : la fusion et l agrégation. La fusion a pour objectif de combiner des modèles présentant des similarités au niveau de leurs éléments structurels. Alors que l agrégation vise à composer des modèles ne possèdent pas de similarités mais plutôt d éventuelles contraintes transversales reliant leurs éléments structurels. Les modèles utilisés sont représentés sous une vue de structures composites d UML et incluent des annotations spécifiques des éléments variables. Les mécanismes que nous proposons traitent l information de variabilité des éléments structurels manipulés, les contraintes de variabilités associées aux éléments annotés variables ainsi que l aspect structurel des modèles à composer. Les mécanismes de composition proposés sont définis selon des propriétés sémantiques bien précises décrivant le but de la composition. Ces propriétés sémantiques doivent alors être vérifiées tout au long du processus de composition. A la fin, une évaluation du travail effectué permet de montrer la capacité à composer des modèles de lignes de produits logiciels en un temps raisonnable ainsi que l importance de la consolidation des modèles structurels dans la réduction du nombre de produits structurellement incomplets.The Software Product Line (SPL) engineering aims at modeling and developing a set of software systems with similarities rather than individual software systems. Modeling task can be, however, tedious or even infeasible for large scale and complex SPLs. To address such a problem, the modeling task is distributed among different stakeholders. At the end, the models separately developed have to be composed in order to obtain the global SPL model. Composing SPL models is not a trivial task; variability information of model elements has to be treated during the composition, as well as the variability constraints. Similarly, the model structure and the composition semantics are key points that have to be considered during the composition. This thesis aims at providing specific mechanisms to compose SPL models. Therefore, we propose two composition mechanisms: the merge and the aggregation mechanisms. The merge mechanism aims at combining models including structural similarities. The aggregation mechanism, however, intends to compose models without any structural similarity but having eventual constraints across their structural elements. We focus on UML composite structures of SPLs and use specific annotations to identify variable elements. Our composition mechanisms deal with the variability information of structural elements, the variability constraints associated with the variable elements as well as the structures of the manipulated models. We also specify a set of semantic properties that have to be considered during the composition process and show how to preserve them. At the end, we have carried out an assessment of the proposals and have showed their ability to compose SPL models in a reasonable time. We have also showed how model consolidation is important in reducing le number of products having incomplete structure.PARIS11-SCD-Bib. électronique (914719901) / SudocSudocFranceF

Feature Model Synthesis

Variability provides the ability to adapt and customize a software system's artifacts for a particular context or circumstance. Variability enables code reuse, but its mechanisms are often tangled within a software artifact or scattered over multiple artifacts. This makes the system harder to maintain for developers, and harder to understand for users that configure the software. Feature models provide a centralized source for describing the variability in a software system. A feature model consists of a hierarchy of features—the common and variable system characteristics—with constraints between features. Constructing a feature model, however, is a arduous and time-consuming manual process. We developed two techniques for feature model synthesis. The first, Feature-Graph-Extraction, is an automated algorithm for extracting a feature graph from a propositional formula in either conjunctive normal form (CNF), or disjunctive normal form (DNF). A feature graph describes all feature diagrams that are complete with respect to the input. We evaluated our algorithms against related synthesis algorithms and found that our CNF variant was significantly faster than the previous comparable technique, and the DNF algorithm performed similarly to a comparable, but newer technique, with the exception of several models where our algorithm was faster. The second, Feature-Tree-Synthesis, is a semi-automated technique for building a feature model given a feature graph. This technique uses both logical constraints and text to address the most challenging part of feature model synthesis—constructing the feature hierarchy—by ranking potential parents of a feature with a textual similarity heuristic. We found that the procedure effectively reduced a modeler's choices from thousands, to five or less when synthesizing the Linux and eCos variability models. Our third contribution is the analysis of Kconfig—a language similar to feature modeling used to specify the variability model of the Linux kernel. While large feature models are reportedly used in industry, these models have not been available to the research community for benchmarking feature model analysis and synthesis techniques. We compare Kconfig to feature modeling, reverse engineer formal semantics, and translate 12 open-source Kconfig models—including the Linux model with over 6000 features—to propositional logic