Version 60 (modified by acher, 7 years ago)



Feature models are a popular formalism for managing variability in software product lines (SPLs). Realistic SPLs involve the modeling of a large number of features to comprehensively represent different viewpoints, sub-systems or concerns of the software system. To manage complexity, there is a need to separate, inter-relate and compose several feature models while automating the reasoning on their compositions -- from validity checks to configuration process. We propose a Domain-Specific Language (DSL) that is dedicated to the management of feature models and that complements existing tool support.

The DSL, called FAMILIAR (for FeAture Model scrIpt Language for manIpulation and Automatic Reasoning), is an executable language that supports manipulating and reasoning about feature models. FAMILIAR is developed in Java language using  Xtext, a framework for development of DSLs. Off-the-shelf SAT solvers (i.e., SAT4J) and BDD library (i.e., JavaBDD) are internally used to perform FAMILIAR operations.

We provide an Eclipse text editor and an interpreter that executes the various scripts. The interpreter can be used in an interactive mode. We provide multiple notations for specifying feature models ( SPLOT,  GUIDSL/FeatureIDE, a subset of  TVL, etc.) The integration of the language to the  FeatureIDE environment has been done to support experimentation, e.g., all graphical edits are synchronized with variables environment and all interactive commands are synchronized with the graphical editors.


Have a look at the screencasts that demonstrate FAMILIAR in the Eclipse/FeatureIDE environment. Do not hesitate to contact us in case of questions or other requests.

NEWS: FAMILIAR was at  ASE'11 conference for a tool demonstration and short paper presentation. New operators and applications have been presented! Have a look at the poster:

ASE poster (slicing)

FAMILIAR has been presented in Belgium for  VaMoS 2011 (tool demonstration) and in Taiwan for  SAC 2011 (formal presentation).

FAMILIAR is under constant development and the current website is regularly updated.


replacing a subtree in a feature model

Managing Multiple SPL: a scenario

Other projects


Persons involved in the development of FAMILIAR are (in alphabetical order):

Do not hesitate to contact us in case of questions or other requests.


 Mathieu Acher Managing Multiple Feature Models: Foundations, Language, and Applications. PhD thesis, september 2011 [ pdf [ bib]

Software Product Line (SPL) engineering is a paradigm shift towards modeling and developing software system families rather than individual systems. It focuses on the means of efficiently producing and maintaining multiple similar software products, exploiting what they have in common and managing what varies among them. This is analogous to what is practiced in the automotive industry, where the focus is on creating a single production line, out of which many customized but similar variations of a car model are produced. Feature models (FMs) are a fundamental formalism for specifying and reasoning about commonality and variability of SPLs. FMs are becoming increasingly complex, handled by several stakeholders or organizations, used to describe features at various levels of abstraction and related in a variety of ways. In different contexts and application domains, maintaining a single large FM is neither feasible nor desirable. Instead, multiple FMs are now used. In this thesis, we develop theoretical foundations and practical support for managing multiple FMs. We design and develop a set of composition and decomposition operators (aggregate, merge, slice) for supporting separation of concerns. The operators are formally defined, implemented with a fully automated algorithm and guarantee properties in terms of sets of configurations. We show how the composition and decomposition operators can be combined together or with other reasoning and editing operators to realize complex tasks. We propose a textual language, FAMILIAR (for FeAture? Model scrIpt Language for manIpulation and Automatic Reasoning), which provides a practical solution for managing FMs on a large scale. An SPL practitioner can combine the different operators and manipulate a restricted set of concepts (FMs, features, configurations, etc.) using a concise notation and language facilities. FAMILIAR hides implementation details (e.g., solvers) and comes with a development environment. We report various applications of the operators and usages of FAMILIAR in different domains (medical imaging, video surveillance) and for different purposes (scientific workflow design, variability modeling from requirements to runtime, reverse engineering), showing the applicability of both the operators and the supporting language. Without the new capabilities brought by the operators and FAMILIAR, some analysis and reasoning operations would not be made possible in the different case studies. To conclude, we discuss different research perspectives in the medium term (regarding the operators, the language and validation elements) and in the long term (e.g., relationships between FMs and other models).

 Mathieu Acher,  Philippe Collet,  Philippe Lahire, and  Robert France. Decomposing Feature Models: Language, Environment, and Applications.

In 26th Automated Software Engineering (ASE), demonstration paper, Kansas (USA), November 2011. [ bib]

Variability in software product lines is often expressed through feature models (FMs). To handle the complexity of increasingly larger FMs, we propose semantically meaningful decomposition support through a slicing operator. We describe how the slicing operator is integrated into the FAMILIAR environment and how it can be combined with other operators to support complex tasks over FMs in different case studies.

 Mathieu Acher,  Philippe Collet,  Philippe Lahire, and  Robert France. Slicing Feature Models.

In 26th Automated Software Engineering (ASE), AR=22%, short paper, Kansas (USA), November 2011. [ bib]

Feature models (FMs) are a popular formalism for describing the commonality and variability of software product lines (SPLs) in terms of features. As SPL development increasingly involves numerous large FMs, scalable modular techniques are required to manage their complexity. In this paper, we present a novel slicing technique that produces a projection of an FM, including constraints. The slicing allows SPL practitioners to find semantically meaningful decompositions of FMs and has been integrated into the FAMILIAR language.

 Mathieu Acher,  Anthony Cleve,  Philippe Collet,  Philippe Merle,  Laurence Duchien and  Philippe Lahire. Reverse Engineering Architectural Feature Models

In 5th European Conference on Software Architecture (ECSA), AR=25%, long paper, page 16, Essen (Germany), September 2011. [ bib]

Reverse engineering the variability of an existing system is a challenging activity. The architect knowledge is essential to identify variation points and explicit constraints between features, for instance in feature models (FMs), but the manual creation of FMs is both time-consuming and error-prone. On a large scale, it is very difficult for an architect to guarantee that the resulting FM ensures a safe composition of the architectural elements when some features are selected. In this paper, we present a comprehensive, tool supported process for reverse engineering architectural FMs. 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 FM. We illustrate the reverse engineering process when applied to a representative software system, FraSCAti, and we report on our experience in this context.

 Mathieu Acher,  Philippe Collet,  Philippe Lahire,  Sabine Moisan, and  Jean-Paul Rigault. Modeling Variability from Requirements to Runtime

In Proceedings of 16th International Conference on Engineering of Complex Computer Systems (ICECCS) AR=31%, IEEE Computer Society, April 2011. [ bib] [ pdf]

In software product line (SPL) engineering, a software configuration can be obtained through a valid selection of features represented in a feature model (FM). With a strong separation between requirements and reusable components and a deep impact of high level choices on technical parts, determining and configuring an well-adapted software configuration is a long, cumbersome and error-prone activity. This paper presents a modeling process in which variability sources are separated in different FMs and inter-related by propositional constraints while consistency checking and propagation of variability choices are automated. We show how the variability requirements can be expressed and then refined at design time so that the set of valid software configurations to be considered at runtime may be highly reduced. Software tools support the approach and some experimentations on a video surveillance SPL are also reported.

 Mathieu Acher,  Philippe Collet,  Philippe Lahire, and  Robert France. Managing Feature Models with FAMILIAR: a Demonstration of the Language and its Tool Support.

In Fifth International Workshop on Variability Modelling of Software-intensive Systems (VaMoS) AR=55%, ACM, Belgium, 27-29 january 2011 [ bib] [ pdf]

Developing software product lines involves modeling a large number of features, usually using feature models, that represent different viewpoints, sub-systems or concerns of the software system. To manage complexity on a large scale, there is a need to separate, relate and compose several feature models while automating the reasoning on their compositions. This demonstration gives an overview of a Domain-Specific Language, FAMILIAR, that is dedicated to the management of feature models. Its comprehensive programming environment, based on Eclipse, is also described. It complements existing tool support (i.e., FeatureIDE).

 Mathieu Acher,  Philippe Collet,  Philippe Lahire, and  Robert France. A Domain-Specific Language for Managing Feature Models

In 26th Symposium on Applied Computing (SAC), Programming Languages Track, AR=33%, ACM, Taiwan, 21-25 march 2011 [ bib] [ pdf]

Feature models are a popular formalism for managing variability in software product lines (SPLs). In practice, developing an SPL can involve modeling a large number of features representing different viewpoints, sub-systems or concerns of the software system. To manage complexity, there is a need to separate, relate and compose several feature models while automating the reasoning on their compositions in order to enable rigorous SPL validation and configuration. In this paper, we propose a Domain-Specific Language (DSL) that is dedicated to the management of feature models and that complements existing tool support. Rationale for this language is discussed and its main constructs are presented through examples. We show how the DSL can be used to realize a non trivial scenario in which multiple SPLs are managed.

 Mathieu Acher,  Philippe Collet,  Philippe Lahire, and  Robert France. Managing Multiple Software Product Lines Using Merging Techniques

Technical report, University of Nice Sophia Antipolis, I3S CNRS, Sophia Antipolis, France, May 2010. [ bib] | [ .pdf]

A growing number of organizations produce and maintain multiple Software Product Lines (SPLs) or design software products that utilize features in SPLs maintained by competing suppliers. Manually building monolithic Feature Models (FMs) to help manage features described across different SPLs is error-prone and tedious and the resulting FMs can be difficult to understand and use. In this paper we propose a compositional approach to managing multiple SPLs that involves automatically merging FMs defined across the SPLs. We illustrate how the approach can be used to create FMs that support selection of products from among sets of competing products provided by different companies or suppliers. The merging techniques can also manage features from different SPLs which are then combined to form products. We show that the proposed approach results in more compact FMs, and we provide some empirical results on the complexity and scalability of the composition operators used in the approach.

 Mathieu Acher,  Philippe Collet,  Philippe Lahire, and  Robert France. Managing Variability in Workflow with Feature Model Composition Operators

In 9th International Conference on Software Composition AR=28%, volume LNCS, page 16. Springer, June 2010. [ bib] [ pdf]

In grid-based scientific applications, building a workflow essentially involves composing parameterized services describing families of services and then configuring the resulting workflow product line. In domains (e.g., medical imaging) in which many different kinds of highly parameterized services exist, there is a strong need to manage variabilities so that scientists can more easily configure and compose services with consistency guarantees. In this paper, we propose an approach in which variable points in services are described with several separate feature models, so that families of workflow can be defined as compositions of feature models. A compositional technique then allows reasoning about the compatibility between connected services to ensure consistency of an entire workflow, while supporting automatic propagation of variability choices when configuring services.

 Mathieu Acher,  Philippe Collet,  Philippe Lahire, and  Robert France. Comparing Approaches to Implement Feature Model Composition

In 6th European Conference on Modelling Foundations and Applications (ECMFA) AR=31%, volume LNCS, page 16. Springer, June 2010. [ bib] [ pdf]

The use of Feature Models (FMs) to define the valid combinations of features in Software Product Lines (SPL) is becoming commonplace. To enhance the scalability of FMs, support for composing FMs describing different SPL aspects is needed. Some composition operators, with interesting property preservation capabilities, have already been defined but a comprehensive and efficient implementation is still to be proposed. In this paper, we systematically compare strengths and weaknesses of different implementation approaches. The study provides some evidence that using generic model composition frameworks are not helping much in the realization, whereas a specific solution is finally necessary and clearly stands out by its qualities.

 Mathieu Acher,  Philippe Collet,  Philippe Lahire, and  Robert France. Composing Feature Models

In 2nd International Conference on Software Language Engineering (SLE'09) AR=19%, LNCS, page 20. LNCS, October 2009. [ bib] | [ .pdf]

Feature modeling is a widely used technique in Software Product Line development. Feature models allow stakeholders to describe domain concepts in terms of commonalities and differences within a family of software systems. Developing a complex monolithic feature model can require significant effort and restrict the reusability of a set of features already modeled. We advocate using modeling techniques that support separating and composing concerns to better manage the complexity of developing large feature models. In this paper, we propose a set of composition operators dedicated to feature models. These composition operators enable the development of large feature models by composing smaller feature models which address well-defined concerns. The operators are notably distinguished by their documented capabilities to preserve some significant properties.

 Mathieu Acher,  Philippe Collet,  Franck Fleurey,  Philippe Lahire,  Sabine Moisan, and  Jean-Paul Rigault. Modeling Context and Dynamic Adaptations with Feature Models

In 4th International Workshop Models@run.time at Models 2009 (MRT'09), page 10, October 2009. [ bib] | [ .pdf]

Self-adaptive and dynamic systems adapt their behavior according to the context of execution. The contextual information exhibits multiple variability factors which induce many possible configurations of the software system at runtime. The challenge is to specify the adaptation rules that can link the dynamic variability of the context with the possible variants of the system. Our work investigates the systematic use of feature models for modeling the context and the software variants, together with their inter relations, as a way to configure the adaptive system with respect to a particular context. A case study in the domain of video surveillance systems is used to illustrate the approach.

 Mathieu Acher,  Philippe Lahire,  Sabine Moisan, and  Jean-Paul Rigault. Tackling High Variability in Video Surveillance Systems through a Model Transformation Approach

In Proceedings of the 2009 international workshop on Modeling in software engineering at ICSE 2009 (MiSE'09) AR=44%. IEEE Computer Society, May 2009. [ bib] | [ .pdf]

This work explores how model-driven engineering techniques can support the configuration of systems in domains presenting multiple variability factors. Video surveillance is a good candidate for which we have an extensive experience. Ultimately, we wish to automatically generate a software component assembly from an application specification, using model to model transformations. The challenge is to cope with variability both at the specification and at the implementation levels. Our approach advocates a clear separation of concerns. More precisely, we propose two feature models, one for task specification and the other for software components. The first model can be transformed into one or several valid component configurations through step-wise specialization. This paper outlines our approach, focusing on the two feature models and their relations. We particularly insist on variability and constraint modeling in order to achieve the mapping from domain variability to software variability through model transformations.