Extending the UML for modelling variability for system families

Silva Robak; Bogdan Franczyk; Silva Robak

International Journal of Applied Mathematics and Computer Science (2002)

  • Volume: 12, Issue: 2, page 285-298
  • ISSN: 1641-876X

Abstract

top
The process of modelling and developing commonality and variability for system families should be supported by suitable methods and notations. The object-oriented methods and their notations, which are used at present, focus on the development of a single system at a time. In this paper we analyse feature models as a representation of the common parts and variants contained in a system family, and propose using a feature diagram as a basic representation of commonality, variability and dependencies. We examine various approaches to customizing the standard modelling language UML to model system families and propose how to extend the UML for the purposes of modelling variants in object-oriented analysis and design techniques. We recommend the use of UML standard lightweight extensibility mechanisms (stereotypes combined with tagged values) without changing the UML metamodel. This enables us to join the advantages of feature models with UML and provides the traceability of a concept throughout system development. An application of lightweight UML extension mechanisms allows the existing standard UML modelling tools to be used without any adaptations. An example of an application illustrates our approach.

How to cite

top

Robak, Silva, Franczyk, Bogdan, and Robak, Silva. "Extending the UML for modelling variability for system families." International Journal of Applied Mathematics and Computer Science 12.2 (2002): 285-298. <http://eudml.org/doc/207588>.

@article{Robak2002,
abstract = {The process of modelling and developing commonality and variability for system families should be supported by suitable methods and notations. The object-oriented methods and their notations, which are used at present, focus on the development of a single system at a time. In this paper we analyse feature models as a representation of the common parts and variants contained in a system family, and propose using a feature diagram as a basic representation of commonality, variability and dependencies. We examine various approaches to customizing the standard modelling language UML to model system families and propose how to extend the UML for the purposes of modelling variants in object-oriented analysis and design techniques. We recommend the use of UML standard lightweight extensibility mechanisms (stereotypes combined with tagged values) without changing the UML metamodel. This enables us to join the advantages of feature models with UML and provides the traceability of a concept throughout system development. An application of lightweight UML extension mechanisms allows the existing standard UML modelling tools to be used without any adaptations. An example of an application illustrates our approach.},
author = {Robak, Silva, Franczyk, Bogdan, Robak, Silva},
journal = {International Journal of Applied Mathematics and Computer Science},
keywords = {UML extensibility mechanisms; system families; object-oriented software engineering; feature diagram; commonality and variability; UML},
language = {eng},
number = {2},
pages = {285-298},
title = {Extending the UML for modelling variability for system families},
url = {http://eudml.org/doc/207588},
volume = {12},
year = {2002},
}

TY - JOUR
AU - Robak, Silva
AU - Franczyk, Bogdan
AU - Robak, Silva
TI - Extending the UML for modelling variability for system families
JO - International Journal of Applied Mathematics and Computer Science
PY - 2002
VL - 12
IS - 2
SP - 285
EP - 298
AB - The process of modelling and developing commonality and variability for system families should be supported by suitable methods and notations. The object-oriented methods and their notations, which are used at present, focus on the development of a single system at a time. In this paper we analyse feature models as a representation of the common parts and variants contained in a system family, and propose using a feature diagram as a basic representation of commonality, variability and dependencies. We examine various approaches to customizing the standard modelling language UML to model system families and propose how to extend the UML for the purposes of modelling variants in object-oriented analysis and design techniques. We recommend the use of UML standard lightweight extensibility mechanisms (stereotypes combined with tagged values) without changing the UML metamodel. This enables us to join the advantages of feature models with UML and provides the traceability of a concept throughout system development. An application of lightweight UML extension mechanisms allows the existing standard UML modelling tools to be used without any adaptations. An example of an application illustrates our approach.
LA - eng
KW - UML extensibility mechanisms; system families; object-oriented software engineering; feature diagram; commonality and variability; UML
UR - http://eudml.org/doc/207588
ER -

References

top
  1. Arrango G. (1994): Domain Analysis Methods, In: Software Reusability (W. Schafer, R. Prieto-Di az and M. Matsumoto, Eds.). - New York: Ellis Horwood, pp. 17-49. 
  2. Bass I., Clements P. and Kazman R. (1998): Software Architecture in Practice. - New York: Addison-Wesley. 
  3. Boellert K. and Philippow I. (2000): Erfahrungen bei der objektorientierten Modellierung von Produktlinien mit FeatuRSEB. 1. - Deutscher Software-Produktlinien Workshop (DSPL-1), Kaiserslautern, IESE-Report No. 076.00E, pp. 29-34. 
  4. Booch G., Rumbaugh, J. and Jacobson I. (1999): The Unified Modeling Language User's Guide. - New York: Addison-Wesley. 
  5. Bosch J. (2000): Design and Use of Software Architectures. Adopting and Evolving Product-Line Approach. - New York: Addison-Wesley. 
  6. Breymann U. (1998): Designing Components with The C++ STL-A New Approach To Programming. - New York: Addison-Wesley. 
  7. Buschmann F., Meunier R., Rohnert H., Sommerlad P. and Stal M. (1996): Pattern-Oriented Software Architecture: A System of Patterns. - New York: John Wiley Sons. 
  8. Clements P. and Northrop L.M. (1999): A Framework for Software Product Line Practice - Version 2.0 [online]. - Pittsburgh, PA: Software Engineering Institute, Carnegie Mellon University, Available at t www.sei.cmu.eduplpframework.html 
  9. Coplien J. (1999): Multi-Paradigm Design for C++. - New York: Addison-Wesley. 
  10. Coriat M., Jourdan J. and Boisbourdin F. (2000): The SPLIT method building product lines for software-intensive systems, In: Proc. Software Product Line Conf. (SPLC1), (P. Donohoe, Ed.). - Massachusetts: The Kluwer Academic Publishers, pp. 147-166. 
  11. Czarnecki K. and Eisenecker U. (2000): Generative Programming Methods, Tools and Applications. - New York: Addison-Wesley. 
  12. DeBaud J.M. and Schmid K. (1999): A systematic approach to derive the Scope of Software Product Lines. - Proc. ICSE'99, Los Angeles, CA, pp. 34-43. 
  13. DeBaud J.M. (2000): The Truescope Approach to Software Product Family Engineering. - First Software Product Line Conference (SPLC1), Denver, USA. 
  14. Dijkstra E.W. (1972): Notes on Structured Programming, In: Structured Programming (O.J. Dahl, E.W. Dijkstra and C.A.R. Hoare, Eds.). - London: Academic Press. 
  15. Gamma E., Helm R., Johnson R. and Vlissides J. (1994): Design Patterns - Elements of Reusable Object-Oriented Software. - New York: Addison-Wesley. Zbl0887.68013
  16. Gomma H. (2000): Object oriented analysis and modeling for families of systems.- Proc. 6th Int. Conf. ICSR-6, Vienna, Austria, In: Software Reuse: Advances in Software Reusability (W.B. Frakes, Ed.), Berlin: Springer, pp. 89-99. 
  17. Griss M.L., Favaro J. and D'Alessandro M. (1998): Integrating Feature Modeling with the RSEB. - Proc. Int. Conf. Software Reuse, ICSR98, Victoria, BC, IEEE, pp. 36-44. 
  18. Griss M.L. (2000): Implementing product-line features with component reuse.- Proc. 6th Int. Conf. ICSR-6, Vienna, Austria, In: Software Reuse: Advances in Software Reusability (W.B. Frakes, Ed.), Berlin: Springer, pp. 137-152. 
  19. Hein A., Schlick M. and Vinga-Martins R. (2000): Applying feature models in industrial settings, In: Proc. Software Product Line Conf.(SPLC1), (P. Donohoe, Ed.). - Massachusetts: The Kluwer Academic Publishers, pp. 47-70. 
  20. Jacobson I., Griss M.L. and Jonnson P. (1997): Software Reuse: Architecture. - Process and Organization for Business Success, New York: Addison-Wesley Longman. 
  21. Jarzabek S. (2000): Product Line Approach. Net. ObjectDays 2000. -Proc. 2-nd Int.Symp. Generative and Component-Based Software Engineering, GCSE'2000, Erfurt, Germany, available at: http://www.netobjectdays.org/node00 
  22. Johnson R.E. (1997): Frameworks = (Components + Patterns). - Comm. ACM, Vol. 40, No. 10, pp. 39-42. 
  23. Kang K., Cohen S., Hess J., Nowak W. and Peterson S. (1990): Feature-oriented domain analysis (FODA). Feasibility study. - Technical Report No. CMUSEI-90-TR-21, Software Engineering Institute, Carnegie Mellon University, Pittsburgh, Pennsylvania. 
  24. Kiczales G., Lamping J., Mendhekar A., Maeda C., Lopes C.V., Loingtier J.M. and Irvin J. (1997): Aspect-Oriented Programming. - Proc. 11th European Conf. Object-Oriented Programming, ECOOP97, Jyvaskyla, Finland, (M. Aksit and S. Matsuoka, Eds.), Berlin: Springer-Verlag. 
  25. Kobryn C. (1999): UML 2001: A standarization Odyssey. - Comm. ACM, Vol. 42, No. 10, pp. 29-37. 
  26. Kruchten P. (1995): The 4+1 view model of architecture. -IEEE Software, Vol. 12, No. 6, pp. 42-50. 
  27. Kruchten P. (1998): The Rational Unified Process. - New York: Addison-Wesley Longman. 
  28. OMG (1997): Object Management Group, available at http://www.omg.org 
  29. OMG (1999): OMG Unified Modeling Language Specification (draft), V. 1.3, available at: www.rational.com/uml/resources/documentation/ (pdf-format). 
  30. Parnas D.L. (1976): On the design and development of program families. - IEEE Trans. Softw. Eng., March. Zbl0352.68032
  31. Rational (2002) - Available at: www.rational.com 
  32. Robak S. and Franczyk B. (2001): An object-oriented evolutional approach for developing system families using frameworks. - Studies in Automatics and Computer Science, Vol. 26, Poznań, pp. 179-189 (in Polish). 
  33. Szyperski C. (1998): Component Software: Beyond Object-Oriented Programming. - New York: Addison-Wesley. 
  34. Szyperski C. and Pfister C. (1997): Workshop on Component-Oriented Programming, Summary. - Special Issues on Object-Oriented Programming, ECOOP96 Workshop Reader (M. Muellhauser, Ed.), Heidelberg: dpunkt Verlag. 
  35. Vici A.D., Argentieri N., Mansour A., d'Alessandro M. and Favaro J. (1998): FODAcom: An Experience with Domain Analysis in the Italian Telecom Industry.- Proc. 6th Int. Conf., ICSR-6, Vienna, Austria, In: Software Reuse: Advances in Software Reusability (W.B. Frakes, Ed.), Berlin: Springer, pp. 166-175. 
  36. Voget S., Angilletta I., Herbst I. and Lutz P. (2000): Behandlung von Variabilitaeten in Produktlinien mit Schwerpunkt Architektur. - 1. Deutscher Software-Produktlinien Workshop (DSPL-1), Kaiserslautern, IESE-Report No. 076.00E, pp. 23-28. 
  37. Webster B. (1995): Pitfalls of Object-Oriented Development: A Guide to the Wary and the Enthusiastic. - New York: MT Books. 
  38. Weiss D.M. and Lai C.T.R. (1999): Software Product-Line Engineering: A Family Based Software Development Process. - New York: Addison-Wesley. 
  39. Withey J. (1996): Investment analysis of software assets for productlines. - Tech. Rep. No. CMUSEI-96-TR-010, ADA 315653. Pittsburgh, PA: Software Engineering Institute, Carnegie Mellon University. 

NotesEmbed ?

top

You must be logged in to post comments.

To embed these notes on your page include the following JavaScript code on your page where you want the notes to appear.

Only the controls for the widget will be shown in your chosen language. Notes will be shown in their authored language.

Tells the widget how many notes to show per page. You can cycle through additional notes using the next and previous controls.

    
                

                
Note: Best practice suggests putting the JavaScript code just before the closing </body> tag.