Google Gears - Performance Out of the Box

Google Gears was released last week and it's been hugely exciting to get a look at this api, along with some of the apps people have come up with already.

Google Gears API

Obviously many of us had been looking at Adobe Apollo for awhile, and Google Gears is of the same mindset -- but even more encouraging it was released under the very liberal BSD license, which only adds encouragement to those of us excited about the rapid advancement of technology. It will be exciting to see the rapid progression of this 'platform' for offline integration of web applications. The community of web developers has so many ideas, and Google's release of Gears to the community in this manner will no doubt generate many ideas that will find their way into the next release of Gears is my only guess.

As an Ajax developer where I am particularly interested in Gears is in terms of performance, over and above online/offline synchronization as a feature. While the two go hand in hand synchronization has a specific place in many apps (internet connection dropped, queue-ing work completed offline, etc), I feel like the performance aspect of Gears with this offline database and client side file cache will become huge. I am looking forward to seeing many engineers benchmark their web applications once they have become enabled with and optimized for Gears.

Developing with Google Gears in mind, could become like Ajax has become the last two to three years. What I mean when I say that is that there are significant performance benefits that can be gained by limiting the number of trips to a server (both web and database), and processing items in batch. We have already seen this with regards to Ajax applications sending bits of data to the server rather than whole page requests, and this takes it a step further. We now have a larger set of boundaries to work with as web developers. We can choose how much to update, when to update, along with a client side failsafe. Having the cross operating system desktop intermediary is the enabler here, and the deployment potential of a large player like Google are obvious.

As Google continues its collaboration with Mozilla Firefox (I can't wait for Classes in Javacript 2.0 by the way!), and open source libraries like Dojo, it will become easier to integrate these offline caching and synch-ing paradigms into our development practices.

All of this enables richer, more responsive user experiences for the end user. It enables exciting new architectures for web applications. The future is surely bright for the paradigm of web-based applications growing in performance, capability and reach.

Tamarin Project -- Adobe contributes to Mozilla

This is older news, but certainly worthy of repeating (now that I have a couple free hours to get my thoughts out).

If you're interested in where the future of client-side software development is going, definitely read this post and the related link from Ajaxian.com. It discusses 'Tamarin', which is a collaborative project between Adobe and Mozilla -- Adobe contributed source code from the ActionScript Virtual Machine to the Mozilla Foundation.

What all of this means, as Brendan Eich states "now web developers have a high-performance, open source virtual machine for building and deploying interactive applications across both Adobe Flash Player and the Firefox web browser"

Especially insightful are the 'comments' section, where Brendan Eich (the individual who created the JavaScript language and one of the first people at Netscape, now the Chief Technology Officer at Mozilla, responsible for architecture and the technical direction of Mozilla) , explains the nature of performance gains that will come from a Just-In-Time JavaScript compiler.

http://hecker.org/mozilla/adobe-mozilla-and-tamarin

All of this gives us insight into the web-centric paradigm that both Adobe and Mozilla (along with obviously Google and others) are pointed towards and that has huge momentum. This collaboration, along with items like Adobe Apollo (and other similar efforts by Sun, for instance), make it very motivating time to be a web application developer. We are at the beginning of a time pointing towards being able to create deeply rich web applications -- apps that run efficiently in a browser that is continually increasing in performance. These web applications can be programmed and run in a web-connected or disconnected mode.

The Ajax libraries and toolsets that have sprung up in the last few years (E.g. Prototype, Dojo, et al), along with the advancement of the browser itself, collaborations between Open Source and industry (Adobe, JVM and Flex), and many of the open source communities supporting this vision for the future of the web really gets me excited and motivated to wake up and write code, and dig deeper each day into the nuances of these technologies. Good times-

(ps, here is another good read: http://weblogs.mozillazine.org/roadmap/archives/2007/04/openness.html)

Apollo -- check it out

Apollo Alpha has been released. I'm excited to try it out:
https://www.adobe.com/cfusion/entitlement/index.cfm?e=labs%5Fapollo

Here is a nice look at some of what can be done for those interested:

Example presentation of Apollo (showcasing Ebay sample app)
http://www.demo.com/demonstrators/demo2007/91259.php

this is an older demo from Dec 2006, shows Apollo with Amazon's api's, Google Maps mashup with client-side address Vcards, and some other items (like Flex):
http://ajaxian.com/archives/adobe-apollo-demos

One intriguing thing about Apollo is that you can use existing web tech to build apps that interact with and run on the client This demo shows an application built using Adobe's Flex technology on the front end (View), and using Ebay on the back end to deliver data to the client. But that is just one incarnation. Apps could also be built with html+css and a database, and run equally well on the Apollo cross-OS runtime.

The API for synchronizing data online/offline, and accessing the file system, is what holds a lot of the power for developers (imo). I'm sure you can find other benefits. Apollo's APIs simplify the process for handling this. There are clever ways of doing it now ( dojotoolkit.org , etc), but they use Flash files, and other client side workarounds to get the job done, and are limited in the size, etc that you can save on the client (without changing preferences, etc).

Basically Apollo extends the reach of web dev tools (not having to write code in Java, C++, VB, etc, but instead using html, css, AJAX, Flash/Flex, etc.) to deliver applications that run on a user's machine as well as online. It enables web app developers with an extra set of API's along with a cross-OS runtime that they can use to extend the reach of their apps..... it has been developed from the paradigm of the 'mostly connected to the internet' that the world is moving towards.