For those seeing NullPointerExceptions in the Debugger with the Chronon 3 udpate, this should fix that.

Also since due to 'per thread time', we run each thread truly independently, if you view the value of a variable that was created in a different thread, chronon will try to guess its value. >95% of the time the value will be correct, but even then the debugger marks such values as <<fuzzy>>.

Its been a long time coming, but Chronon 3 is finally here! 

In the next few posts, we will dive deep into what took us so long and all the technical magic that makes Chronon 3 tick. For now lets see what Chronon 3 brings us:

Features

• Enormous performance upgrade
  

The number one issues of Chronon users has been running into OutOfMemoryErrors and all of Chronon 3 is dedicated to eradicating that. The all new, rewritten from scratch Recorder is built to conserve memory. It uses off heap memory as much as possible and even then limits the amount of total data collected by the Recorder to be many times lower than that of previous versions. This graph gives you an idea of the improvement.

• 5x faster unpacking

The Unpacker is much faster too! Apart from consuming much, much less resources, it also runs 5x faster!

• Per Thread Time

With Chronon 3, we are introducing Per Thread Time, which gives each thread its own timeline, facilitating in must easier and faster debugging. Now the timeline view shows you the time and progess of the current thread instead of the whole system, giving you much more focused data. This is carried on in other views too, like the Stack view shows the current thread only instead of cluttering the view with all the threads in the system. The result of this is much more focused data and it also allows us to make the recorder more concurrent and faster.

• On Demand Split

In case you missed it, a few months back we also introduced On Demand Split in the Recording Server, allowing you to split recordings anytime, without having to wait for a split interval.

• Support for JBoss

Previously, Jboss 7 was having issues with Chronon due to OSGI classloader issues. With Chronon 3, this should be solved and you should be able to fully record your JBoss apps.

Future Updates

Now that we are done with this huge release, we will be doing much, much faster releases to keep bringing you new features. Due to time constraints for this release, we have decided not to include the 'Recorded Console' view. We think with Post Execution Logging you can achieve the same goal without cluttering your code with println() statements. However, if there is demand for it, we will bring the view back in the next update.

Renewed Trial

If you don't own a Chronon subscription and your trial has expired, dont worry! You'll get a fully renewed trial now when you download Chronon 3. Same goes for students. If your student license has expired, request your student license again and you will get a renewed one too.

Download Now

Stop waiting and go ahead and give the Chronon 3 Debugger and Recording Server  a try now!

This is our final feature update for Chronon 2 before the Chronon 3 release. The update is mainly to the Chronon Debugger and contains some bugfixes and polish of existing features:

Keyboard shortcuts in Stack View

Chronon 3 recording warning

If you try to open a Chronon 3 recording in Chronon 2, instead of just a random crash, an appropriate error message is displayed.

More polished Select Value dialog in Method History View

When you select to filter by 'Local' expressions in Method History view, the 'Select Value' dialog now enables/disables controls as you select them and does validation on each field to make sure you enter a correct value.

Next up... Chronon 3

As mentioned previously, next post onwards we will start talking exclusively about Chronon 3. Why we got delayed? What have we been upto? How does Chronon 3 get its insane speed?

We know you have many questions. Take the red pill and come with us down the rabbit hole. The answers are coming!

While we get the final Chronon 3 build ready, lets talk about some of the UI stuff in Chronon 3. Although this release is mainly focused on insane performance improvements, we have taken some time to improve the Chronon Debugger too.

Per Thread Time

Up till Chronon 2, we only had a single global timeline to represent all events.

With Chronon 3, we are introducing 'Per Thread Time', which gives each thread its own timeline, facilitating in must easier and faster debugging.

Timeline View

The Timeline View has always been one of the most critical views in the Chronon Debugger UI. It does the fundamental job of telling you whether you just jumped forward/backward in the execution of your program. Without it, you would be 'lost in time'. The Timeline view also allows to save Time Bookmarks.

Time Progress Bars

The biggest UI change you will notice is that instead of having a single bar showing progress through time, we have 2 bars.

One shows 'global time', which tells you how far you are down the execution of the entire program. This is conceptually similar to the single bar that used to be present in Chronon 2.

The bar below that shows you how far you are down the execution of the current thread.

Time Bookmarks

Time Bookmarks now save time as 'current thread time' instead of 'global time'

Conclusion

Per Thread Time is a feature that many users have wanted and is extremely useful.

A lot of times, in a large recording, you can have many, many threads that were created and destroyed throughout the course of the program, and you really want to know whether the code you are debugging in the current thread, are you close to the end of that thread or in the middle. A good example is when debugging uncaught exceptions, since when you are near an uncaught exception, the 'current thread' bar will be almost full.

With that said, we are just packaging things up for the final release. Stay tuned to our twitter feed to hear about the release as soon as it is available! 

While we get Chronon 3 ready, we thought of making an interim release with some goodies our users have been asking for:

Chronon Recording Server

Recording Server is the highlight of this release, and contains the most voted feature from our users:

On Demand Split

Now when you encounter a bug while testing/QA, no longer do you have to wait for an 'automatic split interval' or do a 'Stop Recording' which results in a lengthy 'deinstrumentation' phase and then 'Start Recording' again (which will result in another lengthy 'instrumentation' phase).

Just click the new 'Split Recording' button and a recording is created instantly on disk and the recorder keeps running!

Here is a demo video demonstrating this feature:

Make sure you get the latest version of Recording Server now!

Chronon Time Travelling Debugger

Some enhancements based on user feedback:

Timeline View

• An Id column has been added to allow easily referring to each time bookmark by an id, instead of a complex, lengthy 'time' value.
• All columns are now sortable.

Exceptions View

• An Id column has been added here too. 

Dont forget to update your debugger!

Embedded Chronon and Chronon Recorder

Plenty of bugfixes and minor performance enhancements in the Chronon Recorder for users of Embedded Chronon and Chronon Recording Server.

If you were getting a corrupt recording when using either Embedded Chronon or Chronon Recording Server, these bugfixes should now prevent that.

Also for the first time we have updated the native agents too, from version 1.0 to 1.1.0.

We have updated the Chronon Eclipse plugin to support the Google GWT plugin. You need GWT plugin version 2.4.2 or higher for the Chronon plugin to be enabled for it.

With the GWT support:

• You can record GWT applications easily in development mode.

• The GWT 'Development mode' view has the Chronon 'blue' stop button that is enabled when you are recording a GWT application. Make sure to use that instead of the 'red' button to stop your GWT applications, otherwise the recording wont be saved properly.

A lot of people come up to me with this peeve:

The Step Forward button in Chronon, when it reaches the end of a method, doesn't perform an automatic 'step out' like your regular debugger. Instead you have to click the 'Step Out' button manually.

The Problem

The reason we don't have the 'Step Forward' button automatically do a 'Step Out' is apparently due to the presence of the 'Step Backward' button.

Consider this scenario:

1. Stepping forward at the end of a method Steps Out of it.
2. Now when the user presses the Step Backward button:
   1. Should we go back inside the method we came out of, or
   2. Should we 'step back' in the current method we just stepped out to.

The undefined semantic of the Step Back button in this case could cause confusion to the user if we took either of those choices, but the user expected the another.

Our Solution

We wanted to keep the semantic of the 'Step Back' button to do exactly the opposite of what the 'Step Forward' button does.

So in this case, to keep that semantics of Step Back intact, we limited the Step Back and Step Forward to only step inside a single method call and requiring the user to press the 'Step Out' button explicitly.

Mitigation

Although considering all the advantages Chronon offers over a regular debugger or logging, pressing the Step Out button is hardly an inconvenience, we made it even easier with the introduction of Keyboard Shortcuts.

The peeves that developers mentioned were really related to the fluidity and smoothness of the debugging experience when you only have to keep track of pressing a single button.

Keeping this in mind, if you use keyboard shortcuts for stepping within Chronon, the Step Out button is only a key away. Also you will notice the speed and fluidity when stepping using keyboard shortcuts is far, far smoother than using a regular debugger since we are not executing any code. Thus stepping over say a method that contains the bulk of your program's execution in Chronon would happen instantly compared to a regular debugger where you would notice pauses.

Conclusion

I think the above post does a good job explaining the rational behind the behavior of the Step Forward button. The keyboard shortcuts introduced recently in Chronon do a good job of keeping the fluidity of the debugging experience and you will find the experience butter-smooth compared to using a regular debugger even with the extra hassle of pressing a different key for step out.

When we were developing Chronon and started using it ourselves, we realized something very intriguing. You see, the various views of Chronon allow you to step not only forward and backward but to any random point in time. For example, using the Variable History view, you can instantly jump to when a variable became ‘null’ or use one of the powerful filters in method history view to jump directly to a particular call of a method.

The problem

Since you are not just stepping forward, it is easy to get lost in time.

For example:

1. How does one event relate to the other, did it happen before or after the other? 
2. Did I just jump forward or backward when I clicked in the variable history view?
3. If I did jump backward/forward, by how much did I jump?
4. Where am I in the execution of my program? Am I near the end of my program/ middle or end?

The Solution

Imagine you are a real world time traveler. What is the most important tool in your arsenal?

A clock.

We needed some sort of a clock inside Chronon to solve all the above issues.
Thus we invented the concept of ‘time’.

Time inside Chronon
 

‘Time’ inside Chronon does not stand for real-world clock time. After all how precisely can you really measure the time interval between say 2 variable assignments, and even if you could looking at the system clock each time your program executed an instruction, would result in a huge performance drain.

Thus ‘time’ in Chronon is merely an application wide counter. It has no relation to clock time. Its sole purpose is to give an ordering to events recorded in a program.

The only thing you know when you look at a time value is:

An event at say time 5 occurred after any event at time < 5, ie 4,3,… and before any event > 5, ie 6,7…

It is not guaranteed that the next time value after 5 would be 6 (though it is in 99% of cases), it could be 7,8 or any time > 5.

All you know about time values is that they are ascending in order, thus putting an ordering on events in your application.

Thus all the views in Chronon, like the Variable History, Method History, Thrown Exceptions, etc have a time value so you can see how the events in each relate to the other.

Timeline View
 

The ‘Timeline View’ was added to quite literally serve the role of a clock inside Chronon.

• It literally shows the current time value.
• The progress bar gives you an idea of how far down the execution of the program you are.
  See the bar completely fill up, well you are near the end, if its almost empty, you are near the beginning.
• We also added ‘time bookmarks’ in this view which act as a checkpoint mechanism for anything interesting you might want to return to in the future.

We have published a Chronon Performance Guide to help people understand and tune the various components of their system and chronon to gain the maximum performance. Of course we will keep updating this as we update Chronon.

Spoiler - 

Performance tip number 1 : Use 64 bit!

Consider the following  piece of code:

class B extends A 
{

  //constructor
  B()
  {
        this.field1 = "asdf";
  }
}

void foo()
{
   B b =  new B();
}

Note that the constructor of class B does not contain an explicit call to super()

In a traditional debugger, if you put a breakpoint on the line

B b = new B();

and 'stepped into' the call to new B(), you would be taken directly inside B(), with no chance to look at the super constructor of class A. The only way out of this would be to

1. Go back and explicitly place a breakpoint inside A()
2. Reproduce the bug (if it is at all possible at this point).
3. Start debugging all over again....
4. ... only to have this happen again accidentally for the constructor of another class.

Step to Super

To deal with the issue of an explicit call to super() not being present, in Chronon we added a 'Step to Super' button in the Stack view. 
This button is active only when you are inside a constructor and clicking it takes you directly to the constructor of the superclass of that method.

(download)

Click here to download:

step-to-super-HBrnvdojpaqjfcGrCnGc.zip (65 KB)

The screenshots above show this in action.