Amazing OnTime Group Calendar performance gains

As I have been tweeting recently I have finished coding the new OnTime Group Calendar Notes UI and we are now shipping it (OnTime Group Calendar 2011 ). This release is a brand new, completely rewritten, product and it’s shipping with some very cool features and UI’s. Currently we’re shipping a standalone UI (Discovery 2011) and the Notes UI (Notes 2011) with a mobile and web UI coming soon (Web 2011 and Mobile 2011). My main contribution is the OnTime Group Calendar Notes 2011 client which is a full Java based group calendar UI that runs inside the Notes 8.5 Standard client. More in a separate post about the Notes 2011 client.

Part of the OnTime Group Calendar is the backend that runs on the server. Previously we easily scaled to 100.000+ users but you normally had to run multiple group calendar databases to control access and visibility of calendar data within your organization.

This “restriction” has now been is now lifted with the new release of OnTime Group Calendar 2011. Now all customers will run a single group calendar database and the OnTime backend takes care of controlling access and visibility either based on custom configuration or based on mail database ACL’s.

To get ready for the new release we have done a number of pilot installs and there we found some very interesting performance numbers at a customer which I’ll share below.

Text OnTime 9.x OnTime 2011 % of previous
Users 8.900 8.900
Storage need 17 GB 170 MB 1%
Number of views required 300 20 6.6%
Document count 300.000 27.000 9%

At another customer we went from a group calendar database of 1.3 GB to 22 MB. That’s also a reduction to a little less than 2% of the previous disk usage (1.6%).

As you can see from the above the disk savings are massive. Smaller databases leads to less I/O which leads to major improvements in performance. Domino as a backend screams for this kind of solution. So cool.

Oh and best of all – it’s still a pure Domino solution.

A (dojo.)mixin configuration approach to XAgents in XPages

Continuing my XPages theme from yesterday I also wrote an XAgent base-class in JavaScript to make XAgents easier to do. Part of the base class is that it allows me to pass in a JSON object to configure the XAgent based on the need. Since the information I pass in should override the built-in defaults I needed a way to easily allow the user supplied values to override the defaults. The easiest way to do this would be to use the dojo.mixin.

"dojo.mixin is a simple utility function for mixing objects
together. Mixin combines two objects from right to left,
overwriting the left-most object, and returning the newly
mixed object for use."

Unfortunately Dojo isn’t available in SSJS I needed to do it myself. To my luck it was surprisingly easy as the below code illustrates.

// create function to allow mixin' two objects
var mixin = function(target, source) {
   if (!source) return;
      var name, s, i;
      for (name in source) {
      s = source[name];
      if (!(name in target) || (target[name] !== s)) {
         target[name] = s;
      }
   }
};

My XAgent base class looks something like this:

function XAGENT(args) {
   // create mixin function
   var mixin = function(target, source) {
      if (!source) return;
         var name, s, i;
         for (name in source) {
         s = source[name];
         if (!(name in target) || (target[name] !== s)) {
            target[name] = s;
         }
      }
   };

   // define default arguments
   this._args = {
      download: false,
      filename: "default.json",
      charset: "iso-8859-1",
      contentType: "application/json"
   };

   // mixin user-supplies arguments
   mixin(this._args, args);
};
XAGENT.prototype.run = function(command) {
   ...
};

What’s super neat is that now, in my run-method I can access the this._args object and all values that the user supplied have overridden the default values because we used the mixin-function. Very cool and an easy and flexible way to have default values but allowing them to be overridden by the caller. Also you know that the variables you need have been defined so no checks are necessary.

Calling my XAgent class is very easy allowing me to override the defaults. The run-method accepts a function which is called when the XAgent stuff has been set up supplying the Writer and the parameters supplied in the URL as a JSON object.

var xa = new XAGENT({
   filename: "feed.json",
   download: true
});
xa.run(function(w, params) {
   ...
});

XPages JavaScript utility function of the day

Yesterday and today I’ve been spending some time doing some XPages coding for a customer project and after spending quite some time doing Java plugin development I’m amazed of how easy XPages are. Don’t get me wrong – there is still work to do for the XPages team but it’s a joy to work with XPages and coding in JavaScript is just – well – flexible and fun.

One of the real joys of JavaScript is it’s dynamic nature and that it allows one to really cut down on the boilerplate and repeated code. For one I spent a lot of key pressed getting field values from backend documents in server side JavaScript. Instead of repeating the same ol’ Document.getItemValueString(String) over and over again I did a neat little shortcut. Since I needed all items from a document I just created a utility function to JSONify a document to make it easier to access. The method is below.

var jsonifyDocument = function(doc) {
   var result = {};
   if (!doc) return result;
   var item;
   for (item in doc.getItems().toArray()) {
      result[item.getName().toLowerCase()] = item.getText();
   }
   return result;
};

So now instead of writing doc.getItemValueString all the time I can now just do property-like access to field values (“Heading” and “Description” are fields on the document).

var jsonDoc = jsonifyDocument(doc);
jsonDoc.heading + " (" + jsonDoc.description + ")";

I also wrote a nice little Dojo-like mixin function to make my XAgents easy to configure. But that’s for another day.

LotusLive Meetings gets a long overdue update

Very happy this morning to see that LotusLive Engage has been updated over the weekend. For me the most noticeable difference is that it’s now possible to specify that the meeting requires a password before hosting the meeting. A pleasant, although loooong overdue, change.

IBM Collaboration Assessment Tool

You should take 10 minutes out of your day to take a look at the IBM Collaboration Assessment Tool. It’s a web-based diagnostic tool designed specifically to help you identify your organization’s personalized path to gaining maximum value from your on-line collaboration practices. The assessment will allow you to see how your organization stacks up against industry peers. At the end of the assessment you will receive a customized report which will help you obtain actionable best practice recommendations for your collaboration strategy.

IBM Collaboration Assessment Tool

Developing an Eclipse plug-in from start to finish

Ryan Baxter from IBM who I had the honor of co-presenting with at Lotusphere just published a new article on the appdev wiki titled Developing an Eclipse plug-in from start to finish. The article takes you step-by-step through building a nice plugin and uses the Eclipse WindowBuilder (GUI editor) for taking the hassle out of building the UI.

A very nice Friday read.

Lotus Community Call presentation

Below is a link to the presentation (click the image for the presentation in PDF format) Tim Parsons and I gave in todays Lotus Community Call. Besides a stunning picture of myself and Tim the presentation contains some info on how to get the RedWiki plugin sample projects from SVN. That info isn’t on the wiki yet but I’ll get it there as soon as possible.