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.

Software deffect prediction, a problem of major relevance within the search-based software engineering field, aims to enhance software quality by early and precisely uncovering faulty software modules. Accurate detection of software defects in new software releases might increase the performance of the software development process in terms of cost, time and software quality. Most approaches from the software deffect prediction literature try to develop general solutions that are designed to work with any type of software deffect. From a software engineering perspective, software defects may take various forms and identifying/fixing different types of defects requires different approaches. Starting from the assumption that specific types of software defects have a particular behaviour, we are introducing in this paper, as a proof of concept, an unsupervised learning-based methodology for mining behavioural patterns for specific classes of software defects and identifying features which would be relevant for detecting the uncovered classes. The experiments performed on an open-source software deffect prediction data set collected from all releases of the Apache Ivy software highlight that the results obtained by applying the proposed methodology are highly correlated with the way human domain experts categorise and address software defects. Creating software deffect prediction models that are specifically tailored for different software deffect types may improve the accuracy of the developed models, open the possibility to apply different sets of predictive models based on the domain of the software and may accelerate the adoption of software deffect prediction approaches by the industry.

This paper presents an experimental evaluation on the accuracy of indoor localisation. The research was carried out as part of a European Union project targeting the creation of ICT solutions for older adult care. Current expectation is that advances in technology will supplement the human workforce required for older adult care, improve their quality of life and decrease healthcare expenditure. The proposed approach is implemented in the form of a configurable cyber-physical system that enables indoor localization and monitoring of older adults living at home or in residential buildings. Hardware consists of custom developed luminaires with sensing, communication and processing capabilities. They replace the existing lighting infrastructure, do not look out of place and are cost effective. The luminaires record the strength of a Bluetooth signal emitted by a wearable device equipped by the monitored user. The system's software server uses trilateration to calculate the person's location based on known luminaire placement and recorded signal strengths. However, multipath fading caused by the presence of walls, furniture and other objects introduces localisation errors. Our previous experiments showed that room-level accuracy can be achieved using software-based filtering for a stationary subject. Our current objective is to assess system accuracy in the context of a moving subject, and ascertain whether room-level localization is feasible in real time.

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.

This paper presents the initial results of our experiments regarding accurate indoor localisation. The research was carried out in the context of a European Union funded project targeting the development of a configurable, cost-effective cyber-physical system for monitoring older adults in their homes. The system comprises a number of hardware nodes deployed as intelligent luminaires that replace light bulbs present in the monitored location. By measuring the strength of a Bluetooth Low Energy signal generated by a device on the monitored person, a rough estimation of the person’s location is obtained. We show that the presence of walls, furniture and other objects in typical indoor settings precludes accurate localisation. In order to improve accuracy, we employ several software-based approaches, including Kalman filtering and neural networks. We carry out an initial experiment showing that additional software processing significantly improves localisation accuracy.

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.

Hospital acquired infections are a serious threat to the health and well-being of patients and medical staff within clinical units. Many of these infections arise as a consequence of medical personnel that come into contact with contaminated persons, surfaces or equipment and then with patients, without following proper hygiene procedures. In this paper we present our ongoing efforts in the development of a wireless sensor network based cyber-physical system which aims to prevent hospital infections by increasing compliance to established hygiene guidelines. The solution, currently developed under European Union funding integrates a network of sensors for monitoring clinical workflows and ambient conditions, a workflow engine that executes encoded workflow instances and monitoring software that provides real-time information in case of infection risk detection. As a motivating example, we employ the workflow in the general practitioner's office in order to comprehensively present types of sensors and their positioning in the monitored location. Using the information collected by deployed sensors, the system is capable of immediately detecting infection risks and taking action to prevent the spread of infections.

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.

Hospital acquired infections (HAI) are infections acquired within the hospital from healthcare workers, patients or from the environment, but which have no connection to the initial reason for the patient's hospital admission. HAI are a serious world-wide problem, leading to an increase in mortality rates, duration of hospitalisation as well as significant economic burden on hospitals. Although clear preventive guidelines exist, studies show that compliance to them is frequently poor. This paper details the software perspective for an innovative, business process software based cyber-physical system that will be implemented as part of a European Union-funded research project. The system is composed of a network of sensors mounted in different sites around the hospital, a series of wearables used by the healthcare workers and a server side workflow engine. For better understanding, we describe the system through the lens of a single, simple clinical workflow that is responsible for a significant portion of all hospital infections. The goal is that when completed, the system will be configurable in the sense of facilitating the creation and automated monitoring of those clinical workflows that when combined, account for over 90\% of hospital infections.

The present paper introduces the open-source Java Event Tracer (JETracer) framework for real-time tracing of GUI events within applications based on the AWT, Swing or SWT graphical toolkits. Our framework provides a common event model for supported toolkits, the possibility of receiving GUI events in real-time, good performance in the case of complex target applications and the possibility of deployment over a network. The present paper provides the rationale for JETracer, presents related research and details its technical implementation. An empirical evaluation where JETracer is used to trace GUI events within five popular, open-source applications is also presented.

The present paper introduces the initial implementation of a software exploration tool targeting graphical user interface (GUI) driven applications. GUITracer facilitates the comprehension of GUI-driven applications by starting from their most conspicuous artefact - the user interface itself. The current implementation of the tool can be used with any Java-based target application that employs one of the AWT, Swing or SWT toolkits. The tool transparently instruments the target application and provides real time information about the GUI events fired. For each event, call relations within the application are displayed at method, class or package level, together with detailed coverage information. The tool facilitates feature location, program comprehension as well as GUI test creation by revealing the link between the application's GUI and its underlying code. As such, GUITracer is intended for software practitioners developing or maintaining GUI-driven applications. We believe our tool to be especially useful for entry-level practitioners as well as students seeking to understand complex GUI-driven software systems. The present paper details the rationale as well as the technical implementation of the tool. As a proof-of-concept implementation, we also discuss further development that can lead to our tool's integration into a software development workflow.