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

Towards Flexible Feature Composition: Static and Dynamic Binding in Software Product Lines

Scalable software composition by reusing software assets is one of the major challenges in software engineering since many years. The goal of software product line engineering is to provide a systematic approach for reuse for a set of similar programs, called a software product line (SPL). The programs of an SPL can be distinguished in terms of features, which describe commonalities and differences between the programs. This allows SPL engineers to describe a program by listing its features. There are several SPL development techniques that support composition of assets to derive a tailor-made program according to a selection of required features. A main difference between existing techniques is their support for different feature binding times, i.e., the time at which a feature is included in a program. We can distinguish between static and dynamic binding. While static binding occurs before runtime (e.g., at compile-time), dynamic binding occurs during program start or in a running program. Both binding times have benefits and drawbacks. Static binding is used to generat

Towards a Refactoring Guideline Using Code Clone Classification

Evolution of software often decreases desired properties like readability and maintainability of the evolved code. The process of refactoring aims at increasing the same desired properties by restructuring the code. New paradigms like AOP allow aspect-oriented refactorings as counterparts of object-oriented refactoring with the same aim. However, it is not obvious to the user, when to use which paradigm for achieving certain goals. In this paper we present an approach of code clone classification, which advises the developer when to use a respective refactoring technique or concept

Avoiding Variability of Method Signatures in Software Product Lines: A Case Study

Software product lines (SPLs) are used to build tailor-made applications based on the features of a domain. Optional and alternative features introduce variability into an SPL that is needed for customization. Variability of method signatures is sometimes necessary to provide additional arguments for optional features. However, this complicates the development of SPLs and is the source of incompatibility between client applications and products of an SPL. In this paper we analyze two techniques to avoid variable method signatures in SPLs and evaluate the solutions in a non-trivial case study. 1

On the Duality of Aspect-Oriented and Feature-Oriented Design Patterns

Design patterns aim at improving reusability and variability of object-oriented software. Despite a notable success, aspect-oriented programming (AOP) has been discussed recently to improve the design pattern implementations. In another line of research it has been noticed that featureoriented programming (FOP) is related closely to AOP and that FOP suffices in many situations where AOP is commonly used. In this paper we explore the assumed duality between AOP and FOP mechanisms. As a case study we use the aspect-oriented design pattern implementations of Hannemann and Kiczales. We observe that almost all of the 23 aspect-oriented design pattern implementations can be transformed straightforwardly into equivalent featureoriented design patterns. For further investigations we provide a set of general rules how to transform aspect-oriented programs into feature-oriented programs