Prioritization of Code Anomalies Based on Architecture Sensitiveness

Code anomalies are symptoms of software maintainability problems, particularly harmful when contributing to architectural degradation. Despite the existence of many automated techniques for code anomaly detection, identifying the code anomalies that are more likely to cause architecture problems remains a challenging task. Even when there is tool support for detecting code anomalies, developers often invest a considerable amount of time refactoring those that are not related to architectural problems. In this paper we present and evaluate four different heuristics for helping developers to prioritize code anomalies, based on their potential contribution to the software architecture degradation. Those heuristics exploit different characteristics of a software project, such as change-density and error-density, for automatically ranking code elements that should be refactored more promptly according to their potential architectural relevance. Our evaluation revealed that software maintainers could benefit from the recommended rankings for identifying which code anomalies are harming architecture the most, helping them to invest their refactoring efforts into solving architecturally relevant problems.

[1]  Cláudio Sant'Anna,et al.  On the Impact of Aspectual Decompositions on Design Stability: An Empirical Study , 2007, ECOOP.

[2]  Foutse Khomh,et al.  An Exploratory Study of the Impact of Code Smells on Software Change-proneness , 2009, 2009 16th Working Conference on Reverse Engineering.

[3]  Yuanfang Cai,et al.  Detecting Design Defects Caused by Design Rule Violations , 2009 .

[4]  Ronald Fagin,et al.  Comparing top k lists , 2003, SODA '03.

[5]  Michael W. Godfrey,et al.  Secrets from the Monster: Extracting Mozilla’s Software Architecture , 2000 .

[6]  Alessandro F. Garcia,et al.  On the Relevance of Code Anomalies for Identifying Architecture Degradation Symptoms , 2012, 2012 16th European Conference on Software Maintenance and Reengineering.

[7]  M. Mäntylä,et al.  Subjective evaluation of software evolvability using code smells: An empirical study , 2006, Empirical Software Engineering.

[8]  Harald C. Gall,et al.  Improving evolvability through refactoring , 2005, ACM SIGSOFT Softw. Eng. Notes.

[9]  Alessandro F. Garcia,et al.  Supporting the identification of architecturally-relevant code anomalies , 2012, 2012 28th IEEE International Conference on Software Maintenance (ICSM).

[10]  R. Graham,et al.  Spearman's Footrule as a Measure of Disarray , 1977 .

[11]  Stéphane Ducasse,et al.  Object-Oriented Metrics in Practice , 2005 .

[12]  Sam Malek,et al.  Reconceptualizing a Family of Heterogeneous Embedded Systems via Explicit Architectural Support , 2007, 29th International Conference on Software Engineering (ICSE'07).

[13]  M.J. Munro,et al.  Product Metrics for Automatic Identification of "Bad Smell" Design Problems in Java Source-Code , 2005, 11th IEEE International Software Metrics Symposium (METRICS'05).

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

[15]  Claes Wohlin,et al.  Experimentation in software engineering: an introduction , 2000 .

[16]  Radu Marinescu,et al.  Detection strategies: metrics-based rules for detecting design flaws , 2004, 20th IEEE International Conference on Software Maintenance, 2004. Proceedings..

[17]  Cláudio Sant'Anna,et al.  Evolving software product lines with aspects , 2008, 2008 ACM/IEEE 30th International Conference on Software Engineering.

[18]  Eduardo Figueiredo,et al.  Understanding the longevity of code smells: preliminary results of an explanatory survey , 2011, WRT '11.

[19]  Alessandro F. Garcia,et al.  Enhancing the Detection of Code Anomalies with Architecture-Sensitive Strategies , 2013, 2013 17th European Conference on Software Maintenance and Reengineering.

[20]  Alessandro F. Garcia,et al.  Automatically detecting architecturally-relevant code anomalies , 2012, 2012 Third International Workshop on Recommendation Systems for Software Engineering (RSSE).

[21]  Diane Kelly,et al.  A study of design characteristics in evolving software using stability as a criterion , 2006, IEEE Transactions on Software Engineering.

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

[23]  Audris Mockus,et al.  Does Code Decay? Assessing the Evidence from Change Management Data , 2001, IEEE Trans. Software Eng..

[24]  Maliha S. Nash,et al.  Handbook of Parametric and Nonparametric Statistical Procedures , 2001, Technometrics.

[25]  Daniela Cruzes,et al.  Are all code smells harmful? A study of God Classes and Brain Classes in the evolution of three open source systems , 2010, 2010 IEEE International Conference on Software Maintenance.

[26]  Zhenchang Xing,et al.  Refactoring Practice: How it is and How it Should be Supported - An Eclipse Case Study , 2006, 2006 22nd IEEE International Conference on Software Maintenance.

[27]  Andrew P. Black,et al.  How we refactor, and how we know it , 2009, 2009 IEEE 31st International Conference on Software Engineering.

[28]  Lorin Hochstein,et al.  Combating architectural degeneration: a survey , 2005, Inf. Softw. Technol..

[29]  Nenad Medvidovic,et al.  Identifying Architectural Bad Smells , 2009, 2009 13th European Conference on Software Maintenance and Reengineering.

[30]  David Hovemeyer,et al.  Using Static Analysis to Find Bugs , 2008, IEEE Software.

[31]  Alan MacCormack,et al.  Exploring the Structure of Complex Software Designs: An Empirical Study of Open Source and Proprietary Code , 2006, Manag. Sci..

[32]  Miryung Kim,et al.  An empirical investigation into the role of API-level refactorings during software evolution , 2011, 2011 33rd International Conference on Software Engineering (ICSE).

[33]  Nenad Medvidovic,et al.  Are automatically-detected code anomalies relevant to architectural modularity?: an exploratory analysis of evolving systems , 2012, AOSD.