Architecture conformance analysis approach within the context of multiple product line engineering

One of the important concerns in software product line engineering is the conformance of the application architecture to the product line architecture. Consistency with the product line architecture is important to ensure that the business rules and constraints that are defined for the entire product family are not violated. Usually, the conformance checking to the product line architecture is a manual and tedious process. A popular approach for ensuring architecture conformance is reflexion modeling which has been primarily used to check the consistency between the architecture and the code. In this paper we present an approach for product line conformance analysis based on reflexion modeling. We consider conformance analysis in product line engineering and extend our discussion to multiple product line engineering. Our study shows several important challenges regarding reflexion modeling within the context of product line engineering. © 2014 IEEE

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

The state of adoption and the challenges of systematic variability management in industry

Handling large-scale software variability is still a challenge for many organizations. After decades of research on variability management concepts, many industrial organizations have introduced techniques known from research, but still lament that pure textbook approaches are not applicable or efficient. For instance, software product line engineering—an approach to systematically develop portfolios of products—is difficult to adopt given the high upfront investments; and even when adopted, organizations are challenged by evolving their complex product lines. Consequently, the research community now mainly focuses on re-engineering and evolution techniques for product lines; yet, understanding the current state of adoption and the industrial challenges for organizations is necessary to conceive effective techniques. In this multiple-case study, we analyze the current adoption of variability management techniques in twelve medium- to large-scale industrial cases in domains such as automotive, aerospace or railway systems. We identify the current state of variability management, emphasizing the techniques and concepts they adopted. We elicit the needs and challenges expressed for these cases, triangulated with results from a literature review. We believe our results help to understand the current state of adoption and shed light on gaps to address in industrial practice.This work is supported by Vinnova Sweden, Fond Unique Interminist´eriel (FUI) France, and the Swedish Research Council. Open access funding provided by University of Gothenbur

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

Conceptual Variability Management in Software Families with Multiple Contributors

To offer customisable software, there are two main concepts yet: software product lines that allow the product customisation based on a fixed set of variability and software ecosystems, allowing an open product customisation based on a common platform. Offering a software family that enables external developers to supply software artefacts means to offer a common platform as part of an ecosystem and to sacrifice variability control. Keeping full variability control means to offer a customisable product as a product line, but without the support for external contributors. This thesis proposes a third concept of variable software: partly open software families. They combine a customisable platform similar to product lines with controlled openness similar to ecosystems. As a major contribution of this thesis a variability modelling concept is proposed which is part of a variability management for these partly open software families. This modelling concept is based on feature models and extends them to support open variability modelling by means of interfaces, structural interface specifications and the inclusion of semantic information. Additionally, the introduction of a rights management allows multiple contributors to work with the model. This is required to enable external developers to use the model for the concrete extension development. The feasibility of the proposed model is evaluated using a prototypically developed modelling tool and by means of a case study based on a car infotainment system

Erklärung von Defekten und Identifizierung von Abhängigkeiten in Zusammenhängenden Feature-Modellen

Software-Produktlinien gelten als anerkanntes Entwicklungskonzept für variable Software in vielen industriellen Anwendungsbereichen, insbesondere im Automobilbereich. Im Zentrum von Software-Produktlinien steht die Variabilität einer Produktlinie, die eine Variantenvielfalt des Produktes durch die Modellierung auf einer hohen Abstraktionsebene ermöglicht. Jedoch ist die Modellierung von Variabilität eine nicht triviale Aufgabe, die mit der wachsenden Anzahl der Varianten komplexer und dadurch fehleranfälliger wird. Modellierungsfehler können beispielsweise dazu führen, dass Produktkonfigurationen nicht mehr möglich sind. Die Detektion von Modellierungsfehlern einer Softwareproduktlinie ist ein weit verbreitetes Forschungsfeld. Die nutzerfreundliche Erklärung von Fehlerursachen - das Thema der vorliegenden Arbeit - stellt dabei weiterhin eine Herausforderung dar und wird immer wichtiger. Im Rahmen dieser Arbeit wird ein generischer Algorithmus ausgearbeitet, um Modellierungsfehler aller Arten auf Basis der Pradikatenlogik zu erklären. Die resultierende Erklärung wird in der natürlichen Sprache nutzerfreundlich und strukturiert generiert und als Tooltip während der Modellierung angezeigt. Der Basisalgorithmus wird zusätzlich erweitert, um kürzeste Erklärungen zu finden und die Relevanz der einzelnen Teile einer Erklärung zu berechnen und visuell hervorzuheben. Weiterhin detektieren wir versteckte Abhängigkeiten in zusammenhängenden Produktlinien und verwenden den oben erwähnten generischen Algorithmus zur Erklärung dieser Abhängigkeiten. In einer qualitativen und quantitativen Analyse evaluieren wir den Algorithmus und resultierende Erklärungen anhand der vorhandenen Beispiele im Hinblick auf ihre Korrektheit, Verständlichkeit, Performance und Länge. Für versteckte Abhängigkeiten untersuchen wir zusätzlich, in welchen typischen Situationen diese Abhängigkeiten am häufigsten entstehen. Durch die Inspektion von Erklärungen können wir darüber hinaus feststellen, wie viele zusammenhängende Produktlinien in einer versteckten Abhängigkeit involviert sind. Zusammenfassend stellen wir fest, dass Erklärungen korrekt und verständlich sind und die Generierung von Erklärungen für unterschiedlich große Produktlinien skaliert. Die Generierung der Erklärung mit dem Basisalgorithmus verdoppelt dabei ungefähr die Rechenzeit der ursprünglichen Modellanalyse, während der erweiterte Algorithmus (welcher nach der kürzesten Erklärung sucht) die Rechenzeit in etwa verdreifacht. Aufällig ist, dass die erste Erklärung meistens die Kürzeste ist, andernfalls ist die kürzeste Erklärung üblicherweise um 25% - 50% kleiner. Die Erklärungslänge wächst nur geringfügig im Vergleich zu der Größe einer Produktlinie. Zum Schluss zeigen wir, dass anhand der analysierten Produktlinien bis zu fünf zusammenhängende Produktlinien zu einer versteckten Abhängigkeit führen können.Software product line engineering has proven to be a successful develop approach for variable software in different industrial applications, especially in the automotive area. The variability of a product line is at the center of software product lines engineering. By modeling variability on a high abstraction level, software product lines enable a wide variety of a product. Nevertheless, modeling variability is not a trivial task. It gets more complex with a growing number of variants and, hence, becomes more error-prone. For instance, modeling errors may result in product congurations being not possible anymore. The detection of such defects is well researched. A user friendly explanation of the defect causes - the subject of the present work - is still a challenge and is becoming increasingly important. In the scope of this thesis, we elaborate a generic algorithm which is able to generate explanations for any kind of modeling defects based on predicate logic. A resulting explanation is generated in a user-friendly and structural manner and displayed within a tool tip during the modeling phase. Additionally, the basic algorithm is improved to find the shortest explanation und to compute and visualize relevant parts of the explanation. Furthermore, we detect hidden dependencies among interrelated product lines and apply the generic explanation algorithm mentioned above to explain such dependencies. In a quantitative and qualitative analysis, we evaluate the explanation algorithm and resulting explanations concerning their correctness, understandability, performance impact and length using existing examples. For hidden dependencies, we additionally inspect situations in which such dependencies occur most often. By analyzing respective explanations, we can furthermore determine the number of involved product lines in a hidden dependency. To summarize the results, we demonstrate the correctness and understandability of explanations and show the scalability of the explanation algorithm for different sizes of product lines. Generating a first explanation approximately doubles the computational time of the former model analysis while the improved algorithm (which searches for a shortest explanation) approximately triples the computational time. It is notable that the first explanation is most often already the shortest one, otherwise it is usually shorter by 25% - 50%. Explanation length slightly increases compared to the size of a product line. Finally, we observe that up to five interrelated feature models may lead to a hidden dependency based on the evaluated product lines

Model checking large design spaces: Theory, tools, and experiments

In the early stages of design, there are frequently many different models of the system under development constituting a design space. The different models arise out of a need to weigh different design choices, to check core capabilities of system versions with varying features, or to analyze a future version against previous ones in the product line. Every unique combinations of choices yields competing system models that differ in terms of assumptions, implementations, and configurations. Formal verification techniques, like model checking, can aid system development by systematically comparing the different models in terms of functional correctness, however, applying model checking off-the-shelf may not scale due to the large size of the design spaces for today’s complex systems. We present scalable algorithms for design-space exploration using model checking that enable exhaustive comparison of all competing models in large design spaces. Model checking a design space entails checking multiple models and properties. Given a formal representation of the design space and properties expressing system specifications, we present algorithms that automatically prune the design space by finding inter-model relationships and property dependencies. Our design-space reduction technique is compatible with off-the-shelf model checkers, and only requires checking a small subset of models and properties to provide verification results for every model-property pair in the original design space. We evaluate our methodology on case-studies from NASA and Boeing; our techniques offer up to 9.4× speedup compared to traditional approaches. We observe that sequential enumeration of the design space generates models with small incremental differences. Typical model-checking algorithms do not take advantage of this information; they end up re-verifying “already-explored” state spaces across models. We present algorithms that learn and reuse information from solving related models against a property in sequential model-checking runs. We formalize heuristics to maximize reuse between runs by efficient “hashing” of models. Extensive experiments show that information reuse boosts runtime performance of sequential model-checking by up to 5.48×. Model checking design spaces often mandates checking several properties on individual models. State-of-the-art tools do not optimally exploit subproblem sharing between properties, leaving an opportunity to save verification resource via concurrent verification of “nearly-identical” properties. We present a near-linear runtime algorithm for partitioning properties into provably high-affinity groups for individual model-checking tasks. The verification effort expended for one property in a group can be directly reused to accelerate the verification of the others. The high-affinity groups may be refined based on semantic feedback, to provide an optimal multi-property localization solution. Our techniques significantly improve multi-property model-checking performance, and often yield \u3e4.0× speedup. Building upon these ideas, we optimize parallel verification to maximize the benefits of our proposed techniques. Model checking tools utilize parallelism, either in portfolio mode where different algorithm strategies run concurrently, or in partitioning mode where disjoint property subsets are verified independently. However, both approaches often degrade into highly-redundant work across processes, or under-utilize available processes. We propose methods to minimize redundant computation, and dynamically optimize work distribution when checking multiple properties for individual models. Our techniques offer a median 2.4× speedup for complex parallel verification tasks with thousands of properties

First-class features

Magdeburg, Univ., Fak. für Informatik, Diss., 2011von Sagar Sunkl