Advertisement

Implementing Product-Line Features with Component Reuse

  • Martin L. Griss
Part of the Lecture Notes in Computer Science book series (LNCS, volume 1844)

Abstract

In this paper, we show how the maturation of several technologies for product-line analysis and component design, implementation and customization provides an interesting basis for systematic product-line development. Independent work in the largely separate reuse (“domain analysis”) and OO (“code and design”) communities has reached the point where integration and rationalization of the activities could yield a coherent approach. We outline a proposed path from the set of common and variable features supporting a product-line, to the reusable elements to be combined into customized feature-oriented components and frameworks to implement the products.

Keywords

Code Fragment Software Reuse Component Reuse Standard Template Library Dagstuhl Seminar 
These keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Preview

Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.

References

  1. 1.
    Parnas, D.L.: On the criteria to be used in decomposing systems into modules. CACM 15(12), 1053–1058 (1972)Google Scholar
  2. 2.
    Parnas, D.L.: On the Design and Development Of Program Families. IEEE Transactions on Software Engineering 2(16), 1–9 (1976)CrossRefGoogle Scholar
  3. 3.
    Parnas, D.L.: Designing Software for Ease of Extension and Contraction. IEEE Trans-actions on Software Engineering 5(6), 310–320 (1979)Google Scholar
  4. 4.
    Bosch, J.: Product-Line Architectures and Industry: A Case Study. In: Proceedings of ICSE 1999, Los Angeles, California, USA, May 16-22, pp. 544–554. ACM press, New York (1999)Google Scholar
  5. 5.
    Arango, G.: Domain Analysis Methods. In: Schäfer, W., et al. (eds.) Software Reusability, Ellis Horwood, Hemel Hempstead, UK (1994)Google Scholar
  6. 6.
    Kang, K.C., et al.: Feature-Oriented Domain Analysis Feasibility Study, SEI Technical Report CMU/SEI-90-TR-21 (November 1990)Google Scholar
  7. 7.
    Griss, M., Favaro, J., d’Alessandro, M.: Integrating Feature Modeling with the RSEB. In: Proceedings of ICSR 1998, Victoria, BC, pp. 36–45. IEEE, Los Alamitos (1998)Google Scholar
  8. 8.
    Kang, K.C., et al.: FORM: A feature-oriented reuse method with domain-specific architectures. Annals of Software Engineering 5, 143–168 (1998)CrossRefGoogle Scholar
  9. 9.
    Kang, K.C.: Feature-oriented Development of Applications for a Domain. In: Proceedings of Fifth International Conference on Software Reuse, Victoria, British Columbia, Canada, June 2-5, pp. 354–355. IEEE computer society press, Los Alamitos (1998)Google Scholar
  10. 10.
    Kang, K.C., Kim, S., Lee, J., Lee, K.: Feature-oriented Engineering of PBX Software for Adaptability and Reusability. Software - Practice and Experience 29(10), 875–896 (1999)CrossRefGoogle Scholar
  11. 11.
    Jacobson, I., Griss, M., Jonsson, P.: Software Reuse: Architecture, Process and Organi-zation for Business Success. Addison-Wesley-Longman, Reading (1997)Google Scholar
  12. 12.
    Booch, G., Rumbaugh, J., Jacobson, I.: The Unified Modeling Language: User Guide. Addison-Wesley-Longman, Reading (1999)Google Scholar
  13. 13.
    Gamma, E., Helm, R., Johnson, R., Vlissides, J.: Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley, Reading (1994)Google Scholar
  14. 14.
    Buschmann, F., et al.: Pattern-Oriented Software Architecture - A System of Patterns. John Wiley & sons, Chichester (1996)Google Scholar
  15. 15.
    Kiczales, G., Ashley, J.M., Rodriguez, L., Vahdat, A., Bobrow, D.G.: Metaobject protocols: Why we want them and what else they can do. In: Paepcke, A. (ed.) Object- Oriented Programming: The CLOS Perspective, pp. 101–118. The MIT Press, Cambridge (1993)Google Scholar
  16. 16.
    Goguen, J.A.: Parameterized Programming. IEEE Trans. Software Eng. SE-10(5), 528–543 (1984)CrossRefGoogle Scholar
  17. 17.
    Kiczales, G., des Rivières, J., Bobrow, D.G.: The Art of the Metaobject Protocol. MIT Press, Cambridge (1991)Google Scholar
  18. 18.
    Garlan, D., Shaw, M.: Software Architecture, Perspectives on an Emerging Discipline. Prentice-Hall, Englewood Cliffs (1996)Google Scholar
  19. 19.
    Musser, D.R., Stepanov, A.A.: Algorithm-Oriented Generic Libraries. Software Practice and Experience 24(7) (1994)Google Scholar
  20. 20.
    Musser, D.R., Saini, A.: STL Tutorial and Reference Guide. Addison-Wesley, Reading (1996)Google Scholar
  21. 21.
    Batory, D., O’Malley, S.: The design and implementation of hierarchical software systems with reusable components. ACM Transactions on Software Engineering and Methodology 1(4), 355–398 (1992)CrossRefGoogle Scholar
  22. 22.
    Dehnert, J., Stepanov, A.: Fundamentals of Generic Programming. In: Proc. Dagstuhl Seminar on Generic Programming. Schloß Dagstuhl, Wadern (April 27- May 1, 1998)Google Scholar
  23. 23.
    Jazayeri, M.: Evaluating Generic Programming in Practice. In: Proc. Dagstuhl Seminar on Generic Programming. Schloß Dagstuhl, Wadern (April 27- May 1, 1998)Google Scholar
  24. 24.
    Van Hilst, M., Notkin, D.: Using C++ Templates to Implement Role-Based Designs. In: JSSST Symposium on Object technologies for Advanced Software, pp. 22–37. Springer, Heidelberg (1996)Google Scholar
  25. 25.
    Van Hilst, M., Notkin, D.: Using Role Components to Implement Collaboration-Based Designs. In: Proc. OOPSLA 1996, pp. 359–369 (1996)Google Scholar
  26. 26.
    Van Hilst, M., Notkin, D.: Decoupling Change From Design. ACM SIGSOFT (1996)Google Scholar
  27. 27.
    Czarnecki, K., Eisenecker, U.W.: Components and Generative Programming. In: Nierstrasz, O., Lemoine, M. (eds.) ESEC 1999 and ESEC-FSE 1999. LNCS, vol. 1687, p. 2. Springer, Heidelberg (1999)CrossRefGoogle Scholar
  28. 28.
    Czarnecki, K., Eisenecker, U.W.: Template-Metaprogramming. Available at, http://home.t-online.de/home/Ulrich.Eisenecker/meta.htm
  29. 29.
    Eisenecker, U.: Generative Programming: Beyond Generic Programming. In: Proc. Dagstuhl Seminar on Generic Programming. Schloß Dagstuhl, Wadern (April 27- May 1, 1998)Google Scholar
  30. 30.
    Bassett, P.G.: Framing Reuse: Lessons from the Real World. Prentice Hall, Englewood Cliffs (1996)Google Scholar
  31. 31.
    Tarr, P., Ossher, H., Harrison, W., Sutton Jr., S.M.: N degrees of Separation: Multidimensional separation of concerns. In: Proc. ICSE 1999, pp. 107–119. IEEE/ACM press (1999)Google Scholar
  32. 32.
    Lopes, C.V., Kiczales, G.: Recent Developments in AspectJTM. In: Demeyer, S., Bosch, J. (eds.) ECOOP 1998 Workshops. LNCS, vol. 1543, pp. 398–401. Springer, Heidelberg (1998)CrossRefGoogle Scholar
  33. 33.
    Harrison, W., Ossher, H.: Subject-Oriented Programming (a critique of pure objects). In: Proc. OOPSLA 1993, Washington, DC, pp. 411–428. ACM, New York (1993)CrossRefGoogle Scholar
  34. 34.
    Batory, D.: Subjectivity and GenVoca Generators. In: Proc. ICSR 1996, Orlando, FLA, pp. 166–175. IEEE, Los Alamitos (1996)Google Scholar
  35. 35.
    Lieberherr, K.J., Xiao, C.: Object-oriented Software Evolution. IEEE Transactions on Software Engineering 19(4), 313–343 (1993)CrossRefGoogle Scholar
  36. 36.
    Kiczales, G., Lamping, J., Mendhekar, A., Maeda, C., Loitinger, L., Irwin, J.: Aspect Oriented Programming. In: Aksit, M., Matsuoka, S. (eds.) ECOOP 1997. LNCS, vol. 1241, pp. 220–242. Springer, Heidelberg (1997)CrossRefGoogle Scholar
  37. 37.
    Akşit, M., Bergmans, L., Vural, S.: An Object Oriented Language-Database Integration Model: the Composition-Filters Approach. In: Lehrmann Madsen, O. (ed.) ECOOP 1992. LNCS, vol. 615, pp. 372–395. Springer, Heidelberg (1992)CrossRefGoogle Scholar
  38. 38.
    Akşit, M.: Composition and Separation of Concerns in the Object-Oriented Model. ACM Computing Surveys 28A(4) (December 1996)Google Scholar
  39. 39.
    Smaragdakis, Y., Batory, D.: Implementing Reusable Object-Oriented Components. In: Proc. of ICSR 1998, Victoria, BC, pp. 36–45 (June 1998)Google Scholar
  40. 40.
    Smaragdakis, Y., Batory, D.: Implementing Layered Designs with Mixin Layers. In: Jul, E. (ed.) ECOOP 1998. LNCS, vol. 1445, p. 550. Springer, Heidelberg (1998)CrossRefGoogle Scholar
  41. 41.
    Smaragdakis, Y.: Reusable Object-Oriented Components. In: Proceedings of Ninth Annual Workshop on Software Reuse, Austin, Texas, January 7-9 (1999)Google Scholar
  42. 42.
    Cardone, R.: On the Relationship of Aspect Oriented Programming and GenVoca. In: Proc. WISR, Austin Texas (1999)Google Scholar
  43. 43.
    Mezini, M., Lieberherr, K.: Adaptive Plug-and-Play Components for Evolutionary Software Development. In: Proceedings of OOPSLA 1998, pp. 97–116 (1998)Google Scholar
  44. 44.
    Walker, R.J., Banniassad, E.L.A., Murphy, G.C.: An Initial Assessment of Aspect Oriented Programming. In: Proc. ICSE 1999, pp. 120–130. IEEE, Las Angeles (1999)Google Scholar
  45. 45.
    Clarke, S., Harrison, W., Ossher, H., Tarr, P.: Towards Improved Alignment of Requirements, Design and Code. In: Proceedings of OOPSLA 1999, pp. 325–339. ACM, New York (1999)CrossRefGoogle Scholar
  46. 46.
    Johnson, R., Foote, B.: Designing reusable classes. Journal of Object-Oriented Pro-gramming 35, 22–30 (1988)Google Scholar
  47. 47.
    Garlan, D., Allen, R., Ockerbloom, J.: Architectural mismatch, or Why it’s hard to build systems out of existing parts. In: Proc. ICSE (1995)Google Scholar

Copyright information

© Springer-Verlag Berlin Heidelberg 2000

Authors and Affiliations

  • Martin L. Griss
    • 1
  1. 1.Hewlett-Packard Company, LaboratoriesPalo AltoUSA

Personalised recommendations