Channels ▼

Eric Bruno

Dr. Dobb's Bloggers

Continuous Debugging

February 22, 2013

I've been following the latest developments in the NetBeans and Eclipse IDEs, and how they both continue to improve with each new release. For instance, notice how the latest versions are adding support for HTML5 development, treating JavaScript as a first class language with full editor and debugger support, and integrating Maven more and more tightly into the IDE's build/deploy process.

More Insights

White Papers

More >>


More >>


More >>

The soon-to-be-released version of NetBeans 7.3 builds upon the above, but also integrates the JavaFX Scene Builder inside the IDE, improves REST development, and spruces up support for other JVM languages such as PHP and Groovy. Eclipse continually streamlines its collaborative development features, and now features an improved UI for multi-monitor support and high-resolution displays.

But I still wonder, what's next? What will be the next sea change in the area of IDEs and application development? I have some ideas, generally revolving around the transition from straightforward coding to building and debugging. For the most part, the popular IDEs have done a good job of blurring the lines between coding and compiling. You don't need to explicitly build your projects anymore. But the same cannot be said for debugging.

I often find myself launching an application in debug mode, stepping through some code, and then entering a series of repeated steps where I stop debugging, make a change, and then resume debugging. Rinse and repeat, and repeat. I know that some IDEs support changes while you're debugging, even if you're running a Java EE application within an application server, but it's not always reliable, and sometimes the changes are too drastic for it to work.

Continuous Debugging

I propose that the next generation of IDEs create an environment of continuous debugging, to be integrated into the continuous integration paradigm. In other words, from the moment I begin coding in an editor, I want the IDE to enter debug mode, attempting to execute the project and update its execution state while I type. You don't think this is possible? It already happens with the compiler. Sure, I get little red lines in the editor and compiler errors in the output window until I modify and fix the code. All of this updates in real time, so why can't the execution state do the same? This way, as I code, I can set breakpoints, see them get hit, and then write new code and modify existing code all at the same time.

As a result, there would be a continuous flow of coding/testing/debugging, with no need to stop my current workflow to start or re-start a debugging session. In reality, the IDE would need to perform those steps behind the scenes, but it could go a long way towards making it look seamless, and appear to execute/debug continuously as I write code.

Total Continuous Integration

Going forward, I'd like to see the IDE merge its capabilities with continuous integration software such as TeamCity, and issue tracking software such as Jira, to more easily enable the Agile development process. Add to this the continuous debugging I've described above, and developer productivity and code quality would increase tremendously as continuous debugging and testing occur seamlessly. Imagine never having to interrupt your state of coding to achieve all of this. Is it possible? What else would you add or change in your favorite IDE?

Happy Coding!


Related Reading

Currently we allow the following HTML tags in comments:

Single tags

These tags can be used alone and don't need an ending tag.

<br> Defines a single line break

<hr> Defines a horizontal line

Matching tags

These require an ending tag - e.g. <i>italic text</i>

<a> Defines an anchor

<b> Defines bold text

<big> Defines big text

<blockquote> Defines a long quotation

<caption> Defines a table caption

<cite> Defines a citation

<code> Defines computer code text

<em> Defines emphasized text

<fieldset> Defines a border around elements in a form

<h1> This is heading 1

<h2> This is heading 2

<h3> This is heading 3

<h4> This is heading 4

<h5> This is heading 5

<h6> This is heading 6

<i> Defines italic text

<p> Defines a paragraph

<pre> Defines preformatted text

<q> Defines a short quotation

<samp> Defines sample computer code text

<small> Defines small text

<span> Defines a section in a document

<s> Defines strikethrough text

<strike> Defines strikethrough text

<strong> Defines strong text

<sub> Defines subscripted text

<sup> Defines superscripted text

<u> Defines underlined text

Dr. Dobb's encourages readers to engage in spirited, healthy debate, including taking us to task. However, Dr. Dobb's moderates all comments posted to our site, and reserves the right to modify or remove any content that it determines to be derogatory, offensive, inflammatory, vulgar, irrelevant/off-topic, racist or obvious marketing or spam. Dr. Dobb's further reserves the right to disable the profile of any commenter participating in said activities.

Disqus Tips To upload an avatar photo, first complete your Disqus profile. | View the list of supported HTML tags you can use to style comments. | Please read our commenting policy.



What you call continuous debugging is exactly what Smalltalk (or Forth for that matter) programmers have been doing since the 80s and scratching their heads wondering why anyone would want to work in any other mode.


Testing and continuous testing is a theme that has been coming out of the comments that I only alluded to in my blog, and that's a good thing. Definitely something to be explored a future blog. Thanks!


Thanks for the links to the videos.


Almost sounds like you are describing a Smalltalk environment...


Continuous debugging is really hard as expalined by dleppik554. However, continuous testing is the present. The key idea introduced by MIT researchers is to execute tests after each modification when the code is saved. In this way new bugs are revealed immediately whose fixing is fast and effective. The problem is when executing all the test cases takes too much time.

The solution is test selection, when only those tests are selected which outcome may change (passed -> failed, failed -> passed) during the modification. Since only quite a few test cases are selected and executed in this way performance problems are solvedt. Detailed information about continuous testing:


Reminds me of some of Bret Victor's ideas, mostly this: but also this:

I use JRebel to do continuous updates to my Tomcat instance, but keep it (and HotSwap) turned off in my IDE (IntelliJ.) The problem is that when you change algorithms and data structures while you're running, you end up with the new algorithm running on out-of-date data. Continuous debugging would work if your program has an obvious entry point and can start over quickly (as in the video in the link.) Indeed, unit tests out to run continuously-- if they are pure unit tests with no outside dependencies.


We published a similar piece on end-user programmable simulations years ago ( This new paper looks very interesting and I'll be forwarding your comment to our Editor in Chief, Andrew Binstock. Thanks!


Thanks for the information. Very interesting!


One idea going in this direction is called Conversational Programming. The idea is to integrate programming and debugging. For now this is mostly aimed at end-user programmers but empirical evidence suggest that it could also be quite relevant to professional programmers. Here is an example that implements an early version of conversational programming by constantly executing relevant parts of your program and annotating the program to indicate potential differences between the program you have and the program you want.