Systematic Review of Code Smell Patterns and Their Impact on Software Technical Debt
DOI:
https://doi.org/10.61467/2007.1558.2025.v16i1.947Keywords:
refactoring, technical debt, software entropy, design qualityAbstract
The accumulation of technical debt in legacy software is primarily manifested through the recurring need to modify code in order to correct defects, adapt it to new requirements, or alter existing functionalities. This situation reduces the useful lifespan of software systems by increasing their fragility, as a consequence of the continuous interventions required for maintenance and correction. Code smells constitute one of the principal contributors to this problem in software development. Consequently, it is essential to address this issue through appropriate design and coding practices in order to enhance code quality, maintainability, and readability. The objective of the present research is to identify the relative frequency of practices employed by developers during the design and coding phases that lead to the generation of malformed code, thereby contributing to entropy and increased technical debt in legacy systems. The study focuses on evaluating factors related to structural design and programming practices, while also conducting statistical analyses to identify recurring patterns associated with code smells. The results provide a detailed understanding of the most common practices and their impact on software quality. Furthermore, they highlight relevant gaps in current software engineering research and development, suggesting potential directions for future investigations aimed at addressing these shortcomings.
Smart citations: https://scite.ai/reports/10.61467/2007.1558.2025.v16i1.947
References
Abdelaziz, T. M., Elghadhafi, H. A., & Maatuk, A. M. (2018, June 19). A novel approach for improving the quality of software code using reverse engineering. ACM International Conference Proceeding Series. https://doi.org/10.1145/3234698.3234729
Akash, P. S., Sadiq, A. Z., & Kabir, A. (2019). An approach of extracting God class exploiting both structural and semantic similarity. ENASE 2019 - Proceedings of the 14th International Conference on Evaluation of Novel Approaches to Software Engineering, 427–433. https://doi.org/10.5220/0007743804270433
Aras, R. (2022). Decision Support System (DSS) dengan Berorientasi -Solver. teknik, 2(1), 58-63. https://doi.org/10.55606/teknik.v2i1.917
Arif, A., & Rana, Z. A. (2020, December 16). Refactoring of Code to Remove Technical Debt and Reduce Maintenance Effort. 2020 14th International Conference on Open Source Systems and Technologies, ICOSST 2020 - Proceedings. https://doi.org/10.1109/ICOSST51357.2020.9332917
Bibiano, A. C., Soares, V., Coutinho, D., Fernandes, E., Correia, J. L., Santos, K., Oliveira, A., Garcia, A., Gheyi, R., Fonseca, B., Ribeiro, M., Barbosa, C., & Oliveira, D. (2020). How does incomplete composite refactoring affect internal quality attributes? IEEE International Conference on Program Comprehension, 149–159. https://doi.org/10.1145/3387904.3389264
Fernandes, S., Aguiar, A., & Restivo, A. (2024). The Impact of a Live Refactoring Environment on Software Development. Proceedings - International Conference on Software Engineering, 337–338. https://doi.org/10.1145/3639478.3643100
Ganea, G., Verebi, I., & Marinescu, R. (2017). Continuous quality assessment with inCode. Science of Computer Programming, 134, 19–36. https://doi.org/10.1016/j.scico.2015.02.007
Gradišnik, M., & Heričko, M. (2018, August 27). Impact of Code Smells on the Rate of Defects in Software: A Literature Review . http://www.webofknowledge.com/
Guggulothu, T., & Moiz, S. A. (2019). An Approach to Suggest Code Smell Order for Refactoring. Communications in Computer and Information Science, 985, 250–260. https://doi.org/10.1007/978-981-13-8300-7_21
Guggulothu, T., & Moiz, S. A. (2020). Code smell detection using multi-label classification approach. Software Quality Journal, 28(3), 1063–1086. https://doi.org/10.1007/s11219-020-09498-y
Gupta, P., Anand, A., & Mellal, M. A. (2023). Resource Allocation Modeling Framework to Refactor Software Design Smells. International Journal of Mathematical, Engineering and Management Sciences, 8(2), 213–229. https://doi.org/10.33889/ijmems.2023.8.2.013
Jaber, K. Mohammad. (2019). Code Smells Analysis Mechanisms, Detection Issues, and Effect on Software Maintainability.
Kaur, A., Jain, S., & Goel, S. (2017). A Support Vector Machine Based Approach for Code Smell Detection. Proceedings - 2017 International Conference on Machine Learning and Data Science, MLDS 2017, 2018-January, 9–14. https://doi.org/10.1109/MLDS.2017.8
Kiss, A., & Mihancea, P. F. (2018). Towards feature envy design flaw detection at block level. Proceedings - 2018 IEEE International Conference on Software Maintenance and Evolution, ICSME 2018, 544–548. https://doi.org/10.1109/ICSME.2018.00064
Kitchenham, B. (2007). Guidelines for performing Systematic Literature Reviews in Software Engineering. https://www.researchgate.net/publication/302924724
Kumar Das, A., Yadav, S., & Dhal, S. (2019). Detecting Code Smells using Deep Learning. 1362.
Lahti, J. R., Tuovinen, A. P., & Mikkonen, T. (2021). Experiences on Managing Technical Debt with Code Smells and AntiPatterns. Proceedings - 2021 IEEE/ACM International Conference on Technical Debt, TechDebt 2021, 36–44. https://doi.org/10.1109/TechDebt52882.2021.00013
Lárez Mata, J. J. (2020). Calidad de Software - Deuda Técnica. https://saber.ucab.edu.ve/handle/123456789/647
Liu, H., Jin, J., Xu, Z., Zou, Y., Bu, Y., & Zhang, L. (2021). Deep learning based code smell detection. IEEE Transactions on Software Engineering, 47(9), 1811–1837. https://doi.org/10.1109/TSE.2019.2936376
Liu, H., Liu, Q., Niu, Z., & Liu, Y. (2016). Dynamic and Automatic Feedback-Based Threshold Adaptation for Code Smell Detection. IEEE Transactions on Software Engineering, 42(6), 544–558. https://doi.org/10.1109/TSE.2015.2503740
Liu, H., Yu, Y., Li, B., Yang, Y., & Jia, R. (2018). Are Smell-Based Metrics Actually Useful in Effort-Aware Structural Change-Proneness Prediction? An Empirical Study. Proceedings - Asia-Pacific Software Engineering Conference, APSEC, 2018-December, 315–324. https://doi.org/10.1109/APSEC.2018.00046
Mehta, Y., Singh, P., & Sureka, A. (2018). Analyzing Code Smell Removal Sequences for Enhanced Software Maintainability.
Merzah, B. M., & Selçuk, Y. E. (2017). Metric Based Detection of Refused Bequest Code Smell. 121.
Mkaouer, M. W., Kessentini, M., Cinnéide, M., Hayashi, S., & Deb, K. (2017). A robust multi-objective approach to balance severity and importance of refactoring opportunities. Empirical Software Engineering, 22(2), 894–927. https://doi.org/10.1007/s10664-016-9426-8
Mohan, M., Greer, D., & McMullan, P. (2016). Technical debt reduction using search based automated refactoring. Journal of Systems and Software, 120, 183–194. https://doi.org/10.1016/j.jss.2016.05.019
M.Sangeetha, & P.Sengottuvelan. (2017). A Perspective Approach for Refactoring Framework Using Monitor based Approach.
Mumtaz, H., Alshayeb, M., Mahmood, S., & Niazi, M. (2018). An empirical study to improve software security through the application of code refactoring. Information and Software Technology, 96, 112–125. https://doi.org/10.1016/j.infsof.2017.11.010
Nyamawe, A. S., Liu, H., Niu, Z., Wang, W., & Niu, N. (2018). Recommending refactoring solutions based on traceability and code metrics. IEEE Access, 6, 49460–49475. https://doi.org/10.1109/ACCESS.2018.2868990
Oliveira, R., Estácio, B., Garcia, A., Marczak, S., Prikladnicki, R., Kalinowski, M., & Lucena, C. (2016). Identifying code smells with collaborative practices: A controlled experiment. Proceedings - 2016 10th Brazilian Symposium on Components, Architectures and Reuse Software, SBCARS 2016, 61–70. https://doi.org/10.1109/SBCARS.2016.18
Ouni, A., Kessentini, M., Ó Cinnéide, M., Sahraoui, H., Deb, K., & Inoue, K. (2017). MORE: A multi-objective refactoring recommendation approach to introducing design patterns and fixing code smells. Journal of Software: Evolution and Process, 29(5). https://doi.org/10.1002/smr.1843
Palomba, F., Panichella, A., Zaidman, A., Oliveto, R., & De Lucia, A. (2018). The scent of a smell: An Extensive Comparison between Textual and Structural Smells. 740–740. https://doi.org/10.1145/3180155.3182530
Palomba, F., Zanoni, M., Fontana, F. A., De Lucia, A., & Oliveto, R. (2019). Toward a smell-aware bug prediction model. IEEE Transactions on Software Engineering, 45(2), 194–218. https://doi.org/10.1109/TSE.2017.2770122
Panigrahi, R., Kumar Kuanar, S., & Kumar, L. (2020). Application of Naïve Bayes classifiers for refactoring Prediction at the method level. 2020 International Conference on Computer Science, Engineering and Applications (ICCSEA).
Pantiuchina, J., Lanza, M., & Bavota, G. (2018). Improving code: The (mis) perception of quality metrics. Proceedings - 2018 IEEE International Conference on Software Maintenance and Evolution, ICSME 2018, 80–91. https://doi.org/10.1109/ICSME.2018.00017
Paulk, Mark. (2016). Code smells´ incidence does it depend on the application domain.
Pecorelli, F., Palomba, F., Khomh, F., & De Lucia, A. (2020). Developer-Driven Code Smell Prioritization. Proceedings - 2020 IEEE/ACM 17th International Conference on Mining Software Repositories, MSR 2020, 220–231. https://doi.org/10.1145/3379597.3387457
Peruma, A., AlOmar, E. A., Newman, C. D., Mkaouer, M. W., & Ouni, A. (2022). Refactoring Debt: Myth or Reality? An Exploratory Study on the Relationship Between Technical Debt and Refactoring. http://arxiv.org/abs/2203.05660
Rahman, M. M., Riyadh, R. R., Khaled, S. M., Satter, A., & Rahman, M. R. (2018). MMRUC3: A recommendation approach of move method refactoring using coupling, cohesion, and contextual similarity to enhance software design. Software - Practice and Experience, 48(9), 1560–1587. https://doi.org/10.1002/spe.2591
Rahman, M., Riyadh, R. R., & Rahman, R. (2017). Recommendation of Move Method Refactorings Using Coupling, Cohesion and Contextual Similarity.
Rani, A., & Chhabra, J. K. (2017a). Evolution of Code Smells over Multiple Versions of Softwares An Empirical Investigation.
Rani, A., & Chhabra, J. K. (2017b). Prioritization of Smelly Classes A Two Phase Approach.
Reeshti, Sehgal, R., Nagpal, R., & Mehrotra, D. (2019, November 21). Measuring Code Smells and Anti-Patterns . 4th International Conference on Information Systems and Computer Networks (ISCON).
Sae-Lim, N., Hayashi, S., & Saeki, M. (2017). How do developers select and prioritize code smells? A preliminary study. Proceedings - 2017 IEEE International Conference on Software Maintenance and Evolution, ICSME 2017, 484–488. https://doi.org/10.1109/ICSME.2017.66
Sangeetha, M., & Sengottuvelan, P. (2017). Systematic Exhortation of Code Smell Detection Using JSmell for Java Source Code.
Sharma, T. (2018). Detecting and managing code smells: Research and practice. Proceedings - International Conference on Software Engineering, 546–547. https://doi.org/10.1145/3183440.3183460
Shen, L., Liu, W., Chen, X., Gu, Q., & Liu, X. (2020). Improving machine learning-based code smell detection via hyper-parameter optimization. Proceedings - Asia-Pacific Software Engineering Conference, APSEC, 2020-December, 276–285. https://doi.org/10.1109/APSEC51365.2020.00036
Singh, R., Bindal, A., & Kumar, A. (2019). A user feedback centric approach for detecting and mitigating god class code smell using frequent usage patterns. Journal of Communications Software and Systems, 15(3), 245–253. https://doi.org/10.24138/jcomss.v15i3.720
Sirikul, K., & Soomlek, C. (2016). Automated Detection of Code Smells Caused by Null Checking Conditions in Java Programs.
Tufano, M., Palomba, F., Bavota, G., Di Penta, M., Oliveto, R., De Lucia, A., & Poshyvanyk, D. (2016). An empirical investigation into the nature of test smells. ASE 2016 - Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering, 4–15. https://doi.org/10.1145/2970276.2970340
Turkistani, B., & Liu, Y. (2019). Reducing the Large Class Code Smell by Applying Design Patterns.
Ubayawardana, G. M., & Karunaratna, D. D. (2018). Bug Prediction Model using Code Smells. 446.
Xu, S., Guo, C., Liu, L., & Xu, J. (2017). A Log-linear Probabilistic Model for Prioritizing Extract Method Refactorings.
Zhang, D., Li, B., Li, Z., & Liang, P. (2018). A preliminary investigation of self-Admitted refactorings in open source software. Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE, 2018-July, 165–168. https://doi.org/10.18293/SEKE2018-081
Zhu, H., Li, Y., Li, J., & Zhang, X. (2023). An Efficient Design Smell Detection Approach with Inter-class Relation. Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE, 2023-July, 181–186. https://doi.org/10.18293/SEKE2023-208
Downloads
Published
How to Cite
Issue
Section
License
Copyright (c) 2025 International Journal of Combinatorial Optimization Problems and Informatics
This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.
