Google BOM feature: ms since pageload

I expect this feature has been around for quite a while already, but this is the first time I have seen it: stealthy browser object model improvements letting a web page figure out how many milliseconds ago it was loaded. It presumably works in any web browser that is Chrome or that runs the Google Toolbar:

function msSincePageLoad() {
  try {
    var t = null;
    if (window.chrome && chrome.csi)
      t = chrome.csi().pageT;
    if (t === null && window.gtbExternal)
      t = window.gtbExternal.pageT();
    if (t === null && window.external)
      t = window.external.pageT;
  } catch (e) {};
  return t;
}

In Chrome it (chrome.csi().pageT, that is) even reports the time with decimals, for sub-millisecond precision.

Google, this kind of browser improvements should be blogged! Maybe even documented. All I caught in a brief googling for it were two now-garbage-collected tweets by Paul Irish, leading to where it was committed to Chromium, and a screenshot of the feature in action, along with all the other related features not brought up now:



The rest of this post, about how I happened upon it myself, is probably only interesting to the insatiably curious:

Upon having grown weary of all the Chinese automated porn/malware comment spam that passes through Blogger's sub-par spam filtering to my moderation inbox, I decided to replace it with one that is maintained by a service specializing in (and presumably committed to!) blog comments: Disqus. In the process, being lazy, I decided to let their template wizard install itself in my blog template, which required dropping my old blogger template, upgrading it a few versions, and then (only required by my own discerning taste) attempting to manually weed out the worst crud from the new template (none of which was added by Disqus, I might add).

In the apparently uneditable <b:include data='blog' name='all-head-content'/> section, sat a minified version of approximately this code, which seems to look up the vertical position of some latency-testing DOM node passed to it, the first time the visitor scrolls the page, if it's above the fold (which in Blogger's world is apparently a constant 750 pixels into the page :-). And maybe other things.

(function() {
  function Ticker(x) {
    this.t = {};
    this.tick = function tick(name, data, time) {
      time = time ? time : (new Date).getTime();
      this.t[name] = [time, data];
    };
    this.tick("start", null, x);
  }

  window.jstiming = {
    Timer: Ticker,
    load: new Ticker
  };

  try {
    var pt = null;
    if (window.chrome && window.chrome.csi)
      pt = Math.floor(window.chrome.csi().pageT);
    if (pt == null && window.gtbExternal)
      pt = window.gtbExternal.pageT();
    if (pt == null && window.external)
      pt = window.external.pageT;
    if (pt) window.jstiming.pt = pt;
  } catch (e) {};

  window.tickAboveFold = function tickAboveFold(node) {
    var y = 0;
    if (node.offsetParent) {
      do y += node.offsetTop;
      while ((node = node.offsetParent))
    }
    if (y <= 750) window.jstiming.load.tick("aft");
  };

  var alreadyLoggedFirstScroll = false;

  function onScroll() {
    if (!alreadyLoggedFirstScroll) {
      alreadyLoggedFirstScroll = true;
      window.jstiming.load.tick("firstScrollTime");
    }
  }

  if (window.addEventListener)
    window.addEventListener("scroll", onScroll, false);
  else
    window.attachEvent("onscroll", onScroll);
})();

Google Gears: next quantum leap after XMLHttpRequest

Not much of great consequence has happened on the javascript, BOM and DOM in recent years since XMLHttpRequest and DOM 1.0. The large proprietary software people (Adobe, Apple, Microsoft, Sun) have all recently tried deploying new lock-in schemes of their own targeting the web to attract web developers into their proprietary, closed-source shackles under various flavours of EULAs and/or restrictions management, all of which will hopefully fail.

Brad Neuberg recently gave an Inventing the Future keynote speech at Yahoo FrontEnd Summit 2007, relating (among many things) that the secret to shaping the future is to be an inventive leader, in turn accomplished by combining leadership, great inventions and good values. There is much truth in that. I would personally add "working in the open" to the list.

This is exactly what Google is presently doing with Gears, which Aaron Boodman presented today (via) at Google Developer Day Sydney:



Google Gears is the next quantum leap in web development since XMLHttpRequest, addressing three of the largest issues with javascript webside development:

• the lack of large scale (gigabyte range) client side storage,
• offline availability of online resources, and
• client side javascript freezing up the browser user interface due to its single-threaded design.

All this, in order to tackle the offline problem, which Brad Neuberg had incidentally been working with in the open for some time already for the Dojo Storage and Offline modules. Gears solves all rather beautifully with these three related but separate modules:

	LocalServer caches and serves resources (HTML, javascript, images, et c.) locally,
	Database stores data locally in a fully-searchable (SQLite) relational database
	WorkerPool makes web applications more responsive by performing resource-intensive operations concurrently and asynchronously

I really recommend watching the half-an-hour presentation for the full story. Gears is already available for Firefox and Internet Explorer, soon for Safari, and, being fully new BSD licensed, allows anyone to port it to any other browser environment too. This is how you evolve the web. It is hardly coincidental that Aaron Boodman, who gave us Greasemonkey (licensed just as liberally) has been on the Gears team and gave the presentation.