Violations of SOLID Principles in Real-World Libraries: A Case Study on Java Collections | IJCT Volume 12 – Issue 5 | IJCT-V12I5P55

SOLID principles are at the core of object- oriented software design, supporting systems to work in modularity, extendibility & maintainability. Nevertheless, most advanced and common frameworks, like the Java Collections Framework (JCF), periodically violate these principles, due to legacy design choices, backward compatibility issues, and platform demands. This study examines such deviations from the JCF model, and finds and analyzes specific cases (e.g. usage of inheritance in Stack and Properties classes and behavioral inconsistency in unmodifiable collections). Here, we have evaluated how these violations impact software maintainability, extensibility, and developer understanding. It also explores the design and engineering tradeoffs that contributed to these deviations and their lasting consequences for sustainable software engineering. In this paper, we propose refactoring strategies and design recommendations to improve library design through SOLID principles.

Our results validate that the Java Collections Framework (JCF), despite developing to a certain extent and getting popular, contains a number of shortcomings of the SOLID principles, in particular the Single Responsibility Principle (SRP) and the Liskov Substitution Principle (LSP),so it’s supporting Hypothesis H1. We found that these violations occurred in the Stack, Properties, and Collections.unmodifiableList() classes, in which design integrity is impaired by improper inheritance, type inconsistency, and behavioral substitution issues Thus consistent with Hypothesis H2, these violations have a negative impact on the maintainability, readability, and long-term use of the software. For example, misusing inheritance in Stack and Properties generates coupling and misunderstanding, and lack of a coherent behavior in unmodifiable collections leads to runtime errors and fuzzy conceptual understanding among developers. In addition, the results support H3 by demonstrating that backward compatibility and legacy design are the most common causes of these violations. Because of the historical development of the JCF and the requirement to maintain compatibility with the previous versions, structural reorganization was not possible, and functional and design issues were compromise-based. Thirdly, reinforcing the hypothesis H4, the research demonstrates the educational significance of such design weaknesses as the JCF also serves to teach concepts associated with object oriented programming. Misconceptions about good design techniques can arise from such infringements if they aren’t adequately considered. Educators and curriculum developers need to remind students to reference these exceptions for the purpose of explaining SOLID as a strategy, in order to avoid misconception among students. On the whole, the study emphasizes the need for regular re-evaluation of existing libraries like JCF based on changing standards in software design. Promoting that a composition rather than an inheritance of code elements would be adopted, the use of type-safe abstractions, and the encouragement of responsible developer behaviour will enable the next Framework to incorporate more of the SOLID approach, improving the quality of codes and instruction in a sound design.

• Journal of Systems and Software Volume 220, February 2025, 112254 . • Abid, C., Alizadeh, V., Kessentini, M., do Nascimento Ferreira, T., Dig, D., 2020. 30 years of software refactoring research: A systematic literature review. arXiv: 2007.02194. • Ampatzoglou, A., Chatzigeorgiou, A., 2007. Evaluation of object-oriented design patterns in game development. Information and Software Technology 49, 445–454. https://doi.org/10.1016/j.infsof.2006.07.003 • Erich Gamma,Richard Helm ,Ralph Johnson,John Vlissides, 1994. Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley Professional. • Martin, R.C., 2000. Design Principles and Design Patterns 34. • Pillay, N., 2010. Teaching Design Patterns • Ramasamy, S., Jekese, G., Hwata, C., 2015. Impact of Object-Oriented Design Patterns on Software Development. International Journal of Scientific and Engineering Research Volume 3, 6. • https://www.researchgate.net/publication/2734 51390_SOLID_Principles_in_Software_Archi tecture_and_Introduction_to_RESM_Concept _in_OOP . • Abid, C., Alizadeh, V., Kessentini, M., do Nascimento Ferreira, T., Dig, D., 2020. 30 years of software refactoring research: A systematic literature review. arXiv: 2007.02194. • AlOmar, E.A., AlRubaye, H., Mkaouer, M.W., Ouni, A., Kessentini, 2021. Refactoring practices in the context of modern code review: An industrial case study at X erox. In: 2021 IEEE/ACM 43rd International Conference on Software Engineering: Software Engineering in Practice. ICS • AlOmar, E.A., Mkaouer, M.W., Ouni, A., 2024. Behind the intent of extract method refactoring: A systematic literature review. IEEE Trans. Softw. Eng. 50 (4), 668–694. http://dx.doi.org/10.1109/TSE.2023.3345800. • Bass, L., Clements, P., Kazman, R., 2012. Software Architecture in Practice: Software Architect Practice_c3. Addison-Wesley. • Becker, C., Chitchyan, R., Duboc, L., Easterbrook, S., Penzenstadler, B., Seyff, N., Venters, C.C., 2015. Sustainability design and software: The Karlskrona manifesto. In: 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering. Vol. 2, IEEE, pp. 467–476. • Bennett, K.H., Rajlich, V.T., 2000. Software maintenance and evolution: a roadmap . In: Proceedings of the Conference on the Future of Software Engineering. pp. 73–87. • Bennett, K.H., Ramage, M., Munro, M., 1999. Decision model for the legacy systems. In: IEE Proceedings-Software. Vol. 146, pp. 153– 159. • Bianchi, A., Caivano, D., Marengo, V., Visaggio, G., 2003. Iterative reengineering of legacy systems. IEEE Trans. Softw. Eng. 29 (3), 225–241. • Candela, I., Bavota, G., Russo, B., Oliveto, R., 2016. Using cohesion and coupling for software re-modularization : Is it enough? ACM Trans. Softw. Eng. Methodol. (TOSEM) 25 (3), 1–28. • Capra, E., Francalanci, C., Merlo, F., 2010. The economics of community open-source software projects: an empirical analysis of maintenance effort. Adv. Softw. Eng. 2010. • Chidamber, S., Kemerer, C., 1994. A metrics suite for object-oriented design. IEEE Trans. Softw. Eng. 20 (6), 476–493. http://dx.doi.org/10.1109/32.295895. Curtis, B., Sappidi, J., Szynkarski, A., 2012. Estimating the size, cost, and type of technical debt. In: 2012 Third International Workshop on Managing Technical Debt. MTD, IEEE, pp. 49–53. • Dams, D., Mooij, A., Kramer, P., Rădulescu, A., Vaňhara, J., 2018. Model-based software restructuring: Lessons from cleaning up COM interfaces in industrial legacy codes . In: 2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering. SANER, pp. 552–556. http://dx.doi.org/10.1109/SANER.2018. 8330258. • https://www.digitalocean.com/community/con ceptual-articles/s-o-l-i-d-the-first-five- principles-of-object-oriented-design • https://stackoverflow.com/questions/30616660 /which-solid-principles-are-violated • Java-8 Documentation https://docs.oracle.com/javase/8/docs/api/java/ util/Properties.html

Call for Paper (Hub) Fast Paper Publication IJCT Indexing & Databases Submit Manuscript Call for Paper: Sep–Oct 2025 Call for Paper: Publish Research