Internships for Master projects and theses

[2025 - 2026] Implementation and Evaluation of Object-Centric Breakpoints.
 Object-centric breakpoints (Ressia et al., 2012) are breakpoints scoped to specific objects. Traditionnal breakpoints are set on methods defined in classes, and interrupt executions for all instances sharing classes whose methods have breakpoints. Instead, object-centric breapoints are scoped to specific objects, and only interrupt executions for these objects.
 In previous work (Bourcier et al., 2025), we investigated the impact of object-centric breakpoints on debugging. We conducted a controlled experiment with 81 developers, in which participants were required to complete two debugging tasks using debugging tools with vs. without object-centric breakpoints. Our findings suggests that the impact of object-centric breakpoints varies depending on the context and the specific nature of the bug being addressed. For one of the tasks object-centric breakpoints significantly reduced the time to debug compared to standard tools, whereas for the other task they significantly increased the time to debug. These findings are the first results towards understanding the real impact of object-centric breakpoints, and assess if they could significantly change how we debug object-oriented programs.
 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:

1. 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.
2. 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.
3. 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.

 This work will be co-supervised with Dr. Pooja Rani (University of Zurich), Dr. Valentin Bourcier (Inria/University of Rennes) and Pr. Alberto Bacchelli (University of Zurich). It can be divided in multiple different and independant projects.