Firas Jolha

Understanding source code is a cognitively demanding task, yet existing complexity metrics primarily rely on structural features and overlook actual human effort. This paper introduces a time-based approach to measuring code comprehension using large language models (LLMs). We investigate whether LLMs can estimate the number of seconds a junior developer would need to understand Java source files. Using a dataset of 371 files from the Apache Hive project, we evaluated five LLMs under a uniform prompt design. Human comprehension times, collected through a controlled study involving junior developers, were used as ground truth. Among the tested models, Gemini 2.0 Flash most closely approximated human estimates, while others exhibited systematic bias or output instability. Our findings show that while LLMs can produce interpretable, numeric predictions of comprehension time, achieving consistent accuracy requires prompt refinement and potential model fine-tuning. This work contributes a behavioral perspective to software complexity analysis, offering time-based estimations as an alternative to static metrics.

Software metrics play a crucial role in the analysis of software quality, detection of code parts to refactor, or identification of bugs. Even though software engineering faced challenges in collecting metrics due to limited tools, the growth of open-source development and gained insights from software production gave rise to the collection of software metrics. However, the analysis of a huge number of metrics can lead to different issues such as collinearity, sparsity, and noise. All of these negatively impact statistical analysis and machine learning models. Moreover, the large volume of different metrics can overwhelm developers and make the understanding of software systems more challenging. To address the problem of many metrics, the researchers have already proposed various solutions such as heuristic algorithms and statistical tests. These approaches require supervised learning algorithms, thus introducing the problem of automatic labeling. In this paper, we propose an approach for identifying minimal subsets of software engineering metrics that effectively explain the structural properties of Python repositories. The proposed approach employs two optimization techniques – Particle Swarm Optimization and Genetic Algorithms with a Sammon error as a fitness function. To run the experiments we collected a large set of metrics from open source Python repositories. We validated our methodology on class and method-level metrics. The results demonstrate that both PSO and GA can successfully used to identify optimal subsets of metrics. Moreover, we presented subsets of optimal metrics obtained through both techniques.

Assessing software quality attributes is vital for verifying the overall functionality and performance of the software system, but measuring the quality attributes is a challenging task due to the reason that not all attributes can be measured quantitatively. The source code of any software is the ultimate product that is delivered to the customer. Despite its importance, code smells are frequently detected within the code, and this can deteriorate the software quality. A code smell suggests a bad structure that is capable of breaching core design principles, perhaps leading to system failures. The presence of code smells suggests the need for refactoring. Refactoring is performed to eradicate the design smell, and produces changes in the internal structure of the code without affecting the system’s exterior behavior, aiming to enhance the code quality.In this paper, I investigate the relationships between code smells and software quality attributes and further study quantitatively the effect of refactoring smelly codes on software quality. This work applies a meta analytical approach across multiple studies. My contributions are: (1) A state-of-art work which quantitatively examines the impact of refactoring on software quality; (2) To investigate the frequently used metrics for measuring the quality of the software product that exhibit code smells. I limit my work to investigating the impact of refactoring code smells on the size attribute of internal code quality and particularly the LOC metric, since only a few studies reported sufficient data to conduct the meta-analytical experiment. My meta analytical results show that there is no statistically significant difference in size between smelly codes after and before refactoring, and these results cannot be guaranteed to have the same impact on other quality attributes.

Mobile devices performance and uptime heavily depend on energy consumed at the hardware and software level. Hence implementation of efficient algorithms has become a crucial aspect for increasing the performance of such systems and battery life for mobile devices. Sorting algorithms are implicitly the building block of many program implementation. Over the past years, researchers have spent more time optimizing hardware components to reduce their energy consumption. However, it has not been so clear which sorting algorithm is more energy efficient. In this study, we conduct a meta-analytical comparison of the energy consumed by the two most common sorting algorithms namely quick sort and merge sort. Our study mainly focused on energy consumption for mobile devices and embedded systems. For our meta-analysis and literature review, we took into consideration studies published not more than 20 years ago. The meta-analytical results show that there is no significant difference between both algorithms in terms of energy efficiency.

Simple detection of bugs, defects or anomalies during software development is not enough - it is necessary to apply corrective actions to eliminate them. To find out whether an anomaly exists in any software, we can measure the quality attributes using software metrics. The main goal of this paper was to find out and explain how to meaningfully attribute metrics to useful corrective actions.