Exploring the Relationship Between SOLID Principles and Code Smells: The Software Developer Perspective
DOI:
https://doi.org/10.5753/jserd.2026.6765Keywords:
Software Engineering, Refactoring, Code Smell, SOLID Principles, Code Maintenance, Software Design, SurveyAbstract
Software engineering principles aim to deliver high-quality products efficiently. However, as development progresses and new features are added, software quality can deteriorate without proactive measures. Refactoring helps maintain software quality by systematically restructuring code through small incremental changes without altering its behavior. A crucial step in the refactoring process is identifying code smells, which are design or structural flaws that increase software complexity, hinder maintenance, and contribute to duplication and rework. This study examines developers' knowledge of code smells and their perceptions of using SOLID principles to avoid them. To explore this relationship, we conducted a survey with 71 professional developers. Our results show no correlation between knowledge of code smells and the developer's academic background or experience level. Additionally, participants widely recognized the SOLID principles as an effective way of avoiding code smells. These findings reinforce the importance of studying code smells, understanding their refactoring techniques, and applying the SOLID principles for maintaining high-quality software products.
Downloads
References
Abdelkader, H., Abdelrazek, M., Rani, P., Vasa, R., and Schneider, J.-G. (2025). Ensuring robustness in ML-enabled software systems: A user survey. arXiv, abs/2510.18292.
Aljedaani, W. and Javed, Y. (2020). Empirical study of software test suite evolution. In 2020 6th Conference on Data Science and Machine Learning Applications (CDMA), pages 87–93.
Amorim, L., da Costa, I. M., Alves, L., and Figueiredo, E. (2025). Bad smell detection using Google Gemini. In IEEE 49th Annual Computers, Software, and Applications Conference (COMPSAC), pages 1637–1642.
Cabral, R., Kalinowski, M., Baldassarre, M. T., Villamizar, H., Escovedo, T., and Lopes, H. (2024). Investigating the impact of SOLID design principles on machine learning code understanding. In Proceedings of the IEEE/ACM 3rd International Conference on AI Engineering – Software Engineering for AI, pages 7–17. Association for Computing Machinery.
Chebanyuk, E. and Markov, K. (2016). An approach to class diagrams verification according to SOLID design principles. In 2016 4th International Conference on Model-Driven Engineering and Software Development (MODELSWARD), pages 435–441.
de Oliveira, R. P. and de Almeida, E. S. (2016). Evaluating Lehman’s laws of software evolution for software product lines. IEEE Software, 33(3):90–93.
Di Nucci, D., Palomba, F., Tamburri, D. A., Serebrenik, A., and De Lucia, A. (2018). Detecting code smells using machine learning techniques: Are we there yet? In 2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER), pages 612–621.
Fernandes, E., Oliveira, J., Vale, G., Paiva, T., and Figueiredo, E. (2016). A review-based comparative study of bad smell detection tools. In Proceedings of the 20th International Conference on Evaluation and Assessment in Software Engineering (EASE).
Fowler, M. (1999). Refactoring: Improving the Design of Existing Code. Addison-Wesley.
Hu, W., Liu, L., Yang, P., Zou, K., Li, J., Lin, G., and Xiang, J. (2023). Revisiting "code smell severity classification using machine learning techniques". In 2023 IEEE 47th Annual Computers, Software, and Applications Conference (COMPSAC), pages 840–849.
Källén, M., Holmgren, S., and Þóra Hvannberg, E. (2014). Impact of code refactoring using object-oriented methodology on a scientific computing application. In IEEE 14th International Working Conference on Source Code Analysis and Manipulation, pages 125–134.
Liu, L., Lin, G., Zhu, L., Yang, Z., Song, P., Wang, X., and Hu, W. (2024). Revisiting code smell severity prioritization using learning to rank techniques. Expert Systems with Applications, 249:123483.
Madeyski, L. and Lewowski, T. (2020). MLCQ: Industry-relevant code smell data set. In Proceedings of the 24th International Conference on Evaluation and Assessment in Software Engineering, EASE ’20, pages 342–347. Association for Computing Machinery.
Martin, R. C. (2017). Clean Architecture: A Craftsman's Guide to Software Structure and Design. Prentice Hall Press, 1st edition.
Oktafiani, I. and Hendradjaya, B. (2018). Software metrics proposal for conformity checking of class diagram to SOLID design principles. In 5th International Conference on Data and Software Engineering (ICoDSE), pages 1–6.
Paiva, T., Damasceno, A., Figueiredo, E., and Sant’Anna, C. (2017). On the evaluation of code smells and detection tools. Journal of Software Engineering Research and Development, 5(1):7.
Palomba, F. (2015). Textual analysis for code smell detection. In Proceedings of the 37th International Conference on Software Engineering – Volume 2, ICSE ’15, pages 769–771. IEEE Press.
Palomba, F., Bavota, G., Di Penta, M., Fasano, F., Oliveto, R., and De Lucia, A. (2018). On the diffuseness and the impact on maintainability of code smells: A large-scale empirical investigation. In Proceedings of the 40th International Conference on Software Engineering, ICSE ’18, page 482. Association for Computing Machinery.
Pathiraja, A. L. C. D. (2024). Software quality assurance practices towards waterfall and agile information systems projects of BOI registered software companies in Sri Lanka. In 2024 9th International Conference on Information Technology Research (ICITR), pages 1–4, Colombo, Sri Lanka.
Replication Package (2025). Survey response dataset repository. Available at: [link].
Riquet, N., Devroey, X., and Vanderose, B. (2024). Debt stories: Capturing social and technical debt in the industry. In 2024 IEEE/ACM International Conference on Technical Debt (TechDebt), pages 40–44.
Santana, A., Figueiredo, E., Alves Pereira, J., and Garcia, A. (2024a). An exploratory evaluation of code smell agglomerations. Software Quality Journal, 32(4):1375–1412.
Santana, A., Figueiredo, E., and Pereira, J. A. (2024b). Unraveling the impact of code smell agglomerations on code stability. In 2024 IEEE International Conference on Software Maintenance and Evolution (ICSME), pages 461–473.
Santos, G., Santana, A., Vale, G., and Figueiredo, E. (2023). Yet another model! A study on model similarities for defect and code smells. In International Conference on Fundamental Approaches to Software Engineering, pages 282–305. Springer.
Silva, L. L., Silva, J. R. d., Montandon, J. E., Andrade, M., and Valente, M. T. (2024). Detecting code smells using ChatGPT: Initial insights. In Proceedings of the 18th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement, ESEM ’24, pages 400–406. Association for Computing Machinery.
Sobrinho, E. V. d. P. and Maia, M. d. A. (2021). On the interplay of smells: Large class, complex class, and duplicate code. In Brazilian Symposium on Software Engineering, pages 64–73.
Wohlin, C. (2000). Experimentation in Software Engineering: An Introduction. Kluwer Academic Publishers.
Yamashita, A. and Moonen, L. (2013). Do developers care about code smells? An exploratory survey. In 2013 20th Working Conference on Reverse Engineering (WCRE), pages 242–251.
Yanakiev, I., Lazar, B.-M., and Capiluppi, A. (2024). Applying SOLID principles for the refactoring of legacy code: An experience report. Journal of Systems and Software, 220.
Ünlü, H., Bilgin, B., and Demirörs, O. (2022). A survey on organizational choices for microservice-based software architectures. Turkish Journal of Electrical Engineering and Computer Sciences, 30(4):1187–1203.
Downloads
Published
How to Cite
Issue
Section
License
Copyright (c) 2026 Ivandeclei Mendes, Mateus Dutra, Khalid Usman, Eduardo Figueiredo
This work is licensed under a Creative Commons Attribution 4.0 International License.
