Balancing Software Maintainability and Performance: An Empirical Study on Refactoring Practices

Le développement logiciel moderne est souvent confronté à des défis de performance découlant d’un code sous-optimal, d’algorithmes inefficaces ou d’une gestion inadéquate des ressources. Le refactoring, technique traditionnellement employée pour améliorer la qualité et la maintenabilité du code sans en modifier le comportement, peut contribuer à atténuer ces problèmes. Alors que la recherche s’est largement penchée sur le lien entre refactoring et bugs fonctionnels, son influence sur la performance reste relativement peu étudiée. Dans ce mémoire, nous présentons deux études empiriques complémentaires examinant la relation entre les pratiques de refactoring et la performance logicielle. La première étude porte sur 255 projets Java open source, analysés à partir de données issues de l’API de GitHub et de RefactoringMiner. Nos résultats indiquent que les problèmes de performance sont fréquemment résolus par des modifications de la structure des classes et de la configuration des méthodes, avec l’opération « Change Variable Type » comme stratégie de refactoring la plus marquante. L’analyse statistique révèle que les commits liés à la performance sont 1,77 fois plus susceptibles de contenir des opérations de refactoring que les commits non liés à la performance. De plus, une classification manuelle de 300 instances de refactoring ciblant la performance met en évidence 11 motivations distinctes pour le refactoring dans ces contextes, ainsi que trois environnements principaux de mise en oeuvre. Fortes de ces constatations, nos recherches se poursuivent dans une deuxième étude consacrée à l’impact du refactoring sur le temps d’exécution dans 15 projets Java open source. À l’aide d’outils automatisés pour tracer les modifications de code et mesurer la performance, nous identifions les types de refactoring les plus souvent associés à des fluctuations de performance en particulier l’extraction de méthodes et l’inlining de variables et évaluons l’ampleur de ces changements. Nous soulignons également des facteurs contextuels qui influent sur la direction et l’ampleur des effets de performance, tels que la structure du code, la fréquence d’invocation des méthodes et la couverture de tests. Globalement, nos résultats soulignent la nature nuancée et ambivalente du refactoring : bien qu’il améliore la maintenabilité, il peut aussi avoir un impact significatif sur les performances, engendrant parfois des gains notables et occasionnellement des régressions. En proposant une méthodologie reproductible pour évaluer les variations de performance liées au refactoring, cette recherche offre des orientations précieuses aux développeurs et aux chercheurs désireux de concilier la qualité du code et l’efficacité à l’exécution.

Abstract

Modern software development often confronts performance challenges stemming from suboptimal code, inefficient algorithms, or inappropriate resource management. Software refactoring, a technique traditionally employed to enhance code quality and maintainability without altering software behavior, has the potential to mitigate these issues. While prior research has extensively investigated the relationship between refactoring and functional defects, its influence on performance remains comparatively underexplored. In this thesis, we present two complementary empirical studies that examine how refactoring practices relate to and affect software performance. The first study investigates 255 Java open-source projects, drawing on data from GitHub’s API and RefactoringMiner. Our findings indicate that performance-related issues are frequently addressed through modifications to class structures and method configurations, with “Change Variable Type” emerging as the most impactful refactoring strategy. Statistical analysis reveals that performance-related commits are 1.77 times more likely to contain refactoring operations than non-performance commits. A deeper manual classification of 300 performance-refactoring instances uncovers 11 distinct motivations for refactoring when tackling performance concerns, as well as three main contexts in which these refactorings are applied. Building on these insights, the second study focuses on refactoring’s effect on execution time in 15 open-source Java projects. By employing automated tools to trace code changes and measure performance, we identify the most common refactoring types associated with performance fluctuations—particularly method extraction and variable inlining—and assess the magnitude of these changes. We further highlight contextual factors that shape the direction and degree of performance impacts, including code structure, method invocation frequency, and test coverage. Collectively, our results underscore the nuanced, dual impact of refactoring: while it enhances maintainability, it can also significantly influence software performance, sometimes leading to notable gains and occasionally to regressions. By providing a replicable methodology for evaluating refactoring-induced performance variations, this work aims to offer valuable guidelines for developers and researchers seeking to strike an optimal balance between code quality and runtime efficiency.