General Info.Project Homepage
Project ArtifactsUse Cases
Vision and Business Case
OtherReferences and Related Work
Current Version: Inception [09 Feb 2003]
About the project
Most all current debugging tools operate at the individual statement scale, that is, the primary interaction the debugging user has with the problematic system is through the series of lines of code being executed. To examine the state of the system, the user is usually provided a list of the local variables and a selected "watch" list of data of interest.
Likewise, profilling tools are focused heavily on the call stack-- the general intent is to identify functions that are taking more CPU than they should.
In contrast the last decade has seen a large movement toward higher-level constructs in both design and programming. Programming has seen the introduction of so called "design patterns", primarily through [Gamma 95]. The disciple of architecture or design has seen benefit from using high-level, schematic diagrams, such as those in the UML.
This project proposes to provide system developers with a variable scale debugging tool and it is my belief that such systemic debugging tools and techniques will allow easier understanding of running systems, especially the complex multithreaded and distrubted environments for which so few tools exist today.
My personal motivation for this project came from a rather unpleasant experience trying to track down a seemingly-random deadlock on a large, multi-threaded software project.
The primary tools that we used to understand the system's threading behavior were massive trace logs and the trick of sending signal three to the JVM to dump a snapshot of the detailed state of each thread.
Over the course of the first few frantic debugging days, we began to get a feel for the execution patterns of the system-- where time was usually spent, what operations were blocking on what locks, and so on. Despite leading the design of the project since it's inception, I was often surprised at the behavior of it at execution time. But after spending a few days carefully watching stack traces and delving into megabytes of trace logs, we began to get a clearer sense of just what might be going wrong.
This project is a direct out-growth of that and similiar experiences debugging large systems and a long-held belief that higher-than-statement-level visualization techniques will provide a better understanding of the execution of complex software applications.
Last modified Monday March 03, 2003.