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.
Valentin Bourcier (Thu,) studied this question.