This empirical study investigates how state-of-the-art Large Language Models (LLMs) can automatically resolve code issues identified by SonarQube, a widely used static analysis tool. As automated maintenance becomes more common, combining AI models with rule-based analysis offers a promising approach to improving code quality. We compare six LLMs, including GPT-4o, Gemini 2.0 Flash, Claude 3 Opus, Mistral Large, Grok 3, and Deep-Seek V3, in performing automated code repair. Using a unified prompt strategy, SonarQube issues are mapped into structured prompts, and LLM-generated fixes replace affected functions in the source code. We evaluate repairs based on syntactic correctness, reduction in SonarQube reported issues, and introduce the Static Repair Success Rate (SRSR), a strict metric that measures the proportion of syntactically valid repairs that resolve all original issues without introducing new ones, followed by a semantic analysis to assess whether the repaired code preserved the intended program behavior. Overall, the average reduction in SonarQube-reported issues, calculated across all models and projects, was about 36.02%. The best result for a single project was achieved by the Grok 3 model, which reduced issues by 71.54%. These findings suggest that LLMs can enhance automated refactoring and help reduce static analysis–reported issues. They offer insights for integrating AI into development workflows, helping companies streamline maintenance, reduce technical debt, and sustain high code quality.

Abstract Empirical research targeting software quality resulted in a consistent body of work, especially with the help of automated tools that allow researchers to mine large amounts of data. However, we find that many of these efforts provide cross-sectional or only short-term longitudinal analyses. Furthermore, they are often focused on a single and in most cases statically typed language such as Java. In the present paper, we aim to broaden the horizon of existing efforts by exploring the composition, distribution, and evolution of source code quality issues in complex, open-source Python projects. We employ the SonarQube static analysis tool on a dataset comprised of 3656 individual releases of 57 Python projects. We explore the impact of these issues on software maintainability, reliability, and security. We investigate the evolution of these issues over the long term and compare our results with those in the literature. We compare our findings with existing research targeting both Python and Java; for the latter, we investigate the impact the development language has on the type and distribution of detected issues. Our study data are published and open source to help replicate our investigation and contribute to building open and large-scale data sets for research.

Commit classification has emerged as a practical approach to improve software quality, providing a systematic way to interpret development activities, measure their impact, and enhance overall software quality. The Conventional Commit Specification offers a structured, detailed framework to classify commits beyond traditional maintenance categories. In this study, we explore how conventional commit specification categories are distributed between software releases. We analyze 2,600 software release pairs of 57 Python open-source projects and employ large language models to label 90,318 commits. We identify which commit types are predominantly responsible for introducing SonarQube issues, and explore the relationship between commit types and clean-code attributes affected by quality issues. We publish our analysis dataset to enable replicating or extending our study. We find that most of the commit types are related to documentation and bug fixing, and the existence of a trend of focusing on improving code quality by tackling common code smells and adhering to best practices. We discuss the threats to the validity of our study and identify avenues for further exploration.

We report on an exploratory evaluation that com-bines static analysis with formal concept analysis to investigate complexity issues in source code produced as part of a mandatory course in computer science. Our dataset includes over 500 Python and Java projects that represent student solutions to four semesters worth of programming assignments. We employ the latest version of SonarQube configured to use an extended set of analysis rules and focus on code complexity issues, which are known to impact code readability and maintainability. We study the distribution and composition of these complexity issues and employ formal concept analysis to study the relation between them and other issue types. We present the results of a comparative evaluation regarding the distribution of code complexity issues between Python and Java. Our most important results are synthesized in a series of remarks to help practitioners and educators allay complexity issues in junior developer code, as well as assist the latter in improving their coding skills. Finally, the dataset and SonarQube configuration are available in the form of an open data package that enables replicating or extending our work.

Refactoring is an important process in software engineering, aiming to improve code quality without altering the behavior. This article presents a systematic review of the literature (SLR) on artificial intelligence in the domain of software refactoring. Following a rigorous methodology consisting of data extraction, snowballing techniques, and manual validation, we created a dataset consisting of 156 articles. The focus of the investigation was to identify the refactoring stages that are addressed. The results show that, as research type, most of the contributions propose solutions, while other forms of research such as evaluation, validation and experience are less represented in publications. Refactoring detection represents the highest interest in research contributions, while other refactoring stages, such as prioritization or testing are less investigated. The most commonly used AI methods include Random Forests, Genetic Algorithms, SVM, CNNs and Decision Trees. Based on this literature review, we have identified research trends and opportunities for future research.

Agile adoption hinges on adherence to the Agile Manifesto's values and principles, which are interdependent and variably challenging for Agile teams. This exploratory study enhances understanding of these challenges, their causes, and mitigation strategies through thematic and quantitative analysis of survey responses. We found that Welcome changing requirements is the most difficult principle to implement, with diverse causes categorized into seven areas. Solutions primarily involve project and process adjustments and improved customer communication.

The quality of software systems is an important aspect, especially for embedded systems, thus strategies and actions for analyzing the trade-off between various quality attributes need to be improved. Objectives: We target firstly to determine which quality attributes are important in embedded systems, and secondly to inquire about maintainability in particular, emphasizing the practices that are associated with it, i.e., coding rules, conventions, documentation, code review, and refactoring. Method: We used interviews and surveys as means to investigate practitioners’ points of view and practices. Applying quantitative and qualitative analysis, we explored a general perspective of quality attributes in embedded systems, followed by specific practices related to the maintainability attribute. Results: At the general perspective level, we learned that the importance of security and safety is extended to all embedded systems, while maintainability remains of major importance, and there is a diversity of methods used to assure the quality of systems throughout the development cycle . At the maintainability-specific level, we learned that code review and refactoring are the most used practices and that the related activities are performed in a variety of ways. Conclusions: Our work recognizes various quality attributes as being important with different priorities, respectively analyses which maintainability-related activities are used.

We present a longitudinal study on the long-term evolution of maintainability in open-source software. Quality assessment remains at the forefront of both software research and practice, with many models and assessment methodologies proposed and used over time. Some of them helped create and shape standards such as ISO 9126 and 25010, which are well established today. Both describe software quality in terms of characteristics such as reliability, security or maintainability. An important body of research exists linking these characteristics with software metrics, and proposing ways to automate quality assessment by aggregating software metric values into higher-level quality models. We employ the Maintainability Index, technical debt ratio and a maintainability model based on the ARiSA Compendium. Our study covers the entire 18 year development history and all released versions for three complex, open-source applications. We determine the maintainability for each version using the proposed models, we compare obtained results and use manual source code examination to put them into context. We examine the common development patterns of the target applications and study the relation between refactoring and maintainability. Finally, we study the strengths and weaknesses of each maintainability model using manual source code examination as the baseline.

Background: A consistent body of research and practice have identified that technical debt provides valuable and actionable insight into the design and implementation deficiencies of complex software systems. Existing software tools enable characterizing and measuring the amount of technical debt at selective granularity levels; by providing a computational model, they enable stakeholders to measure and ultimately control this phenomenon. Aims: In this paper we aim to study the evolution and characteristics of technical debt in open-source software. For this, we carry out a longitudinal study that covers the entire development history of several complex applications. The goal is to improve our understanding of how the amount and composition of technical debt changes in evolving software. We also study how new technical debt is introduced in software, as well as identify how developers handle its accumulation over the long term. Method: We carried out our evaluation using three complex, open-source Java applications. All 110 released versions, covering more than 10 years of development history for each application were analyzed using SonarQube. We studied how the amount, composition and history of technical debt changed during development, compared our results across the studied applications and present our most important findings. Results: For each application, we identified key versions during which large amounts of technical debt were added, removed or both. This had significantly more impact when compared to the lines of code or class count increases that generally occurred during development. However, within each version, we found high correlation between file lines of code and technical debt. We observed that the Pareto principle was satisfied for the studied applications, as 20% of issue types generated around 80% of total technical debt. Interestingly, there was a large degree of overlap between the issues that generated most of the debt across the studied applications. Conclusions: Early application versions showed greater fluctuation in the amount of existing technical debt. We found application size to be an unreliable predictor for the quantity of technical debt. Most debt was introduced in applications as part of milestone releases that expanded their feature set; likewise, we identified releases where extensive refactoring significantly reduced the level of debt. We also discovered that technical debt issues persist for a long time in source code, and their removal did not appear to be prioritized according to type or severity.

Assessment of software quality remains the focus of important research efforts, with several proposed quality models and assessment methodologies. ISO 25010 describes software quality in terms of characteristics such as reliability, security or maintainability. In turn, these characteristics can be evaluated in terms of software metric values, establishing a relation between software metrics and quality. However, a general metric-based model for software quality does not yet exist. The diversity of software applications, metric definitions and differences between proposed quality models all contribute to this. Our paper proposes a longitudinal evaluation of the metric values and their relations in the context of three complex, open-source applications. We cover the entire 18 year development history of the targeted applications. We explore typical values for metrics associated with software product quality and explore their evolution in the context of software development. We identify dependant metrics and explore the effect class size has on the strength of dependencies. At each step, we compare the obtained results with relevant related work in order to contribute to a growing pool of evidence towards our goal - a metric-based evaluation of software quality characteristics.

In this paper we propose an approach to automatically discover meaningful changes to maintainability of applications developed using object oriented programming languages. Our approach consists of an algorithm that employs the values of several class-level software metrics that can be easily obtained using open source software. Based on these values, a score that illustrates the maintainability change between two versions of the system is calculated. We present relevant related work, together with the state of research regarding the link between software metrics and maintainability for object oriented systems. In order to validate the approach, we undertake a case study that covers the entire development history of the jEdit open source text editor. We consider 41 version pairs that are assessed for changes to maintainability. First, a manual tool assisted examination of the source code was performed, followed by calculating the Maintainability Index for each application version. In the last step, we apply the proposed approach and compare the findings with those of the manual examination as well as those obtained using the Maintainability Index. In the final section, we present the identified issues and propose future work to further fine tune the approach.

Constructing software automatically from highlevel models is one of the challenges in software engineering nowadays. There is an urgent need for adequate methods to ensure high quality of models. The Executable Foundational UML (fUML) has been proposed as a computationally complete and compact subset of UML. A fUML model is supposed to be executed and tested in the early stage of the software development process. The complete static and operational semantics of fUML is still in its early stages, and although several proposals to execute and verify fUML models have been issued, this problem is still open. Our project aims to develop a complete virtual machine for fUML models using the K-framework which is a rewrite-based executable semantic framework. Our novel model execution will enable to efficiently test and verify fUML models.