Detecting, Tracing, and Monitoring Architectural Tactics in Code

Software architectures are often constructed through a series of design decisions. In particular, architectural tactics are selected to satisfy specific quality concerns such as reliability, performance, and security. However, the knowledge of these tactical decisions is often lost, resulting in a gradual degradation of architectural quality as developers modify the code without fully understanding the underlying architectural decisions. In this paper we present a machine learning approach for discovering and visualizing architectural tactics in code, mapping these code segments to tactic traceability patterns, and monitoring sensitive areas of the code for modification events in order to provide users with up-to-date information about underlying architectural concerns. Our approach utilizes a customized classifier which is trained using code extracted from fifty performance-centric and safety-critical open source software systems. Its performance is compared against seven off-the-shelf classifiers. In a controlled experiment all classifiers performed well; however our tactic detector outperformed the other classifiers when used within the larger context of the Hadoop Distributed File System. We further demonstrate the viability of our approach for using the automatically detected tactics to generate viable and informative messages in a simulation of maintenance events mined from Hadoop's change management system.

[1]  Gang Huang,et al.  Runtime recovery and manipulation of software architecture of component-based systems , 2006, Automated Software Engineering.

[2]  J. D. Aplin Primary flight computers for the Boeing 777 , 1997, Microprocess. Microsystems.

[3]  Nelis Boucké,et al.  Using code analysis tools for architectural conformance checking , 2011, SHARK '11.

[4]  Jane Cleland-Huang,et al.  Using tactic traceability information models to reduce the risk of architectural degradation during system maintenance , 2011, 2011 27th IEEE International Conference on Software Maintenance (ICSM).

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

[6]  Jane Huffman Hayes,et al.  Advancing candidate link generation for requirements tracing: the study of methods , 2006, IEEE Transactions on Software Engineering.

[7]  Jane Cleland-Huang,et al.  Towards mining replacement queries for hard-to-retrieve traces , 2010, ASE.

[8]  Muhammad Ali Babar,et al.  A Tool for Managing Software Architecture Knowledge , 2007, Second Workshop on Sharing and Reusing Architectural Knowledge - Architecture, Rationale, and Design Intent (SHARK/ADI'07: ICSE Workshops 2007).

[9]  Onaiza Maqbool,et al.  Hierarchical Clustering for Software Architecture Recovery , 2007, IEEE Transactions on Software Engineering.

[10]  Jane Cleland-Huang,et al.  A tactic-centric approach for automating traceability of quality concerns , 2012, 2012 34th International Conference on Software Engineering (ICSE).

[11]  Felix Bachmann,et al.  Deriving Architectural Tactics: A Step Toward Methodical Architectural Design , 2003 .

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

[13]  Daphne Koller,et al.  Support Vector Machine Active Learning with Applications to Text Classification , 2000, J. Mach. Learn. Res..

[14]  Yuanfang Cai,et al.  Leveraging design rules to improve software architecture recovery , 2013, QoSA '13.

[15]  Joakim Nivre,et al.  Evaluation of Accuracy in Design Pattern Occurrence Detection , 2010, IEEE Transactions on Software Engineering.

[16]  Stéphane Ducasse,et al.  Software Architecture Reconstruction: A Process-Oriented Taxonomy , 2009, IEEE Transactions on Software Engineering.

[17]  Giuliano Antoniol,et al.  Recovering Traceability Links between Code and Documentation , 2002, IEEE Trans. Software Eng..

[18]  Philippe Kruchten,et al.  The Decision View's Role in Software Architecture Practice , 2009, IEEE Software.

[19]  David Madigan,et al.  Large-Scale Bayesian Logistic Regression for Text Categorization , 2007, Technometrics.

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

[21]  Domenico Cotroneo,et al.  A survey of software aging and rejuvenation studies , 2014, ACM J. Emerg. Technol. Comput. Syst..

[22]  Philippe Kruchten,et al.  The value of design rationale information , 2013, TSEM.

[23]  Jane Cleland-Huang,et al.  Archie: a tool for detecting, monitoring, and preserving architecturally significant code , 2014, FSE 2014.

[24]  J. Ross Quinlan,et al.  C4.5: Programs for Machine Learning , 1992 .

[25]  D. Siewiorek,et al.  FAULT-TOLERANT ARCHITECTURES FOR SPACE AND AVIONICS APPLICATIONS , 2005 .

[26]  Nello Cristianini,et al.  Classification using String Kernels , 2000 .

[27]  Kamran Sartipi,et al.  Software architecture recovery based on pattern matching , 2003, International Conference on Software Maintenance, 2003. ICSM 2003. Proceedings..

[28]  Carl K. Chang,et al.  Supporting event based traceability through high-level recognition of change events , 2002, Proceedings 26th Annual International Computer Software and Applications.

[29]  Jintae Lee,et al.  Design Rationale Systems: Understanding the Issues , 1997, IEEE Expert.

[30]  Jane Cleland-Huang,et al.  A machine learning approach for tracing regulatory codes to product specific requirements , 2010, 2010 ACM/IEEE 32nd International Conference on Software Engineering.

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

[32]  Denys Poshyvanyk,et al.  Concept location using formal concept analysis and information retrieval , 2012, TSEM.

[33]  Yoram Singer,et al.  A simple, fast, and effective rule learner , 1999, AAAI 1999.

[34]  Aiko M. Hormann,et al.  Programs for Machine Learning. Part I , 1962, Inf. Control..

[35]  Richard N. Taylor,et al.  Software traceability with topic modeling , 2010, 2010 ACM/IEEE 32nd International Conference on Software Engineering.

[36]  David Notkin,et al.  Software Reflexion Models: Bridging the Gap between Design and Implementation , 2001, IEEE Trans. Software Eng..

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

[38]  Giuliano Antoniol,et al.  Object-oriented design patterns recovery , 2001, J. Syst. Softw..

[39]  Heather Hinkel,et al.  NASA CEV Reference GN&C Architecture , 2007 .

[40]  Richard N. Taylor,et al.  Enhancing architecture-implementation conformance with change management and support for behavioral mapping , 2012, 2012 34th International Conference on Software Engineering (ICSE).

[41]  Horst Lichter,et al.  On bridging the gap between practice and vision for software architecture reconstruction and evolution: a toolbox perspective , 2014, WICSA '14 Companion.

[42]  Tom Mens,et al.  Design preservation over subsequent releases of a software product: a case study of Baan ERP: Practice Articles , 2005 .

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

[44]  Rainer Koschke,et al.  Architecture Reconstruction , 2009, ISSSE.

[45]  Jane Cleland-Huang,et al.  Utilizing supporting evidence to improve dynamic requirements traceability , 2005, 13th IEEE International Conference on Requirements Engineering (RE'05).

[46]  Mehdi Mirakhorli,et al.  Preserving the Quality of Architectural Tactics in Source Code , 2014 .

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

[48]  Thorsten Joachims,et al.  Text Categorization with Support Vector Machines: Learning with Many Relevant Features , 1998, ECML.

[49]  David Lorge Parnas,et al.  Software aging , 1994, Proceedings of 16th International Conference on Software Engineering.

[50]  Oscar Nierstrasz,et al.  Evolutionary and collaborative software architecture recovery with Softwarenaut , 2014, Sci. Comput. Program..

[51]  Rick Kazman,et al.  Playing Detective: Reconstructing Software Architecture from Available Evidence , 1999, Automated Software Engineering.

[52]  Philippe Kruchten,et al.  Sharing and Reusing Architectural Knowledge--Architecture, Rationale, and Design Intent , 2007, 29th International Conference on Software Engineering (ICSE'07 Companion).

[53]  Rick Kazman,et al.  A Software Architecture Reconstruction Method , 1999, WICSA.

[54]  Jane Cleland-Huang,et al.  Automated classification of non-functional requirements , 2007, Requirements Engineering.

[55]  David C. Brown,et al.  Software Engineering Using RATionale , 2008, J. Syst. Softw..

[56]  Francesca Arcelli Fontana,et al.  Using Design Pattern Clues to Improve the Precision of Design Pattern Detection Tools , 2011, J. Object Technol..

[57]  Jane Cleland-Huang,et al.  Tracing architectural concerns in high assurance systems: (NIER track) , 2011, 2011 33rd International Conference on Software Engineering (ICSE).

[58]  Yoav Freund,et al.  Experiments with a New Boosting Algorithm , 1996, ICML.

[59]  Cambridge Ma,et al.  Orion GN&C Architecture for Increased Spacecraft Automation and Autonomy Capabilities , 2008 .

[60]  Robert Hanmer,et al.  Patterns for Fault Tolerant Software , 2007 .

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

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

[63]  Emden R. Gansner,et al.  Bunch: a clustering tool for the recovery and maintenance of software system structures , 1999, Proceedings IEEE International Conference on Software Maintenance - 1999 (ICSM'99). 'Software Maintenance for Business Change' (Cat. No.99CB36360).

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

[65]  Ian Gorton,et al.  Essential software architecture , 2006 .

[66]  Leo Breiman,et al.  Bagging Predictors , 1996, Machine Learning.

[67]  Humberto Cervantes,et al.  A Principled Way to Use Frameworks in Architecture Design , 2013, IEEE Software.

[68]  Ghulam Rasool,et al.  Evaluation of design pattern recovery tools , 2011, WCIT.

[69]  Stephen Clark,et al.  Best Practices for Automated Traceability , 2007, Computer.