Category Archives: ajax

Mashup: Google Maps + Amazon Reviews

Saturday morning I woke up with a rather odd idea: to create a mashup of google maps and Amazon book reviews. I was mildly surprised to discover it hadn’t been done yet. Here’s the result of spending a chunk of the weekend writing it in python (11/15 Update: should now work in Safari, Firefox2, and IE6):

It didn’t take long to write, since I’d recently been investigating the google maps API for a friend, and I’d also been doing bits of Amazon integration for a project. The biggest pain was dealing with the 1 call per second per IP address rate limiting mechanism of Amazon’s ECS API: the service returns error codes if you exceed the limit. So the application is pretty slow, especially if others are also using it.

But if you’re patient, it’s fun to watch the map markers gradually pop up. It’s also fun to look up a book with strong political leanings, and see how the ratings are distributed geographically. For example, you can look at The Communist Manifesto by Marx, and Bill O’Reilly’s Culture Warrior (*shudder*). Data for both are cached, so they should load very fast.

The Joy of Documentation

I almost always have reference documentation open on my desktop: browser windows with API docs, man pages in terminal windows, Acrobat files. It’s too hard to remember every detail about infrequently used calls and more obscure language syntax; I’ve got better things to do with my brain. It’s strange, I’ve always preferred learning by examples + reference docs, rather than by hand-holding tutorials or “how to” books. I like the anal-retentiveness of official standards. =)

AJAX certainly requires familiarity with a lot of different specs. It was difficult initially to know where to look for something, so hopefully this list will help someone out there who learns the same way I do.

Document Object Model (DOM) Level 2 Core – This spec gives you info about the fundamentals of the DOM. This is the “base” upon which the HTML DOM is built, so it’s very useful for figuring out how to traverse the document hierarchy and manipulate it in basic ways.

Document Object Model (DOM) Level 2 HTML – This spec describes the HTML-specific DOM. This is the “meat” of building any highly dynamic, interactive application, since you’ll certainly need to know how to manipulate HTML elements.

Cascading Style Sheets Level 2 Revision 1 (CSS 2.1) – I look here not just for info about stylesheets, but for an understanding of the model for how document elements are (supposed to be) laid out. Go here when something looks misaligned or off-kilter, or when trying to programmatically control aspects of visual layout.

Core JavaScript 1.5 Reference – This reference on the Mozilla site is comprehensive and easier to read and navigate than the ECMA docs in PDF format.

XMLHttpRequest Object – Without this object, it ain’t AJAX. This baby is how the browser performs asynchronous data requests and conveniently makes available XML responses as Document objects. Neato!

Prototype.js API – This is a pretty amazing library that extends the DOM, providing all sorts of extras for working with document elements and ensuring cross-browser compatibility. It’s not a library for fancy effects or pre-built interface widgets; rather, it makes up for the convenience deficiencies in some of the DOM specs.

Boy, that’s a lot of docs. Right now, I’m still looking for good info on support and compatibility for various versions of DOM and CSS in various browsers.

First Thoughts on AJAX

Okay, so I’m a bit behind the times. =)

The website I’ve been working on has a dynamically generated page that’s data-intensive and can take several seconds to load. I’ve been AJAX-ifying it so that the client browser immediately loads a skeleton page and then retrieves pieces of data as they become available on the server. Nothing extraordinary.

I’ve worked with XML before as well as a touch of Javascript here and there. The rest of the AJAX pieces took some researching but weren’t hard to learn: mostly it was a matter of seeing what the XMLHttpRequest object provides, getting a hang of the DOM for HTML, and looking up relevant CSS attributes. We (my boss has also been coding a bit) also use the prototype.js library, which extends the DOM to make it much easier to manipulate. We’re still working out kinks in how the UI should look, but it’s been surprisingly smooth so far.

What I like so far:

Needless to say, AJAX is very conducive to a clean separation between data and presentation. For me, this is a major advantage. Designing XML schemas forces one to think about what data should be provided, not how it looks. The server-side code stays clean, since it mostly just churns out data for delivery.

What I dislike so far:

Only two things really bug me so far. One is that exposing the data layer via HTTP calls can result in clients accessing that layer in ways you might not appreciate. This is a pretty common complaint about AJAX, but there are clever ways to deal with it.

The second is a more conceptual matter. The HTML document isn’t really a “document” anymore. This has been happening since before AJAX, so maybe I’m just being grumpy, but really, what your browser is getting is not a document, it’s an application!

At its inception, HTML was a format for simple page layout: “p” tags described a paragraph, a “table” tag meant rows and columns of data to be displayed. In mid-1990s, the commercial web horribly mangled HTML, making “p” tags meaningless, and forcing tables to do contortionist tricks for complex layout with graphics, which it was never intended to do. CSS has helped greatly to correct these abuses, but now AJAX is turning HTML into a sort of template language, with Javascript being in charge of interactivity.

Maybe there should be a new HTTP “Content-type” for AJAX applications. The identification would help with search engines and information accessibility, letting clients know that hey, this isn’t data you’re seeing, it’s an app. Surely, people more thoughtful than me have considered these issues already. I’ll have to look it up. Unless, that is, you can only access that material through a non-googleable AJAX interface. =)

In general, an AJAX architecture requires more human work to maintain: AJAX and non-AJAX versions of information with different presentation instances; more thoughtful design to keep the layers separate and maintainable, and to manage complexity; more testing for cross-browser, cross-platform compatibility. These are not “problems” per se, but definitely things to consider when embarking upon a site overhaul.