Recently there has been a lot of discussion on the usefulness of current web performance metrics. We all got used to First Impression, onLoad and Fully Loaded time. With dynaTrace Ajax Edition we also provide all this metrics. Joshua Bixby wrote a very good post an why they do not really tell us what we eventually want to know.

The major question we all want to answer is when the user is ready to use a page . While the current metrics help us to understand the behavior of a page,  they cannot provide this information. Looking at the different metrics we find some shortcomings with all of them.

First Impression time tells us when the user gets the first visual of the page. While this tells us that the user sees something it does saywhat he sees nor whether he could interact with the page.

OnLoad time is the time when the onLoad event triggers.  This is a good indicator to know when this code starts being executed. With dynaTrace we can look a bit deeper to see when a specific function has been executed. The effects of this timer on end users cannot be defined in general. In some case this is the point when JavaScript code begins to build the page in others is the time when progressive enhancement of the page content kicks in. Steve Souders has written an excellent blog about rendering vs JS execution . So in one case this metric is highly important and in other cases it is not.

Fully Loaded time tells us when all content including all downloads (and execution) triggered by onLoad handlers is finished. So this metric provides a hint when we are done downloading and executing all we need. Ok, there might still be additional content which is downloaded even later, but we get pretty close. The effect on the end-user is difficult to determine.  The application developer will know best what this means for end-user experience.

So while all these metrics provide some important insight they still cannot provide the ultimate answer. I see this becoming a more and more important  topic in web performance space.  So the questions “When are ready to go?” still remains. Using an anlogy to driving I called this the clutch time – the time we lift our foot and start driving.

The hard part is to define how to measure it in a technically correct way. Using dynaTrace Ajax Edition we have tried several approaches but did not find the ultimate answer yet. For each approach  there is at least one situation where it does not work as it seems. This is mainly caused by the huge number of different ways of how to build a page.

While I am not providing a final answer here is what our definition of clutch time is:

  1. First Impression Time if there is no blocking JavaScript execution thereafter or any DOM manipulation causing reflow in the onLoad method
  2. First drawing event after the last DOM manipulation in the onLoad event handler, if there is no JavaScript execution after that.
  3. End of continuous JavaScript execution either after First Impression Time if there is no onLoad DOM manipulation or end of JavaScript execution in the onLoad handler.

While I am sure that this definition is far from perfect it is a good starting point. I am looking forward to ideas on how to improve the measurement.