March 25, 2013

Study: Reverse Debuggers can Decrease Debugging Time by an Average of 26%

Nicole Hemsoth

There is no doubt that software bugs are time consuming, but can the time investment be Rogue Wavedrastically decreased? YES! Solving bugs in a parallel programming environment eats up a lot of time because conventional debugging techniques only allow users to control program execution in the forward direction, forcing developers to apply laborious and inefficient methods in their attempt to identify the problem. Introduce the concept of reverse debuggers, and debugging suddenly becomes extremely efficient. Reverse debuggers allow you to work backward from a failure, error, or crash to its root cause and step freely both forwards and backwards through execution without having to restart the program.

According to the recent study at the University of Cambridge, researchers found that when respondents use reverse debugging tools, like Rogue Wave’s ReplayEngine, their debugging time decreased by an average of 26%. Developers, like you, can leverage these time savings to develop additional products, features, and capabilities.

“This research confirms what our customers have been saying for years about the ability of TotalView to drastically reduce development time and costs during the debugging stage of software development,” stated Chris Gottbrath, Rogue Wave Principal Product Manager. “As a market leader in debugging technology, we continually advocate the time and cost-savings benefit of ReplayEngine, Rogue Wave’s reverse debugging feature as a part of TotalView. We are pleased to see robust academic research highlighting this technique as an important opportunity for the global economy.”

Researchers at the University of Cambridge’s Judge Business School conducted a survey which found that when respondents used advanced reverse debugging tools, they spent an average of 26% less time on debugging. Specifically, the time fixing bugs decreased from 25% to 18% and reworking code decreased from 25% to 19% while using reverse debuggers. This means, on the macro-economic level, that reverse debuggers have the potential to save 13% of total programming time, which translates to $41 billion dollars of annual savings to the economy.

As hardware architectures continue to advance from multicore towards manycore, debugging applications developed for these platforms has become exponentially more challenging, with higher levels of concurrency compounding the difficulty of finding and fixing bugs. Conventional debuggers, which allow developers to step through code looking for errors only in the forward direction, are no longer sophisticated enough. When dealing with software that has threads or processes that interact with each other or shared resources, it is common for timing and communications to become out of synch. Non-deterministic bugs, which occur from errors like race conditions and other concurrency issues, may only appear once in ten, a hundred or even more than a thousand executions. If the application runs across large grids, or is shipped to thousands of customers, that rarely occurring bug now appears much more frequently. The ability to simply rewind the application’s execution to determine the exact point of the error is invaluable.

Designed to improve developer productivity, TotalView® simplifies and shortens the process of developing, debugging, and optimizing complex code. It provides a unique combination of capabilities for pinpointing and fixing hard-to-reproduce bugs, memory leaks, and performance issues. TotalView’s reverse debugging capability records the execution history of programs and makes that history available for diagnosis. This new approach—working back from a failure, error, or crash to its root cause—eliminates the need to restart a program repeatedly with different breakpoint locations. The ability to do reverse debugging, stepping freely both forwards and backwards through program execution, drastically reduces the amount of time invested in troubleshooting code.

Read the Reverse Debugging White Paper.