Omniscient Debugger

Bill Lewis' Omniscient debugger is in essence very close to what TOD aims to be, and has been a great source of inspiration. Here is an excerpt of OD's page that summarises well what it is about:

What if your debugger could go “go backwards in time?” Would that make debugging easier? By simply recording all variable assignments, it is possible to do essentially this. This is the underlying idea for omniscient debugging. The amazing part is that significantly large programs can be debugged in this fashion – Ant, JUnit, the debugger itself.

(…)

The debugger works by collecting “time stamps” which record everything that happens in a program. A GUI then allows you to navigate backwards in time to look at objects, variables, method calls, etc.

This means that you can see which values are bad, then find where those values came from, who set them and why. This also means that there are no non-deterministic problems. You don't have to guess where the problems might be, you don't have to set breakpoints, you don't have to wonder which threads ran when, you don't ever have to repeat a program run. This is the debugger that you always dreamed about, but never thought was possible.

So what it does is that it first instruments all the classes of the debugged program so that each interesting event is logged (variable assignment, method call, etc.). When the program runs, a complete trace of events is recorded.

The debugger then analyses the trace and lets the programmer drive the virtual (because actual execution already occurred) execution in a way that is infinitely richer than with traditional debuggers' controlled execution:

Stepping forwards _and backwards_.
Going to all the times a method was invoked, a field was set, data was sent to standard output. etc.

Additionally it permits to

See all the values that have been assigned to a given field.
Go to a specific point in time in the execution of the program, change the values of some variables, and resume execution at this point.

Although the Omniscient Debugger provides an unprecedented ease of navigation in a program's control flow, it doesn't differentiate from traditional debuggers when it comes to memory inspection: it is still a hierarchical view of the objects, with no ability to customize views. So it shares the same issues as traditional debuggers with this respect.