Generative software product line development using variability-aware design patterns

Highlights

• Use of design patterns in Software Product Lines to realize different features.

• Variability-aware design patterns Observer, Strategy, Template Method and Composite.

• Technology neutral specification and validity checks using role modeling.

• Generative model-based implementation for Java, C++ and UML class diagrams.

• Support for variability with Antenna, preprocessor, FOP, DeltaJ, DeltaEcore.

Abstract

Software Product Lines (SPLs) are an approach to reuse in-the-large that models a set of closely related software systems in terms of commonalities and variabilities. Design patterns are best practices for addressing recurring design problems in object-oriented source code. In the practice of implementing SPL, instances of certain design patterns are employed to handle variability, which makes these “variability-aware design patterns” a best practice for SPL design. However, currently there is no dedicated method for proactively developing SPLs using design patterns suitable for realizing variable functionality. In this paper, we present a method to perform generative SPL development with design patterns. We use role models to capture design patterns and their relation to a variability model. We further allow mapping of individual design pattern roles to (parts of) implementation elements to be generated (e.g., classes, methods) and check the conformance of the realization with the specification of the pattern. We provide definitions for the variability-aware versions of the design patterns Observer, Strategy, Template Method and Composite. Furthermore, we support generation of realizations in Java, C++ and UML class diagrams utilizing annotative, compositional and transformational variability realization mechanisms. Hence, we support proactive development of SPLs using design patterns to apply best practices for the realization of variability. We realize our concepts within the Eclipse IDE and demonstrate them within a case study.

Introduction

Design patterns are templates for standard solutions to recurring design problems, predominantly in object-oriented languages [1], e.g., Java, C++ or UML class diagrams (see Section 2.2). Software Product Lines (SPLs) are an approach to reuse in-the-large where a family of closely related software systems is represented in terms of commonalities and variabilities—often referred to as features (see Section 2.1). SPLs utilize, among others, object-oriented programming and modeling languages to realize features.

In our previous work [2], [3], we analyzed multiple SPLs for their use of design patterns. We found that instances of the design patterns Observer [1], Strategy [1], Template Method [1] and Composite [1] are used to explicitly realize variability. Furthermore, we determined that there also are common practices with regard to how the different entities of a design pattern are distributed to individual features of a feature model in and SPL. As an example, Fig. 1 illustrates the Observer pattern, where an entity produces state changes (Observable/Subject) that are received by a loosely coupled interested entity (Observer/ConcreteObserver), e.g., to react to these state changes. Within the exemplary usage of Fig. 1 in an SPL context, the concrete entities of the pattern (i.e., ConcreteObserver, Subject) are realized by different features than the more general entities (i.e., Observer, Observable). The features of the figure are abstractions from a concrete SPL we inspected.

Furthermore, we have determined that the distribution of a design pattern׳s entities to features follows specific rules [4] (see Section 3) in order to realize functionality associated with particular features. With these findings, design patterns can be considered a best practice in SPL design so that it seems well-advised to explicitly employ them in developing SPLs. A design pattern is instantiated by implementing its entities in a particular language, e.g., Java or UML, even though the structure of the pattern does not have to be matched exactly to be valid (see Section 2.2). Furthermore, the instantiation of variability-aware design patterns needs to incorporate the distribution of the individual entities of the design pattern to different features. Performing this procedure manually is both tedious and error-prone as the specification of the design pattern may inadvertently be violated by improper implementation.

To aid the process of applying variability-aware design patterns to SPLs as best practices for design, we present a generative method that allows tailoring a pattern׳s realization to a particular SPL and that generates realization artifacts that instantiate the pattern with specified parameters.

We provide definitions for the variability-aware versions of the design patterns Observer, Strategy, Template Method and Composite. Furthermore, we support generation of realizations in Java, C++ and UML class diagrams utilizing annotative, compositional and transformational variability realization mechanism (see Section 2.1).

The rest of this paper is structured as follows: Section 2 provides foundations of SPLs, design patterns and role modeling. Section 3 elaborates on how to specify variability-aware design patterns as reusable catalog entries and provides catalog pages for the variability-aware versions of the design patterns Observer, Strategy, Template Method and Composite. Section 4 introduces our method of applying variability-aware design patterns to SPLs by generating required realization artifacts that contain appropriate variability information. Section 5 elaborates on the model-based implementation of our method. Section 6 discusses how our approach can be integrated in proactive, reactive and extractive SPL development processes. Section 7 demonstrates the feasibility of our method within a case study. Finally, Section 8 discusses related work before Section 9 closes with a conclusion and an outlook to future work.

The work in this paper is mainly based on our previous work published in [5]. We improve over this work in the following points: For one, we define the variability-aware version of the Composite pattern and incorporate it into our generation facilities. Moreover, we provide detailed descriptions for each of the presented variability-aware design patterns in the form of a full catalog page. Furthermore, we extended our code generation facilities to also generate C++ code with appropriate preprocessor directives as annotative variability realization mechanism as is used frequently in industrial practice [6]. Accordingly, we extended our case study to incorporate the application of the Composite pattern and the generation of C++ code. In addition, we supply information on how to ease the application process of design patterns (see Section 4.3). Finally, we provide a detailed discussion on how to integrate our generative approach into SPL development processes for proactive, reactive and extractive development [7] (see Section 6).