Pattern-based tool support for frameworks towards architecture-oriented software development environment

Software engineering aims at techniques for producing better software products with less resources. A central concept for achieving this goal is a product line architecture. Frameworks are a popular object-oriented way to implement product line architectures. However, frameworks are often difficult to learn and their specializations consist of small and crosscutting logical entities that overlap with other design solutions of the software product. Implementation becomes fragmented, difficult to trace, and the original reasoning of the design is easily forgotten. Thus, the essential problems to be solved are the following: • How to teach the software developer to understand different frameworks and design principles in the context of her software product? • How to guide the software developer to use frameworks and product line architectures? • How to maintain and document implemented design solutions and framework specializations? In this dissertation it is argued that a practical pattern-based approach can be used to support the software developer to learn, implement, and sustain design solutions in her software project. Instructions, like how to use a particular framework, can be given as simple pattern specifications; a tool takes these specifications as input and generates tasks as output. The generated programming tasks will guide the software developer to gradually instantiate the patterns, repair possible violations, and in that way to adopt and maintain the design. Integrating the pattern-based tool support with a common software development environment makes that environment architecture-oriented in terms of the patterns used. The main contributions of this dissertation are the following: • Participation in the development of the Fred/JavaFrames tool concept. • A description of a general pattern-based tool support that allows the use of the pattern concept in different software development environments, making the environment architecture-oriented. • Integration of such a tool platform into the Eclipse environment. • A goal-oriented process to use the pattern-based tool support to specialize frameworks. • A specification of the extension interface of the tool platform using the tool itself. • An evaluation of the pattern-based approach for framework engineering using case studies.

[1]  Stanley M. Sutton,et al.  Modeling of software concerns in Cosmos , 2002, AOSD '02.

[2]  Petri Selonen,et al.  Establishing a software architecting environment , 2004, Proceedings. Fourth Working IEEE/IFIP Conference on Software Architecture (WICSA 2004).

[3]  Wolfgang Pree,et al.  Meta Patterns - A Means For Capturing the Essentials of Reusable Object-Oriented Design , 1994, ECOOP.

[4]  Marcelo R. Campo,et al.  Assisting the Development of Aspect-Based Multi-agent Systems Using the Smartweaver Approach , 2002, SELMAS.

[5]  Kai Koskimies,et al.  Generating Pattern-Based Web Tutorials for Java Frameworks , 2002, FIDJI.

[6]  Peter Kilpatrick,et al.  A Relational Architecture Description Language for Software Families , 2003, PFE.

[7]  Linda Rising,et al.  The Pattern Almanac 2000 , 2000 .

[8]  G. A. Miller.  THE PSYCHOLOGICAL REVIEW THE MAGICAL NUMBER SEVEN, PLUS OR MINUS TWO: SOME LIMITS ON OUR CAPACITY FOR PROCESSING INFORMATION 1 , 1956 .

[9]  Jeff Conklin,et al.  Hypertext: An Introduction and Survey , 1987, Computer.

[10]  Neil B. Harrison,et al.  Organizational Patterns of Agile Software Development , 2004 .

[11]  Roy H. Campbell,et al.  Monitoring compliance of a software system with its high-level design models , 1996, Proceedings of IEEE 18th International Conference on Software Engineering.

[12]  Mary Shaw,et al.  Software architecture - perspectives on an emerging discipline , 1996 .

[13]  Ivar Jacobson,et al.  The Unified Software Development Process , 1999 .

[14]  Jason E. Robbins,et al.  Extending design environments to software architecture design , 1996, Proceedings of the 11th Knowledge-Based Software Engineering Conference.

[15]  Kai Koskimies,et al.  Architecture-oriented programming using FRIED , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

[16]  Imed Hammouda,et al.  Managing Variability Using Heterogeneous Feature Variation Patterns , 2005, FASE.

[17]  Christopher Alexander,et al.  A New Theory of Urban Design , 1991 .

[18]  Paul Clements,et al.  Software architecture in practice , 1999, SEI series in software engineering.

[19]  Peter Sommerlad,et al.  Pattern-Oriented Software Architecture: A System of Patterns: John Wiley & Sons , 1987 .

[20]  Imed Hammouda,et al.  Tool-supported customization of UML class diagrams for learning complex system models , 2004, Proceedings. 12th IEEE International Workshop on Program Comprehension, 2004..

[21]  Krzysztof Czarnecki,et al.  Generative programming - methods, tools and applications , 2000 .

[22]  Paul G. Sorenson,et al.  Requirements for a Hooks Tool , 1998 .

[23]  James H. Cross,et al.  Reverse engineering and design recovery: a taxonomy , 1990, IEEE Software.

[24]  Ivar Jacobson,et al.  The Unified Modeling Language User Guide , 1998, J. Database Manag..

[25]  Tzilla Elrad,et al.  Designing an aspect-oriented framework in an object-oriented environment , 2000, CSUR.

[26]  Ralph Johnson,et al.  A framework for network protocol software , 1995, OOPSLA.

[27]  D. M. Hutton,et al.  Process Patterns: Building Large‐Scale Systems Using Object Technology , 1999 .

[28]  Juha Hautamäki,et al.  Task-Driven Framework Specialization: Goal-Oriented Approach , 2002 .

[29]  Bonnie Lee Appleton.  Patterns and Software: Essential Concepts and Terminology , 1997 .

[30]  Markku Hakala,et al.  Feature Models, Pattern Languages and Software Patterns: Towards a Unified Approach , 2002 .

[31]  Ralph E. Johnson,et al.  Frameworks = (components + patterns) , 1997, CACM.

[32]  Jan Bosch,et al.  Design and use of software architectures - adopting and evolving a product-line approach , 2000 .

[33]  John M. Vlissides,et al.  Automatic Code Generation from Design Patterns , 1996, IBM Syst. J..

[34]  Marcelo Campo,et al.  An Empirical Study About Separation of Concerns Approaches , 2002 .

[35]  David Garlan,et al.  Software architecture: a roadmap , 2000, ICSE '00.

[36]  S. Mohan,et al.  Performance Solutions: A Practical Guide to Creating Responsive, Scalable Software [Book Review] , 2003, IEEE Software.

[37]  Theo D'Hondt,et al.  Reasoning with Design Knowledge for Interactively Supporting Framework Reuse , 2001 .

[38]  Brian Foote,et al.  Designing Reusable Classes , 2001 .

[39]  Hanspeter Mössenböck,et al.  Designing a Framework by Stepwise Generalization , 1995, ESEC.

[40]  Alexander Egyed,et al.  Integrating COTS Software into Systems through Instrumentation and Reasoning , 2006, Automated Software Engineering.

[41]  Kai Koskimies,et al.  TASK-DRIVEN SPECIALIZATION SUPPORT FOR OBJECT-ORIENTED FRAMEWORKS , 2000 .

[42]  Gerard G. Meszaros,et al.  A pattern language for pattern writing , 1997 .

[43]  Dennis Heimbigner,et al.  Capturing Architectural Configurability: Variants, Options, and Evolution , 1999 .

[44]  Alexander L. Wolf,et al.  Acm Sigsoft Software Engineering Notes Vol 17 No 4 Foundations for the Study of Software Architecture , 2022 .

[45]  Robert W. Sebesta,et al.  Concepts of programming languages , 1973 .

[46]  James O. Coplien,et al.  A generative development-process pattern language , 1995 .

[47]  Robert Martin.  Discovering patterns in existing applications , 1995 .

[48]  Martin Fowler,et al.  Analysis patterns - reusable object models , 1996, Addison-Wesley series in object-oriented software engineering.

[49]  Jan Bosch,et al.  On the notion of variability in software product lines , 2001, Proceedings Working IEEE/IFIP Conference on Software Architecture.

[50]  Bernhard Rumpe,et al.  UML-F: A Modeling Language for Object-Oriented Frameworks , 2000, ECOOP.

[51]  Axel van Lamsweerde,et al.  Formal specification: a roadmap , 2000, ICSE '00.

[52]  Alfonso Fuggetta,et al.  Software process: a roadmap , 2000, ICSE '00.

[53]  Serge Demeyer,et al.  Making design patterns explicit in FACE: a frame work adaptive composition environment , 1997, ESEC '97/FSE-5.

[54]  Peter Sommerlad,et al.  Active Guidance of Framework Development , 1995, Softw. Concepts Tools.

[55]  John Millar Carroll.  The Nurnberg Funnel: Designing Minimalist Instruction for Practical Computer Skill , 1990 .

[56]  Eila Niemelä,et al.  Tool support for traceable product evolution , 2004, Eighth European Conference on Software Maintenance and Reengineering, 2004. CSMR 2004. Proceedings..

[57]  Gregor Kiczales,et al.  Aspect-oriented programming , 2001, ESEC/FSE-9.

[58]  Ivar Jacobson,et al.  The unified modeling language reference manual , 2010 .

[59]  Stephen Travis Pope,et al.  A cookbook for using the model-view controller user interface paradigm in Smalltalk-80 , 1988 .

[60]  Dirk Riehle,et al.  Framework Design: A Role Modeling Approach , 2000, Softwaretechnik-Trends.

[61]  Mohamed Fayad,et al.  Achieving bottom-line improvements with enterprise frameworks , 1998, CACM.

[62]  Paul G. Sorenson,et al.  Hooking into Object-Oriented Application Frameworks , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[63]  L J D'Errico.  Patterns from practice. , 1984, Journal of the American Dental Association.

[64]  Wolfgang Pree,et al.  Design Patterns for Object-Oriented Software Development , 1994, Proceedings of the (19th) International Conference on Software Engineering.

[65]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

[66]  Dirk Riehle,et al.  Pattern Languages of Program Design 3 , 1997 .

[67]  Roy H. Campbell,et al.  Choices, frameworks and refinement , 1991, Proceedings 1991 International Workshop on Object Orientation in Operating Systems.

[68]  Hany H. Ammar,et al.  POD: a composition environment for pattern-oriented design , 2000, Proceedings. 34th International Conference on Technology of Object-Oriented Languages and Systems - TOOLS 34.

[69]  Amnon H. Eden,et al.  A Theory of Object-Oriented Design , 2002, Inf. Syst. Frontiers.

[70]  Jukka Viljamaa,et al.  Tools Supporting the Use of Design Patterns in Frameworks , 1997 .

[71]  Christopher Alexander,et al.  A New Theory of Urban Design , 1989 .

[72]  Jim Welsh,et al.  Towards pattern-based design recovery , 2002, ICSE '02.

[73]  J. C. Wortmann,et al.  Development and Evolution of Software Architectures for Product Families , 1998, Lecture Notes in Computer Science.

[74]  Imed Hammouda.  A Tool Infrastructure for Model-Driven Development Using Aspectual Patterns , 2005, Model-Driven Software Development.

[75]  William G. Griswold,et al.  The design of whole-program analysis tools , 1996, Proceedings of IEEE 18th International Conference on Software Engineering.

[76]  Amnon H Eden.  A VISUAL FORMALISM FOR OBJECT-ORIENTED ARCHITECTURE , 2002 .

[77]  Danny B. Lange,et al.  Interactive visualization of design patterns can help in framework understanding , 1995, OOPSLA.

[78]  Harold Ossher,et al.  Software engineering tools and environments: a roadmap , 2000, ICSE '00.

[79]  Kevin Benner,et al.  An Experience Using Design Patterns: Lessons Learned and Tool Support , 1996, Theory Pract. Object Syst..

[80]  Kyle G. Brown,et al.  Design reverse-engineering and automated design-pattern detection in Smalltalk , 1996 .

[81]  Harold Ossher,et al.  Subject-oriented programming: a critique of pure objects , 1993, OOPSLA '93.

[82]  Jan Bosch,et al.  Design Erosion: Problems & Causes , 2001 .

[83]  Tommi Mikkonen,et al.  Design Templates for Collective Behavior , 2000, ECOOP.

[84]  Christopher Alexander,et al.  The production of houses , 1985 .

[85]  Arie van Deursen,et al.  Feature-Based Product Line Instantiation Using Source-Level Packages , 2002, SPLC.

[86]  I. Hammouda,et al.  A tool environment for aspectual patterns in UML , 2004, ICSE 2004.

[87]  Jiri Soukup,et al.  Implementing patterns , 1995 .

[88]  Ivar Jacobson,et al.  Software Reuse: Architecture, Process And Organization For Business Success , 1998, Proceedings. Technology of Object-Oriented Languages. TOOLS 26 (Cat. No.98EX176).

[89]  Ralph E. Johnson,et al.  Patterns Generate Architectures , 1994, ECOOP.

[90]  Raheel Ahmad,et al.  Expert Systems: Principles and Programming , 2006, Scalable Comput. Pract. Exp..

[91]  Scott W. Ambler,et al.  Process patterns: building large-scale systems using object technology , 1998 .

[92]  Christopher Alexander,et al.  The Timeless Way of Building , 1979 .

[93]  Jan Bosch,et al.  Design Patterns as Language Constructs , 1998, J. Object Oriented Program..

[94]  Tommi Mikkonen,et al.  Practical perspectives on software architectures, high-level design, and evolution , 2001, IWPSE '01.

[95]  Günther Ruhe.  Methodological contributions to professional education and training , 2000, Proceedings 24th Annual International Computer Software and Applications Conference. COMPSAC2000.

[96]  Ralph E. Johnson,et al.  Documenting frameworks using patterns , 1992, OOPSLA '92.

[97]  Klaus Quibeldey-Cirkel,et al.  Using Patterns for Design and Documentation , 1997, ECOOP.

[98]  Kai Koskimies,et al.  Generating Application Development Environments for Java Frameworks , 2001, GCSE.

[99]  Jason E. Robbins,et al.  Cognitive support features for software development tools , 1999 .

[100]  Marcelo R. Campo,et al.  Towards agent-oriented assistance for framework instantiation , 2000, OOPSLA '00.

[101]  Rudolf K. Keller,et al.  Pattern-based reverse-engineering of design components , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[102]  James Coplien,et al.  Advanced C++ Programming Styles and Idioms , 1991, Proceedings. Technology of Object-Oriented Languages and Systems, TOOLS 25 (Cat. No.97TB100239).

[103]  Amnon H. Eden,et al.  Objectives , 1975 .

[104]  Safei El-Deen Hamed,et al.  A NEW THEORY OF URBAN DESIGN , 1989, Landscape Journal.

[105]  Thomas J. Mowbray,et al.  AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis , 1998 .

[106]  Tommi Mikkonen,et al.  Formalizing design patterns , 1998, Proceedings of the 20th International Conference on Software Engineering.

[107]  Linda Rising,et al.  The Pattern Almanac , 2000 .

[108]  Mary Shaw,et al.  Software architecture: the next step for object technology (panel) , 1993, OOPSLA '93.

[109]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[110]  D. Schmidt,et al.  Applying Design Patterns and Frameworks to Develop Object-Oriented Communication Software , 1997 .

[111]  A. Hoek.  Capturing Product Line Architectures , 2000 .

[112]  James O. Coplien,et al.  Pattern languages of program design , 1995 .

[113]  Rob C. van Ommering.  Koala, a Component Model for Consumer Electronics Product Software , 1998, ESPRIT ARES Workshop.

[114]  Dirk Riehle.  Composite design patterns , 1997, OOPSLA '97.

[115]  Kyo Chul Kang,et al.  Feature-Oriented Domain Analysis (FODA) Feasibility Study , 1990 .

[116]  Mehdi Jazayeri,et al.  Software Architecture for Product Families: Principles and Practice , 2000 .

[117]  J. Craig Cleaveland.  Program Generators with XML and Java , 2001 .

[118]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[119]  Douglas C. Schmidt,et al.  Patterns, frameworks, and middleware: their synergistic relationships , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[120]  Marco Meijers,et al.  Tool Support for Object-Oriented Patterns , 1997, ECOOP.

[121]  Tommi Mikkonen,et al.  Adaptable concern-based framework specialization in UML , 2004, Proceedings. 19th International Conference on Automated Software Engineering, 2004..

[122]  Don Roberts,et al.  Evolving Frameworks A Pattern Language for Developing Object-Oriented Frameworks , 2004 .

[123]  Paul Clements,et al.  Software product lines - practices and patterns , 2001, SEI series in software engineering.

[124]  Bernhard Rumpe,et al.  Product Line Annotations with UML-F , 2002, SPLC.

[125]  Wolfgang Pree.  Framelets—small is beautiful , 1999 .

[126]  Wolfgang Goebl.  A Survey and a Categorization Scheme of Automatic Programming Systems , 1999, GCSE.

[127]  Marcelo R. Campo,et al.  SmartBooks: a step beyond active-cookbooks to aid in framework instantiation , 1999, Proceedings Technology of Object-Oriented Languages and Systems. TOOLS 29 (Cat. No.PR00275).

[128]  Christopher Alexander.  The Linz Café , 1981 .

[129]  Douglas C. Schmidt,et al.  Software patterns , 1996, CACM.

[130]  Imed Hammouda,et al.  Generating a pattern-based application development environment for Enterprise JavaBeans , 2002, Proceedings 26th Annual International Computer Software and Applications.

[131]  Giuliano Antoniol,et al.  Object oriented design pattern inference , 1999, Proceedings IEEE International Conference on Software Maintenance - 1999 (ICSM'99). 'Software Maintenance for Business Change' (Cat. No.99CB36360).

[132]  Jukka Viljamaa,et al.  Applying Formal Concept Analysis to Extract Framework Reuse Interface Specifications from Source Code , 2004 .

[133]  Doug Lea,et al.  Christopher Alexander: an introduction for object-oriented designers , 1998, SOEN.

[134]  L. G. Pawlson.  The Oregon Experiment , 1991, Journal of the American Geriatrics Society.

[135]  David Garlan,et al.  Architectural Mismatch or Why it's hard to build systems out of existing parts , 1995, 1995 17th International Conference on Software Engineering.

[136]  Oscar Nierstrasz,et al.  Design Guidelines for Tailorable Frameworks , 1997 .

[137]  Max Jacobson,et al.  A Pattern Language: Towns, Buildings, Construction , 1981 .

[138]  Jukka Viljamaa,et al.  Reverse engineering framework reuse interfaces , 2003, ESEC/FSE-11.

[139]  Walter Zimmer,et al.  Relationships between design patterns , 1995 .