Object-Oriented Breakpoints
Introduction
Object-centric breakpoints (Ressia et al., 2012) are breakpoints scoped to specific objects. Traditional breakpoints are set on methods defined in classes, and interrupt executions for all instances sharing classes whose methods have breakpoints. Instead, object-centric breakpoints are scoped to specific objects, and only interrupt executions for these objects. Bourcier et al. (2025) studied the impact of object-centric breakpoints through a controlled experiment with 81 developers performing two debugging tasks—with and without these breakpoints. Results showed that their effectiveness depends on context: in one task, they reduced debugging time significantly; in the other, they increased it. These findings offer initial insights into how object-centric breakpoints might reshape debugging in object-oriented programming.
Task Overview
In this project, we want to reproduce the experiment in a different setting to challenge our findings, further study the impact of object-centric breakpoints and improve our understanding of how to debug object-oriented programs. The goals of this project are three-fold:
- Implement object-centric breakpoints in Python and Java. We tested the object-centric breakpoints implementation of the Pharo language, because it is a production tool present in the Pharo language for more than 5 years. We want to implement the breakpoints in Python and Java to enable their evaluation in other settings. This work require to manipulate debuggers (such as PDB or JDI), to dynamically modify running executions by means of, e.g., reflection techniques and to rigorously test the new implementation.
- Integrate the new implementation in standards IDE and tools. Object-centric breakpoints do not replace standard tools, but come in complement. It is therefore necessary to include them in the standard debugging flow, and to make them available from standard tools. Typically, they must be available from various debugging menus in standard debuggers. This work require to extend IDEs such as PyCharm, IntelliJ and Jupyter notebooks to enable object-centric breakpoints, and to document their usage in these IDEs.
- Design and conduct replication experiments as well as new experiments to further understand and go beyond our first resuls. Python, Java and Jupyter developers use slightly different tools than Pharo developers. Reproducing our first experiment (Bourcier et al., 2025) requires careful adaptation of the original design. Furthermore, new experiments can be designed to explore the different specificities of these programming languages and environments.
Technologies
This project requires software development skills, including proficiency in Java or Python for concepts like meta-programming, Reflection, and the ability to work with the GitHub API, HTML/CSS/JavaScript, and REST APIs. Knowledge of designing a user study is appreciated but not mandatory.