Decomposing Feature Models: Language, Environment and Applications

Feature models are increasingly complex to elaborate and maintain. Nowadays feature models with hundreds of features, describing the variability of large implemented software systems, exist. In addition, we and others observe that managing only one feature model is not appropriate when developers have to deal with of a large number of concerns, artefacts and sub-systems. As software development increasingly involves numerous large feature models, scalable modular techniques are required to manage their complexity.

We have developed a novel decomposition technique, called slicing, that produces a projection of a feature model, including constraints. The slicing allows developers to find semantically meaningful decompositions of feature models.

The objectives of the demo are as follows:

  • introduce the slicing operator and its properties (configuration semantics, hierarchy)
  • describe its integration into the language FAMILIAR (e.g., syntax) and into an Eclipse-based environment, including textual and graphical editors ;
  • show how the slicing operator can be combined with other operators to realize complex management scenarios ;
  • demonstrate the various applications of the operator in different case studies ;

Demonstration Schedule

We plan to conduct the demonstration as follows:

  • first, we describe the general motivation of our work (increasing complexity of feature models, multiplicity of feature models in SPL developement, lack of separation of concerns support, our case studies) ;
  • then, we present the foundations of the slicing operator using the language and the environment. We use very simple examples to explain the properties guaranteed by the operator in terms of set of configurations and hierarchy (see Section Slicing by Examples below). In the same time, the syntax of the language is described as well as the textual/graphical editors and the console of the environment.
  • finally, we combine the slicing operator with other operators of FAMILIAR (aggregate, compare, etc) using a case study in reverse engineering an architectural feature model (see Section Applications below). We show how we obtain, at the end of the process, a re-enforced feature model.

Other applications of the slicing operator can be shown in the demonstration area open to attendees at scheduled times during the conference, during which demonstrators are expected to be available. The applications have been developed in different domains (medical imaging, video surveillance) and for different purposes (scientific workflow design, variability modeling from requirements to runtime). Finally, we also plan to revisit some approaches / examples from the state-of-the-art using the slicing operator.

Slicing by Examples


The overall idea behind feature model slicing is similar to  program slicing. Program slicing eliminates all parts from the program that are not currently of interest to the programmer. It aims at simplifying or abstracting programs by focusing on selected aspects of semantics. We want to obtain the same benefits for the formalism of feature models.

Program slicing techniques usually proceed in two steps: the subset of elements of interest (e.g., a set of variables of interest and a program location), called the slicing criterion, is first identified ; then, a slice (e.g., a subset of the source code) is computed. In the context of feature model, we define the slicing criterion as a set of features considered to be pertinent by a software product line practitioner while the slice is a new feature model.

Semantics and Examples

We consider the feature model fm1 (see below): Input feature model (fm1)

We apply three times the slice on fm1, using different slicing criterion. It gives three feature models fm2, fm3 and fm4 (see below):

fm2 fm3 fm4

Language Support

Using FAMILIAR, we can produce the feature models fm2, fm3, fm4 (see below). During the demonstration, we will:

  • describe in more details the syntax designed to ease the selection of a set of features
  • illustrate the properties of the slicing operator (hierarchy, set of configurations)
  • show how we can then apply reasoning operations on fm2, fm3 and fm4

Foundation by examples (Environment)

FAMILIAR users can interact with the variables using the Eclipse console (basically an  intervative toplevel). In the example below, a FAMILIAR user evaluates the value of fm5 (a variable of type feature model), converts its representation into  SPLOT format and creates a variable of type configuration. Feature model or configuration editors are displayed on demand.

Example of interactive session


In this demonstration, we focus on one case study in which the slicing operator is intensively used.

Case Study

(see for more information on the case study and additional resources.)

Reverse engineering the variability of an existing system is a challenging activity. We develop automated techniques to extract and combine different variability descriptions of an architecture. Then, alignment and reasoning techniques are applied to integrate the architect knowledge and reinforce the extracted feature model. We illustrate the techniques when applied to a representative software system, FraSCAti.

Simplified Example

During the demonstration, we will:

  • start with a simplified example to illustrate the overall approach (the different variability descriptions of the architecture correspond to fmArch150 and fmPlugins.)
  • explain the central role of composition (aggregate) and decomposition (slice) operators (for reducing the set of configurations but also for removing unnecessary features)
  • show the benefits (e.g., one configuration has been originally removed from fmArch150)
  • apply the techniques on a larger scale (using real feature models of FraSCAti)

Reverse engineering process with FAMILIAR