Feature-Oriented Programming: Back to the Future

Feature-oriented programming has its origin in the old quest of computer
science: modular composition of software "artifacts" in software
development. While there exist many notions of modularity and composition,
feature-oriented programming tackles the case of highly-entangled software
features where typical module or component concepts fail. The reason for
this are feature interactions and dependencies which make it very hard to
write modular software which can be composed in a flexible way. In contrast
to other efforts like aspect-oriented programming, feature-oriented
programming has from the beginning focused on the semantics or behavior of
software, not just code modularity.

In this presentation, we review the origins of feature composition and
feature interactions, which first occurred as an explicit research problem
in telecommunication software. We argue that feature interactions are
pervasive in many areas of software development and a common source of
modularity and quality problems. Then, we present more precise formalization
of modularity and compositionality of features. We discuss when adding
features is modular or "harmless" from a semantic or behavioral point of
view. In particular, we focus on modularity and interaction for multiple
feature compositions. A future challenge for feature-oriented software is
the graphical modeling of features and feature interactions.  As we aim to
have modular composition for graphical models and to generate code from
these graphical artifacts, it is important to have a precise semantics and
clear refinement concepts. For this, we discuss how features and
interactions can be represented by state-based specifications in a graphical
way. Refinement concepts are presented which allow the flexible composition
of features and interactions in statechart diagrams.