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

research-article

An empirical investigation on the relationship between design and architecture smells

Authors:

Paramvir Singh,

Diomidis SpinellisAuthors Info & Claims

Empirical Software Engineering, Volume 25, Issue 5

Pages 4020 - 4068

https://doi.org/10.1007/s10664-020-09847-2

Published: 01 September 2020 Publication History

Abstract

Context:

Architecture of a software system represents the key design decisions and therefore its quality plays an important role to keep the software maintainable. Code smells are indicators of quality issues in a software system and are classified based on their granularity, scope, and impact. Despite a plethora of existing work on smells, a detailed exploration of architecture smells, their characteristics, and their relationships with smells in other granularities is missing.

Objective:

The paper aims to study architecture smells characteristics, investigate correlation, collocation, and causation relationships between architecture and design smells.

Method:

We implement smell detection support for seven architecture smells. We mine 3 073 open-source repositories containing more than 118 million lines of C# code and empirically investigate the relationships between seven architecture and 19 design smells.

Results:

We find that smell density does not depend on repository size. Cumulatively, architecture smells are highly correlated with design smells. Our collocation analysis finds that the majority of design and architecture smell pairs do not exhibit collocation. Finally, our causality analysis reveals that design smells cause architecture smells.

References

[1]

Abbes M, Khomh F, Gueheneuc Y, Antoniol G (2011) An empirical study of the impact of two antipatterns, blob and spaghetti code, on program comprehension. In: 2011 15Th european conference on software maintenance and reengineering, pp 181–190. 10.1109/CSMR.2011.24

[2]

Arcelli Fontana F, Mäntylä MV, Zanoni M, and Marino A Comparing and experimenting machine learning techniques for code smell detection Empir Softw Eng 2016 21 3 1143-1191

[3]

Bass L, Clements P, Kazman R (2012) Software Architecture in Practice, 3rd edn, Addison-Wesley Professional

[4]

Bavota G, De Lucia A, Di Penta M, Oliveto R, and Palomba F An experimental investigation on the innate relationship between quality and refactoring J Syst Softw 2015 107 1-14

[5]

Behnamghader P, Le DM, Garcia J, Link D, Shahbazian A, and Medvidovic N A large-scale study of architectural evolution in open-source software systems Empir Softw Eng 2017 22 3 1146-1193

[6]

Besker T, Martini A, Bosch J (2018) Managing architectural technical debt: A unified model and systematic literature review. J Syst Softw 135:1–16. 10.1016/j.jss.2017.09.025. http://www.sciencedirect.com/science/article/pii/S0164121217302121

[7]

Bloch J (2008) Effective Java (2nd Edition) (The Java Series), 2 edn. Prentice Hall PTR

[8]

Booch G, Rumbaugh J, Jacobson I (1999) The unified modeling language user guide. Addison-wesley, Reading

[9]

Brown WJ, Malveau RC, McCormick HWS, Mowbray TJ (1998) Antipatterns: Refactoring Software, Architectures, and Projects in Crisis, 1 edn. Wiley, New York

[10]

Chidamber SR and Kemerer CF A metrics suite for object oriented design IEEE Trans Softw Eng 1994 20 6 476-493

[11]

Couto C, Pires P, Valente MT, da Silva Bigonha R, Hora AC, Anquetil N (2013) Bugmaps-granger: A tool for causality analysis between source code metrics and bugs

[12]

Couto C, Pires P, Valente MT, Bigonha RS, Anquetil N (2014) Predicting software defects with causality tests. J Syst Softw 93:24–41. 10.1016/j.jss.2014.01.033. http://www.sciencedirect.com/science/article/pii/S0164121214000351

[13]

Cox D, Miller H (1965) The Theory of Stochastic Process, 1 edn. Chapman and Hall, London

[14]

Cramer H (1946) Mathematical Methods of Statistics, 1 edn. Princeton University Press

[15]

Cui D, Liu T, Cai Y, Zheng Q, Feng Q, Jin W, Guo J, Qu Y (2019) Investigating the impact of multiple dependency structures on software defects. In: Proceedings of the 41st International Conference on Software Engineering, ICSE ’19. IEEE Press, Piscataway, pp 584–595. 10.1109/ICSE.2019.00069

[16]

de Andrade HS, Almeida E, Crnkovic I (2014) Architectural bad smells in software product lines: an exploratory study. In: Proceedings of the WICSA 2014 Companion Volume, WICSA ’14 Companion. ACM, pp 12:1–12:6. 10.1145/2578128.2578237

[17]

Deursen Av, Moonen L, Bergh Avd, Kok G (2001) Refactoring test code. In: M. Marchesi (ed.) Proceedings of the 2nd International Conference on Extreme Programming and Flexible Processes (XP2001). University of Cagliari, pp 92–95

[18]

Ferreira KA, Bigonha MA, Bigonha RS, Mendes LF, Almeida HC (2012) Identifying thresholds for object-oriented software metrics. J Syst Softw 85(2):244–257. 10.1016/j.jss.2011.05.044. http://www.sciencedirect.com/science/article/pii/S0164121211001385. Special issue with selected papers from the 23rd Brazilian Symposium on Software Engineering

[19]

Filó TGS, Da Silva Bigonha MA (2015) A catalogue of thresholds for object-oriented software metrics

[20]

Fontana FA, Ferme V, Marino A, Walter B, Martenka P (2013) Investigating the impact of code smells on system’s quality: an empirical study on systems of different application domains. In: 2013 IEEE International conference on software maintenance (ICSM). IEEE, pp 260–269

[21]

Fontana FA, Ferme V, Zanoni M (2015) Towards assessing software architecture quality by exploiting code smell relations. In: Proceedings of the 2015 IEEE/ACM 2Nd International Workshop on Software Architecture and Metrics, SAM ’15. IEEE Computer Society, Washington, pp 1–7. 10.1109/SAM.2015.8

[22]

Fontana FA, Pigazzini I, Roveda R, Zanoni M (2016) Automatic detection of instability architectural smells. In: 2016 IEEE international conference on Software maintenance and evolution (ICSME). IEEE, pp 433–437

[23]

Fontana FA, Pigazzini I, Roveda R, Tamburri D, Zanoni M, Nitto ED (2017) Arcan: a tool for architectural smells detection. In: 2017 IEEE International conference on software architecture workshops (ICSAW). IEEE, pp 282–285

[24]

Fontana FA, Lenarduzzi V, Roveda R, Taibi D (2019) Are architectural smells independent from code smells? an empirical study. J Syst Softw 154:139–156. 10.1016/j.jss.2019.04.066. http://www.sciencedirect.com/science/article/pii/S0164121219301013

[25]

Fourati R, Bouassida N, Abdallah HB (2011) A Metric-Based Approach for Anti-pattern Detection in UML Designs. In: Computer and information science 2011. Springer, Berlin, pp 17–33

[26]

Fowler M (1999) Refactoring: Improving the Design of Existing Programs, 1 edn. Addison-Wesley Professional

[27]

Fuller WA (1976) Introduction to Statistical Time Series, 1 edn. Wiley, New York

[28]

Garcia J, Popescu D, Edwards G, Medvidovic N (2009) Toward a catalogue of architectural bad smells. In: Proceedings of the 5th International Conference on the Quality of Software Architectures: Architectures for Adaptive Software Systems, QoSA ’09. Springer, Berlin, pp 146–162. 10.1007/978-3-642-02351-4_10

[29]

Garcia J (2014) Technical report: Architectural Smell Definitions and Formalizations. http://csse.usc.edu/TECHRPTS/2014/reports/usc-csse-2014-500.pdf. [Online; accessed 16-June-2017]

[30]

Granger CWJ (1969) Investigating causal relations by econometric models and cross-spectral methods. Econometrica 37(3):424–438. http://www.jstor.org/stable/1912791

[31]

Guimaraes E, Garcia A, Cai Y (2014) Exploring blueprints on the prioritization of architecturally relevant code anomalies – a controlled experiment. In: 2014 IEEE 38Th annual computer software and applications conference, pp 344–353. 10.1109/COMPSAC.2014.57

[32]

Guimarães E, Vidal S, Garcia A, Diaz Pace JA, Marcos C (2018) Exploring architecture blueprints for prioritizing critical code anomalies: Experiences and tool support. Softw Pract Exper 48(5):1077–1106. 10.1002/spe.2563

[33]

Herbold S, Grabowski J, and Waack S Calculation and optimization of thresholds for sets of software metrics Empir Softw Eng 2011 16 812-841

[34]

Hochstein L, Lindvall M (2003) Diagnosing architectural degeneration. In: 2003. Proceedings of 28Th annual NASA goddard software engineering workshop, pp 137–142

[35]

Kessentini W, Kessentini M, Sahraoui H, Bechikh S, and Ouni A A cooperative parallel Search-Based software engineering approach for Code-Smells detection IEEE Trans Softw Eng 2014 40 9 841-861

[36]

Khomh F, Vaucher S, Guéhéneuc YG, Sahraoui H (2009) A bayesian approach for the detection of code and design smells. In: QSIC ’09: Proceedings of the 2009 Ninth International Conference on Quality Software, pp 305–314. IEEE Computer Society

[37]

Koschke R (2007) Duplication, Redundancy, and Similarity in Software, no. 06301 in Dagstuhl Seminar Proceedings. Internationales Begegnungs- und Forschungszentrum für Informatik (IBFI), Schloss Dagstuhl. http://drops.dagstuhl.de/opus/volltexte/2007/962 Koschke R, Merlo E, Walenstein A (eds)

[38]

Koziolek H, Domis D, Goldschmidt T, and Vorst P Measuring architecture sustainability IEEE Softw 2013 30 6 54-62

[39]

Kruchten P, Nord RL, and Ozkaya I Technical debt: From metaphor to theory and practice IEEE Softw 2012 29 6 18-21

[40]

Kwiatkowski D, Phillips PC, Schmidt P, Shin Y (1992) Testing the null hypothesis of stationarity against the alternative of a unit root: How sure are we that economic time series have a unit root? J Econ 54(1):159–178. 10.1016/0304-4076(92)90104-Y. http://www.sciencedirect.com/science/article/pii/030440769290104Y

[41]

Lanza M, Marinescu R, Ducasse S (2005) Object-Oriented Metrics in practice. Springer, Berlin

[42]

Le DM, Carrillo C, Capilla R, Medvidovic N (2016) Relating architectural decay and sustainability of software systems. In: 2016 13Th working IEEE/IFIP conference on software architecture (WICSA), pp 178–181. 10.1109/WICSA.2016.15

[43]

Le DM, Link D, Shahbazian A, Medvidovic N (2018) An empirical study of architectural decay in open-source software. In: 2018 IEEE International conference on software architecture (ICSA), pp 176–17609. 10.1109/ICSA.2018.00027

[44]

Li Z, Liang P, Avgeriou P (2015) Architectural technical debt identification based on architecture decisions and change scenarios. In: 2015 12Th working IEEE/IFIP conference on software architecture, pp 65–74. 10.1109/WICSA.2015.19

[45]

Lippert M, Roock S (2006) Refactoring in large software projects: performing complex restructurings successfully. Wiley, New York

[46]

Liu H, Ma Z, Shao W, and Niu Z Schedule of bad smell detection and resolution: a new way to save effort IEEE Trans Softw Eng 2012 38 1 220-235

[47]

Lozano A, Mens K, Portugal J (2015) Analyzing code evolution to uncover relations. In: 2015 IEEE 2Nd international workshop on patterns promotion and anti-patterns prevention (PPAP), pp 1–4. 10.1109/PPAP.2015.7076847

[48]

Lutellier T, Chollak D, Garcia J, Tan L, Rayside D, Medvidović N, and Kroeger R Measuring the impact of code dependencies on software architecture recovery techniques IEEE Trans Softw Eng 2018 44 2 159-181

[49]

Ma W, Chen L, Zhou Y, Xu B, Zhou X (2015) Are anti-patterns coupled? an empirical study. In: 2015 IEEE International conference on software quality, reliability and security, pp 242–251. 10.1109/QRS.2015.43

[50]

Macia I, Arcoverde R, Garcia A, Chavez C, von Staa A (2012a) On the relevance of code anomalies for identifying architecture degradation symptoms. In: 2012 16Th european conference on software maintenance and reengineering, pp 277–286

[51]

Macia I, Garcia J, Popescu D, Garcia A, Medvidovic N, von Staa A (2012b) Are automatically-detected code anomalies relevant to architectural modularity? In: the 11th annual international conference, pp 167–178 ACM Press

[52]

Mantyla M, Vanhanen J, Lassenius C (2003a) A taxonomy and an initial empirical study of bad smells in code. In: 2003. ICSM 2003. Proceedings of International conference on software maintenance, pp 381–384. 10.1109/ICSM.2003.1235447

[53]

Mantyla M, Vanhanen J, Lassenius C (2003b) A taxonomy and an initial empirical study of bad smells in code. In: 2003. ICSM 2003. Proceedings of International conference on software maintenance, pp 381–384. 10.1109/ICSM.2003.1235447

[54]

Marinescu R (2004) Detection strategies: Metrics-based rules for detecting design flaws. In: Proceedings of the 20th IEEE International Conference on Software Maintenance, ICSM ’04. IEEE Computer Society, pp 350–359

[55]

Martin RC (2002) Agile software development: principles, patterns, and practices. Prentice Hall

[56]

Martini A, Fontana FA, Biaggi A, Roveda R (2018) Identifying and prioritizing architectural debt through architectural smells: a case study in a large software company. In: 12Th european conference on software architecture (ECSA 2018). 10.1109/ICSA.2018.00027

[57]

Miller GA The magical number seven plus or minus two: some limits on our capacity for processing information Psychol Rev 1956 63 2 81-97

[58]

Mo R, Cai Y, Kazman R, Xiao L (2015) Hotspot patterns: The formal definition and automatic detection of architecture smells. In: WICSA. IEEE Computer Society, pp 51–60. 10.1109/WICSA.2015.12

[59]

Mo R, Cai Y, Kazman R, Xiao L, Feng Q (2019) Architecture anti-patterns: Automatically detectable violations of design principles. EEE Transactions on Software Engineering:1–1. 10.1109/TSE.2019.2910856

[60]

Moha N, Guėhėneuc Y, Duchien L, and Meur AL DECOR: A Method for the specification and detection of code and design smells IEEE Trans Softw Eng 2010 36 1 20-36

[61]

Munaiah N, Kroh S, Cabrey C, and Nagappan M Curating github for engineered software projects Empir Softw Eng 2017 22 6 3219-3253

[62]

Nam D, Lee YK, Medvidovic N (2018) Eva: a tool for visualizing software architectural evolution. In: 2018 IEEE/ACM 40Th international conference on software engineering: Companion (ICSE-companion), pp 53–56

[63]

Oizumi WN, Garcia AF, Colanzi TE, Ferreira M, Staa A (2014) When code-anomaly agglomerations represent architectural problems? an exploratory study. In: 2014 Brazilian symposium on software engineering, pp 91–100. 10.1109/SBES.2014.18

[64]

Oizumi WN, Garcia AF, Colanzi TE, Ferreira M, and Staa AV On the relationship of code-anomaly agglomerations and architectural problems J Softw Eng Res Dev 2015 3 1 11

[65]

Oizumi W, Garcia A, da Silva Sousa L, Cafeo B, Zhao Y (2016) Code anomalies flock together: Exploring code anomaly agglomerations for locating design problems. In: Proceedings of the 38th International Conference on Software Engineering, ICSE ’16. ACM, New York, pp 440–451. 10.1145/2884781.2884868

[66]

Palomba F, Bavota G, Di Penta M, Oliveto R, Poshyvanyk D, and De Lucia A Mining version histories for detecting code smells IEEE Trans Softw Eng 2015 41 5 462-489

[67]

Palomba F, Bavota G, Penta MD, Oliveto R, Lucia AD, Poshyvanyk D (2013) Detecting bad smells in source code using change history information. In: 2013 28Th IEEE/ACM international conference on automated software engineering (ASE), pp 268–278. 10.1109/ASE.2013.6693086

[68]

Palomba F, Bavota G, Penta MD, Fasano F, Oliveto R, Lucia AD (2018) A large-scale empirical study on the lifecycle of code smell co-occurrences. Inf Softw Technol 99:1–10. 10.1016/j.infsof.2018.02.004

[69]

Pietrzak B, Walter B (2006) Leveraging code smell detection with inter-smell relations. In: Abrahamsson P, Marchesi M, Succi G (eds) Extreme programming and agile processes in software engineering. Springer, Berlin, pp 75–84

[70]

Samarthyam G, Suryanarayana G, Sharma T (2016) Refactoring for software architecture smells. In: Proceedings of the 1st International Workshop on Software Refactoring. ACM, pp 1–4. 10.1145/2975945.2975946

[71]

Sharma T, Fragkoulis M, Spinellis D (2016a) Does your configuration code smell?. In: Proceedings of the 13th International Workshop on Mining Software Repositories, MSR’16, pp 189–200. 10.1145/2901739.2901761

[72]

Sharma T, Mishra P, Tiwari R (2016b) Designite — a software design quality assessment tool. In: Proceedings of the First International Workshop on Bringing Architecture Design Thinking into Developers’ Daily Activities, BRIDGE ’16. ACM. 10.1145/2896935.2896938

[73]

Sharma T, Fragkoulis M, Spinellis D (2017) House of cards: Code smells in open-source c# repositories. In: 2017 ACM/IEEE International symposium on empirical software engineering and measurement (ESEM), pp 424–429. 10.1109/ESEM.2017.57

[74]

Sharma T (2018a) Designite - A Software Design Quality Assessment Tool. http://www.designite-tools.com. [Online; accessed 31-Mar-2018]

[75]

Sharma T, Spinellis D (2018b) A survey on software smells. J Syst Softw 138:158–173. 10.1016/j.jss.2017.12.034. http://www.sciencedirect.com/science/article/pii/S0164121217303114

[76]

Sharma T (2019a) A dataset of code smells. 10.5281/zenodo.2538646

[77]

Sharma T (2019b) Designite validation data. 10.5281/zenodo.2538655

[78]

Suryanarayana G, Samarthyam G, Sharma T (2014) Refactoring for Software Design Smells: Managing Technical Debt, 1 edn. Morgan Kaufmann

[79]

Tamburri D, Kazman R, Van Den Heuvel WJ (2019) Splicing community and software architecture smells in agile teams: an industrial study. In: Agile and lean: organizations, Products and Development. 10.24251/HICSS.2019.843

[80]

Tran JB, Godfrey MW, Lee EHS, Holt RC (2000) Architectural repair of open source software. In: Proceedings IWPC 2000. 8th International Workshop on Program Comprehension, pp 48–59. 10.1109/WPC.2000.852479

[81]

VanderWeele TJ and Shpitser IOn the definition of a confounderAnn Stat2013411196-2203059415

[82]

Verdecchia R, Malavolta I, Lago P (2018) Architectural technical debt identification: The research landscape. In: Proceedings of the 2018 International Conference on Technical Debt, TechDebt ’18. ACM, New York, pp 11–20. 10.1145/3194164.3194176

[83]

Vidal S, Vazquez H, Díaz-pace JA, Marcos C, Garcia A, Oizumi W (2016a) JSpIRIT: A flexible tool for the analysis of code smells. In: Proceedings - International Conference of the Chilean Computer Science Society, SCCC. Universidad Nacional del Centro de la Provincia de Buenos Aires, Tandil, IEEE, pp 1–6

[84]

Vidal SA, Marcos C, and Díaz-Pace JA An approach to prioritize code smells for refactoring Autom Softw Eng 2016 23 3 501-532

[85]

Walter B, Fontana FA, and Ferme V Code smells and their collocations: a large-scale experiment on open-source systems J Syst Softw 2018 144 1-21

[86]

Xiao L, Cai Y, Kazman R (2014) Titan: a toolset that connects software architecture with quality analysis. In: FSE 2014: Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering. Drexel University, ACM, pp 763–766

[87]

Yamashita A, Moonen L (2013a) Exploring the impact of inter-smell relations on software maintainability: an empirical study. In: 2013 35Th international conference on software engineering (ICSE). 10.1109/ICSE.2013.6606614, pp 682–691

[88]

Yamashita A and Moonen L To what extent can maintenance problems be predicted by code smell detection? – an empirical study Inf Softw Technol 2013 55 12 2223-2242

[89]

Yamashita A, Zanoni M, Fontana FA, Walter B (2015) Inter-smell relations in industrial and open source systems: a replication and comparative analysis. In: 2015 IEEE International conference on software maintenance and evolution (ICSME), pp 121–130

Cited By

Meng FWang YChong CYu HZhu Z(2024)CLUE: Customizing clustering techniques using machine learning for software modularizationProceedings of the 15th Asia-Pacific Symposium on Internetware10.1145/3671016.3674816(189-198)Online publication date: 24-Jul-2024
https://dl.acm.org/doi/10.1145/3671016.3674816
Sharma TSpinellis DConstantinou EBacchelli A(2024)Multi-faceted Code Smell Detection at Scale using DesigniteJava 2.0Proceedings of the 21st International Conference on Mining Software Repositories10.1145/3643991.3644881(284-288)Online publication date: 15-Apr-2024
https://dl.acm.org/doi/10.1145/3643991.3644881
Caglayan DÖzcan-Top ÖHong JPark J(2024)Revisiting Technical Debt Types and Indicators for Software SystemsProceedings of the 39th ACM/SIGAPP Symposium on Applied Computing10.1145/3605098.3636043(834-841)Online publication date: 8-Apr-2024
https://dl.acm.org/doi/10.1145/3605098.3636043
Show More Cited By

Recommendations

House of cards: code smells in open-source C# repositories
ESEM '17: Proceedings of the 11th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement

Background: Code smells are indicators of quality problems that make a software hard to maintain and evolve. Given the importance of smells in the source code's maintainability, many studies have explored the characteristics of smells and analyzed their ...
Are architectural smells independent from code smells? An empirical study
Highlights
- Case study analyzing the correlations among code smells, groups of code smells and architectural smells.
Abstract
Background. Architectural smells and code smells are symptoms of bad code or design that can cause different quality problems, such as faults, technical debt, or difficulties with maintenance and evolution. Some studies ...
An interactive ambient visualization for code smells
SOFTVIS '10: Proceedings of the 5th international symposium on Software visualization

Code smells are characteristics of software that indicate that code may have a design problem. Code smells have been proposed as a way for programmers to recognize the need for restructuring their software. Because code smells can go unnoticed while ...

Comments

Please enable JavaScript to view thecomments powered by Disqus.

Information & Contributors

Information

Published In

cover image Empirical Software Engineering

Empirical Software Engineering Volume 25, Issue 5

Sep 2020

1335 pages

ISSN:1382-3256

Issue’s Table of Contents

© Springer Science+Business Media, LLC, part of Springer Nature 2020.

Publisher

Kluwer Academic Publishers

United States

Publication History

Published: 01 September 2020

Author Tags

Qualifiers

Research-article

Funding Sources

H2020 Marie Sk&lstrok;odowska-Curie Actions

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

15
Total Citations
View Citations
0
Total Downloads

Downloads (Last 12 months)0
Downloads (Last 6 weeks)0

Reflects downloads up to 13 Dec 2024

Other Metrics

View Author Metrics

Citations

Cited By

Meng FWang YChong CYu HZhu Z(2024)CLUE: Customizing clustering techniques using machine learning for software modularizationProceedings of the 15th Asia-Pacific Symposium on Internetware10.1145/3671016.3674816(189-198)Online publication date: 24-Jul-2024
https://dl.acm.org/doi/10.1145/3671016.3674816
Sharma TSpinellis DConstantinou EBacchelli A(2024)Multi-faceted Code Smell Detection at Scale using DesigniteJava 2.0Proceedings of the 21st International Conference on Mining Software Repositories10.1145/3643991.3644881(284-288)Online publication date: 15-Apr-2024
https://dl.acm.org/doi/10.1145/3643991.3644881
Caglayan DÖzcan-Top ÖHong JPark J(2024)Revisiting Technical Debt Types and Indicators for Software SystemsProceedings of the 39th ACM/SIGAPP Symposium on Applied Computing10.1145/3605098.3636043(834-841)Online publication date: 8-Apr-2024
https://dl.acm.org/doi/10.1145/3605098.3636043
Gnoyke PSchulze SKrüger J(2024)Evolution patterns of software-architecture smellsJournal of Systems and Software10.1016/j.jss.2024.112170217:COnline publication date: 1-Nov-2024
https://dl.acm.org/doi/10.1016/j.jss.2024.112170
Venters CCapilla RNakagawa EBetz SPenzenstadler BCrick TBrooks I(2024)Sustainable software engineeringInformation and Software Technology10.1016/j.infsof.2023.107316164:COnline publication date: 10-Jan-2024
https://dl.acm.org/doi/10.1016/j.infsof.2023.107316
Rio AAbreu FMendes D(2024)Causal inference of server- and client-side code smells in web apps evolutionEmpirical Software Engineering10.1007/s10664-024-10478-029:5Online publication date: 5-Aug-2024
https://dl.acm.org/doi/10.1007/s10664-024-10478-0
Sousa ARocha LBritto R(2023)Architectural Technical Debt - A Systematic Mapping StudyProceedings of the XXXVII Brazilian Symposium on Software Engineering10.1145/3613372.3613399(196-205)Online publication date: 25-Sep-2023
https://dl.acm.org/doi/10.1145/3613372.3613399
Arcelli Fontana FCamilli MRendina DTaraboi ATrubiani C(2023)Impact of Architectural Smells on Software Performance: an Exploratory StudyProceedings of the 27th International Conference on Evaluation and Assessment in Software Engineering10.1145/3593434.3593442(22-31)Online publication date: 14-Jun-2023
https://dl.acm.org/doi/10.1145/3593434.3593442
Santana de Almeida EAhmed Ivan der Hoek A(2023)Let's Go to the Whiteboard (Again): Perceptions From Software Architects on Whiteboard Architecture MeetingsIEEE Transactions on Software Engineering10.1109/TSE.2023.331441049:10(4773-4795)Online publication date: 1-Oct-2023
https://dl.acm.org/doi/10.1109/TSE.2023.3314410
Rio ABrito e Abreu F(2023)PHP code smells in web appsJournal of Systems and Software10.1016/j.jss.2023.111644200:COnline publication date: 1-Jun-2023
https://dl.acm.org/doi/10.1016/j.jss.2023.111644
Show More Cited By

View Options

View options

Media

Figures

Other

Tables

View Issue’s Table of Contents