From our experience with several organizations that employ software product families, we have learned that, contrary to popular belief, deriving individual products from shared software assets is a time-consuming and expensive activity. In this paper we therefore present a study that investigated the source of those problems. We provide the reader with a framework of terminology and concepts regarding product derivation. In addition, we present several problems and issues we identified during a case study at two large industrial organizations that are relevant to other, for example, comparable or less mature organizations.

Abstract. A key aspect of variability management in software product families is the explicit representation of the variability. Experiences at several industrial software development companies have shown that a software variability model (1) should uniformly represent variation points as first class entities in all abstraction layers (ranging from features to code) and (2) allow for hierarchical organization of the variability. It furthermore (3) should allow for first class representation of simple, i.e. one-to-one, and complex, i.e. n-to-m, dependencies, and (4) allow for modeling the relations between dependencies. Existing variability modeling approaches only support the first two requirements, but lack support for the latter two. The contribution of this paper is a framework for variability modeling, COVAMOF, that provides support for all four requirements. 1

Abstract Nowadays, process oriented software systems, like many business information systems, don’t exist only in one single version, but in many variants for better coverage of the target market. Until now, the corresponding customization has to be done manually, which is a timeconsuming and error-prone task, which could be realized much more efficient by applying process family engineering techniques. Process family engineering is a modern software development approach, which allows for the rapid and cost-effective development and deployment of customer tailored process oriented systems. In this paper we present our findings in the area of process family architectures for e-business systems, described as variant-rich process models in the Business Process Modeling Notation. We moreover tackle variability implementation issues using Java variability mechanisms and code generators. The presentation of our findings is oriented to a case study for the validation of our process family engineering concepts developed in the context of the research project PESOA. 1

In this paper we discuss the construction of software products from customer-specific feature selections. We address variability management with the Feature Description Language (FDL) to capture variation points of product line architectures. We describe feature packaging which covers selecting and packaging implementation components according to feature selections using the autobundle tool. Finally, we discuss a generic approach, based on the abstract factory design pattern, to make instantiated (customer-specific) variability accessible in applications.

An argument pro component-based software development is the idea of constructing software systems by assembling preexisting components instead of redeveloping similar or identical functionality always from scratch. Unfortunately, integrating existing components practically means adaptation and use rather than use only, which makes an ideal component-based development hard to realize in practice. Product line engineering, however, tackles this problem by making components as generic as needed for a particular product family and thus allows component reuse. Such a component covers variabilities and thus its implementation must consider variabilities as well.

This paper describes the OBS Instantiation Environment, which demonstrates a generative approach to automating the instantiation process of a component-based framework. The process is automated in the sense that designers configure and assemble the framework components using intuitive visual operations in a GUI-based environment. Their configuration actions are then used to automatically generate the framework instantiation code. Generative techniques for framework instantiation are not new but tend to rely on domainspecific languages or on bespoke specification encoding and compilation techniques.

Software product lines (SPLs) are used to create tailor-made software products by managing and composing reusable assets. Generating a software product from the assets of an SPL is possible statically before runtime or dynamically at load-time or runtime. Both approaches have benefits and drawbacks with respect to composition flexibility, performance, and resource consumption. Which type of composition is preferable should be decided by taking the application scenario into account. Current tools and languages, however, force a programmer to decide between static and dynamic composition during development. In this paper, we present an approach that employs code generation to support static and dynamic composition of features of a single code base. We offer an implementation on top of FeatureC++, an extension of the C++ programming language that supports software composition based on features. To simplify dynamic composition and to avoid creation of invalid products we furthermore provide means to (1) validate the correctness of a composition at runtime, (2) automatically instantiate SPLs in case of stand-alone applications, and (3) automatically apply interaction code of crosscutting concerns.

Software product lines can be implemented with many different approaches. However, there are common underlying mechanisms which allow a classification into compositional and annotative approaches. While research focuses mainly on composition approaches like aspect- or feature-oriented programming because those support feature traceability and modularity, in practice annotative approaches like preprocessors are common as they are easier to adopt. In this paper, we compare both groups of approaches and find complementary strengths. We propose an integration of compositional and annotative approaches to combine advantages, increase flexibility for the developer, and ease adoption. 1.

Abstract. The problem of managing the evolution of complex and large software systems is well known. Evolution implies reuse and modification of existing software artifacts, and this means that the related knowledge must be documented and maintained. This paper focuses on the evolution of software product families, although the same principles apply in other software development environments as well. We describe our experience gained in a case study recovering a family of six software products. We give an overview of the case study, and report a list of lessons learned, a list of implicit assumptions reconstructed during the case study, and some rules that we think are generally applicable. Our experience indicates that organizing architectural knowledge is a difficult issue. To properly serve the various uses of this knowledge, it needs to be organized along different dimensions. For effective use, tools are required. Our experience also indicates that, next to variability explicitly designed into the product family, there is a ”variation creep”, caused by different, and evolving, technical and organizational environments of the products. We propose to explicitly model invariabilities, next to variabilities, in software product lines to get a better grip on this variation creep. 1

Software product line engineering introduces two new dimensions into the traditional engineering of software-based systems: the variability modeling and the product derivation. The variability gathers characteristics that differ from one product to another, while the product derivation is defined as a complete process of building products from the product line. Software Product Line Engineering with the UML has received a lot of attention in recent years. However most of these works only concern variability modeling in UML static models and few works concern behavioral models. In addition, there is very little research on product derivation. This chapter investigates the product derivation in the context of the product line engineering with the UML. First, a set of extensions are proposed to model product line variability in two types of UML models: class diagrams (the static aspect) and sequence diagrams (the behavioral aspect). Then we formalize product derivation using a UML model transformation. An algorithm is given to derive a static model for a product and an algebraic approach is proposed to derive product-specific statecharts from the sequence diagrams of the product line. Two simple case studies are presented, based on a Mercure