• Langue : Anglais
• Discipline : Informatique et applications
• Identifiant : 2025ULILB019
• Type de thèse : Doctorat
• Date de soutenance : 30/10/2025

Résumé en langue originale

Le débogage des logiciels reste difficile et coûteux en raison de la complexité des systèmes, qui rend souvent difficile la compréhension de l'exécution des programmes et la recherche de l'origine des problèmes qu'ils comportent. Les paradigmes de programmation tels que la programmation orientée objet (POO) peuvent amplifier cette complexité en introduisant des concepts tels que l'encapsulation, les interactions entre objets et les couches d'abstraction. Pour déboguer un programme orienté objet, les développeurs disposent traditionnellement de debuggers (débogueurs) dotés de fonctionnalités telles que les breakpoints (points d'arrêt), steps (instruction de navigation) et d'une call-stack (d'une pile d'appels), qui leur permettent de naviguer dans le code source et les méthodes impliquées dans l'exécution d'un programme. Cependant, des recherches suggèrent que, lors de la maintenance de programmes orientés objet, les développeurs ne pensent pas seulement en termes de code source et de méthodes, mais aussi en termes de comportement des objets, de transitions d'état et d'interactions avec d'autres objets.Pour remédier à l'écart entre les outils de débogage et les informations dont les développeurs ont besoin lors du débogage, les chercheurs ont proposé l'object-centric debugging (débogage centré sur les objets). L'object-centric debugging est une approche qui utilise des outils de débogage focalisés sur des objets particuliers plutôt que sur des classes et des méthodes. Ces outils comprennent des object-centric breakpoints (points d'arrêt centrés sur les objets), qui suspendent l'exécution pour des objets spécifiques, et des débogueurs omniscients, qui permettent aux développeurs de capturer et d'explorer le comportement des objets pendant l'exécution. Bien que des évaluations de cette approche aient été proposées, à travers des benchmarks et des études de cas, des recherches supplémentaires sont nécessaires pour connaître l'impact du débogage centré sur les objets.L'objectif général de cette thèse est d'étudier l'impact de l'object-centric debugging et de proposer des solutions pour améliorer cette approche. Pour ce faire, nous avons mené une évaluation empirique des object-centric breakpoints. Nos résultats suggèrent que ces breakpoints pourraient aider les développeurs à gagner du temps lors du débogage. Cependant, ils révèlent également des limites dans les scénarios impliquant des bugs dans l'initialisation des objets. Nous avons mis ces résultats en relation avec les solutions de debugging object-centric basées sur des debuggers omniscients, en réalisant une étude de cas dans laquelle nous avons examiné des sessions de débogage avec des breakpoints object-centric et l'équivalent omniscient que nous avons implémenté, les Time-Traveling Object-Centric Breakpoints (TTOCBs). Nos observations suggèrent que les TTOCBs aideraient les développeurs à déboguer des scénarios pour lesquels les breakpoints object-centric semblent limités. Enfin, nous avons comparé les caractéristiques des debuggers object-centric existants avec les méthodologies de débogage décrites dans la littérature. Nous avons constaté que ces debuggers n'apportent pas de soutien technologique pour aider les développeurs à suivre la méthode de débogage systématique. Pour remédier à ce problème, nous proposons Scopeo, un debugger omniscient, interrogeable (via des requêtes) et centré sur les objets, qui introduit les exploration scopes (périmètres d'exploration). Les exploration scopes sont des sous-parties de l'exécution du programme que les développeurs peuvent créer et réutiliser dans le cadre de requêtes. Nous avons présenté une étude de cas illustrant la faisabilité du débogage à l'aide des exploration scopes et avons identifié des pistes potentielles pour de futures recherches.

Résumé traduit

Debugging software remains challenging and costly due to the difficulty of understanding program execution and tracing the origin of problems, which are often obscured by system complexity. Language paradigms such as object-oriented programming (OOP) can amplify this complexity by introducing concepts like encapsulation, object interactions, and layers of abstraction. To debug object-oriented program, developers are traditionnally provided with debuggers featuring breakpoints, steps, and a call stack, to navigate the source code and methods involved in a program execution. However, research suggests that, when maintaining object-oriented programs, developers think not only in terms of source code and methods but also about objects' behavior, state transitions, and interactions with other objects.To address the discrepancy between the available debugging tools and the information developers need while debugging, researchers have proposed object-centric debugging. Object-centric debugging is an approach that uses debugging tools which focus on particular objects rather than classes and methods. These tools include object-centric breakpoints, which pause execution for specific objects, and omniscient debuggers, which allow developers to capture and explore object behavior during execution. Although evaluations of this approach have been proposed, through benchmark and case studies, further research is needed to learn the impact of object-centric debugging.The overarching goal of this thesis is to investigate the impact of object-centric debugging and propose solutions to improve the approach. To this end, we conducted an empirical evaluation of object-centric breakpoints. Our results suggest that these breakpoints could help developers save time while debugging. However, they also reveal limitations in scenarios involving bugs in object initialization. We compared these results with those of object-centric debugging solutions based on omniscient debuggers, by performing a case study that examined debugging sessions with object-centric breakpoints and our implemented omniscient equivalent, Time-Traveling Object-Centric Breakpoints (TTOCBs). Our observations suggest that TTOCBs would help developers debug scenarios in which object-centric breakpoints seem limited and reduce the number of actions performed with the debugger. Finally, we compared the characteristics of existing object-centric debuggers with the debugging methodologies described in the literature. We discovered a lack of technological support from debuggers for the systematic debugging method. To address this issue, we propose Scopeo, an omniscient, queryable, and object-centric debugger featuring exploration scopes. Exploration scopes are subparts of program execution that developers can create and reuse within queries. We presented a case study that illustrates the feasibility of debugging using an exploration scope and identified potential avenues for future research.