INVESTIGATION OF CODE SMELLS IN ECLIPSE FRAMEWORK USING SONARQUBE: AN EMPIRICAL ANALYSIS

Authors

  • Simon Kawuma Software and Informatics Engineering Department, Mbarara University Science and of Technology, Uganda
    • David Sabiiti Bamutura Computer Science Department, Mbarara University Science and of Technology, Uganda
      • Enock Mabberi Software and Informatics Engineering Department, Mbarara University of Science and Technology, Uganda
        • Moreen Kabarungi Software and Informatics Engineering Department, Mbarara University of Science and Technology, Uganda
          • Dickson Kalungi Software and Informatics Engineering Department, Mbarara University of Science and Technology, Uganda
            • Aggrey Obbo Software and Informatics Engineering Department, Mbarara University Science and of Technology,
              • Evarist Nabaasa Computer Science Department, Mbarara University Science and of Technology, Uganda

                DOI:

                https://doi.org/10.15282//ijsecs.11.2.2025.14.0146

                Keywords:

                Eclipse, Public APIs, Internal APIs, Code Smell, Software Quality

                Abstract

                The Eclipse Framework provides both public and internal Application Programming Interfaces (APIs). Public APIs are widely supported and encouraged for use, while internal APIs are considered immature and subject to frequent changes. However, the quality of these APIs is not guaranteed, with many users reporting code smells, which could lead to application failures if unresolved. While some studies indicate that not all code smells can be easily fixed, users often face the challenge of either addressing these issues themselves or abandoning problematic APIs. To address this, we conducted an empirical investigation using the SonarQube static code analysis tool on 28 major Eclipse releases, aiming to identify code-smell-free APIs. Our study provides a dataset of 218K code-smell-free public APIs and 321K internal APIs. We found that 87.3% of public APIs and 91.5% of internal APIs in the analysed releases are free from code smells, highlighting the importance of using these cleaner alternatives for application stability and long-term usability. Furthermore, we have discovered that the number of code smells proportionately increases as the Eclipse Framework evolves. The average number of code smells and technical debt is 147K and 2,744 days, respectively, in all the studied Eclipse releases.  Results from this study can be used by both interface providers and users as a starting point to recognize code smell-free interfaces and estimate efforts needed to fix code smells in each version of Eclipse.

                Downloads

                Download data is not yet available.

                References

                [1] T. Tourwé and T. Mens, “Automated support for framework-based software,” in Proc. Int. Conf. Software Maintenance (ICSM), 2003, pp. 148-157.

                [2] D. Konstantopoulos, J. Marien, M. Pinkerton, and E. Braude, “Best principles in the design of shared software,” in Proc. 33rd Annu. IEEE Int. Computer Software and Applications Conf. (COMPSAC), vol. 2, 2009, pp. 287-292.

                [3] J. Businge, S. Kawuma, M. Openja, E. Bainomugisha, and A. Serebrenik, “How stable are Eclipse application framework internal interfaces?” in Proc. 26th IEEE Int. Conf. Software Analysis, Evolution and Reengineering (SANER), 2019, pp. 117–127, https://doi.org/10.1109/SANER.2019.8668018.

                [4] J. des Rivières, “How to use the Eclipse API,” Eclipse Foundation. [Online]. Available: https://www.eclipse.org/articles/Article-API-Use/index.html. [Accessed: Jan. 2024].

                [5] jBPM Team, “The jBPM APIs,” Red Hat. [Online]. Available: https://docs.jboss.org/jbpm/v5.0/userguide/ch05.html#d0e2099. [Accessed: Jan. 2024].

                [6] Oracle, “Why developers should not write programs that call ‘sun’ packages.” [Online]. Available: https://www.oracle.com/java/technologies/faq-sun-packages.html. [Accessed: Jan. 2024].

                [7] JUnit Team, “JUnit 5 user guide.” [Online]. Available: https://junit.org/junit5/docs/current/user-guide/. [Accessed: Jan. 2024].

                [8] Eclipse Foundation, “Provisional API guidelines,” Eclipsepedia. [Online]. Available: https://wiki.eclipse.org/Provisional_API_Guidelines. [Accessed: Jan. 2024].

                [9] J. Businge, A. Serebrenik, and M. van den Brand, “Eclipse API usage: The good and the bad,” Software Quality Journal, vol. 23, pp. 107-141, 2015, https://doi.org/10.1007/s11219-013-9221-3.

                [10] A. Hora, M. T. Valente, R. Robbes, and N. Anquetil, “When should internal interfaces be promoted to public?” in Proc. 24th ACM SIGSOFT Int. Symp. Foundations of Software Engineering, 2016, pp. 278-289, https://doi.org/10.1145/2950290.2950306.

                [11] J. Businge, A. Serebrenik, and M. van den Brand, “Analyzing the Eclipse API usage: Putting the developer in the loop,” in Proc. 17th European Conf. Software Maintenance and Reengineering, 2013, pp. 37-46, https://doi.org/10.1109/CSMR.2013.14.

                [12] D. Johannes, F. Khomh, and G. Antoniol, “A large-scale empirical study of code smells in JavaScript projects,” Software Quality Journal, vol. 27, pp. 1271-1314, 2019.

                [13] A. Gupta, B. Suri, and S. Misra, “Code bad smells in Java source code: A systematic literature review,” in Proc. Int. Conf. Computational Science and Its Applications (ICCSA), 2017, pp. 665-682.

                [14] A. Walker, D. Das, and T. Cerny, “Automated code-smell detection in microservices through static analysis: A case study,” Applied Sciences, vol. 10, no. 21, Art. no. 7800, 2020, https://doi.org/10.3390/app10217800.

                [15] A. D. F. Martins, C. S. Melo, J. M. Monteiro, and J. C. Machado, “Class change proneness prediction using software metrics and code smells,” in Proc. Int. Conf. Enterprise Information Systems (ICEIS), 2020, pp. 140-147.

                [16] M. Alfadel, K. Aljasser, and M. Alshayeb, “Relationship between design patterns and code smells: An empirical study,” PLoS ONE, vol. 15, no. 4, Art. no. e0231731, 2020, https://doi.org/10.1371/journal.pone.0231731.

                [17] F. Li, M. Zhang, S. Wang, J. Zhang, and Q. Gu, “On the relative value of imbalanced learning for code smell detection,” Journal of Systems and Software, vol. 198, Art. no. 111566, 2023, https://doi.org/10.1016/j.jss.2023.111566.

                [18] T. Paiva, A. Damasceno, E. Figueiredo, and C. Sant’Anna, “On the evaluation of code smells and detection tools,” Journal of Software Engineering Research and Development, vol. 5, Art. no. 7, 2017, https://doi.org/10.1186/s40411-017-0041-1.

                [19] M. Gradisnik and M. Hericko, “Impact of code smells on defect rate: A literature review,” CEUR Workshop Proceedings, vol. 2217, pp. 27-30, 2018.

                [20] R. S. Menshawy, A. H. Yousef, and A. Salem, “Code smells and detection techniques: A survey,” in Proc. MIUCC, 2021, pp. 78-83.

                [21] U. Mansoor, M. Kessentini, B. R. Maxim, and K. Deb, “Multi-objective code-smells detection using good and bad design examples,” Software Quality Journal, vol. 25, pp. 529–552, 2017, https://doi.org/10.1007/s11219-016-9309-7

                [22] E. Doğan and E. Tüzün, “Towards a taxonomy of code review smells,” Information and Software Technology, vol. 142, Art. no. 106737, 2022, https://doi.org/10.1016/j.infsof.2021.106737.

                [23] A. Tahir, A. Yamashita, S. Licorish, J. Dietrich, and S. Counsell, “How developers discuss code smells on Stack Overflow,” in Proc. Evaluation and Assessment in Software Engineering (EASE), 2018, pp. 68-78.

                [24] A. Campbell, “SonarQube documentation,” Jan. 2022. [Online]. Available: https://scm.thm.de/sonar/documentation/user-guide/metric-definitions/. [Accessed: Jan. 2024].

                [25] S. Kawuma, J. Businge, and E. Bainomugisha, “Stable alternatives for unstable Eclipse interfaces,” in Proc. IEEE Int. Conf. Program Comprehension (ICPC), 2016, pp. 1–10.

                [26] S. Kawuma and E. Nabaasa, “Identification of promoted Eclipse unstable interfaces using clone detection technique,” International Journal of Software Engineering & Applications, vol. 9, no. 5, pp. 15–25, 2018, https://doi.org/10.5121/ijsea.2018.9502.

                [27] L. Guerrouj, A. Azad, G. Antoniol, and Y.-G. Guéhéneuc, “Investigating the relation between lexical smells and change- and fault-proneness,” Software Quality Journal, vol. 25, pp. 641-670, 2017.

                [28] B. Seref and O. Tanriover, “Software code maintainability: A literature review,” International Journal of Software Engineering and Applications, vol. 7, no. 3, pp. 1-16, 2016.

                [29] A. J. Jafari, D. E. Costa, R. Abdalkareem, E. Shihab, and N. Tsantalis, “Dependency smells in JavaScript projects,” IEEE Transactions on Software Engineering, vol. 48, no 10, pp. 3790-3807, 2022, https://doi.org/10.1109/TSE.2021.3106247.

                [30] G. Lacerda, F. Petrillo, M. Pimenta, and Y.-G. Guéhéneuc, “Code smells and refactoring: A tertiary systematic review,” Journal of Systems and Software, vol. 167, Art. no. 110610, 2020, https://doi.org/10.1016/j.jss.2020.110610.

                [31] M. Agnihotri and A. Chug, “Software metrics, code smells and refactoring techniques: A systematic survey,” International Journal of Information Processing Systems, vol. 16, no. 4, pp. 915-934, 2020.

                [32] H. M. Dos Santos, V. H. Durelli, M. Souza, E. Figueiredo, L. T. Silva, and R. S. Durelli, “CleanGame: Gamifying the identification of code smells,” in Proc. Brazilian Symp. Software Engineering, 2019, pp. 437-446.

                [33] P. Meananeatra, “Identifying refactoring sequences for improving software maintainability,” in Proc. IEEE/ACM Int. Conf. Automated Software Engineering (ASE), 2012, pp. 406-409.

                [34] D. Taibi, A. Janes, and V. Lenarduzzi, “How developers perceive smells in source code,” Information and Software Technology, vol. 92, pp. 223–235, 2017, https://doi.org/10.1016/j.infsof.2017.08.008.

                [35] A. Yamashita and L. Moonen, “Do developers care about code smells?” in Proc. Working Conf. Reverse Engineering (WCRE), 2013, pp. 242-251.

                [36] D. J. Kim, “An empirical study on the evolution of test smells,” in Proc. IEEE/ACM Int. Conf. Software Engineering Companion (ICSE-Companion), 2020, pp. 149-151.

                [37] S. Jain and A. Saha, “An empirical study on research and developmental opportunities in refactoring practices,” in Proc. Int. Conf. Software Engineering and Knowledge Engineering (SEKE), 2019, pp. 313-318.

                [38] B. F. Békefi, K. Szabados, and A. Kovács, “A case study on the effects and limitations of refactoring,” in Proc. Informatics, 2019, pp. 213-218.

                [39] S. Vidal, I. Berra, S. Zulliani, C. Marcos, and J. A. D. Pace, “Assessing the refactoring of brain methods,” ACM Transactions on Software Engineering and Methodology, vol. 27, no. 1, pp. 1-43, 2018.

                [40] A. AbuHassan, M. Alshayeb, and L. Ghouti, “Software smell detection techniques: A systematic literature review,” Journal of Software: Evolution and Process, vol. 33, no. 3, Art. no. e2320, 2021, https://doi.org/10.1002/smr.2320.

                [41] A. Kaur and G. Dhiman, “A review on search-based tools and techniques to identify bad code smells in object-oriented systems,” International Journal of Applied Engineering Research, vol. 14, pp. 909-921, 2019.

                [42] M. Tufano, F. Palomba, and G. Bavota, “When and why your code starts to smell bad,” in Proc. IEEE/ACM Int. Conf. Software Engineering (ICSE), 2015, pp. 403-414.

                [43] T. Sharma, V. Efstathiou, P. Louridas, and D. Spinellis, “Code smell detection by deep direct-learning and transfer-learning,” Journal of Systems and Software, vol. 176, Art. no. 110936, 2021, https://doi.org/10.1016/j.jss.2021.110936.

                [44] N. A. A. Khleel and K. Nehéz, “Deep convolutional neural network model for bad code smells detection based on oversampling method,” Indonesian Journal of Electrical Engineering and Computer Science, vol. 26, no. 3, pp. 1725–1735, Jun. 2022, https://doi.org/10.11591/ijeecs.v26.i3.pp1725-1735.

                [45] S. Dewangan, R. S. Rao, A. Mishra, and M. Gupta, “Code smell detection using ensemble machine learning algorithms,” Applied Sciences, vol. 12, no. 20, Art. no. 10321, 2022, https://doi.org/10.3390/app122010321.

                [46] A. K. Das, S. Yadav, and S. Dhal, “Detecting code smells using deep learning,” in Proc. IEEE Region 10 Conf. (TENCON), 2019, pp. 2081–2086.

                [47] Y. Zhang and C. Dong, “MARS: Detecting brain class and brain method code smells,” Journal of Software: Evolution and Process, vol. 36, no. 1, Art. no. e2403, 2024.

                [48] M. Y. Mhawish and M. Gupta, “Predicting code smells and analysis of predictions using machine learning techniques,” Journal of Computer Science and Technology, vol. 35, no. 6, pp. 1428–1445, 2020.

                [49] M. Fawad, G. Rasool, and F. Palma, “Android source code smells: A systematic literature review,” Software: Practice and Experience, vol. 54, no. 2, pp. 345–372, 2024.

                [50] Z. Wu, X. Chen, and S. J. Lee, “A systematic literature review on Android-specific smells,” Journal of Systems and Software, vol. 201, Art. no. 111677, 2023, https://doi.org/10.1016/j.jss.2023.111677.

                [51] J. A. Hurtado Alegría, M. C. Bastarrica, and A. Bergel, “Avispa: A tool for analyzing software process models,” Journal of Software: Evolution and Process, vol. 26, no. 4, pp. 434–450, 2014.

                [52] Eclipse Foundation, “Eclipse project archived downloads.” [Online]. Available: https://archive.eclipse.org/eclipse/downloads/. [Accessed: Jan. 2024].

                [53] Eclipse Foundation, “Eclipse IDE for Java Developers.” [Online]. Available: https://www.eclipse.org/downloads/packages/. [Accessed: Jan. 2024].

                [54] V. Lenarduzzi, A. Sillitti, and D. Taibi, “Analyzing forty years of software maintenance models,” in Proc. IEEE/ACM Int. Conf. Software Engineering Companion (ICSE-C), 2017, pp. 146-148.

                [55] V. Lenarduzzi, A. Sillitti, and D. Taibi, “A survey on code analysis tools for software maintenance prediction,” in Proc. SEDA, 2020, pp. 165-175.

                [56] D. Marcilio, R. Bonifácio, E. Monteiro, E. Canedo, W. Luz, and G. Pinto, “Are static analysis violations really fixed?” in Proc. IEEE Int. Conf. Program Comprehension (ICPC), 2019, pp. 209-219.

                [57] C. Vassallo, S. Panichella, F. Palomba, S. Proksch, H. C. Gall, and A. Zaidman, “How developers engage with static analysis tools in different contexts,” Empirical Software Engineering, vol. 25, pp. 1419-1457, 2020.

                [58] L. Lavazza, D. Tosi, and S. Morasca, “An empirical study on the persistence of SpotBugs issues in open-source software evolution,” in Proc. Int. Conf. Quality of Information and Communications Technology (QUATIC), 2020, pp. 144-151.

                [59] J. Businge, S. Kawuma, E. Bainomugisha, F. Khomh, and E. Nabaasa, “Code authorship and fault-proneness of open-source Android applications,” in Proc. Int. Conf. Predictive Models and Data Analytics in Software Engineering (PROMISE), 2017, pp. 33-42.

                [60] V. Lenarduzzi, F. Lomio, H. Huttunen, and D. Taibi, “Are SonarQube rules inducing bugs?” in Proc. 27th IEEE Int. Conf. Software Analysis, Evolution and Reengineering (SANER), 2020, pp. 501-511, https://doi.org/10.1109/SANER48275.2020.9054821.

                [61] SonarSource, “Java rules.” [Online]. Available: https://rules.sonarsource.com/java/. [Accessed: Jan. 2024].

                [62] S. Kawuma, E. Nabaasa, D. B. Sabiiti, and V. Mabirizi, “An empirical study of bugs in Eclipse stable internal interfaces,” Indian Journal of Software Engineering and Project Management, vol. 2, no. 2, pp. 4–10, 2022, https://doi.org/10.54105/ijsepm.D9015.072222.

                [63] S. Kawuma, D. S. Bamutura, A. Obbo, V. Mabirizi, M. Kabarungi, and E. Nabaasa, “Eclipse application programming interfaces: How buggy are they?” VFAST Transactions on Software Engineering, vol. 13, no. 2, pp. 228–244, 2025, https://doi.org/10.21015/vtse.v13i2.2134

                Downloads

                Published

                2026-01-26

                Issue

                Vol. 11 No. 2 (2025): International Journal of Software Engineering and Computer Systems

                Section

                Full Length Article

                License

                Copyright (c) 2025 The Author(s)

                Creative Commons License

                This work is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License.

                How to Cite

                [1]
                Simon Kawuma, “INVESTIGATION OF CODE SMELLS IN ECLIPSE FRAMEWORK USING SONARQUBE: AN EMPIRICAL ANALYSIS”, IJSECS, vol. 11, no. 2, pp. 176–187, Jan. 2026, doi: 10.15282//ijsecs.11.2.2025.14.0146.

                Share