Architectural design decisions

A software architecture can be considered as the collection of key decisions concerning the design of the software of a system. Knowledge about this design, i.e. architectural knowledge, is key for understanding a software architecture and thus the software itself. Architectural knowledge is mostly tacit; it only exists in the heads of the creators. A problem is that this type of knowledge is easily lost. This phenomenon is called architectural knowledge vaporization and contributes to a number of problems that the industry is struggling with: expensive system evolution, difficult stakeholder communication, and limited reusability. The central theme of this thesis is how to reduce this vaporization of architectural knowledge. The focus is on one important form of architectural knowledge: architectural design decisions. This form is important, as the architecting process is all about making these key decisions. To reduce vaporization, this thesis explores a codification solution, in which these decisions are documented and modeled. For codification, the concepts one wants to codify must be understood well. To this end, a conceptual model of architectural design decisions is presented that explains the parts that this concept is made of and how it relates to other concepts. Based on this model, two approaches have been developed. The first, the Archium approach, is used for codifying, managing, and maintaining architectural design decisions in a forward engineering setting. The second approach is the Architectural Design Decision Recovery Approach (ADDRA) for recovering architectural design decisions in a reverse engineering setting. The Archium approach is evaluated in two ways. First, a study of how Archium deals with common use-cases for managing architectural knowledge is presented. Second, to address the issue of expensive system evolution, the Archium tool is compared with other tools using an evaluation framework. To evaluate ADDRA, the approach is applied on a case study. Both ADDRA and Archium help the architect with codifying architectural design decisions. This codification has two important consequences for software architecting. First, design decisions become explicit bridges between design and rationale. Second, once codified, a software architecture can be seen as set of architectural (design) decisions. Both consequences put a software architecture into a new perspective and deepen our understanding about what software architecting is all about and they also help to reduce architectural knowledge vaporization. As future work, we plan to investigate other types of architectural knowledge and their relationship to architectural design decisions.

[1]  Muhammad Ali Babar,et al.  A Survey of the Use and Documentation of Architecture Design Rationale , 2005, 5th Working IEEE/IFIP Conference on Software Architecture (WICSA'05).

[2]  Jaejoon Lee,et al.  FORM: A feature-;oriented reuse method with domain-;specific reference architectures , 1998, Ann. Softw. Eng..

[3]  David Lorge Parnas,et al.  A Rational Design Process: How and Why to Fake It , 1985, TAPSOFT, Vol.2.

[4]  Zhenyu Wang,et al.  ACCA: An Architecture-Centric Concern Analysis Method , 2005, 5th Working IEEE/IFIP Conference on Software Architecture (WICSA'05).

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

[6]  Marija Mikic-Rakic,et al.  Mae---a system model and environment for managing architectural evolution , 2004, TSEM.

[7]  William G. Griswold,et al.  An Overview of AspectJ , 2001, ECOOP.

[8]  Trygve Reenskaug,et al.  Working with objects - the OOram software engineering method , 1995 .

[9]  Robert L. Nord,et al.  Generalizing a Model of Software Architecture Design from Five Industrial Approaches , 2005, 5th Working IEEE/IFIP Conference on Software Architecture (WICSA'05).

[10]  Krzysztof Czarnecki,et al.  Overview of Generative Software Development , 2004, UPP.

[11]  Darcy Wiborg Weber Change Sets Versus Change Packages: Comparing Implementations of Change-Based SCM , 1997, SCM.

[12]  Venkataraman Ramesh,et al.  Research in software engineering: an analysis of the literature , 2002, Inf. Softw. Technol..

[13]  M. Broy Automotive software and systems engineering , 2005, Proceedings. Second ACM and IEEE International Conference on Formal Methods and Models for Co-Design, 2005. MEMOCODE '05..

[14]  Gul A. Agha,et al.  ACTORS - a model of concurrent computation in distributed systems , 1985, MIT Press series in artificial intelligence.

[15]  M. E. Conway HOW DO COMMITTEES INVENT , 1967 .

[16]  Philippe Kruchten,et al.  Casting software design in the function-behavior-structure framework , 2005, IEEE Software.

[17]  Richard C. Holt,et al.  ACCD: an algorithm for comprehension-driven clustering , 2000, Proceedings Seventh Working Conference on Reverse Engineering.

[18]  Patricia Lago,et al.  Explicit assumptions enrich architectural models , 2005, Proceedings. 27th International Conference on Software Engineering, 2005. ICSE 2005..

[19]  Remco C. de Boer,et al.  In search of `architectural knowledge' , 2008, SHARK '08.

[20]  David C. Brown,et al.  AN INTEGRATED APPROACH FOR SOFTWARE DESIGN CHECKING USING DESIGN RATIONALE , 2004 .

[21]  Thomas P. Moran,et al.  Questions, Options, and Criteria: Elements of Design Space Analysis , 1991, Hum. Comput. Interact..

[22]  Philippe Kruchten,et al.  An Ontology of Architectural Design Decisions in Software-Intensive Systems , 2004 .

[23]  Alexander L. Wolf,et al.  A conceptual basis for feature engineering , 1999, J. Syst. Softw..

[24]  Jan Bosch,et al.  Documenting after the fact: Recovering architectural design decisions , 2008, J. Syst. Softw..

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

[26]  Jan Bosch,et al.  Software Architecture: The Next Step , 2004, EWSA.

[27]  Richard N. Taylor,et al.  A Component- and Message-Based Architectural Style for GUI Software , 1995, 1995 17th International Conference on Software Engineering.

[28]  Mark Klein,et al.  Capturing design rationale in concurrent engineering teams , 1993, Computer.

[29]  Erwin Fielt,et al.  Scenarios for the identification of objects in legacy systems , 1997, Proceedings of the Fourth Working Conference on Reverse Engineering.

[30]  Bruria Haberman,et al.  Research methods in computing: what are they, and how should we teach them? , 2006, ACM SIGCSE Bull..

[31]  Martin L. Griss,et al.  Integrating feature modeling with the RSEB , 1998, Proceedings. Fifth International Conference on Software Reuse (Cat. No.98TB100203).

[32]  Philippe Kruchten,et al.  Building Up and Reasoning About Architectural Knowledge , 2006, QoSA.

[33]  Björn Regnell,et al.  Is a Design Rationale Vital when Predicting Change Impact? A Controlled Experiment on Software Architecture Evolution , 2000, PROFES.

[34]  Muhammad Ali Babar,et al.  A survey of architecture design rationale , 2006, J. Syst. Softw..

[35]  Yann-Gaël Guéhéneuc A systematic study of UML class diagram constituents for their abstract and precise recovery , 2004, 11th Asia-Pacific Software Engineering Conference.

[36]  David De Roure,et al.  Ontological Mediation of Meeting Structure: Argumentation, Annotation, and Navigation , 2003 .

[37]  Vasant Dhar,et al.  Supporting Systems Development by Capturing Deliberations During Requirements Engineering , 1992, IEEE Trans. Software Eng..

[38]  Robert L. Nord,et al.  Global Analysis: moving from software requirements specification to structural views of the software architecture , 2005, IEE Proc. Softw..

[39]  William C. Regli,et al.  A Survey of Design Rationale Systems: Approaches, Representation, Capture and Retrieval , 2000, Engineering with Computers.

[40]  Glenn J. Browne,et al.  Conceptual foundations of design problem solving , 1993, IEEE Trans. Syst. Man Cybern..

[41]  Paris Avgeriou,et al.  Using Architectural Decisions , 2006 .

[42]  Caspar Boekhoudt The Big Bang Theory of IDEs , 2003, ACM Queue.

[43]  Loe Feijs,et al.  A relational approach to support software architecture analysis , 1998 .

[44]  Frantisek Plasil,et al.  Software Connectors and their Role in Component Deployment , 2001, DAIS.

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

[46]  Muhammad Ali Babar,et al.  A Framework for Supporting Architecture Knowledge and Rationale Management , 2006 .

[47]  Kuntz Werner,et al.  Issues as Elements of Information Systems , 1970 .

[48]  Dirk Riehle,et al.  Role model based framework design and integration , 1998, OOPSLA '98.

[49]  Christian Prehofer An Object-Oriented Approach to Feature Interaction , 1997, FIW.

[50]  Bedir Tekinerdogan,et al.  Special issue on Early aspects: aspect-oriented requirements engineering and architecture design , 2004, IEE Proc. Softw..

[51]  S. Sarkar,et al.  EAML - architecture modeling language for enterprise applications , 2004, IEEE International Conference on E-Commerce Technology for Dynamic E-Business.

[52]  Jos Nijhuis,et al.  Design Decisions: The Bridge between Rationale and Architecture , 2006 .

[53]  Michael L. Begeman,et al.  gIBIS: A tool for all reasons , 1989, JASIS.

[54]  Matthias Jarke,et al.  Dependency Directed Reasoning and Learning in Systems Maintenance Support , 1987, IEEE Trans. Software Eng..

[55]  Curtis R. Cook,et al.  Assessing the State of Software Documentation Practices , 2004, PROFES.

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

[57]  Robert L. Nord,et al.  Applied Software Architecture , 1999, Addison Wesley object technology series.

[58]  Martin P. Robillard,et al.  Representing concerns in source code , 2007, TSEM.

[59]  Paul Clements,et al.  Capturing and Using Rationale for a Software Architecture , 2006 .

[60]  Aniello Cimitile,et al.  Identifying objects in legacy systems using design metrics , 1999, J. Syst. Softw..

[61]  Jeff Magee,et al.  The Koala Component Model for Consumer Electronics Software , 2000, Computer.

[62]  J. Paul Gibson Feature Requirements Models: Understanding Interactions , 1997, FIW.

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

[64]  Martin P. Robillard,et al.  Concern graphs: finding and describing concerns using structural program dependencies , 2002, Proceedings of the 24th International Conference on Software Engineering. ICSE 2002.

[65]  David Garlan,et al.  Documenting software architectures: views and beyond , 2002, 25th International Conference on Software Engineering, 2003. Proceedings..

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

[67]  I. Nonaka A Dynamic Theory of Organizational Knowledge Creation , 1994 .

[68]  Harold Ossher,et al.  Multi-Dimensional Separation of Concerns and the Hyperspace Approach , 2002 .

[69]  Ann E. Nicholson,et al.  Predicting Change Impact in Architecture Design with Bayesian Belief Networks , 2005, 5th Working IEEE/IFIP Conference on Software Architecture (WICSA'05).

[70]  Esperanza Marcos,et al.  Software engineering research versus software development , 2005, ACM SIGSOFT Softw. Eng. Notes.

[71]  Ajay S. Vinze,et al.  Understanding the Philosophical Underpinnings of Software Engineering Research in Information Systems , 2001, Inf. Syst. Frontiers.

[72]  Muhammad Ali Babar,et al.  Toward a Framework for Capturing and Using Architecture Design Knowledge , 2005 .

[73]  Ned Chapin,et al.  Types of software evolution and software maintenance , 2001, J. Softw. Maintenance Res. Pract..

[74]  Richard N. Taylor,et al.  A Classification and Comparison Framework for Software Architecture Description Languages , 2000, IEEE Trans. Software Eng..

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

[76]  Ellis Horowitz,et al.  Software Cost Estimation with COCOMO II , 2000 .

[77]  Hong Yan,et al.  DiscoTect: a system for discovering architectures from running systems , 2004, Proceedings. 26th International Conference on Software Engineering.

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

[79]  Rafael Capilla,et al.  A web-based tool for managing architectural design decisions , 2006, SOEN.

[80]  Anton Jansen Athena , a large scale programming lab support tool , 2004 .

[81]  Mary Shaw,et al.  What makes good research in software engineering? , 2002, International Journal on Software Tools for Technology Transfer.

[82]  Jan Bosch,et al.  Evaluation of tool support for architectural evolution , 2004 .

[83]  Patricia Lago,et al.  What's in Constructing a Domain Model for Sharing Architectural Knowledge? , 2006, SEKE.

[84]  Stanley M. Sutton,et al.  Multi-Dimensional Separation of Concerns , 1999 .

[85]  Albert M. Selvin,et al.  A framework for assessing group memory approaches for software design projects , 1997, DIS '97.

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

[87]  Jia Liu,et al.  Refinements and multi-dimensional separation of concerns , 2003, ESEC/FSE-11.

[88]  E. Jeffrey Conklin,et al.  A process-oriented approach to design rationale , 1991 .

[89]  Paul Clements,et al.  Software Architecture in Practice: Addison-Wesley , 1998 .

[90]  Pamela Zave Feature-Oriented Description, Formal Methods, and DFC , 2000, FIREworks.

[91]  Anton Jansen,et al.  Feature based composition , 2002 .

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

[93]  Dieter K. Hammer,et al.  Tool Support for Architectural Decisions , 2007, 2007 Working IEEE/IFIP Conference on Software Architecture (WICSA'07).

[94]  Martin L. Griss,et al.  Implementing Product-Line Features with Component Reuse , 2000, ICSR.

[95]  Raymond McCall,et al.  Rationale Management in Software Engineering , 2006 .

[96]  Philippe Kruchten,et al.  Building up and Exploiting Architectural Knowledge , 2005, 5th Working IEEE/IFIP Conference on Software Architecture (WICSA'05).

[97]  Christian Prehofer,et al.  Feature-Oriented Programming: A Fresh Look at Objects , 1997, ECOOP.

[98]  Ian Sommerville,et al.  Software Engineering, 8. Auflage , 2007, it : Informatik.

[99]  Arie van Deursen Software architecture recovery and modelling: [WCRE 2001 discussion forum report] , 2002 .

[100]  Mary Shaw,et al.  Abstractions for Software Architecture and Tools to Support Them , 1995, IEEE Trans. Software Eng..

[101]  Richard N. Taylor,et al.  A language and environment for architecture-based software development and evolution , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[102]  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).

[103]  Nenad Medvidovic,et al.  Improving System Understanding via Interactive, Tailorable, Source Code Analysis , 2005, FASE.

[104]  Charles J. Petrie,et al.  Constrained Decision Revision , 1992, AAAI.

[105]  Martin L. Griss Implementing Product-line features by composing aspects , 2000, SPLC.

[106]  Daniel Shawcross Wilkerson,et al.  Winnowing: local algorithms for document fingerprinting , 2003, SIGMOD '03.

[107]  René L. Krikhaar,et al.  A two-phase process for software architecture improvement , 1999, Proceedings IEEE International Conference on Software Maintenance - 1999 (ICSM'99). 'Software Maintenance for Business Change' (Cat. No.99CB36360).

[108]  Tim Kelly,et al.  Capturing and Replaying Architectural Knowledge through Derivational Analogy , 2007, Second Workshop on Sharing and Reusing Architectural Knowledge - Architecture, Rationale, and Design Intent (SHARK/ADI'07: ICSE Workshops 2007).

[109]  Gail C. Murphy,et al.  Design pattern rationale graphs: linking design to source , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[110]  Rokia Missaoui,et al.  Applying Concept Formation Methods to Software Reuse , 1995, Int. J. Softw. Eng. Knowl. Eng..

[111]  Hai Zhuge,et al.  The knowledge grid , 2004 .

[112]  Colin Potts,et al.  Recording the reasons for design decisions , 1988, Proceedings. [1989] 11th International Conference on Software Engineering.

[113]  Jan Bosch,et al.  Maturity and Evolution in Software Product Lines: Approaches, Artefacts and Organization , 2002, SPLC.

[114]  Paolo Tonella,et al.  Static and dynamic C++ code analysis for the recovery of the object diagram , 2002, International Conference on Software Maintenance, 2002. Proceedings..

[115]  João Araújo,et al.  Early aspects: a model for aspect-oriented requirements engineering , 2002, Proceedings IEEE Joint International Conference on Requirements Engineering.

[116]  Eric M. Dashofy,et al.  An infrastructure for the rapid development of XML-based architecture description languages , 2002, Proceedings of the 24th International Conference on Software Engineering. ICSE 2002.

[117]  C. Chambers,et al.  ArchJava: connecting software architecture to implementation , 2002, Proceedings of the 24th International Conference on Software Engineering. ICSE 2002.

[118]  Arie van Deursen,et al.  Symphony: view-driven software architecture reconstruction , 2004, Proceedings. Fourth Working IEEE/IFIP Conference on Software Architecture (WICSA 2004).

[119]  Jeff Kramer,et al.  Developing an approach for the recovery of distributed software architectures , 1998, Proceedings. 6th International Workshop on Program Comprehension. IWPC'98 (Cat. No.98TB100242).

[120]  Yannis Smaragdakis,et al.  Implementing Layered Designs with Mixin Layers , 1998, ECOOP.

[121]  Marvin V. Zelkowitz,et al.  Experimental validation in software engineering , 1997, Inf. Softw. Technol..

[122]  Philippe Kruchten,et al.  The 4+1 View Model of Architecture , 1995, IEEE Softw..

[123]  Jan Bosch,et al.  Superimposition: a component adaptation technique , 1999, Inf. Softw. Technol..

[124]  Peyman Oreizy,et al.  Architecture-based runtime software evolution , 1998, Proceedings of the 20th International Conference on Software Engineering.

[125]  Frantisek Plasil,et al.  SOFA/DCUP: architecture for component trading and dynamic updating , 1998, Proceedings. Fourth International Conference on Configurable Distributed Systems (Cat. No.98EX159).

[126]  Jan Bosch,et al.  Software Architecture as a Set of Architectural Design Decisions , 2005, 5th Working IEEE/IFIP Conference on Software Architecture (WICSA'05).

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

[128]  Jeff Tyree,et al.  Architecture decisions: demystifying architecture , 2005, IEEE Software.

[129]  Jan Bosch,et al.  First class feature abstractions for product derivation , 2004, IEE Proc. Softw..

[130]  Tom Mens,et al.  Towards a Taxonomy of Software Evolution , 2003 .

[131]  Guillermo Arango,et al.  A tool shelf for tracking design decisions , 1991, IEEE Software.

[132]  Frank Tip,et al.  Reengineering class hierarchies using concept analysis , 1998, SIGSOFT '98/FSE-6.

[133]  Antony Tang,et al.  A rationale-based architecture model for design traceability and reasoning , 2007, J. Syst. Softw..

[134]  Udo Kelter,et al.  Differences between versions of UML diagrams , 2003, ESEC/FSE-11.

[135]  David Garlan,et al.  Acme: architectural description of component-based systems , 2000 .

[136]  David Notkin,et al.  Language Support for Connector Abstractions , 2003, ECOOP.

[137]  Tao Qin,et al.  Discovering use cases from source code using the branch-reserving call graph , 2003, Tenth Asia-Pacific Software Engineering Conference, 2003..

[138]  Patricia Lago,et al.  Effective Tool Support for Architectural Knowledge Sharing , 2007, ECSA.

[139]  Arie van Deursen,et al.  Identifying objects using cluster and concept analysis , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[140]  Rob C. van Ommering Building product populations with software components , 2002, ICSE '02.

[141]  Marco Sinnema,et al.  Using variability modeling principles to capture architectural knowledge , 2006, SOEN.

[142]  Frank Buschmann,et al.  A system of patterns , 1995 .

[143]  Arun Lakhotia,et al.  A Unified Framework For Expressing Software Subsystem Classification Techniques , 1997, J. Syst. Softw..

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

[145]  Muhammad Ali Babar,et al.  Architectural Knowlege Management Strategies: Approaches in Research and Industry , 2007, Second Workshop on Sharing and Reusing Architectural Knowledge - Architecture, Rationale, and Design Intent (SHARK/ADI'07: ICSE Workshops 2007).

[146]  강문설 [서평]「The Unified Modeling Language User Guide」 , 1999 .

[147]  Martin Fowler,et al.  Dealing with Roles , 1997 .

[148]  Giovanni Cantone,et al.  Documenting design decision rationale to improve individual and team design decision making: an experimental evaluation , 2006, ISESE '06.

[149]  Marija Mikic-Rakic,et al.  Taming architectural evolution , 2001, ESEC/FSE-9.

[150]  Anneke Kleppe,et al.  MDA explained - the Model Driven Architecture: practice and promise , 2003, Addison Wesley object technology series.

[151]  Jintae Lee,et al.  Extending the Potts and Bruns model for recording design rationale , 1991, [1991 Proceedings] 13th International Conference on Software Engineering.

[152]  Patricia Lago,et al.  Architectural Knowledge: Getting to the Core , 2007, QoSA.

[153]  William A. Wulf,et al.  Capturing design rationale in concurrent engineering teams , 1993 .

[154]  John Leaney,et al.  Structural Analysis of the Software Architecture - A Maintenance Assessment Case Study , 1999, WICSA.

[155]  Uwe Zdun,et al.  Using Patterns to Capture Architectural Decisions , 2007, IEEE Software.

[156]  Robert T. Monroe Capturing Software Architecture Design Expertise with Armani , 2000 .

[157]  Rainer Koschke,et al.  Aiding program comprehension by static and dynamic feature analysis , 2001, Proceedings IEEE International Conference on Software Maintenance. ICSM 2001.

[158]  Stanley M. Sutton,et al.  N degrees of separation: multi-dimensional separation of concerns , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[159]  野中 郁次郎,et al.  The Knowledge-Creating Company: How , 1995 .

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

[161]  Marco Sinnema,et al.  COVAMOF: A Framework for Modeling Variability in Software Product Families , 2004, SPLC.

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

[163]  Keith H. Bennett,et al.  Software maintenance and evolution: a roadmap , 2000, ICSE '00.

[164]  Morten T. Hansen,et al.  What's your strategy for managing knowledge? , 1999, Harvard business review.

[165]  Paris Avgeriou,et al.  First workshop on sharing and reusing architectural knowledge , 2006, SOEN.