Fabian Benduhn

FeatureIDE: An extensible framework for feature-oriented software development

FeatureIDE is an open-source framework for feature-oriented software development (FOSD) based on Eclipse. FOSD is a paradigm for the construction, customization, and synthesis of software systems. Code artifacts are mapped to features, and a customized software system can be generated given a selection of features. The set of software systems that can be generated is called a software product line (SPL). FeatureIDE supports several FOSD implementation techniques such as feature-oriented programming, aspect-oriented programming, delta-oriented programming, and preprocessors. All phases of FOSD are supported in FeatureIDE, namely domain analysis, requirements analysis, domain implementation, and software generation.

FeatureIDE: taming the preprocessor wilderness

Preprocessors are a common way to implement variability in software. They are used in numerous software systems, such as operating systems and databases. Due to the ability of preprocessors to enable and disable code fragments, not all parts of the program are active at the same time. Thus, programmers and tools need to handle the interactions resulting from annotations in the program. With our Eclipse-based tool FeatureIDE, we provide tool support to tackle multiple challenges with preprocessors, such as code comprehension, feature traceability, separation of concerns, and program analysis. With FeatureIDE, instead of focusing on one particular preprocessor, we provide tool support, which can easily be adopted for further preprocessors. Currently, we support development with CPP, Antenna, and Munge. https://youtu.be/jVe7f32mLCQ

Potential synergies of theorem proving and model checking for software product lines

The verification of software product lines is an active research area. A challenge is to efficiently verify similar products without the need to generate and verify them individually. As solution, researchers suggest family-based verification approaches, which either transform compile-time into runtime variability or make verification tools variability-aware. Existing approaches either focus on theorem proving, model checking, or other verification techniques. For the first time, we combine theorem proving and model checking to evaluate their synergies for product-line verification. We provide tool support by connecting five existing tools, namely FeatureIDE and FeatureHouse for product-line development, as well as KeY, JPF, and OpenJML for verification of Java programs. In an experiment, we found the synergy of improved effectiveness and efficiency, especially for product lines with few defects. Further, we experienced that model checking and theorem proving are more efficient and effective if the product line contains more defects.

Feature-model interfaces: the highway to compositional analyses of highly-configurable systems

Today’s software systems are often customizable by means of load-time or compile-time configuration options. These options are typically not independent and their dependencies can be specified by means of feature models. As many industrial systems contain thousands of options, the maintenance and utilization of feature models is a challenge for all stakeholders. In the last two decades, numerous approaches have been presented to support stakeholders in analyzing feature models. Such analyses are commonly reduced to satisfiability problems, which suffer from the growing number of options. While first attempts have been made to decompose feature models into smaller parts, they still require to compose all parts for analysis. We propose the concept of a feature-model interface that only consists of a subset of features, typically selected by experts, and hides all other features and dependencies. Based on a formalization of feature-model interfaces, we prove compositionality properties. We evaluate feature-model interfaces using a three-month history of an industrial feature model from the automotive domain with 18,616 features. Our results indicate performance benefits especially under evolution as often only parts of the feature model need to be analyzed again.

An overview on analysis tools for software product lines

A software product line is a set of different software products that share commonalities. For a selection of features, specialized products of one domain can be generated automatically from domain artifacts. However, analyses of software product lines need to handle a large number of products that can be exponential in the number of features. In the last decade, many approaches have been proposed to analyze software product lines efficiently. For some of these approaches tool support is available. Based on a recent survey on analysis for software product lines, we provide a first overview on such tools. While our discussion is limited to analysis tools, we provide an accompanying website covering further tools for product-line development. We compare tools according to their analysis and implementation strategy to identify underrepresented areas. In addition, we want to ease the reuse of existing tools for researchers and students, and to simplify research transfer to practice.

Mutation Operators for Preprocessor-Based Variability

Mutation testing has emerged as one of the most promising techniques to increase the quality of software-intensive systems. In mutation testing, random faults based on a predefined set of mutation operators are automatically injected into a program to evaluate test suites. The effectiveness of mutation testing strongly depends on the representativeness of the mutation operators. Existing operators are not sufficient to represent typical faults caused by variability. Thus, we propose a set of mutation operators for software with preprocessor-based variability. We derive the operators systematically based on a taxonomy of variability-related faults and evaluate them by investigating their applicability to real-world faults that have previously been identified in research on configurable software systems. Our goal is to leverage mutation testing to highly-variable software for its practical application and to enable empirical evaluation of testing techniques.

A Survey on Modeling Techniques for Formal Behavioral Verification of Software Product Lines

As software product lines are increasingly used for safety-critical systems, researchers have adapted formal verification techniques such as model checking and theorem proving to cope with compiletime variability. While the focus of the ongoing debate lies on the verification mechanisms itself, it becomes increasingly difficult for researchers to maintain an overview about the various accompanying modeling techniques. We survey existing approaches as a first step towards a unifying view on variability mechanisms in formal modeling techniques for product lines. We illustrate the approaches by means of a running example to illustrate their commonalities and differences.

Composing annotations without regret? Practical experiences using FeatureC

Software product lines enable developers to derive similar products from a common code base. Existing implementation techniques can be categorized as composition‐based and annotation‐based approaches, with both approaches promising complementary benefits. However, annotation‐based approaches are commonly used in practice despite composition allowing physical separation of features and, thus, improving traceability and maintenance. A main hindrance to migrate annotated systems toward a composition‐based product line is the challenging and time‐consuming transformation task. For a company, it is difficult to predict the corresponding costs, and a successful outcome is uncertain. To overcome such problems, a solution proposed by the previous work is to use a hybrid approach, utilizing composition and annotation simultaneously. Based on this idea, we introduce a stepwise migration process from annotation‐based toward composition‐based approaches to lower the adoption barrier of composition. This process itself is independent of used implementation techniques and enables developers to incrementally migrate toward composition. We support our approach with detailed examples by partially migrating a real‐world system. In detail, we describe the following: (1) our migration process, (2) its application on a real‐world system, and (3) discuss practical challenges we face. We implemented the proposed approach and show that appropriate tool support helps to migrate toward composition‐based product lines. Based on the case study, we show that the hybrid product lines work correctly and can compete with the performance of the original annotated system. However, the results also illustrate open issues that have to be solved to apply such migrations in practice.

Modularization of Refinement Steps for Agile Formal Methods

The combination of agile methods and formal methods has been recognized as a promising field of research. However, many formal methods rely on a refinement-based development process which poses problems for their integration into agile processes. We consider redundancies within refinement hierarchies as a challenge for the practical application of stepwise refinement and propose superimposition-based modularization of refinement steps as a potential solution. While traditionally, each model in a refinement hierarchy must be developed and maintained separately, our concept allows developers to specify the refinement steps that transform a model into a refined one. We have developed tool support for the language AsmetaL and evaluated our approach by means of a case study. The results indicate a reduction of complexity for the development artifacts in terms of their overall size by 48.6% for the ground model and four refinements. Furthermore, the case study shows that superimposition-based refinement eases the development of alternative refinements for exploratory development and to cope with changing requirements. Thus, we consider this work as a step towards agile formal methods that are tailored to support iterative development, facilitating their incorporation into agile development processes.

Overview on FeatureIDE

The goal of this chapter is to give an overview on FeatureIDE’s functionality. While previous parts and chapters focused on aspects of the tool support only, we aim to present the big picture in the following. That is, we present the goal of views and editors as well as how they differ when using other implementation techniques as composers. In addition, we discuss what tool support is already available in the current release, in experimental versions, or planned for future releases.