A major goal of software and systems engineering is to construct systems from reusable parts, which we call features (end-user--visible units of behavior or increments in system functionality). Such a compositional approach can decrease time to market, improve product quality, and diversify the product portfolio. However, the success of a compositional approach depends on the modularity of the reusable parts. The quest for modularity has a long tradition in software and systems engineering, programming languages research, and even in newer fields such as synthetic biology.

In the early days of software and systems engineering, the feature-interaction problem was identified (and coined) as a major threat to modularity [8,31,25]. A feature interaction occurs when the behavior of one feature is affected by the presence of another feature. Often the interaction cannot be deduced easily from the intended behaviors of the individual features involved. A canonical example is the inadvertent interaction between the call-forwarding and call-waiting features of a telephony system [8]: If both features are active, the system can reach an undefined possibly unsafe state when it receives a call on a busy line, because it is not specified whether the call should be suspended or forwarded. Alternatively, a feature interaction can be planned: for example, advanced cruise-control features are designed to interact with and extend basic cruise control.

To be safe, software developers must analyze the consequences of all possible feature interactions, in order to find and fix the undesired interactions. The feature-interaction problem is that the number of potential interactions to consider is exponential in the number of features. As a result, software developers find that their work in developing new features is dominated by the tasks to detect, analyze, and verify interactions.

The feature-interaction problem is deeply rooted in the fact that the world is often not compositional [25,20]. That is, a feature is not an island. It communicates and cooperates with other features and the environment, so it cannot be completely isolated. Insights from complex-systems research suggest that feature interactions are a form of emergent behavior that is inherent to any system that consists of many, mutually interacting parts. So, emergent system behavior - which is not deducible from the individual parts of a system - can be observed in many situations including in quantum systems (e.g., superconductivity), biological systems (e.g., swarm intelligence), and economical systems (e.g., trading market crashes). The challenge is to foster and manage desired interactions and to detect, resolve, and even avoid undesired feature interactions - in a scalable manner.

The feature-interaction problem became a crisis in the telecommunications industry in the late 1980s [5]. To handle complexity, there was the strong desire to compose systems from independently developed features, but there was no means to detect, express, and reason about feature interactions. Researchers responded with formalisms that enable automatic detection of feature interactions [4, 7, 15, 14, 21, 26], architectures that avoid classes of interactions [17, 29, 18, 28, 31], and techniques for resolving interactions at run-time [16, 27]. Architectural solutions have been the most successful because they impose general coordination strategies (i.e., serial execution) that apply to all features that are 'plugged' into the architecture, thereby, addressing the scalability issue at the heart of the feature-interaction problem. In coordination-based approaches, such as BIP [2, 3] or Composition Patterns [10], the interactions among a set of features are specified explicitly and can be specialized for subsets of features.

While the pioneering work on the feature-interaction problem in telecommunication systems was foundational and very successful [8], it is limited in the sense that it is based on assumptions that hold for telecommunication systems, but that do not hold in other domains. For example, architecture-based approaches take advantage of the fact that communication takes place over a mostly serial connection between communicating parties -- which is not the case in systems made up of parallel components (e.g., service systems, automotive software) or software product lines (e.g., features implemented via conditional compilation such as the Linux kernel). Specifying interactions explicitly is not a general solution either. When facing systems composed of thousands of features, attempting to identify and model a possibly exponential number of feature interactions is elusive. Furthermore, the highly dynamic nature of feature (or service) composition in self-adaptive systems, dynamic product lines, cloud computing, and systems of systems imposes a new class of challenges to solving the feature-interaction problem [24, 9, 1]. So, it is not surprising that different notions of feature interactions have emerged in different communities [6]. Instances of the feature-interaction problem have been observed and addressed in Internet applications [11], service systems [30], automotive systems [12], software product lines [19], requirements engineering [23], computational biology [13], and in many other fields outside of computer science. While all instances of the problem are rooted in the nature of modularity and compositionality [25, 20] the individual views, interpretations, and possible solutions differ considerably. For example, the view on feature interactions taken in program synthesis [22] differs significantly from the view in automotive systems engineering [12]: there are structural vs. behaviour views, static vs. dynamic views, sequential vs. parallel views, functional vs. non-functional, coordinated vs. emergent-behaviour views, and so on. It turns out that feature interactions are a much more general concept than investigated in the past in the context of telecommunication systems, but a classification, comparison, and generalization of the multitude of different views is missing.

The feature-interaction problem is still of pivotal importance in various industrial applications, but, despite significant efforts, it is far from being solved. The underlying hypothesis of organizing a Dagstuhl seminar on this topic was that the time is ripe to gather researchers and practitioners from different areas of computer science and other disciplines to compare, discuss, and consolidate their views, experience, and domain-specific solutions to the feature-interaction problem. To make progress, scientific discourse on the feature-interaction problem must be based on a broader foundation to be able to join forces of different communities. Can other domains learn from the success of domain-specific solutions for telecommunication systems? Are there key principles, patterns, and strategies to represent, identify, manage, and resolve feature interactions that are domain-independent, that are valid and useful across domains? Or, should we strive for domain-specific solutions that are only loosely related to solutions from other domains? Can we develop a unified terminological and conceptual framework for feature-interaction research? Is that even possible or meaningful, given that interactions in telecommunication systems and emergent behavior and phase transitions in swarm systems are, although related, quite different views?

Goals of the Seminar and Further Activities

It is our goal and firm belief that the feature-interaction problem needs to be viewed from a broader perspective. While feature interactions are still a major challenge in software and systems engineering, both in academia and industry, research on the feature-interaction problem has diversified and diverged in the last decade. Researchers working on similar problems, but in different contexts, are largely disconnected and unaware of related work. A major goal of the seminar was to (re)launch a sustained research community that embraces researchers and practitioners from different fields within and outside computer science. We firmly believe that we reached this goal with our seminar. In particular, a subset of the participants is going to organize a follow-up seminar that directly builds on this seminar's results. The next major milestone will be -- now as we gained a better understanding of the similarities and differences between the different notions of feature interactions -- to establish a catalog on feature-interaction patterns and solutions thereof. The idea for this pattern catalog arose from the final panel session of the seminar. It is inspired by work on patterns in architecture (of buildings). Such a catalog will be the necessary basis for further research on leveraging patterns for detecting, managing, and resolving feature interactions in different kinds of systems.

References

1. L. Baresi, S. Guinea, and L. Pasquale. Service-oriented dynamic software product lines. IEEE Computer, 45(10):42–48, 2012.
2. A. Basu, M. Bozga, and J. Sifakis. Modeling heterogeneous real-time components in BIP. In Proc. of the Int’l Conf. on Software Engineering and Formal Methods (SEFM), pages 3–12. IEEE, 2006.
3. S. Bliudze and J. Sifakis. The algebra of connectors – Structuring interaction in BIP. IEEE Transactions on Computers, 57(10):1315–1330, 2008.
4. J. Blom, B. Jonsson, and L. Kempe. Using temporal logic for modular specification of telephone services. In Feature Interactions in Telecommunications Systems, pages 197–216. IOS Press, 1994.
5. T. Bowen, F. Dworack, C. Chow, N. Griffeth, G. Herman, and Y.-J. Lin. The feature interaction problem in telecommunications systems. In Proc. of the Int’l Conf. on Software Engineering for Telecommunication Switching Systems (SETSS), pages 59–62. IEEE, 1989.
6. G. Bruns. Foundations for features. In Feature Interactions in Telecommunications and Software Systems VIII, pages 3–11. IOS Press, 2005.
7. G. Bruns, P. Mataga, and I. Sutherland. Features as service transformers. In Feature Interactions in Telecommunications Systems V, pages 85–97. IOS Press, 1998.
8. M. Calder, M. Kolberg, E. Magill, and S. Reiff-Marganiec. Feature interaction: A critical review and considered forecast. Computer Networks, 41(1):115–141, 2003.
9. B. Cheng, R de Lemos, H. Giese, P. Inverardi, J. Magee, et al. Software engineering for selfadaptive systems: A research roadmap. In Software Engineering for Self-Adaptive Systems, LNCS 5525, pages 1–26. Springer, 2009.
10. S. Clarke and R. Walker. Composition patterns: An approach to designing reusable aspects. In Proc. of the Int’l Conf. on Software Engineering (ICSE), pages 5–14. IEEE, 2001.
11. R. Crespo, M. Carvalho, and L. Logrippo. Distributed resolution of feature interactions for Internet applications. Computer Networks, 51(2):382–397, 2007.
12. A. Dominguez. Detection of Feature Interactions in Automotive Active Safety Features. PhD thesis, School of Computer Science, University of Waterloo, 2012.
13. R. Donaldson and M. Calder. Modular modelling of signalling pathways and their cross-talk. Theoretical Computer Science, 456(0):30–50, 2012.
14. A. Felty and K. Namjoshi. Feature specification and automated conflict detection. ACM Transactions on Software Engineering and Methodology, 12(1):3–27, 2003.
15. M. Frappier, A. Mili, and J. Desharnais. Defining and detecting feature interactions. In Proc. of the IFIP TC 2 WG 2.1 Int’l Workshop on Algorithmic Languages and Calculi, pages 212–239. Chapman & Hall, Ltd., 1997.
16. N. Griffeth and H. Velthuijsen. The negotiating agents approach to runtime feature interaction resolution. In Feature Interactions in Telecommunications Systems, pages 217–235. IOS Press, 1994.
17. J. Hay and J. Atlee. Composing features and resolving interactions. In Proc. of the ACM SIGSOFT Symp. on Foundations of Software Engineering (FSE), pages 110–119. ACM, 2000.
18. M. Jackson and P. Zave. Distributed feature composition: A virtual architecture for telecommunications services. IEEE Transactions on Software Engineering (TSE), 24(10):831–847, 1998.
19. P. Jayaraman, J. Whittle, A. Elkhodary, and H. Gomaa. Model composition in product lines and feature interaction detection using critical pair analysis. In Proc. of the Int’l Conf. on Model Driven Engineering Languages and Systems (MoDELS), LNCS 4735, pages 151–165. Springer, 2007.
20. C. Kästner, S. Apel, and K. Ostermann. The road to feature modularity? In Proc. of the Int’l Workshop on Feature-Oriented Software Development (FOSD), pages 5:1–5:8. ACM, 2011.
21. F. Lin and Y.-J. Lin. A building block approach to detecting and resolving feature interactions. In Feature Interactions in Telecommunications Systems, pages 86–119. IOS Press, 1994.
22. J. Liu, D. Batory, and C. Lengauer. Feature oriented refactoring of legacy applications. In Proc. of the Int’l Conf. on Software Engineering, pages 112–121. ACM, 2006.
23. A. Nhlabatsi, R. Laney, and B. Nuseibeh. Feature interaction: The security threat from within software systems. Progress in Informatics, (5):75–89, 2008.
24. L. Northrop, P. Feiler, R. Gabriel, J. Goodenough, R. Linger, T. Longstaff, R. Kazman, M. Klein, D. Schmidt, K. Sullivan, and K. Wallnau. Ultra-large-scale systems – The software challenge of the future. Technical report, Software Engineering Institute, Carnegie Mellon University, 2006.
25. K. Ostermann, P. Giarrusso, C. Kästner, and T. Rendel. Revisiting information hiding: Reflections on classical and nonclassical modularity. In Proc. of the Europ. Conf. on Object-Oriented Programming (ECOOP), LNCS 6813, pages 155–178, 2011.
26. K. Pomakis and J. Atlee. Reachability analysis of feature interactions: A progress report. In Proc. of the Int’l Symp. on Software Testing and Analysis (ISSTA), pages 216–223. ACM, 1996.
27. S. Tsang and E. Magill. Learning to detect and avoid run-time feature interactions in intelligent networks. IEEE Transactions on Software Engineering (TSE), 24(10):818–830, 1998.
28. G. Utas. A pattern language of feature interaction. In Feature Interactions in Telecommunications Systems V, pages 98–114. IOS Press, 1998.
29. R. van der Linden. Using an architecture to help beat feature interaction. In Feature Interactions in Telecommunications Systems, pages 24–35. IOS Press, 1994.
30. M. Weiss, B. Esfandiari, and Y. Luo. Towards a classification of web service feature interactions. Computer Networks, 51(2):359–381, 2007.
31. Pamela Zave. Modularity in Distributed Feature Composition. In Software Requirements and Design: The Work of Michael Jackson, pages 267–290. Good Friends Publishing, 2010.

Creative Commons BY 3.0 Unported license

Sven Apel, Joanne M. Atlee, Luciano Baresi, and Pamela Zave