Abstract Feature modeling is an important approach to capture the commonalities and variabilities in system families and product lines. Cardinality-based feature modeling integrates a number of existing extensions of the original feature-modeling notation from Feature-Oriented Domain Analysis. Staged configuration is a process that allows the incremental configuration of cardinality-based feature models. It can be achieved by performing a step-wise specialization of the feature model. In this paper, we argue that cardinality-based feature models can be interpreted as a special class of context-free grammars. We make this precise by specifying a translation from a feature model into a context-free grammar. Consequently, we provide a semantic interpretation for cardinalitybased feature models by assigning an appropriate semantics to the language recognized by the corresponding grammar. Finally, we give an account on how feature model specialization can be formalized as transformations on the grammar equivalent of feature models.

Abstract Feature modeling is a key technique for capturing commonalities and variabilities in system families and product lines. In this paper, we propose a cardinality-based notation for feature modeling, which integrates a number of existing extensions of previous approaches. We then introduce and motivate the novel concept of staged configuration. Staged configuration can be achieved by the stepwise specialization of feature models or by multi-level configuration, where the configuration choices available in each stage are defined by separate feature models. Staged configuration is important because in a realistic development process, different groups and different people make product configuration choices in different stages. Finally, we also discuss how multi-level configuration avoids a breakdown between the different abstraction levels of individual features. This problem, sometimes referred to as “analysis paralysis”, easily occurs in feature modeling because features can denote entities at arbitrary levels of abstractions within a system family. Key words: Software product lines, system families, domain analysis, software configuration

Software factories have been proposed as a comprehensive and integrative approach to generative software development. Feature modeling has several applications in generative software development, including domain analysis, product-line scoping, and feature-based product specification. This paper reports on our recent progress in cardinalitybased feature modeling and its support for expressing additional constraints. We show that the Object-Constraint Language (OCL) can adequately capture such constraints. Furthermore, we identify a set of facilities based on constraint satisfaction that can be provided by feature modeling and feature-based configuration tools and present a prototype implementing some of these facilities. We report on our experience with the prototype and give directions for future work.

Abstract. System family engineering seeks to exploit the commonalities among systems from a given problem domain while managing the variabilities among them in a systematic way. In system family engineering, new system variants can be rapidly created based on a set of reusable assets (such as a common architecture, components, models, etc.). Generative software development aims at modeling and implementing system families in such a way that a given system can be automatically generated from a specification written in one or more textual or graphical domainspecific languages. This paper gives an overview of the basic concepts and ideas of generative software development including DSLs, domain and application engineering, generative domain models, networks of domains, and technology projections. The paper also discusses the relationship of generative software development to other emerging areas such as Model Driven Development and Aspect-Oriented Software Development. 1

Abstract. For some organizations, the proactive approach to product lines may be inadequate due to prohibitively high investment and risks. As an alternative, the extractive and the reactive approaches are incremental, offering moderate costs and risks, and therefore sometimes may be more appropriate. However, combining these two approaches demands a more detailed process at the implementation level. This paper presents a method for extracting a product line and evolving it, relying on a strategy that uses refactorings expressed in terms of simpler programming laws. The approach is evaluated with a case study in the domain of games for mobile devices, where variations are handled with aspect-oriented constructs. 1

A mechanically formalized feature modeling metamodel is presented. This theory is a generic higher-order formalization of a mathematical model synthesizing several feature modeling approaches found in the literature. This meta-model support not only a better understanding of the various approaches to feature modeling, but also supports reasoning about and within feature model approaches, feature models, and on feature trees and their configurations. 1

Feature models are widely used to model software product-line (SPL) variability. SPL variants are configured by selecting feature sets that satisfy feature model constraints. Configuration of large feature models involve multiple stages and participants, which makes it hard to avoid conflicts and errors. New techniques are therefore needed to debug invalid configurations and derive the minimal set of changes to fix flawed configurations. This paper provides three contributions to debugging feature model configurations: (1) we present a technique for transforming a flawed feature model configuration into a Constraint Satisfaction Problem (CSP) and show how a constraint solver can derive the minimal set of feature selection changes to fix an invalid configuration, (2) we show how this diagnosis CSP can automatically resolve conflicts between configuration participant decisions, and (3) we present experiment results that evaluate our technique. These results show how our technique scales to models with over 5,000 features, which is beyond the size used to validate other automated techniques.

Abstract. Extended Feature Oriented Domain Analysis (FODA) Feature Diagrams (EFD) were introduced to compensate for a purported ambiguity and lack of precision and expressiveness of the original FODA feature diagrams (OFD). However, EFD never received a formal semantics, which is the hallmark of precision and unambiguity. We propose here a semantics for both diagrams. From this we demonstrate that OFD are precise, unambiguous, and expressively complete, and thus that all extensions add no expressiveness. A finer notion is thus needed to compare these languages. Two solutions are well-established: succinctness and embeddability, that measures naturalness of a language. This tool shows that EFD indeed bring some naturalness, but are harmfully redundant and that the same naturalness can be attained with the simpler varied FD (VFD). We also show that no ambiguity is present, in fact.

Feature models have been cited as one of the main contributions to model software product families. However, there is still a gap in product family engineering which is the automated reasoning on feature models. In this paper we describe how to reason on feature models using constraint programming. Although, there are a few attempts to reason on feature models there are two main drawbacks in these proposals: ## none of them associate parameters to features ### none of them use constraint programming as the reasoning base. Using constraint programming endows our proposal with a more powerful reasoning capacity and greater expressiveness than others.

Goal models are effective in capturing stakeholder needs at the time when features of the system-to-be have not yet been conceptualized. Relating goals to solution-oriented features gives rise to a requirement traceability problem. In this paper, we present a new model-driven extension to an Early Requirements Engineering tool (OpenOME) that generates an initial feature model of the systemto-be from stakeholder goals. Enabled by such generative mapping, configuration constraints among variability features can be obtained by reasoning about stakeholder goals.