From prototype to product
BugJail 2019.1 took last year's private beta version, which was of prototype or MVP quality, and made it a proper product. Or at least fairly stable beta of a product.
The work ranged from adding hundreds of test cases and adding support for 100% of Java 8 language features, to signed Windows and Mac installer packages and guided start experience.
Complete rewrite of the front-end application
After evaluating feedback from last year's private beta and the quality of the front-end application, a decision was made to throw the front-end away and start from the beginning. This time, instead of using generic architecture and ready-made UI framework, we designed everything from scratch for BugJail's exact requirements (which in terms of performance are hardcore).
The result of the rewrite is a front-end application that will hopefully prove to be solid foundation for years to come. On the other hand the front-end application is now roughly two years newer, and two years less mature, than the other components (capturing agent and local server).
200x faster viewing of objects
Slow data access between front-end application and the local server/database was the #1 complaint from private beta.
In BugJail 2019.1 the raw performance of data access is not any faster than before. But the data access is hell of a lot smarter For example one of our benchmarks captures the startup of Eclipse, which results in over 500 million captured events. In last year's private beta it took on average 5 second to fetch and view an object. In BugJail 2019.1 it still takes 5 seconds to fetch, but now in 99% of situations the object you want to view has already been pre-fetched, and can be viewed as fast as the UI refreshes. That's about 25 milliseconds, instead of previous 5 seconds.
Source level debugging with mouse - Stage 1
BugJail 2019.1 pioneers new kind of source level debugging where you see source code of a method overlaid with runtime captured information from a single call/invocation of that method. Code branches that were executed are highlighted, so you can just glance at the source and see immediately how the method executed instead of much slower line-by-line stepping, and then point and click with mouse where you want to navigate.
This is a very different way to debug, but in our experience it works really well with high level languages, where the usual line-by-line stepping is tedious. Give it a try and let us know what you think!
Stage 1 is still fairly limited: field writes, local variable assignments and thrown exceptions are missing, and only Java is supported. Stage 2 (coming in next major version) will add these and hopefully at least partial Scala support.
Slider that moves debug time, like in music player.
Normal debugger pauses program execution at single point in time, but BugJail captures the entire execution to database, so it has history of every field write. By using that history we can reconstruct what the field values of any object were at any given point in time. And we give you a slider for specifying that point in time.
It is of course very cool and shiny to drag a slider around and see interactively how some object graph evolves through time. But behind the shine there is one of the most common use cases of debugging: checking what the value of a field is at certain time. In BugJail you just move the slider back to see history from current debugging time, or forward to see the future! Contrast that with traditional debugger where you need to step forward only line-by-line until something happens...
This feature also works fully with BugJail's knowledge of who wrote the field value (just click the "written by" call to switch debugging the method call that wrote the currently displayed field value). Again, give it a try and let us know what you think, or how to improve this.