Abstract
Most traditional industries focus on the reproduction-based mass production of physical products, which is not suited for the software industry. To achieve efficient and effective production in the software industry, software reuse is a realistic approach, focusing on the customization-based mass production of software products. Feature-oriented software reuse provides a technical approach to enforcing the customization-based mass production of software products and has shown important influence on the research and practice of software reuse. This paper clarifies basic concepts and key ideas in feature-oriented software reuse and presents important achievements in recent years in this field. In particular, this paper: (1) inspects the existing definitions of features from the two viewpoints of intension and extension; (2) explains the basic structure of feature models and its semantics based on propositional logic; (3) describes general ways of modeling the traceability between feature models and implementation artifacts (use cases, software architecture, and source code).
The Challenge of Mass Customization
In traditional manufacturing, industrialization is synonymous with the mass production of identical physical goods. However, the software industry faces a unique challenge: mass customization. While digital replication is virtually free, tailoring software to diverse user needs across different customers (space) and evolving requirements (time) is prohibitively expensive.
Feature-oriented software reuse addresses the fundamental hurdle of managing a library of reusable components. It allows developers to efficiently "pick and mix" parts to build specific products by defining a unit of reuse—the "feature"—that bridges the gap between high-level user requirements and low-level executable code.
Defining the "Feature"
To formalize this approach, the paper categorizes features through two primary lenses:
- Intension: A logical set of requirements or a functional unit.
- Extension: A user-visible characteristic or quality of the system.
By treating features as the primary unit of management, technical complexity is hidden from the user while maintaining a strict mapping to the underlying implementation.
Formal Modeling and Logic
Feature Models typically utilize tree structures governed by propositional logic and Object Constraint Language (OCL). This formalization transforms the "validity" of a software configuration into a mathematical problem, enabling automated tools to verify if a specific combination of features is valid or if it contains conflicts (e.g., Feature A requiring Feature B, which was excluded).
As shown in the comparison above, while traditional activity diagrams focus on interaction details, feature models provide a more flexible, hierarchical decomposition of domain knowledge. This granularity allows for better reuse than rigid "Use Case" models.
Traceability: Linking Requirements to Code
A core contribution of this field is the establishment of traceability between the conceptual feature space and the implementation space. The paper identifies two primary strategies:
- Annotation-based (Negative Variability): Starting with a "super-model" containing all possible components and removing parts based on feature selection.
- Delta-based (Positive Variability): Starting with a core product and adding "deltas" (increments) for each selected feature.
This traceability framework ensures that selecting a high-level requirement automatically results in the assembly of the correct underlying code, architecture, and design models.
Future Outlook
Despite significant progress, several "open frontiers" remain. Current methods often rely on an "omniscient expert" to define all constraints upfront, which is increasingly difficult in rapidly evolving domains. Future research is shifting toward Collective Intelligence, utilizing community-driven modeling to evolve feature sets. Additionally, better modeling of non-functional requirements (like security and performance) across different feature combinations remains a critical technical challenge for the next generation of software product lines.
Summary updated