How I Came To Despise AJAX

The Seeds of Malcontent

I absolutely
despise the acronym “ "">AJAX“.
Something about it rubs me the wrong way.

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

Nonetheless, I just don’t feel comfortable with it. Not
only is it impossible for me to say or write it with a straight
face, I find it difficult to hear it from others without
unconsciously stereotyping the other party as some sort of
malleable, misinformed Johnny Come Lately.

It just seems like an uninformed way of uselessly simplifying a
complex ecosystem of evolving and varying solutions into a
meaningless, trite acronym (don’t get me started on “Web

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, it
has become a more generalized term meaning some sort of
nebulous “interactive web application” (what we
historically called a rich web application, or even the logically
descriptive Dynamic HTML or DHTML). Now it’s popular for it to just
be the non-acronym “Ajax”, with a much less restrictive meaning. If
it’s a cool web application, well that’s courtesy of the
new-fangled Ajax!

Even "">ridiculously
pedestrian uses of scripted objects
are hopping on the AJAX
bandwagon these days. “It uses JavaScript…and that’s the
J….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 MSXML
team – these were the people who made the superlative XML
parser – added an oddball little object into the MSXML
library: The XMLHTTP COM object. This object – one
which originally used its own HTTP transport outside of IE’s,
leading to all sorts of proxy configuration fun – allowed one to
programmatically send parameterized GET and POST requests to HTTP
servers, retrieving data back for processing or display. They
deserve credit for inventing it, but at the same time it was one of
those inevitable solutions (in fact there were already safe for
scripting third party HTTP clients, but of course they had very
limited deployment).

XMLHTTP, like the rest of the MSXML COM library, was usable
and valuable both by "">
native applications
, and by Internet Explorer
client-side script (because they handily marked it as "">
Safe For Scripting
, which is the flag that reveals a COM
component to the IE scripting engine). It isn’t actually tied to
XML in any meaningful way, and the XML misnomer was purely a result
of it being created by the MSXML team (it was just a bit of
namespace). Microsoft widely distributed the library alongside
other products.

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

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

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

XMLHttpRequest Goes International

In early 2001, after seeing the value that it brought to the
table, the Mozilla team added XMLHttpRequest to Mozilla
0.8. As the years passed, all of the other major-minor browsers
incorporated compatible implementations. It was becoming a
technology that was usable in the mainstream…but for one small
issue: Up into even 2003, a lot of large corporations stuck with
Netscape 4.x as their primary browser, or as their back-up
cross-platform browser (e.g. they had Internet Explorer as their
primary, with Netscape 4.x as the umbrella if Microsoft suddenly
jacked up licensing costs and they needed to switch all of their
client operating systems).

This lowest common denominator inhibited public sites, forcing
them to stick with the tried and true, so even with the pervasive
availability of this functionality across all of the late-model
browsers it was still off-limits for widescale use because of a
very small minority. Imagine a nation restricted by a 30km/h speed
limits because there are a couple of people with old, beat-up
Yugos, while everyone else is pounding their steering wheels in
their beefed-up gas-guzzling 8-cylinders. That was the web

Google Shakes Up The Web World

In late-2004/early-2005 Google shocked a lot of the
blissfully-unaware world by adding XMLHttpRequest-backed
functionality to Google Suggests, offering “type-ahead” usability
enhancements (it can also use IFRAMEs, which is one of the original
background-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 move
ahead with technologies that have long been
available. Google was the biggest player leading the way, but
of course they weren’t alone, and there were already plenty of
public implementations of this sort of dynamic content that
demanded a modern browser (Outlook Web Access, a component of
Microsoft 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 had
been evangelizing for years. Suddenly the unaware could see
potential that had been there for years. Google also set a new bar
for the amount of server side processing and bandwidth that could
be allocated to a single random web visitor (not long ago it would
have been considered insane to do that sort of processing
and data transfer constantly as users typed keystrokes, for
instance, but the availability of cheap computer cycles and copious
bandwidth has changed the equation).

Human Nature – The Defensive Compensation Effect

I’m going to segue to a little human-nature story here – I’m a
Microsoft-centric user and developer: I chose to professionally
focus on their tools and technologies as my specialty early on, and
I’ve done very well with it (though I’ll switch to other primary
specialties if and when it’s in my best interest). Nonetheless I
regularly use Linux (primarily through the magic of virtual
machines. I’d recommend that everyone does this, as an aside,
especially now that VMWare has made their "">Player free. You owe
it to yourself to give Linux a try – you will probably be surprized
at how rich and capable it
really is on the desktop), and I try to keep myself fairly
competent with it. I have lots of experience with other OSs as
well, though sadly I’ve yet to try OS X. Anyways, putting all of
that operating system defensiveness aside, I’ve been with Windows
for quite some time.

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

I feel that a lot of the AJAX hype follows the same
pattern – someone either poo-poohed web applications for years, or
perhaps 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 everything
that came before irrelevant.

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

You can see this going the alternate direction as well – “Linux
was garbage before kernel 2.x.x” – and for virtually any other
technology. If someone is late to the game, there’s a good chance
that they’ll try to manufacture some reason to validate making the
switch now. Sometimes it’s rational, but often it’s just complete
nonsense. I haven’t spent any time with OS X, so instead I’ll just
wait a bit until the next iteration and declare whatever trivial
change they’ve made to be the pivotal reason that justified my

This applies not only to engineers and their technologies, but
to business hypsters as well – Instead of pimping themselves as
yet-another entrant in the competitive web application market, they
need 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 perhaps
their career just finally brought them into web applications.
Instead of feeling that they’re a junior in a long established
field, they have to invent or embrace some paradigm
that renders everything that came before irrelevant.
Disregard that the “technology stack” that facilitates a modern web
application is extraordinarily wide and deep, and just pretend that
this one small schism represents everything.


The crux of the matter, in my opinion, is that the
acronym AJAX brings absolutely no clarity to the table, and instead
introduces nothing but noise.
Not only does it poorly
define an implementation pattern that has been in use by experts
for years, but its street use is so generic as to be detrimental
(just look at that use of AJAX for the “AMASS” solution linked near
the outset – Now AJAX just means “something done in a web
app”. How utterly inane). To others it is a buzzword that tries to
simplify a multi-faceted technology platform into a nonsensically
literal implementation detail, putting an inordinate amount of
attention on one very small part of an interactive web

There is such a rich array of techniques and technologies
available to a web developer to make a first rate platform, that
such a simplistic and meaningless bit of language just confuses

Furthermore, there is this simpleton tendency for the hypsters
and the unaware alike to see, or
talk about, revolutions, where instead
there has been a continual evolution (they’re
ignoring the fossil evidence!). One just has to read Tim O’Reilly’s
latest self-aggrandizement platform – Web 2.0 – to see
this sort of distortion in action. Where many in-the-know see a
constant evolution as the platform matured – everyone got faster
computers, storage got cheaper, bandwidth became less expensive,
the lowest common denominator got better, and so on – these
people, with their enormous blind spot, instead see some
monumentous divergence between yesterday and
today. 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 Honda
Accord 2.0, with nothing in between.

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