More Web Proxy on the site http://driver.im/

research-article

Are automatically-detected code anomalies relevant to architectural modularity?: an exploratory analysis of evolving systems

Authors:

Daniel Popescu,

Alessandro Garcia,

Nenad Medvidovic,

Arndt von StaaAuthors Info & Claims

AOSD '12: Proceedings of the 11th annual international conference on Aspect-oriented Software Development

Pages 167 - 178

https://doi.org/10.1145/2162049.2162069

Published: 25 March 2012 Publication History

Abstract

As software systems are maintained, their architecture modularity often degrades through architectural erosion and drift. More directly, however, the modularity of software implementations degrades through the introduction of code anomalies, informally known as code smells. A number of strategies have been developed for supporting the automatic identification of implementation anomalies when only the source code is available. However, it is still unknown how reliable these strategies are when revealing code anomalies related to erosion and drift processes. In this paper, we present an exploratory analysis that investigates to what extent the automatically-detected code anomalies are related to problems that occur with an evolving system's architecture. We analyzed code anomaly occurrences in 38 versions of 5 applications using existing detection strategies. The outcome of our evaluation suggests that many of the code anomalies detected by the employed strategies were not related to architectural problems. Even worse, over 50% of the anomalies not observed by the employed techniques (false negatives) were found to be correlated with architectural problems.

References

[1]

Aldrich, J. ArchJava: Connecting Software Architecture to Implementation. In Proc of the 24th ICSE, pp. 187--197, 2002.

Digital Library

[2]

Alikacem, E.H and Sahraoui, H. Generic metric extraction framework. In Proc. of the 16th IWSM/MetriKon, 2006, pp. 383--390.

[3]

Bieman, J.M. and Kang, B.K. Cohesion and Reuse in an Object Oriented System. In Proc of the ISSR, pp 259--262, 1995.

Digital Library

[4]

Clements, P et al. Documenting Software Architectures: Views and Beyond. Addison-Wesley, 2nd Edition, 2010

Digital Library

[5]

Code smells study: http://www.inf.puc-rio.br/~ibertran/aosd12.

[6]

D'Ambros, M. et al. the Impact of Design Flaws on Software Defects. In Proc. of the 10th QSIC, pp. 23 - 31, 2010.

Digital Library

[7]

Dhambri et al. Visual Detection of Design Anomalies. In Proc. of the 12th CSMR, pp. 279--283, 2008.

Digital Library

[8]

Eichberg, M. et al. Defining and Continuous Checking of Structural Program Dependencies. In Proc. of the 30th ICSE, 2008.

Digital Library

[9]

Emden, E. and Moonen, L. Java quality assurance by detecting code smells. In Proceedings of the 9th ICRE, 2002.

[10]

FEAT tool, http://www.cs.mcgill.ca/~swevo/feat/

[11]

Ferrari, F. et al. An exploratory study of error-proneness in evolving Aspect-Oriented Programs. In: Proc. of the 25th OOPSLA, USA, 2009.

[12]

Figueiredo, E. et al. Evolving software product lines with aspects: An empirical study on design stability. In Proc of the 30th ICSE, 2008.

Digital Library

[13]

Fowler, M. Refactoring: Improving the Design of Existing Code. Addison-Wesley, 1999.

Digital Library

[14]

Garcia, J. et al. Identifying architectural bad smells. In Proc of the. 13th CSMR, pp 255--258, 2009.

Digital Library

[15]

Greenwood, P. et al. On the impact of aspectual decompositions on design stability: An empirical study. In Proc. of the 21st ECOOP, 2007.

Digital Library

[16]

Hochstein, L. and Lindvall, M. Combating architectural degeneration: A survey. Info. & Soft. Technology July, 2005.

Digital Library

[17]

Hosmer, D. and Lemeshow, S. Applied Logistic Regression (2nd Edition). Wiley, 2000.

[18]

Khomh, K. et al. An exploratory study of the impact of code smells on software change-proneness. In Proc of the 16th WCRE, 2009.

Digital Library

[19]

Kiczales, G.,et al. Aspect-oriented programming. In Proc. of the 11th ECOOP. LNCS, vol. 1241. Springer, Heidelberg. pp. 220--242, 1997.

[20]

Kitchenham, B. et al. Evaluating guidelines for empirical software engineering studies. ISESE pp 38--47, 2006

Digital Library

[21]

Lanza, M. and Marinescu, R. Object-Oriented Metrics in Practice. Springer, 2006.

Digital Library

[22]

Lippert, M. and Roock, S. Refactoring in Large Software Projects: Performing Complex Restructurings Successfully. Wiley. 2006.

[23]

Macia, I. et al. A. An Exploratory Study of Code Smells in Evolving Aspect-Oriented Systems. In Proc of the 10th AOSD, 2011.

Digital Library

[24]

Malek, S. et al. Reconceptualizing a family of heterogeneous embedded systems via explicit architectural support. In Proc. of the 29th ICSE. 2007.

Digital Library

[25]

Mantyla, M.V. and Lassenius, C. Subjective evaluation of software evolvability using code smells: An empirical study. Empirical Software Enggineering, vol. 11, no. 3, pp. 395--431, 2006.

Digital Library

[26]

Mara, L. et al. Hist-Inspect: A Tool for History-Sensitive Detection of Code Smells. In Proc. of the 10th AOSD, 2011

Digital Library

[27]

Marinescu, R. Detection strategies: Metrics-based rules for detecting design flaws. In Proc. of the 20th ICSM, pp 350--359, 2004.

Digital Library

[28]

Marinescu,R.; Ganea, G. and Veredi, I. inCode: Continuous Quality Assessment and Improvement. In Proc of the 14th CSMR, 2010.

Digital Library

[29]

Martin, R. Agile Principles, Patterns, and Practices. Prentice Hall, 2002.

Digital Library

[30]

McCabe, T.J. A Software Complexity Measure. IEEE Transactions on Software Engineering, 2 (4), pp 308--320, 1976.

Digital Library

[31]

Meyer, B. Object-Oriented Software Construction. Prentice Hall Professional Technical 2nd edition, 2000.

Digital Library

[32]

Moha, N. et al. DECOR: A Method for the Specification and Detection of Code and Design Smells. IEEE TSE, 2010.

Digital Library

[33]

Munro, MJ. Product metrics for automatic identification of bad smell design problems in java source-code. In Proc of 11th METRICS, 2005

Digital Library

[34]

MuLATo tool, http://sourceforge.net/projects/mulato/ (3/08/2009)

[35]

Murphy, G.C., et al. Software Reflexion Models: Bridging the Gap between Design and Implementation. IEEE TSE, pp 364--380, 2001.

Digital Library

[36]

Murphy-Hill, E. Scalable, expressive, and context-sensitive code smell display. In Proc of the 23rd OPSLA, 2008.

Digital Library

[37]

Olbrich, S.M. et al. Are all code smells harmful? A study of God Classes and Brain Classes in the evolution of three open source systems. In Proc of the 26th ICSM pp 1--10, 2010.

Digital Library

[38]

Olbrich, S.M. et al. The evolution and impact of code smells: A case study of two open source systems. In Proc of the 3rd ESEM, 2009.

Digital Library

[39]

Perry, D.E. and Wolf, A.L. Foundations for the study of software architecture, ACM Software. Eng. Notes 17 (4) pp 40--52, 1992.

Digital Library

[40]

Ratiu, D. et al. Using History Information to Improve Design Flaws Detection. In Proc of the 8th CSMR, 2004.

Digital Library

[41]

Ratzinger, J. et al. Improving evolvability through refactoring. In Proc of the 5th IEEE MSR, 2005.

Digital Library

[42]

Sant'anna, C. et al. On the modularity of software architectures: A Concern-Driven measurement framework. In Proc. of ECSA, 2007.

Digital Library

[43]

Sonar: http://docs.codehaus.org/display/SONAR/

[44]

Srivisut, K. and Muenchaisri, P. Bad-smell Metrics for Aspect-Oriented Software. In Proc of the 6th ICIS, 2007.

[45]

Together: http://www.borland.com/us/products/together/

[46]

Tsantalis, N. and Chatzigeorgiou, A. Identification of move method refactoring opportunities. IEEE TSE, 35(3), pp 347--367, 2009.

Digital Library

[47]

Understand: http://www.scitools.com/

[48]

Wake, W.C. Refactoring Workbook. Boston, MA, USA: Addison-Wesley Longman Publishing Co., Inc., 2003.

Digital Library

[49]

Wettel, R. and Lanza, M. Visually localizing design problems with disharmony maps. In Proc. of the 4th Softvis pp. 155--164, 2008.

Digital Library

Cited By

Tandon SKumar VSingh V(2024)Study of Code Smells: A Review and Research AgendaInternational Journal of Mathematical, Engineering and Management Sciences10.33889/IJMEMS.2024.9.3.0259:3(472-498)Online publication date: 1-Jun-2024
https://doi.org/10.33889/IJMEMS.2024.9.3.025
Wan ZZhang YXia XJiang YLo DChandra SBlincoe KTonella P(2023)Software Architecture in Practice: Challenges and OpportunitiesProceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering10.1145/3611643.3616367(1457-1469)Online publication date: 30-Nov-2023
https://dl.acm.org/doi/10.1145/3611643.3616367
Agouf NLabsari SDucasse SEtien AAnquetil N(2023)A Visualization for Client-Server Architecture Assessement2023 IEEE Working Conference on Software Visualization (VISSOFT)10.1109/VISSOFT60811.2023.00010(1-11)Online publication date: 1-Oct-2023
https://doi.org/10.1109/VISSOFT60811.2023.00010
Show More Cited By

Index Terms

Are automatically-detected code anomalies relevant to architectural modularity?: an exploratory analysis of evolving systems
1. General and reference
  1. Cross-computing tools and techniques
    1. Metrics
2. Software and its engineering
  1. Software creation and management
    1. Designing software

Recommendations

Automatically detecting architecturally-relevant code anomalies
RSSE '12: Proceedings of the Third International Workshop on Recommendation Systems for Software Engineering

Software architecture degradation is a long-standing problem in software engineering. Previous studies have shown that certain code anomalies - or patterns of code anomalies - are likely to be harmful to architecture design, although their ...
Architecture-sensitive heuristics for prioritizing critical code anomalies
MODULARITY 2015: Proceedings of the 14th International Conference on Modularity

The progressive insertion of code anomalies in evolving software systems might lead to architecture degradation symptoms. Code anomalies are particularly harmful when they contribute to the architecture degradation. Although several approaches have ...
On the criteria for prioritizing code anomalies to identify architectural problems
SAC '16: Proceedings of the 31st Annual ACM Symposium on Applied Computing

Architectural problems constantly affect evolving software projects. When not properly addressed, those problems can hinder the longevity of a software system. Some studies revealed that a wide range of architectural problems are reflected in source code ...

Comments

Please enable JavaScript to view thecomments powered by Disqus.

Information & Contributors

Information

Published In

cover image ACM Conferences

AOSD '12: Proceedings of the 11th annual international conference on Aspect-oriented Software Development

March 2012

286 pages

ISBN:9781450310925

DOI:10.1145/2162049

Conference Chair:
Michael Haupt
Oracle Labs, Potsdam, Germany
,
General Chair:
Robert Hirschfeld
Hasso-Plattner-Institut, University of Potsdam, Germany
,
Program Chairs:
Éric Tanter
Universidad de Chile, Chile
,
Kevin J. Sullivan
University of Virginia, USA
,
Richard P. Gabriel
IBM Research, USA

Copyright © 2012 ACM.

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]

Sponsors

In-Cooperation

AOSA: Aspect-Oriented Software Association

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 25 March 2012

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article

Conference

AOSD '12

Sponsor:

AOSD '12: Aspect-oriented Software Development

March 25 - 30, 2012

Potsdam, Germany

Acceptance Rates

AOSD '12 Paper Acceptance Rate 20 of 79 submissions, 25%;

Overall Acceptance Rate 41 of 139 submissions, 29%

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

86
Total Citations
View Citations
576
Total Downloads

Downloads (Last 12 months)35
Downloads (Last 6 weeks)1

Reflects downloads up to 03 Jan 2025

Other Metrics

View Author Metrics

Citations

Cited By

Tandon SKumar VSingh V(2024)Study of Code Smells: A Review and Research AgendaInternational Journal of Mathematical, Engineering and Management Sciences10.33889/IJMEMS.2024.9.3.0259:3(472-498)Online publication date: 1-Jun-2024
https://doi.org/10.33889/IJMEMS.2024.9.3.025
Wan ZZhang YXia XJiang YLo DChandra SBlincoe KTonella P(2023)Software Architecture in Practice: Challenges and OpportunitiesProceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering10.1145/3611643.3616367(1457-1469)Online publication date: 30-Nov-2023
https://dl.acm.org/doi/10.1145/3611643.3616367
Agouf NLabsari SDucasse SEtien AAnquetil N(2023)A Visualization for Client-Server Architecture Assessement2023 IEEE Working Conference on Software Visualization (VISSOFT)10.1109/VISSOFT60811.2023.00010(1-11)Online publication date: 1-Oct-2023
https://doi.org/10.1109/VISSOFT60811.2023.00010
Jin WZhong DCai YKazman RLiu T(2023)Evaluating the Impact of Possible Dependencies on Architecture-Level MaintainabilityIEEE Transactions on Software Engineering10.1109/TSE.2022.317128849:3(1064-1085)Online publication date: 1-Mar-2023
https://doi.org/10.1109/TSE.2022.3171288
Oliveira ACorreia JSousa LAssunção WCoutinho DGarcia AOizumi WBarbosa CUchôa APereira J(2023)Don’t Forget the Exception! : Considering Robustness Changes to Identify Design Problems2023 IEEE/ACM 20th International Conference on Mining Software Repositories (MSR)10.1109/MSR59073.2023.00064(417-429)Online publication date: May-2023
https://doi.org/10.1109/MSR59073.2023.00064
Baabad AZulzalil HHassan SBaharom S(2022)Characterizing the Architectural Erosion Metrics: A Systematic Mapping StudyIEEE Access10.1109/ACCESS.2022.315084710(22915-22940)Online publication date: 2022
https://doi.org/10.1109/ACCESS.2022.3150847
Oliveira DAssunção WGarcia AFonseca BRibeiro M(2022)Developers’ perception matters: machine learning to detect developer-sensitive smellsEmpirical Software Engineering10.1007/s10664-022-10234-227:7Online publication date: 12-Oct-2022
https://dl.acm.org/doi/10.1007/s10664-022-10234-2
Santos JPetronilo G(2022)Building empirical knowledge on the relationship between code smells and design patterns: An exploratory studyJournal of Software: Evolution and Process10.1002/smr.248734:9Online publication date: 21-Jul-2022
https://doi.org/10.1002/smr.2487
Uchôa AAssunção WGarcia A(2021)Do Critical Components Smell Bad? An Empirical Study with Component-based Software Product LinesProceedings of the 15th Brazilian Symposium on Software Components, Architectures, and Reuse10.1145/3483899.3483907(21-30)Online publication date: 27-Sep-2021
https://dl.acm.org/doi/10.1145/3483899.3483907
Sobrinho EDe Lucia AMaia M(2021)A Systematic Literature Review on Bad Smells–5 W's: Which, When, What, Who, WhereIEEE Transactions on Software Engineering10.1109/TSE.2018.288097747:1(17-66)Online publication date: 1-Jan-2021
https://dl.acm.org/doi/10.1109/TSE.2018.2880977
Show More Cited By

View Options

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Publication

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Media

Figures

Other

Tables

View Table of Contents