Abstract
A software product line (SPL) is a family of programs that share assets from a common code base. The programs of an SPL can be distinguished in terms of features, which represent units of program functionality that satisfy stakeholders’ requirements. The features of an SPL can be bound either statically at program compile time or dynamically at run time. Both binding times are used in SPL development and have different advantages. For example, dynamic binding provides high flexibility whereas static binding supports fine-grained customizability without any impact on performance (e.g., for use on embedded systems). However, contemporary techniques for implementing SPLs force a programmer to choose the binding time already when designing an SPL and to mix different implementation techniques when multiple binding times are needed. We present an approach that integrates static and dynamic feature binding seamlessly. It allows a programmer to implement an SPL once and to decide per feature at deployment time whether it should be bound statically or dynamically. Dynamic binding usually introduces an overhead regarding resource consumption and performance. We reduce this overhead by statically merging features that are used together into dynamic binding units. A program can be configured at run time by composing binding units on demand. We use feature models to ensure that only valid feature combinations can be selected at compile and at run time. We provide a compiler and evaluate our approach on the basis of two non-trivial SPLs.
Similar content being viewed by others
References
Alves, V., Gheyi, R., Massoni, T., Kulesza, U., Borba, P., Lucena, C.: Refactoring product lines. In: Proceedings of the International Conference on Generative Programming and Component Engineering (GPCE), pp. 201–210. ACM Press, New York (2006)
Anastasopoules, M., Gacek, C.: Implementing product line variabilities. In: Proceedings of the Symposium on Software Reusability (SSR), pp. 109–117. ACM Press, New York (2001)
Apel, S., Beyer, D.: Feature cohesion in software product lines. In: Proceedings of the International Conference on Software Engineering (ICSE) (2011, to appear)
Apel, S., Kästner, C.: An overview of feature-oriented software development. J. Object Technol. 8(5), 49–84 (2009)
Apel, S., Kästner, C., Batory, D.: Program refactoring using functional aspects. In: Proceedings of the International Conference on Generative Programming and Component Engineering (GPCE), pp. 161–170. ACM Press, New York (2008a)
Apel, S., Leich, T., Saake, G.: Aspectual feature modules. IEEE Trans. Softw. Eng. 34(2), 162–180 (2008b)
Apel, S., Lengauer, C., Möller, B., Kästner, C.: An algebraic foundation for automatic feature-based program synthesis. Sci. Comput. Program. 75(11), 1022–1047 (2010)
Aracic, I., Gasiunas, V., Mezini, M., Ostermann, K.: An overview of CaesarJ. In: Transactions on Aspect-Oriented Software Development I. Lecture Notes in Computer Science, vol. 3880, pp. 135–173. Springer, Berlin (2006)
Batory, D., Lofaso, B., Smaragdakis, Y.: JTS: Tools for implementing domain-specific languages. In: Proceedings of the International Conference on Software Reuse (ICSR), pp. 143–153. IEEE Computer Society, Washington (1998)
Batory, D., Sarvela, J.N., Rauschmayer, A.: Scaling step-wise refinement. IEEE Trans. Softw. Eng. 30(6), 355–371 (2004)
Bockisch, C., Haupt, M., Mezini, M., Ostermann, K.: Virtual machine support for dynamic join points. In: Proceedings of the International Conference on Aspect-Oriented Software Development (AOSD), pp. 83–92. ACM, New York (2004)
Cardone, R., Lin, C.: Comparing frameworks and layered refinement. In: Proceedings of the International Conference on Software Engineering (ICSE), pp. 285–294. IEEE Computer Society, Washington (2001)
Chakravarthy, V., Regehr, J., Eide, E.: Edicts: Implementing features with flexible binding times. In: Proceedings of the International Conference on Aspect-Oriented Software Development (AOSD), pp. 108–119. ACM, New York (2008)
Classen, A., Hubaux, A., Heymans, P.: A formal semantics for multi-level staged configuration. In: Proceedings of the Workshop on Variability Modelling of Software-intensive Systems (VaMoS), pp. 51–60 (2009)
Czarnecki, K., Eisenecker, U.: Generative Programming: Methods, Tools, and Applications. Addison-Wesley, Reading (2000)
Czarnecki, K., Helsen, S., Eisenecker, U.W.: Staged configuration using feature models. In: Proceedings of the International Software Product Line Conference (SPLC). Lecture Notes in Computer Science, vol. 3154, pp. 266–283. Springer, Berlin (2004)
Gamma, E., Helm, R., Johnson, R., Vlissides, J.: Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley, Reading (1995)
Gilani, W., Spinczyk, O.: Dynamic aspect weaver family for family-based adaptable systems. In: Proceedings of Net.ObjectDays, pp. 94–109. Gesellschaft für Informatik, Munich (2005)
Griss, M.L.: Implementing product-line features with component reuse. In: Proceedings of the International Conference on Software Reuse (ICSR). Lecture Notes in Computer Science, vol. 1844, pp. 137–152. Springer, Berlin (2000)
Hallsteinsen, S., Hinchey, M., Park, S., Schmid, K.: Dynamic software product lines. Computer 41(4), 93–95 (2008)
Hirschfeld, R., Costanza, P., Nierstrasz, O.: Context-oriented programming. J. Object Technol. 7(3), 125–151 (2008)
Hundt, C., Mehner, K., Pfeiffer, C., Sokenou, D.: Improving alignment of crosscutting features with code in product line engineering. J. Object Technol. 6(9), 417–436 (2007)
Kiczales, G., Lamping, J., Mendhekar, A., Maeda, C., Lopes, C.V., Loingtier, J.-M., Irwin, J.: Aspect-oriented programming. In: Proceedings of the European Conference on Object-Oriented Programming (ECOOP). Lecture Notes in Computer Science, vol. 1241, pp. 220–242. Springer, Berlin (1997)
Lee, J., Kang, K.C.: A feature-oriented approach to developing dynamically reconfigurable products in product line engineering. In: Proceedings of the International Software Product Line Conference (SPLC), pp. 131–140. IEEE Computer Society, Washington (2006)
Lieberherr, K.J., Lorenz, D., Ovlinger, J.: Aspectual collaborations—combining modules and aspects. Comput. J. 46(5), 542–565 (2003)
Liebermann, H.: Using prototypical objects to implement shared behavior in object-oriented systems. In: Proceedings of the International Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pp. 214–223. ACM Press, New York (1986)
Lippman, S.B.: Inside the C++ Object Model. Addison-Wesley, Reading (1996)
Lopez-Herrejon, R., Batory, D., Lengauer, C.: A disciplined approach to aspect composition. In: Proceedings of the International Symposium on Partial Evaluation and Semantics-Based Program Manipulation (PEPM), pp. 68–77. ACM Press, New York (2006)
McDirmid, S., Flatt, M., Hsieh, W.C.: Jiazzi: New-age components for old-fashioned Java. In: Proceedings of the International Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pp. 211–222. ACM Press, New York (2001)
Mezini, M., Seiter, L., Lieberherr, K.: Component Integration with Pluggable Composite Adapters. Kluwer, Dordrecht (2000)
Nicoara, A., Alonso, G., Roscoe, T.: Controlled, systematic, and efficient code replacement for running java programs. SIGOPS Oper. Syst. Rev. 42(4), 233–246 (2008)
Ostermann, K.: Dynamically composable collaborations with delegation layers. In: Proceedings of the European Conference on Object-Oriented Programming (ECOOP). Lecture Notes in Computer Science, vol. 2374, pp. 89–110. Springer, Berlin (2002)
Prehofer, C.: Feature-oriented programming: a fresh look at objects. In: Proceedings of the European Conference on Object-Oriented Programming (ECOOP). Lecture Notes in Computer Science, vol. 1241, pp. 419–443. Springer, Berlin (1997)
pure-systems GmbH: Technical White Paper: Variant Management with pure::variants (2004). http://www.pure-systems.com
Rosenmüller, M., Siegmund, N.: Automating the configuration of multi software product lines. In: Proceedings of the Workshop on Variability Modelling of Software-intensive Systems (VaMoS), pp. 123–130 (2010)
Rosenmüller, M., Apel, S., Leich, T., Saake, G.: Tailor-made data management for embedded systems: a case study on Berkeley DB. Data Knowl. Eng. 68(12), 1493–1512 (2009)
Rosenmüller, M., Siegmund, N., Apel, S., Saake, G.: Code generation to support static and dynamic composition of software product lines. In: Proceedings of the International Conference on Generative Programming and Component Engineering (GPCE), pp. 3–12. ACM Press, New York (2008)
Smaragdakis, Y., Batory, D.: Mixin layers: an object-oriented implementation technique for refinements and collaboration-based designs. ACM Trans. Softw. Eng. Methodol. 11(2), 215–255 (2002)
van Gurp, J., Bosch, J., Svahnberg, M.: On the notion of variability in software product lines. In: Proceedings of the Working Conference on Software Architecture (WICSA), pp. 45–55. IEEE Computer Society, Washington (2001)
Villazón, A., Binder, W., Ansaloni, D., Moret, P.: HotWave: creating adaptive tools with dynamic aspect-oriented programming in Java. In: Proceedings of the International Conference on Generative Programming and Component Engineering (GPCE), pp. 95–98. ACM Press, New York (2009)
Zdun, U.: Some patterns of component and language integration. In: Proceedings of the European Conference on Pattern Languages of Programs (EuroPlop), pp. 1–26. UVK Verlagsgesellschaft mbH, Konstanz (2004)
Zdun, U., Strembeck, M., Neumann, G.: Object-based and class-based composition of transitive mixins. Inf. Softw. Technol. 49(8), 871–891 (2007)
Author information
Authors and Affiliations
Corresponding author
Rights and permissions
About this article
Cite this article
Rosenmüller, M., Siegmund, N., Apel, S. et al. Flexible feature binding in software product lines. Autom Softw Eng 18, 163–197 (2011). https://doi.org/10.1007/s10515-011-0080-5
Received:
Accepted:
Published:
Issue Date:
DOI: https://doi.org/10.1007/s10515-011-0080-5