Ajax World East 2008 started earlier today.

I delievered my "Web 2.0 Application development using jMaki" and the slides are available here. There were several demos shown in the talk (using NetBeans and GlassFish) and they are all accessible at the links mentiond below:

• RSS feeds in jMaki widgets
• Mashing up the Maps
• Rails powered by jMaki
• Sun Tech Days Event Map

Several other related demos are available here. Luckily I could deliver without much hassle inspite of having a high fever and cough! I hope I can hold at least until tomorrow morning when the big preso is scheduled @ 11:35am.

Anyway I attended 3 more talks today and took notes to share:

• Picking the Right Technology for Enterprise Rich Internet Applications
• Performance Tuning your Ajax Applications
• Performance Paradigm of a Mashup World

See below for notes from each talk.

The first talk I attended was: Picking the Right Technology for Enterprise Rich Internet Applications. I got little late and the session was packed with attendees standing way outside the room so I joined them.

The session talked about AIR, Silverlight & JavaFX as three possible technologies for Enterprise RIA. Per the talk, here are the basic criteria for RIA tools requirement:

• Seamless deployment on client
• High penetration of runtime
• Web browser independence
• Fast client/server communication protocol
• Robust security

Of course, this session was given in Ajax World so pros/cons of Ajax were dicussed:

Pros of Ajax	Cons of Ajax
No deployment required	Ajax apps are browser depdendent
100+ Frameworks	100+ Frameworks
Open Source, no need to purchase software license	Expensive due to long cycle, skilled developers demand top rate
	JavaScript is an interpreted language, entire source code can be viewed using "View Source"
	Network communication speed is not optimizedf for Ajax requests

And then basically it talked about the three technologies and their pros & cons are well captured in the slides.

The second session I attended was Performance Tuning your Ajax Applications. This was an interesting session and I learned a few tricks. Interstingly we have implemented quite a few of these performance enhancements in jMaki already.

Improving the performance of Ajax applications require tuning the following parameters:

• Number of requests
• Reduce number of JavaScript files that are loaded. This is the most important since each request to the backend adds extra cost. Even when the scripts are cached, the browser still makes a request (unless Since-Modified header is set correctly).
• Typical approaches are to concatenate the files at dev time or at runtime based upon request.
• Dev time approaches
• Ant - concat all JS files using <concat> task
• Dojo - Run Rhino over all provide/requires and then concatenate the files
• Command-line
• Run time approaches - Concatenation happens depending upon the request. Cons are:
• Server-side dependent
• Makes it harder to distribute code
• Server is loaded as concatenation happens on server (mitigated with caching)
• Works for <15 JS files
• Does not track dependency
• Size of requests
• Remove white spaces and comments (Packer, Dojo, YCompresser, SafeCompress, ShrinkSafe are some of the tools)
• Shorten the variable names
• Gzip the code
• Semicolon is optional but needed if you remove EOL (careful when compressing the code)
• Drastically reduces the file size (e.g. Apache XAP reduced the file size from 330 kb to 70 kb)
• Lots of gzip tools
• Need to put appropriate headers so that browsers recognize gzipped content
• Coding Style
• Single line "if" and "for" do not need "{ }"
• Combine var declarations into a single var such as var x=1, y = 2;
• Use JavaScript style object
• Time of requests
• Time of initial code completion
• Minimize the time that is executed @ start up
• Bring the data once the initial page is loaded
• Show images telling users that something is going on
• Distracts user from the time it's taking
• Other tips
• Don't write your own parser  - use the native parsers
• "If" statement optimization
• Use the native facilities like getElementById() or getElementByTagName()
• Consider different approaches of DOM creation
• Tail Recursion
• Setting the value in innerHTML
• Consider JSON over DOM for object graph traversal - JSON could be much faster

Similar tips can be used for CSS as well.

My third talk of the day was Performance Paradigm of a Mashup World.

This talk given by Vice President of Webmetrics and laid a special emphasis on "Collaborative Monitoring" for performance measuring any mashup. This process involves not only monitoring your own application, but also setting up agents that measure performance with other services being invoked in the mashup, their further partners and so on. It also talked about a layered approach of using:

• Standard monitoring - HTML page load time, DNS request processing time, etc.
• Pixel Mapping monitoring - required mainly for GUI intensive application
• Web services monitoring - Used for partner monitoring

This was further clarified using a 6-step process:

• Know your apps
• Learn where the points are in your ecosystem
• Measure your perspective
• Monitor your APIs
• Collaborate within your organization
• Collaborate with your partners & customers

That's it!

Check out some of the pictures:


The expo hall opens tomorrow and Sun's booth is right between the ballroom and the main door to expo hall, can't miss us ;)

The complete album is available at:


The Internet connection at the Roosevelt hotel is painfully slow inspite of charging $14.95/night where as most of the "modern" hotels offer free wireless :(

Technorati: conf ajaxworld newyork glassfish netbeans ria sun web2.0