Patrick Sabin:
Implementing a Reversible Debugger for Python

The programmer usually initiates a debugging process because of a
failure and his goal is to find the defect. The defect is always
executed before the failure occurs, so it is natural to start at the
failure and move backwards in a program to find the defect. However
this procedure is usually not supported by actual debuggers.

There are two different methods of implementing a reversible debugger,
i.e., a debugger which can run the program forwards and backwards. The
first one is the logging-based approach, which records the state of
the program after every instruction and allows inspection after the
program has finished running. The second one is the replay-based
approach, where the debugger runs the debuggee interactively. For this
purpose it makes periodic snapshots and runs the debuggee backwards by
restoring a previous snapshot and then running the program forward
until it reaches the desired position.

In this thesis, I want to show that it is possible to implement a
reversible debugger by continuous snapshotting of the program
state. There are indeed some problems with using such a feature. For
example, there are non-deterministic instructions, which execute
differently each instance the interpreter executes them, e.g., a
function, which returns the system time. Another example of this is
when instructions change some external state like a file on the hard
drive, which the debugger does not save when it makes a
snapshot. Another problem is that some instructions do something
different each time the debugger executes them.

Therefore I present some methods of treating these
problems. Accompanying this paper I have developed a proof-of-concept
implementation of a reversible debugger called epdb for the Python
programming language, which solves most of the problems of reversible
debugging.