pith. sign in

arxiv: 2604.27893 · v1 · submitted 2026-04-30 · 💻 cs.SE

An Empirical Evaluation of Code Smell Detection in Angular Applications

Maykon Nunes , Emanuel Coutinho , Carla Bezerra , Ivan Machado This is my paper

Pith reviewed 2026-05-07 05:21 UTC · model grok-4.3

classification 💻 cs.SE
keywords Angularcode smellsstatic analysissoftware maintenancegrey literatureempirical evaluationweb applicationsfront-end development
0
0 comments X

The pith

An automated tool detects 11 Angular code smells with accuracy above 0.88 and F1-scores from 0.89 to 1.00.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper gathers 11 Angular code smells by reviewing grey literature from developer discussions and technical sources. It organizes the smells by their technical traits, noting that six also appear in React applications. From this catalog the authors build a static analysis tool and test it on a manually checked collection of Angular code. The tool performs strongly on standard detection metrics. If the results hold, teams working on large Angular projects gain a practical way to spot problems such as overloaded components, duplicated logic, and inefficient template bindings without relying solely on manual review.

Core claim

A grey literature review yielded a catalog of 11 distinct Angular code smells. Six of these smells also occur in React-based systems. The authors implemented a static analysis tool that applies detection rules derived from the catalog and evaluated it on a manually validated dataset of Angular applications. The tool achieved accuracy values above 0.88 and F1-scores ranging from 0.89 to 1.00 across all smells.

What carries the argument

The catalog of 11 Angular code smells compiled from grey literature, which supplies the rules for the custom static analysis tool.

If this is right

  • Developers gain an automated way to locate recurring issues such as component overloading and duplicated logic in Angular codebases.
  • The overlap with React smells points to a set of cross-framework problems that could be addressed with shared detection strategies.
  • The catalog supplies concrete examples and groupings that future studies can use to measure how these smells affect maintainability.
  • High detection metrics indicate that static analysis can support code reviews in large-scale Angular projects.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same grey-literature approach could be repeated for other front-end frameworks such as Vue to build comparable catalogs.
  • Embedding the detector in common IDEs or build pipelines could shift detection from post-facto fixes to prevention during development.
  • Performance on the current dataset leaves open whether the same accuracy holds for very large enterprise Angular codebases or for code written in newer Angular versions.

Load-bearing premise

The grey literature sources reviewed capture every relevant Angular code smell without major omissions or false inclusions, and the manually validated dataset represents typical real-world Angular applications without selection or labeling errors.

What would settle it

Applying the tool to a fresh, independently gathered collection of open-source Angular projects and obtaining accuracy below 0.88 or identifying many additional smells absent from the catalog would contradict the reported performance.

Figures

Figures reproduced from arXiv: 2604.27893 by Carla Bezerra, Emanuel Coutinho, Ivan Machado, Maykon Nunes.

Figure 1
Figure 1. Figure 1: Methodology for cataloging code smells in Angular view at source ↗
Figure 2
Figure 2. Figure 2: Component diagram of the tool generates the abstract syntax tree (AST) for each file. Next, the Con￾troller coordinates the execution of the detection modules according to the identified framework. This module ensures that the React￾Sniffer detector operates exclusively on React projects, while the SniffTSX addresses TypeScript-specific smells that can occur in both React and Angular. After aggregating the… view at source ↗
read the original abstract

Angular is one of the most widely adopted frameworks for developing large-scale, dynamic web applications. As projects increase in scope and complexity, developers face growing challenges in managing architecture and maintaining clean, modular code. These challenges often lead to design flaws, commonly referred to as code smells. While React-specific smells have been cataloged in prior studies, limited knowledge exists regarding Angular-specific smells and how they manifest. This study investigates Angular code smells through a grey literature review, consolidating community knowledge and technical discussions. From the collected sources, 11 distinct Angular code smells were identified, 6 of which also occur in React-based systems, suggesting that some issues are cross-framework. Each smell was analyzed, exemplified, and grouped according to its technical characteristics. Based on the resulting catalog, we implemented an automated static analysis tool to detect Angular code smells. The tool was empirically evaluated using a manually validated dataset, and its effectiveness was assessed through standard information retrieval metrics. The evaluation results indicate high detection performance across all smells, achieving accuracy values above 0.88 and F1-scores ranging from 0.89 to 1.00. The findings reveal recurring issues such as component overloading, duplicated logic, and inefficient template bindings, reinforcing the relevance of systematic detection support. This study presents the first catalog of Angular-specific code smells derived from grey literature and demonstrates the feasibility and effectiveness of automated detection, providing a solid foundation for future empirical studies and tool development aimed at improving front-end code quality.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

3 major / 3 minor

Summary. The paper conducts a grey literature review to identify 11 Angular code smells (6 overlapping with React), implements a static analysis tool based on the catalog, and evaluates the tool on a manually validated dataset of Angular applications, reporting accuracy >0.88 and F1-scores of 0.89–1.00 across all smells via standard IR metrics.

Significance. If the evaluation holds, the work supplies the first grey-literature-derived catalog of Angular-specific smells together with a working detector, addressing a clear gap relative to React-focused studies. The cross-framework overlap finding and the reported performance numbers would be useful for practitioners and for follow-on empirical work on front-end maintenance. The contribution is primarily empirical and tool-oriented rather than theoretical.

major comments (3)
  1. [Grey Literature Review] Grey Literature Review section: the search protocol, databases or forums queried, inclusion/exclusion criteria, and saturation check are not described. Without these, it is impossible to judge whether the 11-smell catalog is complete or contains non-smells, directly affecting the foundation of the subsequent tool and evaluation.
  2. [Evaluation / Dataset] Dataset Construction and Manual Validation subsection: no information is given on (a) number of Angular projects or components examined, (b) selection criteria (stars, random sampling, author choice), (c) total smell instances per category, or (d) inter-rater reliability (Cohen’s kappa or equivalent) for the manual labeling. The high F1-scores (0.89–1.00) are only interpretable if the ground truth is reliable and representative; the current description leaves open the possibility of author bias and limited generalizability.
  3. [Tool Implementation and Evaluation] Tool Implementation and Evaluation sections: the paper does not report whether the manual labels were produced independently of the smell definitions used to build the detector, nor does it provide a confusion-matrix breakdown or error analysis per smell. This makes it difficult to assess whether the reported accuracy >0.88 reflects genuine detection power or circularity in labeling.
minor comments (3)
  1. [Introduction / Related Work] The abstract states that 6 smells also occur in React; a dedicated comparison table or subsection would strengthen the cross-framework claim.
  2. [Smell Catalog] Example code snippets for each smell (mentioned in the abstract) should be accompanied by the corresponding Angular version or file type to aid reproducibility.
  3. [Tool Implementation] The paper should cite the exact versions of Angular and the static-analysis framework used by the tool.

Simulated Author's Rebuttal

3 responses · 0 unresolved

We thank the referee for their thorough review and valuable comments, which have helped us identify areas for improvement in our manuscript. We address each major comment below and commit to revising the paper to enhance clarity, transparency, and completeness.

read point-by-point responses

  1. Referee: [Grey Literature Review] Grey Literature Review section: the search protocol, databases or forums queried, inclusion/exclusion criteria, and saturation check are not described. Without these, it is impossible to judge whether the 11-smell catalog is complete or contains non-smells, directly affecting the foundation of the subsequent tool and evaluation.

    Authors: We agree with the referee that the Grey Literature Review section lacks sufficient methodological detail. In the revised manuscript, we will expand this section to describe the search protocol, the specific databases and forums queried (e.g., Stack Overflow, Reddit, Angular community blogs, and GitHub issues), the search strings employed, the inclusion and exclusion criteria (focusing on Angular-specific code quality discussions while excluding duplicates and non-technical content), and the saturation check process used to confirm completeness of the 11-smell catalog. This will directly address concerns about reproducibility and the catalog's validity. revision: yes

  2. Referee: [Evaluation / Dataset] Dataset Construction and Manual Validation subsection: no information is given on (a) number of Angular projects or components examined, (b) selection criteria (stars, random sampling, author choice), (c) total smell instances per category, or (d) inter-rater reliability (Cohen’s kappa or equivalent) for the manual labeling. The high F1-scores (0.89–1.00) are only interpretable if the ground truth is reliable and representative; the current description leaves open the possibility of author bias and limited generalizability.

    Authors: We acknowledge that the Dataset Construction and Manual Validation subsection requires additional information to support interpretation of the results. In the revision, we will report (a) the number of Angular projects and components examined, (b) the selection criteria (including any use of GitHub stars or sampling methods), (c) the total smell instances per category in the ground truth, and (d) the inter-rater reliability measure (such as Cohen’s kappa) between labelers. These details will demonstrate the reliability and representativeness of the dataset and reduce concerns about bias. revision: yes

  3. Referee: [Tool Implementation and Evaluation] Tool Implementation and Evaluation sections: the paper does not report whether the manual labels were produced independently of the smell definitions used to build the detector, nor does it provide a confusion-matrix breakdown or error analysis per smell. This makes it difficult to assess whether the reported accuracy >0.88 reflects genuine detection power or circularity in labeling.

    Authors: We thank the referee for highlighting this important point on potential circularity. The manual labeling was performed by reviewing source code against the smell definitions prior to implementing and executing the detector. In the revised manuscript, we will explicitly state this independence and add a per-smell confusion matrix along with an error analysis discussing false positives and negatives. This will allow readers to better evaluate the tool's detection power. revision: yes

Circularity Check

0 steps flagged

No circularity: empirical catalog and tool evaluation are self-contained

full rationale

The paper performs a grey-literature review to compile an external catalog of 11 Angular code smells, implements a static-analysis tool from that catalog, and reports detection performance on a separately manually validated dataset using standard IR metrics (accuracy >0.88, F1 0.89-1.00). No equations, fitted parameters, or derivation steps exist that could reduce to the inputs by construction. No self-citation chains are invoked as load-bearing uniqueness theorems or ansatzes. The evaluation metrics are direct empirical measurements rather than predictions forced by the catalog definitions. This matches the default expectation of a non-circular empirical study; concerns about labeling bias or dataset representativeness affect experimental validity but do not constitute circularity under the enumerated patterns.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

This is an empirical software engineering study with no mathematical derivations. The central claims rest on the completeness and accuracy of the grey literature search for identifying the 11 smells and on the correctness of the manual validation of the tool's detections. No free parameters, standard mathematical axioms, or invented entities (such as new particles or forces) are introduced. The smells themselves are extracted from community sources rather than postulated without evidence.

pith-pipeline@v0.9.0 · 5567 in / 1560 out tokens · 122177 ms · 2026-05-07T05:21:24.102690+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

52 extracted references · 45 canonical work pages

  1. [1]

    Danyllo Albuquerque, Everton Guimar¯aes, Mirko Perkusich, Thiago Rique, Felipe Cunha, Hyggo Almeida, and Angelo Perkusich. 2023. On the Assessment of Interactive Detection of Code Smells in Practice: A Controlled Experiment.IEEE Access11 (2023), 84589–84606. doi:10.1109/ACCESS.2023.3302260

    work page doi:10.1109/access.2023.3302260 2023

  2. [2]

    Eman Abdullah AlOmar, Mohamed Wiem Mkaouer, and Ali Ouni. 2024. Au- tomating Source Code Refactoring in the Classroom. InProceedings of the 55th ACM Technical Symposium on Computer Science Education V. 1 (SIGCSE 2024). Association for Computing Machinery, 60–66. doi:10.1145/3626252.3630787

    work page doi:10.1145/3626252.3630787 2024

  3. [3]

    Maurício Aniche, Gabriele Bavota, Christoph Treude, Marco Aurélio Gerosa, and Arie van Deursen. 2018. Code smells for Model-View-Controller architectures. Empirical Software Engineering23, 4 (2018), 2121–2157. doi:10.1007/s10664-017- 9540-2

    work page doi:10.1007/s10664-017- 2018

  4. [4]

    Narjes Bessghaier, Ali Ouni, and Mohamed Wiem Mkaouer. 2020. On the Diffu- sion and Impact of Code Smells in Web Applications. InServices Computing – SCC 2020, Qingyang Wang, Yunni Xia, Sangeetha Seshadri, and Liang-Jie Zhang (Eds.). Springer International Publishing, 67–84. doi:10.1007/978-3-030-59592-0_5

    work page doi:10.1007/978-3-030-59592-0_5 2020

  5. [5]

    Aryan Boloori and Tushar Sharma. 2025. DPy: Code Smells Detection Tool for Python. In2025 IEEE/ACM 22nd International Conference on Mining Software Repositories (MSR). 826–830. doi:10.1109/MSR66628.2025.00119

    work page doi:10.1109/msr66628.2025.00119 2025

  6. [6]

    Boris Cherry, Jehan Bernard, Thomas Kintziger, Csaba Nagy, Anthony Cleve, and Michele Lanza. 2024. A Multivocal Mapping Study of MongoDB Smells. In2024 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER). 792–803. doi:10.1109/SANER60148.2024.00086

    work page doi:10.1109/saner60148.2024.00086 2024

  7. [7]

    Lucas Francisco da Matta Vegi and Marco Tulio Valente. 2023. Towards a Catalog of Refactorings for Elixir. In2023 IEEE International Conference on Software Main- tenance and Evolution (ICSME). 358–362. doi:10.1109/ICSME58846.2023.00045

    work page doi:10.1109/icsme58846.2023.00045 2023

  8. [8]

    Lucas Francisco da Matta Vegi and Marco Tulio Valente. 2025. Understanding refactorings in Elixir functional language.Empirical Softw. Engg.30, 4 (2025), 58 pages. doi:10.1007/s10664-025-10652-y

    work page doi:10.1007/s10664-025-10652-y 2025

  9. [9]

    José Pereira dos Reis, Fernando Brito e Abreu, Glauco de Figueiredo Carneiro, and Craig Anslow. 2022. Code Smells Detection and Visualization: A Systematic Literature Review.Archives of Computational Methods in Engineering29, 1 (2022), 47–94. doi:10.1007/s11831-021-09566-x

    work page doi:10.1007/s11831-021-09566-x 2022

  10. [10]

    Rim El Jammal and Danielle Azar. 2025. Does it smell? A homogeneous stacking approach for code smell prediction.Information and Software Technology186 (2025), 107801. doi:10.1016/j.infsof.2025.107801

    work page doi:10.1016/j.infsof.2025.107801 2025

  11. [11]

    Amin Milani Fard and Ali Mesbah. 2013. JSNOSE: Detecting JavaScript Code Smells. In2013 IEEE 13th International Working Conference on Source Code Analysis and Manipulation (SCAM). 116–125. doi:10.1109/SCAM.2013.6648192

    work page doi:10.1109/scam.2013.6648192 2013

  12. [12]

    Muhammad Fawad, Ghulam Rasool, and Muhammad Bilal Riaz. 2025. Refactoring Android Source Code Smells From Android Applications.IEEE Access13 (2025), 14122–14150. doi:10.1109/ACCESS.2025.3529687

    work page doi:10.1109/access.2025.3529687 2025

  13. [13]

    Hamed Fawareh, Yazan Al-Smadi, Hamzeh Aljawawdeh, Faid AlNoor Fawareh, Fuad Alshraiedeh, and Mohammed Khouj. 2024. An Empirical Study on Measur- ing the Impact of Code Smells on Web Applications. In2024 25th International Arab Conference on Information Technology (ACIT). 1–5. doi:10.1109/ACIT62805. 2024.10877192

    work page doi:10.1109/acit62805 2024

  14. [14]

    Fabio Ferreira, Hudson Borges, and Marco Valente. 2021. On the (un-)adoption of JavaScript front-end frameworks.Software: Practice and Experience52 (2021), 947–966. doi:10.1002/spe.3044

    work page doi:10.1002/spe.3044 2021

  15. [15]

    Fabio Ferreira, Hudson Silva Borges, and Marco Tulio Valente. 2024. Refactoring react-based Web apps.Journal of Systems and Software215 (2024), 112105. doi:10. 1016/j.jss.2024.112105

    work page arXiv 2024

  16. [16]

    Fabio Ferreira and Marco Tulio Valente. 2023. Detecting code smells in React- based Web apps.Information and Software Technology155 (2023), 107111. doi:10. 1016/j.infsof.2022.107111

    work page arXiv 2023

  17. [17]

    2018.Refactoring

    M Fowler. 2018.Refactoring. Addison-Wesley Professional

    2018

  18. [18]

    Vahid Garousi, Michael Felderer, and Mika V. Mäntylä. 2019. Guidelines for including grey literature and conducting multivocal literature reviews in software engineering.Information and Software Technology106 (2019), 101–121. doi:10. 1016/j.infsof.2018.09.006

    2019

  19. [19]

    Geetha, Monisha Mittal, K

    G. Geetha, Monisha Mittal, K. Mohana Prasad, and J. Godwin Ponsam. 2022. Interpretation and Analysis of Angular Framework. In2022 International Con- ference on Power, Energy, Control and Transmission Systems (ICPECTS). 1–6. doi:10.1109/ICPECTS56089.2022.10047474

    work page doi:10.1109/icpects56089.2022.10047474 2022

  20. [20]

    Aakanshi Gupta and Nidhi Kumari Chauhan. 2022. A Severity-Based Classi- fication Assessment of Code Smells in Kotlin and Java Application.Arabian Journal for Science and Engineering47, 2 (2022), 1831–1848. doi:10.1007/s13369- 021-06077-6

    work page doi:10.1007/s13369- 2022

  21. [21]

    Bruno Góis Mateus and Matias Martinez. 2019. An empirical study on quality of Android applications written in Kotlin language.Empirical Software Engineering 24, 6 (2019), 3356–3393. doi:10.1007/s10664-019-09727-4

    work page doi:10.1007/s10664-019-09727-4 2019

  22. [22]

    Esraa Hamouda, Abeer El-Korany, and Soha Makady. 2025. Smell-ML: A Machine Learning Framework for Detecting Rarely Studied Code Smells.IEEE Access13 (2025), 12966–12980. doi:10.1109/ACCESS.2025.3530927

    work page doi:10.1109/access.2025.3530927 2025

  23. [23]

    Mário Hozano, Alessandro Garcia, Baldoino Fonseca, and Evandro Costa. 2018. Are you smelling it? Investigating how similar developers detect code smells. Information and Software Technology93 (2018), 130–146. doi:10.1016/j.infsof.2017. 09.002

    work page doi:10.1016/j.infsof.2017 2018

  24. [24]

    Slavina Ivanova and Georgi Georgiev. 2019. Using modern web frameworks when developing an education application: a practical approach. In2019 42nd In- ternational Convention on Information and Communication Technology, Electronics and Microelectronics (MIPRO). 1485–1491. doi:10.23919/MIPRO.2019.8756914

    work page doi:10.23919/mipro.2019.8756914 2019

  25. [25]

    Guilherme Lacerda, Fabio Petrillo, Marcelo Pimenta, and Yann Gaël Guéhéneuc

  26. [26]

    https: //doi.org/10.1016/j.jss.2020.110610

    Code smells and refactoring: A tertiary systematic review of challenges and observations.Journal of Systems and Software167 (2020), 110610. https: //doi.org/10.1016/j.jss.2020.110610

    work page doi:10.1016/j.jss.2020.110610 2020

  27. [27]

    Jacinto Ramirez Lahti, Antti-Pekka Tuovinen, and Tommi Mikkonen. 2021. Ex- periences on Managing Technical Debt with Code Smells and AntiPatterns. In 2021 IEEE/ACM International Conference on Technical Debt (TechDebt). 36–44. doi:10.1109/TechDebt52882.2021.00013

    work page doi:10.1109/techdebt52882.2021.00013 2021

  28. [28]

    Lorenz and Ofir Shmuel

    David H. Lorenz and Ofir Shmuel. 2023. ReactCOP: Modular and Scalable Web Development with Context-Oriented Programming. Association for Computing Machinery, 63–64. doi:10.1145/3618305.3623609

    work page doi:10.1145/3618305.3623609 2023

  29. [29]

    Júlio Martins, Carla Bezerra, Anderson Uchôa, and Alessandro Garcia. 2020. Are Code Smell Co-occurrences Harmful to Internal Quality Attributes? A Mixed- Method Study. InProceedings of the XXXIV Brazilian Symposium on Software Engineering. Association for Computing Machinery, 52–61. https://doi.org/10. 1145/3422392.3422419

    work page arXiv 2020

  30. [30]

    Alessandro Midolo and Massimiliano Di Penta. 2025. Automated Refactoring of Non-Idiomatic Python Code: A Differentiated Replication with LLMS. In2025 IEEE/ACM 33rd International Conference on Program Comprehension (ICPC). 01–11. doi:10.1109/ICPC66645.2025.00020

    work page doi:10.1109/icpc66645.2025.00020 2025

  31. [31]

    Biruk Asmare Muse, Mohammad Masudur Rahman, Csaba Nagy, Anthony Cleve, Foutse Khomh, and Giuliano Antoniol. 2020. On the Prevalence, Impact, and Evolution of SQL Code Smells in Data-Intensive Systems. InProceedings of the 17th International Conference on Mining Software Repositories (MSR ’20). Association for Computing Machinery, 327–338. doi:10.1145/3379...

    work page doi:10.1145/3379597.3387467 2020

  32. [32]

    Cornelia Mihaela Novac, Ovidiu Constantin Novac, Raluca Marina Sferle, Mircea Ioan Gordan, Gyöngyi BUJDOSó, and Camelia Maria Dindelegan. 2021. Comparative study of some applications made in the Vue.js and React.js frame- works. In2021 16th International Conference on Engineering of Modern Electric Sys- tems (EMES). IEEE Computer Society, 1–4. doi:10.1109...

    work page doi:10.1109/emes52337.2021.9484149 2021

  33. [33]

    Ovidiu-Constantin Novac, Cornelia-Mihaela Novac, Mihai Costar, Mihai Oproescu, Mircea-Petru Ursu, and Gyongyi Bujdoso. 2025. Comparison of Fron- tend Frameworks Angular Vs. Blazor. In2025 18th International Conference on Engineering of Modern Electric Systems (EMES). 1–4. doi:10.1109/EMES65692.2025. 11045632

    work page doi:10.1109/emes65692.2025 2025

  34. [34]

    Radinal Dwiki Novendra and Wikan Danar Sunindyo. 2024. Emerging Trends in Code Quality: Introducing Kotlin-Specific Bad Smell Detection Tool for Android Apps.IEEE Access12 (2024), 63895–63903. doi:10.1109/ACCESS.2024.3397055

    work page doi:10.1109/access.2024.3397055 2024

  35. [35]

    Maykon Nunes, Carla Bezerra, Fabio Ferreira, Bruno Gois, and Marco Tulio Valente. 2025. Detection of code smells in react with TypeScript applications. Information and Software Technology187 (2025), 107835. doi:10.1016/j.infsof.2025. 107835

    work page doi:10.1016/j.infsof.2025 2025

  36. [36]

    Partha Protim Paul, Md Tonoy Akanda, Mohammed Raihan Ullah, Dipto Mondal, Nazia Sultana Chowdhury, and Fazle Mohammed Tawsif. 2024. xNose: A Test Smell Detector for C#. InProceedings of the 2024 IEEE/ACM 46th International Conference on Software Engineering: Companion Proceedings (ICSE-Companion ’24). Association for Computing Machinery, 370–371. doi:10.1...

    work page doi:10.1145/3639478.3643116 2024

  37. [37]

    Dimitri Prestat, Naouel Moha, Roger Villemaire, and Florent Avellaneda. 2024. DynAMICS: A Tool-Based Method for the Specification and Dynamic Detection of Android Behavioral Code Smells.IEEE Transactions on Software Engineering 50, 4 (2024), 765–784. doi:10.1109/TSE.2024.3363223

    work page doi:10.1109/tse.2024.3363223 2024

  38. [38]

    Kristiina Rahkema and Dietmar Pfahl. 2020. Empirical study on code smells in iOS applications. InProceedings of the IEEE/ACM 7th International Conference on Mobile Software Engineering and Systems (MOBILESoft ’20). Association for Computing Machinery, 61–65. doi:10.1145/3387905.3388597

    work page doi:10.1145/3387905.3388597 2020

  39. [39]

    Ajeet Singh Rajput, Harsh Pratap Singh, Garima Bang, Shelley Joshi, and Trapti Patidar. 2023. Comparing Spring Boot and ReactJS with Other Web Development Frameworks: A Study. InInternational Conference on Data Science and Applications. Springer, 149–160. https://doi.org/10.1007/978-981-99-7817-5_12

    work page doi:10.1007/978-981-99-7817-5_12 2023

  40. [40]

    Amir Saboury, Pooya Musavi, Foutse Khomh, and Giulio Antoniol. 2017. An em- pirical study of code smells in JavaScript projects. In2017 IEEE 24th International Conference on Software Analysis, Evolution and Reengineering (SANER). 294–305. doi:10.1109/SANER.2017.7884630

    work page doi:10.1109/saner.2017.7884630 2017

  41. [41]

    Amanda Santana, Eduardo Figueiredo, and Juliana Alves Pereira. 2024. Unrav- eling the Impact of Code Smell Agglomerations on Code Stability. In2024 IEEE International Conference on Software Maintenance and Evolution (ICSME). 461–473. doi:10.1109/ICSME58944.2024.00049

    work page doi:10.1109/icsme58944.2024.00049 2024

  42. [42]

    Arooba Shahoor, Satbek Abdyldayev, Hyeongi Hong, Jooyong Yi, and Dongsun Kim. 2025. Proactive Debugging of Memory Leakage Bugs in Single Page Web Applications.IEEE Transactions on Software Engineering51, 7 (2025), 1969–1995. EASE 2026, 9–12 June, 2026, Glasgow, Scotland, United Kingdom Trovato et al. doi:10.1109/TSE.2025.3571192

    work page doi:10.1109/tse.2025.3571192 2025

  43. [43]

    Tushar Sharma, Vasiliki Efstathiou, Panos Louridas, and Diomidis Spinellis. 2021. Code smell detection by deep direct-learning and transfer-learning.Journal of Systems and Software176 (2021), 110936. doi:10.1016/j.jss.2021.110936

    work page doi:10.1016/j.jss.2021.110936 2021

  44. [44]

    Tushar Sharma, Marios Fragkoulis, and Diomidis Spinellis. 2017. House of Cards: Code Smells in Open-Source C# Repositories. In2017 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM). 424–429. doi:10.1109/ESEM.2017.57

    work page doi:10.1109/esem.2017.57 2017

  45. [45]

    Amjed Tahir, Jens Dietrich, Steve Counsell, Sherlock Licorish, and Aiko Yamashita

  46. [46]

    doi:10.1016/j.infsof.2020.106333

    A large scale study on how developers discuss code smells and anti-pattern in Stack Exchange sites.Information and Software Technology125 (2020), 106333. doi:10.1016/j.infsof.2020.106333

    work page doi:10.1016/j.infsof.2020.106333 2020

  47. [47]

    Lucas Francisco da Matta Vegi and Marco Tulio Valente. 2022. Code smells in Elixir: early results from a grey literature review. InProceedings of the 30th IEEE/ACM International Conference on Program Comprehension (ICPC ’22). Asso- ciation for Computing Machinery, 580–584. doi:10.1145/3524610.3527881

    work page doi:10.1145/3524610.3527881 2022

  48. [48]

    Antonio Vitale, Rocco Oliveto, and Simone Scalabrino. 2025. A Catalog of Data Smells for Coding Tasks.ACM Trans. Softw. Eng. Methodol.34, 4, Article 113 (2025), 32 pages. doi:10.1145/3707457

    work page doi:10.1145/3707457 2025

  49. [49]

    Ohlsson, Björn Regnell, and Anders Wesslén

    Claes Wohlin, Per Runeson, Martin Höst, Magnus C. Ohlsson, Björn Regnell, and Anders Wesslén. 2012.Experimentation in software engineering. Springer Science & Business Media

    2012

  50. [50]

    Enes Yigitbas, Klementina Josifovska, Ivan Jovanovikj, Ferhat Kalinci, Anthony Anjorin, and Gregor Engels. 2019. Component-based development of adaptive user interfaces. InProceedings of the ACM SIGCHI Symposium on Engineering Interactive Computing Systems. Association for Computing Machinery, Article 13, 7 pages. doi:10.1145/3319499.3328229

    work page doi:10.1145/3319499.3328229 2019

  51. [51]

    Morteza Zakeri-Nasrabadi, Saeed Parsa, Ehsan Esmaili, and Fabio Palomba. 2023. A Systematic Literature Review on the Code Smells Datasets and Validation Mechanisms.ACM Comput. Surv.55, 13s (2023), 48 pages. https://doi.org/10. 1145/3596908

    2023

  52. [52]

    He Zhang, Xin Zhou, Xin Huang, Huang Huang, and Muhammad Ali Babar. 2020. An Evidence-Based Inquiry into the Use of Grey Literature in Software Engi- neering. In2020 IEEE/ACM 42nd International Conference on Software Engineering (ICSE). 1422–1434

    2020