How I Came To Despise AJAX

The Seeds of Malcontent

I absolutelydespise the acronym “AJAX“.Something about it rubs me the wrong way.

Perhaps it’s a silly hang-up. Perhaps I’m foolish for notgetting with the current lingo.

Nonetheless, I just don’t feel comfortable with it. Notonly is it impossible for me to say or write it with a straightface, I find it difficult to hear it from others withoutunconsciously stereotyping the other party as some sort ofmalleable, misinformed Johnny Come Lately.

It just seems like an uninformed way of uselessly simplifying acomplex ecosystem of evolving and varying solutions into ameaningless, trite acronym (don’t get me started on “Web2.0”).

Of course AJAX isn’t really an acronym for anything anymore -realizing that it was founded on a solid foundation of ignorance,along with an unhealthy lack of historical knowledge, ithas become a more generalized term meaning some sort ofnebulous “interactive web application” (what wehistorically called a rich web application, or even the logicallydescriptive Dynamic HTML or DHTML). Now it’s popular for it to justbe the non-acronym “Ajax”, with a much less restrictive meaning. Ifit’s a cool web application, well that’s courtesy of thenew-fangled Ajax!

Even ridiculouslypedestrian uses of scripted objects are hopping on the AJAXbandwagon these days. “It uses JavaScript…and that’s theJ….so it’s AJAX!”

The History of the Artist Currently Known as AJAX

As a bit of “AJAX” history, way back in 1999 the Microsoft MSXMLteam – these were the people who made the superlative XMLparser – added an oddball little object into the MSXMLlibrary: The XMLHTTP COM object. This object – onewhich originally used its own HTTP transport outside of IE’s,leading to all sorts of proxy configuration fun – allowed one toprogrammatically send parameterized GET and POST requests to HTTPservers, retrieving data back for processing or display. Theydeserve credit for inventing it, but at the same time it was one ofthose inevitable solutions (in fact there were already safe forscripting third party HTTP clients, but of course they had verylimited deployment).

XMLHTTP, like the rest of the MSXML COM library, was usableand valuable both by native applications, and by Internet Explorerclient-side script (because they handily marked it as Safe For Scripting, which is the flag that reveals a COMcomponent to the IE scripting engine). It isn’t actually tied toXML in any meaningful way, and the XML misnomer was purely a resultof it being created by the MSXML team (it was just a bit ofnamespace). Microsoft widely distributed the library alongsideother products.

Voila, another method of background data loading wasreleased to the world, adding to the already existing and utilizedhidden-IFRAME technique. Like many developers in the Microsoftworld, I saw the benefits of this relatively small enhancement, andstarted enabling internal web applications with partial pageloading, rendering and post backs (using other parts of MSXML totransform received XML against an XSLT for display – a nextgeneration technique that still has very limited deployment).Indeed, I even used this object in rich,native applications as an easy way of communicating with webservices. It was a convenient little object.

All back in the year 2000, half a decade ago. I was hardly apioneer, and there were thousands of others doing the same thing ormore.

Nonetheless, given that it only worked with Internet Explorer,it was a complete non-starter for the public web, at least for therational.

XMLHttpRequest Goes International

In early 2001, after seeing the value that it brought to thetable, the Mozilla team added XMLHttpRequest to Mozilla0.8. As the years passed, all of the other major-minor browsersincorporated compatible implementations. It was becoming atechnology that was usable in the mainstream…but for one smallissue: Up into even 2003, a lot of large corporations stuck withNetscape 4.x as their primary browser, or as their back-upcross-platform browser (e.g. they had Internet Explorer as theirprimary, with Netscape 4.x as the umbrella if Microsoft suddenlyjacked up licensing costs and they needed to switch all of theirclient operating systems).

This lowest common denominator inhibited public sites, forcingthem to stick with the tried and true, so even with the pervasiveavailability of this functionality across all of the late-modelbrowsers it was still off-limits for widescale use because of avery small minority. Imagine a nation restricted by a 30km/h speedlimits because there are a couple of people with old, beat-upYugos, while everyone else is pounding their steering wheels intheir beefed-up gas-guzzling 8-cylinders. That was the webworld.

Google Shakes Up The Web World

In late-2004/early-2005 Google shocked a lot of theblissfully-unaware world by adding XMLHttpRequest-backedfunctionality to Google Suggests, offering “type-ahead” usabilityenhancements (it can also use IFRAMEs, which is one of the originalbackground-communication techniques). The moment was right,especially for a non-critical beta service, when the old (e.g.Netscape 4.7) could finally be tossed aside, and we could moveahead with technologies that have long beenavailable. Google was the biggest player leading the way, butof course they weren’t alone, and there were already plenty ofpublic implementations of this sort of dynamic content thatdemanded a modern browser (Outlook Web Access, a component ofMicrosoft Exchange, being one of the earliest and best known).

Google Suggests was the largest, most visible implementation,and it opened a lot of web naysayers eyes up to what many of us hadbeen evangelizing for years. Suddenly the unaware could seepotential that had been there for years. Google also set a new barfor the amount of server side processing and bandwidth that couldbe allocated to a single random web visitor (not long ago it wouldhave been considered insane to do that sort of processingand data transfer constantly as users typed keystrokes, forinstance, but the availability of cheap computer cycles and copiousbandwidth has changed the equation).

Human Nature – The Defensive Compensation Effect

I’m going to segue to a little human-nature story here – I’m aMicrosoft-centric user and developer: I chose to professionallyfocus on their tools and technologies as my specialty early on, andI’ve done very well with it (though I’ll switch to other primaryspecialties if and when it’s in my best interest). Nonetheless Iregularly use Linux (primarily through the magic of virtualmachines. I’d recommend that everyone does this, as an aside,especially now that VMWare has made their Player free. You oweit to yourself to give Linux a try – you will probably be surprizedat how rich and capable itreally is on the desktop), and I try to keep myself fairlycompetent with it. I have lots of experience with other OSs aswell, though sadly I’ve yet to try OS X. Anyways, putting all ofthat operating system defensiveness aside, I’ve been with Windowsfor quite some time.

One thing I’ve noticed over the past several years, as a Windowsuser, is that quite a few historically anti-MSers are making theswitch to (or back-to) Windows on their desktop. PerhapsMicrosoft’s security initiative is having an impact, or some otherextenuating circumstance is making them want to switch, butnonetheless they’re “coming back”.

I feel that a lot of the AJAX hype follows the samepattern – someone either poo-poohed web applications for years, orperhaps their career just finally brought them to web applications.Instead of feeling that they’re a junior in an established field,they have to invent some paradigm shift that renders everythingthat came before irrelevant.

Almost invariably they will defend their switch as beingjustified only by some relatively recent extraordinary revelationin the Windows platform – e.g. “That Windows 2000 was a real pieceof crap, and I wouldn’t have touched that with a 10-foot pole, butthe new XP kernel is pretty good. Windows was crap before, but nowit’s good”. Of course anyone who follows Windows knows that this isutter claptrap – XP is largely 2000 with a facelift and somerelatively minor kernel changes. Really 2000 was already quite awell designed, nicely executed, very stable operating system,but they couldn’t concede that prior iterations had value if theyweren’t a part of the game. Ultimately it only has value oncethey’ve entered the contest.

You can see this going the alternate direction as well – “Linuxwas garbage before kernel 2.x.x” – and for virtually any othertechnology. If someone is late to the game, there’s a good chancethat they’ll try to manufacture some reason to validate making theswitch now. Sometimes it’s rational, but often it’s just completenonsense. I haven’t spent any time with OS X, so instead I’ll justwait a bit until the next iteration and declare whatever trivialchange they’ve made to be the pivotal reason that justified mytime.

This applies not only to engineers and their technologies, butto business hypsters as well – Instead of pimping themselves asyet-another entrant in the competitive web application market, theyneed to present the idea that they’re coming at the perfect time:So much is possible now that wasn’t possible yesterday.

I feel that a lot of the AJAX hype follows the same pattern -someone either poo-poohed web applications for years, or perhapstheir career just finally brought them into web applications.Instead of feeling that they’re a junior in a long establishedfield, they have to invent or embrace some paradigmshift that renders everything that came before irrelevant.Disregard that the “technology stack” that facilitates a modern webapplication is extraordinarily wide and deep, and just pretend thatthis one small schism represents everything.


The crux of the matter, in my opinion, is that theacronym AJAX brings absolutely no clarity to the table, and insteadintroduces nothing but noise. Not only does it poorlydefine an implementation pattern that has been in use by expertsfor years, but its street use is so generic as to be detrimental(just look at that use of AJAX for the “AMASS” solution linked nearthe outset – Now AJAX just means “something done in a webapp”. How utterly inane). To others it is a buzzword that tries tosimplify a multi-faceted technology platform into a nonsensicallyliteral implementation detail, putting an inordinate amount ofattention on one very small part of an interactive webapplication.

There is such a rich array of techniques and technologiesavailable to a web developer to make a first rate platform, thatsuch a simplistic and meaningless bit of language just confusesthings.

Furthermore, there is this simpleton tendency for the hypstersand the unaware alike to see, ortalk about, revolutions, where insteadthere has been a continual evolution (they’reignoring the fossil evidence!). One just has to read Tim O’Reilly’slatest self-aggrandizement platform – Web 2.0 – to seethis sort of distortion in action. Where many in-the-know see aconstant evolution as the platform matured – everyone got fastercomputers, storage got cheaper, bandwidth became less expensive,the lowest common denominator got better, and so on – thesepeople, with their enormous blind spot, instead see somemonumentous divergence between yesterday andtoday. Yesterday was old-sk00l 1.0, and today is 2.0. Get it?Yesterday’s car is a Model-T 1.0, and today’s car is 2006 HondaAccord 2.0, with nothing in between.

Great, now come to my conferences, link my pages, and buy mynot-open-source-but-open-source-is-great books!