Tracker is a debugger I'm thinking of writing. It will have two
special features: value tracking and control tracking. The idea
for Tracker was triggered by my first boss, Mike Gilbert, while he was
ranting about language designers not giving enough thought to issues
of debugging. This was right after I had spent five weeks working
with a particularly brain-dead debugging environment (all I had to
work with was printf). One of us -- I don't remember who -- came
up with the idea of value tracking.
You're in the debugger, looking at a null reference. As soon as
you step, the program will try to use this reference, and then
promptly crash. How did this reference get to be null? Did it get
explicitly set to null or was it just never initialized? Value
tracking lets you find out when and where a variable was modified.
Value tracking is similar to the break on modify capability of many
debuggers, but it has several advantages:
- It works backwards in time. You find the variable first and then ask when it was
last written to, instead of setting a breakpoint and re-running.
- It's more specific than a breakpoint. Instead of breaking every time the function
is called, you only have to pay attention to when the function was called for this
- It works even if you don't know which function you need to look at.
Control Flow Tracking
You're in the debugger, looking at a function that's only supposed to be called on
the Mac. But you're debugging on a PC. How did you get here? What conditional branch
went wrong? Control flow tracking lets you find out exactly why you got where you
are, and where you were before.
Control flow tracking is similar to viewing a stack trace, but it has these
- It has a better memory. You can view the entire call tree of the program, instead
of just the current stack.
- It has a finer resolution. It remembers which branch it took in an if-statement.
- You can do diffs. If your program works once and then breaks, you can quickly
determine what changed between the two invocations.
Tracker will be written in Java for Java. Because I don't want to write an entire VM,
it will be implemented as a special ClassLoader. This means that it can only track the
classes that it loads. However it will have mechanisms for black-box tracking other
I would like to see the entire operating system become trackable. Can't ping a
machine? Find out where the problem is by examining the track of the error message.
Tracker is still very immature. I still need to figure out how to represent an
overwhelming amount of information in a manageable way. And I need to work out an
implementation technique that won't make programs ten times slower, or consume
gigabytes of memory.
Last updated sometime in 1997
Back to Kimberley's Code.
Back to Kimberley's Home Page.