UndoDB gets smarter

Hi LWN-dudes!  Think many of your readers will be interested in this:


UndoDB, the smart debugger for Linux gets smarter
- Reversible debugger for Linux gets support for threads and signals

FOR IMMEDIATE RELEASE

Cambridge, UK - March 12, 2007.

Jacob Rideout is a developer on the prestigious KDE project. After 
struggling for over a week with a particularly nasty bug, he turned to 
UndoDB: the reversible debugger for Linux applications. He says of the 
experience:

     "I found the idea of [the] product amazing and a boon to my 
productivity ... I already have been able to fix a deadlock that was 
driving me crazy for a week in only 10 minutes".

UndoDB is different to most other debuggers because it is able to step a 
program back in time, showing the programmer exactly what their program 
has done, and so making even the most difficult bug trivial to uncover.

Bugs are the bane of software developers' lives, and those of their 
managers. Yet until recently, the tools that are used to resolve them 
had hardly evolved in decades. Greg Law, co-founder and CEO of Undo 
Software (http://undo-software.com/) found the general lack of interest 
in debugging in the computer science community perplexing:

     Bugs are by far software's single biggest issue. It's always been 
so, and it's been getting steadily worse as software has become ever 
more complicated. Debugging may not be glamorous, but it totally 
dominates software development costs, schedule delays, and product 
quality. Even now a very small proportion of computer scientists are 
directly working on this problem. But things are beginning to change — 
Undo Software is one of a small but growing number of players in the 
industry who are giving this huge problem the attention it deserves.

The US government estimate that bugs cost $60bn per year to the US 
economy alone [1]. This huge sum is partly due to productivity (the same 
report estimates programmers spend 80% of their time debugging), and 
also due to the cost of in-the-field bugs.

Law goes on to say

     We have been truly delighted with the feedback and very positive 
response we received with the release of version 1 of UndoDB last year 
and we look forward to helping many more in the Linux community with the 
release of UndoDB v2 which is able to operate on programs that use 
threads and asynchronous signals.

Traditional debuggers have been in widespread use for decades, allowing 
the developer to stop his program and peer inside. The program can then 
be started again, and may be inched forwards an instruction or more at a 
time. These tools have their uses, but they are unable to tell the 
programmer what their program has done previously. A new breed of 
debugger, reversible debuggers, allow the programmer to pause a running 
program and inspect its state not just at that moment, but at any point 
in the past. The program can be stepped back a single instruction, or a 
larger amount of time, giving the developer much more information to 
help diagnose the cause of the bug.

A reversible debugger effectively records everything that the debuggee 
program does, down to the finest detail: every memory access, every 
computation, every call to the operating system and every input it 
receives. This colossal amount of data is then presented to the 
programmer using a very powerful metaphor: the ability to travel 
backwards in time (and forwards again) and inspect the program state. 
UndoDB does not need to store this huge amount of data though: its 
snapshot and replay technique allows it to store only non-deterministic 
inputs, making the space required for the log much smaller than would 
otherwise be the case.

Reversible debugging is so useful because it gives the user control over 
time. To debug a program is to reason backwards from the point of 
failure to determine the cause of that failure. On the first page of 
their book, The Practice of Programming, Brian Kernighan and Rob Pike 
(two of the pioneers of modern computer programming) give the following 
advice to programmers when debugging:

     Reason back from the state of the crashed program to determine what 
could have caused this. Debugging involves backwards reasoning, like 
solving murder mysteries. Something impossible occurred, and the only 
solid information is that it really did occur. So we must think 
backwards from the result to discover the reasons.

With this analogy, a programmer using a reversible debugger is like the 
detective finding detailed CCTV footage of a murder and everything 
leading up to it.

UndoDB uniquely enables reversible debugging of arbitrary Linux binary 
programs, including those written in C or C++. UndoDB requires no 
recompilation or other modifications to the program being debugged, nor 
does it require any specialized hardware, kernel patches, or kernel modules.

UndoDB uses the ubiquitous gdb as its front-end, so Linux developers 
will feel right at home, and be productive the moment they get started. 
gdb has been complemented with a few new commands which work just like 
gdb's existing commands, only they step the program backwards in time, 
rather than forwards. For example, whereas gdb's step command steps the 
program forwards one source line, UndoDB's bstep command steps the 
program back one source line. UndoDB also compliments gdb's next, until, 
finish, stepi and nexti commands with their respective counterparts: 
bnext, buntil, bfinish, bstepi and bnexti. UndoDB also adds some new 
commands which have no parallel in gdb, such as the bgoto and bgoton 
commands, which jump to an arbitrary point in the program's history. 
When the program is paused at any point in its history, the programmer 
can inspect the full state of their program using the usual gdb commands 
(e.g. print, backtrace and display).

Although UndoDB is not open source, developers who don't get paid for 
their work can use UndoDB for free. For professional use, UndoDB costs 
between $195 and $495 per seat. There is also a free 30-day evaluation 
version. UndoDB is available now, from http://undo-software.com/.
References

[1] NIST -- Software Errors Cost U.S. Economy $59.5 Billion Annually 
http://www.nist.gov/public_affairs/releases/n02-10.htm.

[2] Dr. Dobb's Journal, May 09, 2005 -- Omniscient Debugging (RetroVue 
at Work) http://www.ddj.com/dept/debug/184406101?pgno=5.
Notes to Editors

Undo Ltd is a privately held software company based in Cambridge, UK. It 
was founded by Greg Law and Julian Smith in 2005. Both hold a Ph.D. and 
have worked in the computer industry for many years. The company was 
formed out of the founders' frustration with existing debugging tools. 
UndoDB is Undo Software's first product.
Contact Details

Email support@undo-software.com, visit http://undo-software.com/ or call 
Greg Law on +44 7712 588 091 for more information.

-- 
Greg Law, Undo Software                       http://undo-software.com/