JavaScript is the future of RIA

A few days back I had written an article about JavaScript being the future of RIA. Adobe Flex, Microsoft Silverlight, etc. are all nice and good to have. The fact of the matter is that a whopping percentage of people still prefer JavaScript when it comes to implementing RIA solutions. 

To corroborate this claim of mine, I had been running a poll for quite some time now. After having got around 550 odd votes I think the time is now right to publish the results. The winner by a far and clear margin is JavaScript. Flex comes second. Here is graphic showing the results:

With the release of the new breed of web browsers that run on-steroid JavaScript engines this dominance of JavaScript in the field of RIA is most likely to increase.

The data presented here is not sponsored by any camp or company. Its strictly a poll that I ran in my personal capacity.

Google Chrome breaks Kubuntu 8.04 download: WebKit to blame?

Kubuntu has launched a KDE 4.0 version of its operating system. The KDE 4.0 environment sports a new UI also termed as Plasma which gives a refreshing new look to Linux systems. Even though the new UI needs a bit more on graphics power, I decided to try it on my humble PC.

First step was to download the ISO image. My PC that has a DVD burner runs Windows XP (unfortunately I cannot change that since its a shared one ). So I opened up Google Chrome and punched in http://www.kubuntu.org/ . The Kubuntu website came up with a big download icon on the left as shown in the following screen shot:

When I clicked on the “Free download” buttion nothing happened. Initially I thought that the click did not register properly. So I clicked again. Nothing. I kept on trying and it just did not respond. I tried the same on Firefox and it immediately took me to the download page.

So what’s going on? Is this because Google Chrome is based on WebKit unlike Firefox? Looks likely. I tried the same thing on Apple’s Safari and faced the same problem. So probably its the WebKit software that is to blame here and not Chrome.

Here’s the version of Google Chrome that I am using:

Google Chrome losing user base

According to statistics gathered by Net Applications, the market share of Google’s Chrome seems to be diminishing. Within an hour of its release on Sept 2, 2008, Chrome had captured about 1% of the browser market. This share is apparently declining steadily. According to reports, users who had switched to Chrome from Mozilla’s Firefox and Microsoft’s Internet Explorer are going back to those.

Here are some of the figures:

Apple’s Safari has remained more or less unaffected by the launch of Chrome. This is because Google is yet to launch Chrome for the Mac platform. 

Chrome’s decline is being attributed to a couple of factors. Firstly, many companies mandate the use of IE in the workplace. That is one of the reasons that Chrome’s acceptance has not improved. Secondly Google had not put in much effort in marketing its browser. Even though Chrome shows up as the first hit on Google search, on Yahoo its second while on Windows Live it does not seem to appear on the first page.

A silver lining to this seemingly dark cloud is the fact that the number of people using Chrome increases during after work hours. 

JavaScript for RIA gets yet another boost from WebKit SquirrelFish

Rich internet applications or RIAs are becoming a defacto standard for web applications. The selling point of RIAs is to provide responsive web applications that behave more like desktop applications than traditional web apps. Initially JavaScript seemed to be the only option for creating RIAs but it suffered from certain maladies, most important ones being performance and cross-browser compatibility. Taking advantage of this, Adobe came up with Flex and more recently Microsoft offered Silverlight. Both these platforms took away a portion of developers who were working on providing RIA capabilities in brower based apps.

With the popularity of Flex and to a limited extent Silverlight, JavaScript seemed to be heading for certain death until recently. The announcement of TraceMonkey from Mozilla and the subsequent release of Google Chrome that incorporated a JavaScript virtual machine called V8, JavaScript seems poised to make a come back. Both TraceMonkey and V8 have put the JavaScript engines on steroids and the reported boosts in performance are impressive. TraceMonkey is slated to be released with Mozilla Firefox 3.1 but interested people can have a taste of it by using the v3.1alpha releases from Mozilla’s web site. Chrome has already drawn rave reviews with its fast performance and responsiveness of JavaScript apps.

The latest salvo in this war between JavaScript and other technologies comes from WebKit. WebKit forms the core of brilliant web browsers like Apple Safari, KDE Konqueror and Google Chrome. The programmers at WebKit recently announced their own improvements in the JavaScript engine called the SquirrelFish Extreme. This new engine is supposed to be more than twice as fast as its previous incarnation. Here’s a graphic to show the performance boost:

According certain other studies SquirrelFish is reported to have beaten Google’s V8 and Mozilla’s TraceMonkey on performance. Click here for that study.

So is SquirrelFish Extreme the fasted JavaScript engine yet? Well we would have to wait for some more data to decide that one. But one thing is for sure – JavaScript is here to stay.

With all this attributed importance to JavaScript by the major players, the indication is stronger than ever that RIA developers would switch over to JavaScript once its major problems are sorted out. The work that is being done seems to be concentrating on this very aspect. 

Is this the second coming of JavaScript based applications? Just wait and watch.

Why Google Chrome uses Microsoft code

Scott Hansen in a recent post of his has dissected Google’s recently released Chrome web browser and has found code that uses the Windows Template Library(WTL). The WTL was open sourced by Microsoft in 2004. Till now it was relatively unknown, but now since Google has used it, its going to pickup interest. Google uses the WTL to draw the UI for Chrome. In using this library Chrome makes the most of native speeds. Another of Microsoft’s pioneering efforts, the XMLHttpRequest object in web browsers, was also popularised by Google in its GMail web mail system. Prior to that this little gem from Microsoft was pretty much unknown. GMail ushered in the era of Ajax and the RIA.

It makes very good business sense for Google to use the WTL for Chrome. That way they can generate impressive startup speeds and make the user experience a lot more enjoyable one. Unfortunately Chrome is yet to be released for Mac and Linux operating systems. Taking a different perpective, it makes all the more sense for Google to target the Windows version first. The fact is Microsoft Windows is the dominant desktop operating system. By providing Chrome for Windows first, Google has ensured that it reaches a huge number of people even though the Mac and Linux audiences are being made to wait. Also, due to the WTL, Google could achieve a more enjoyable experience with Chrome on Windows with relatively less effort. That is definitely one of Google’s objectives.

According to reports, the Mac and Linux versions are still some distance away.

“Enterprises stay away from Google Chrome”, says Preston Gralla

Here is a rather ‘interesting’ article that I came across from Preston Gralla. In a gist, Gralla warns enterprises from embracing Google’s Chrome web browser, because he feels that Google intends to take over the enterprise world using it!!! WOW. Is that even possible?

Ok, so Gmail, Google Docs, etc. would run faster on Google Chrome. But is that a serious enough reason for enterprises to dump their current setup of Microsoft Exchange(or any other mail solution), Microsoft Office, etc ? Come on Mr Gralla get real. 

For arguments sake let’s accept Mr Gralla’s warning. So Google intends to dominate the enterprise. So what? Hasn’t Microsoft being doing that successfully to a large extent for years? Where were the warnings then? Doesn’t Apple harbor similar ambitions? 

In fact Microsoft and Apple’s products have much more potential of casting dominance rather than Google’s. But according to Mr Gralla, Chrome is what people should be worried about. 

With Chrome, the enterprises would rather have an expanded choice. They can choose to run JavaScript enabled web applications that would be responsive and efficient. Their software teams have more flexibility in choosing a technology stack for implementation. There would be a very steady flow of development resources that would keep their development efforts from being stymied. For developers who would otherwise have to learn new tips and tricks, Google’s Chrome saves their existing skills from obsolescence. Isn’t that a good thing? 

I am not against new technologies, but I firmly believe in open technologies. Embracing open standards based new technologies is probably the best bet for enterprises keeping in mind return on investments in the long term. Proprietary technologies, though sometimes very compelling, can prove to be very expensive and might be an overkill. 

Chrome is meant to be a browser and people should consider it exactly that and nothing more. I doubt that Google would be betting on seeing an increase in their enterprise business because of Chrome.

Google Chrome performs better than Firefox 3.1 Alpha 1 … at least for now

Reports have been rife that Mozilla’s TraceMonkey JavaScript engine would leave Google’s V8 in the dust. As of the latest build, this does not seem to be the case. 

TraceMonkey is the new JavaSctipt engine that would be integrated in Mozilla’s next release of the Firefox web browser (v 3.1). Presently the alpha release of the browser is available for download and since its still alpha TraceMonkey is disabled by default. To enable TraceMonkey for Firefox 3.1a1, go to the about:config URL and add a Boolean preference with the name javascript.options.jit.content and set it to true.

I used the SunSpider JavaScript Benchmark tests to see how Google Chrome and Mozilla Firefox 3.1a1 measure up against each other. Here are the results:

Mozilla Firefox 3.1a1

Total:                     2413.0ms +/- 1.4%

3d:                   	    267.0ms +/- 5.8%
	cube:                89.4ms +/- 0.8%
	morph:               78.2ms +/- 2.6%
	raytrace:            99.4ms +/- 15.1%

access:                     340.2ms +/- 5.1%
	binary-trees:        42.8ms +/- 32.8%
	fannkuch:           156.0ms +/- 2.0%
	nbody:              101.8ms +/- 3.7%
	nsieve:              39.6ms +/- 5.7%

bitops:                     272.8ms +/- 1.6%
	3bit-bits-in-byte:   51.6ms +/- 1.3%
	bits-in-byte:        67.4ms +/- 1.0%
	bitwise-and:         66.8ms +/- 4.6%
	nsieve-bits:         87.0ms +/- 1.8%

controlflow:                 31.6ms +/- 2.2%
	recursive:           31.6ms +/- 2.2%

crypto:                     167.0ms +/- 1.7%
	aes:                 60.8ms +/- 0.9%
	md5:                 53.0ms +/- 4.7%
	sha1:                53.2ms +/- 4.2%

date:                       201.8ms +/- 12.2%
	format-tofte:       122.2ms +/- 20.6%
	format-xparb:        79.6ms +/- 2.4%

math:                       257.0ms +/- 1.5%
	cordic:             114.0ms +/- 0.8%
	partial-sums:        91.2ms +/- 2.2%
	spectral-norm:       51.8ms +/- 8.4%

regexp:                     209.0ms +/- 10.2%
	dna:                209.0ms +/- 10.2%

string:                     666.6ms +/- 2.8%
	base64:              67.4ms +/- 2.8%
	fasta:              120.4ms +/- 3.3%
	tagcloud:           118.0ms +/- 4.9%
	unpack-code:        273.6ms +/- 4.3%
	validate-input:      87.2ms +/- 9.2%

Google Chrome

Total:                     1291.8ms +/- 1.5%

3d:                          92.6ms +/- 1.8%
	cube:                22.8ms +/- 13.6%
	morph:               39.8ms +/- 8.1%
	raytrace:            30.0ms +/- 10.2%

access:                      66.6ms +/- 4.7%
	binary-trees:         5.4ms +/- 12.6%
	fannkuch:            22.8ms +/- 4.6%
	nbody:               23.2ms +/- 17.9%
	nsieve:              15.2ms +/- 6.8%

bitops:                      49.2ms +/- 2.1%
	3bit-bits-in-byte:    4.2ms +/- 13.2%
	bits-in-byte:         9.0ms +/- 13.8%
	bitwise-and:         14.4ms +/- 7.7%
	nsieve-bits:         21.6ms +/- 8.7%

controlflow:                  2.6ms +/- 26.2%
	recursive:            2.6ms +/- 26.2%

crypto:                      44.6ms +/- 2.5%
	aes:                 17.0ms +/- 5.2%
	md5:                 14.4ms +/- 4.7%
	sha1:                13.2ms +/- 7.9%

date:                       215.8ms +/- 5.0%
	format-tofte:       136.4ms +/- 3.6%
	format-xparb:        79.4ms +/- 10.1%

math:                        86.0ms +/- 4.2%
	cordic:              46.6ms +/- 6.7%
	partial-sums:        29.2ms +/- 1.9%
	spectral-norm:       10.2ms +/- 13.4%

regexp:                     309.2ms +/- 1.8%
	dna:                309.2ms +/- 1.8%

string:                     425.2ms +/- 2.4%
	base64:              53.6ms +/- 11.0%
	fasta:               46.0ms +/- 0.0%
	tagcloud:           117.0ms +/- 2.8%
	unpack-code:        148.8ms +/- 2.0%
	validate-input:      59.8ms +/- 0.9%

Well from these results it looks like Google Chrome is almost twice as fast as Mozilla Firefox 3.1a1 in its present form.  Firefox trumps Chrome in the date tests and the regexp tests. In all the others Chrome outdoes Firefox by a huge margin.

Hopefully the final version that would be coming out of Mozilla will have better results.

The future of RIA is JavaScript not Flex or Silverlight

With the advent of Web 2.0 a new concept became the most sought-after technology for web applications. Popularized by Google’s GMail, rich internet applications or RIA very quickly became the need of the hour. At the heart of RI applications was JavaScript, a scripting language for the web, that was in existence long before Google was even born. Google, with its GMail, demonstrated what could be achieved with JavaScript and thus paved the way for the next generation of web applications.

JavaScript had its own problems. The biggest of them was probably cross-browser compatibility. Led by Microsoft through its Internet Explorer web browser, JavaScript quickly became a victim of non-standard usage. Microsoft, in order to prove its dominance over Netscape, supplied browser objects and functions that could be used to generate ‘cool’ effects in a web page easily. These were never ratified by any standards bodies. Since Microsoft was dominant on the desktop and also bundled IE with its Windows operating system, the exponential growth of IE in popularity apparently vindicated their arrogant violation of established standards. Netscape died under Microsoft’s onslaught and so did the standards of JavaScript. Developers started writing applications that were IE specific. It was not uncommon to see applications labeled “Best viewed in Microsoft Internet Explorer”.

The arrival of Mozilla’s Firefox web browser changed all this. Users, plagued by IE’s numerous vulnerabilities and instability, adapted to Firefox. Firefox implemented a more standards compliant version of JavaScript. So developers started writing rich applications that used standards compliant JavaScript. Even then there was one more problem with JavaScript and that came to the forefront due to RIAs. This was performance. 

Some of the leading vendors saw an opportunity in this short coming of JavaScript. Notable amongst them is Adobe and more recently Microsoft. Adobe’s Flash technology was initially meant to serve the multimedia needs of web applications. Flash was great for animations and effects, for video and audio playback, for slide shows and image manipulations, but it was never meant for rich internet applications. So enter Adobe Flex, a technology based on Flash, but offering widgets and controls for business applications. Cross-browser compatibility was achieved but at the cost of an added Flash plug-in. Not to be undone by Adobe, Microsoft entered into the fray with its Silverlight software. Silverlight did all the cools things that Flash did and also needed a plug-in to run. It seemed like JavaScript was doomed.

Mozilla and Google had different plans. Mozilla’s Firefox 3.1 browser, still in testing, and Google’s recent Chrome web browser breathed a new life into JavaScript applications. In Google Chrome, Google introduced the V8 JavaScript virtual machine that offered significant performance boosts for existing applications. Mozilla has incorporated the new TraceMonkey JavaScript engine that has reportedly achieved performance boosts of up to 85%!!! With these two products JavaScript is surely set to make a come back.

As things stand, JavaScript has overcome its two worst adversaries – cross browser compatibility and performance. With the availability of brilliant libraries like Yahoo UI Toolkit, Dojo toolkit, etc. that help ease development of RIAs, JavaScript is here to stay and the way to go for future applications. For a JavaScript performance comparison study click here.

Google Chrome peformance data through about: commands

Google Chrome, the latest browser to enter the arena, has already seen quite a few downloads and reports. There have been rave reviews and circumspection. Only time can say whether it would be a success. 

Google Chrome is a from-scratch browser that incorporates quite a few new design methodologis and performance boosting technologies. The most talked about of those is the new V8 JavaScript virtual machine. 

To get more data on the browser’s peformance Google enables certain special URLs commonly known as about: commands. Mozilla Firefox implements quite a few of them. Also its not all work and no play for the folks at Google. Check out this one - about:internets. Here are a few of the rest:

about:, about:version – shows the version

about:cache – shows cache information

about:plugins – shows information on plugins

about:memory – shows memory usage information

about:stats – shows statistics

about:network – shows network activity data

about:histograms – performance information

about:crash – crashes the active browser tab

These commands will surely help developers get an insight into how their applications are behaving inside Google Chrome.

Google Chrome web browser review: First impressions

Google released its from-scratch open source web browser today called Chrome. The various articles and specs abounding the web seemed to be promising. Intrigued I took it for a test ride. 

Installation was a breeze. Coming from a Unix background I make prodigious use of the keyboard and one of them is to use the Run… option available in the start menu of Microsoft Windows. I am habituated to launching applications by typing in the names of their executable files in this little box that appears when you press the Windows key + R key combination. Chrome disappointed a bit here. I tried launching it by the name of its executable file, which by the way is ‘chrome.exe’, but unfortunately Windows complained saying nothing with that name was found. Well IE and FF both can be launched this way and no extra tweaking is necessary. It would be good if Google would make sure to add the path to the Chrome executable to the system path. Anyway, I had to launch it from the Start menu option. No big deal of course.

The browser launched in a jiffy. It was so quick to launch that one would have thought that it was just a dormant process that was minized to the taskbar that just maximized itself. To make sure I closed the browser and checked the task manager to see whether anything was there. Nothing. Good. I launched the browser again and it was just there. Very very quick. I compared it to the launch times of IE and FF on my machine and it surely beat both of them hands down. Good going Google.

Even though the browser opens with a single tab (this setting can be changed), two processes by the name of ‘chrome.exe’ are created. You can verify this by looking at the Task Manager. This is due to the way Google Chrome handles tabs. One of these processes is for the browser application as a whole and the other one is for the default tab that opens with it. This brings me to the really nice and handy feature called the Chrome Task manager. The architecture of Chrome is such that it handles each and every tab in a separate process. All these processes are listed in the Chrome Task manager. Usually the number of processes listed in the task manager is the number of tabs open in the browser plus 1 for the browser process itself. Also if any plug-ins were loaded these are also listed as different processes. The operating system process manager would however register processes that equal the number of open tabs plus one for the browser. The different processes that are launched for the plug-ins have the scope of the tab in which they are opened. All pop-ups also are also contained in a tab. With a browser running, if another instance of Chrome is launched from the Start menu, it registers as a separate process in the OS task manager, but as a new tab in the Chrome task manager. There is one thing though. After running the browser for some time a process called GoogleUpdate.exe starts running. This process does not show up in the Chrome Task Manager. From what I understand, this process is responsible for updates to the security and privacy features of the browser like anti-phishing. Through the Chrome task manager a user can view the resource utilization of every open tab and also the loaded plug-ins. If a tab or plug-in is seen to be hogging a lot of resources, it can be killed from this task manager. The isolated process architecture of Chrome spawns individual tabs as separate processes. So if a single tab crashes, it will not affect the other tabs and can be killed from the Chrome task manager or the operating system’s process monitor. If the browser process crashes and has to be focibly closed, a subsequent launch does offer the option of restoring the tabs that were open before the crash.

Chrome offers a lot of features. Of course these are also available in FF, IE and Safari but Chrome adds little twists to them. The private browsing mode for instance. When a private browsing window is opened it is immediately distinguishable by the different shade of blue that it uses and the icon of a detective at the top left corner. This is quite a nice improvement. At least on Safari you would have to check the menu to see whether you are in private browsing mode or not. When the browser is launched, it opens up a page (the default setting by the way) that shows up the recently visited web sites and also a search box to search the browser history. There is a slight digression from the normal practice of having a bookmarks menu though. In Chrome the bookmarks are only accessible via the bookmarks toolbar. I do not use bookmarks that much so I cannot really comment on how much this change would affect users who depend a whole lot on them. That having said, Chrome does offer features to search and manager bookmarks like other major browsers. There was another feature that I found missing in Chrome. Usually you can set the browser to show a blank page on launching. In Chrome apparently there is no such option available. The only way that I could do that was to add a custom page called ‘about:blank’ in the setting for this. This showed up a tab containing blank page each time the browser was launched. However, if you open a new tab, the recent history page shows up with all the data in it. I have not found out a way of stopping this from happening and I do not think one exists. If it really does not exist Google should think of putting one in. After all not everyone would like to launch a tab that lists all their recent activities.

The address bar, called the Omnibar, doubles up as a search box. The default search engine is obviously Google, though there are options to change this. The address bar has auto complete enabled and the options that are shown are definitely more relevant than what I get in FF. For bookmarking, Chrome offers a simple star icon by the side of the Omnibar. Clicking this button bookmarks the current page. Also if a bookmarked page is visited in future, the star icon shows up in yellow color.

Other features include:

• Detailed report of memory and process usage through the ‘Stats for nerds’ link in the Chrome task manager
• Integrated Google gears, no separate download or installation required
• Window controls on every tab making it possible for developers to inject specific window behavior that would not be overridden by the browser
• A download history window
• JavaScript console
• JavaScript debugging
• Bookmark management
• History management
• Import/export of bookmarks

The real preceptible difference is in how the browser performs. It sure is fast. The fastest browser that I have used till date is Apple’s Safari. But it had its own quirks. Chrome is really fast. Probably even faster than Safari. Even though I do not have any data to corroborate this, it sure feels to be so. Web pages loaded with a speed that I have never experienced with other browsers. The pleasure of browsing is palpable in Chrome. Gmail was fantastically responsive. The V8 JavaScript virtual machine seems to be doing a brilliant job. 

Having said that there are still a few features that I would like to have in Chrome:

• Search as you type
• RSS aggregator and news reader
• Integrated universal chat client for the major protocols
• Integrated blogging tools

These features would surely make Chrome the Swiss army knife of browsers. And since its from Google, it sure is possible.

There have been lots of discussions saying that Chrome would affect the user base of Mozilla Firefox more than Microsoft’s Internet Explorer. But I am not very convinced with this argument. A present IE user, even if he/she wants to switch to a new browser has Firefox as the only alternative (Opera devotees might take offence to this, but I think Firefox is a whole lot more popular than it). So if this user does not like it (for whatever reasons) he/she might not make the switch. Now though they would have not one, but two very viable alternatives in Firefox and Chrome (not discounting Safari or Opera).

Exciting times lie ahead of us in the browser sphere. Chrome definitely has the potential of changing the rules of the game and I sincerely hope that even if does not do so itself, it engenders a new breed of browsers.