Microformats: the new, new XML

Its interesting to watch the wheel of reincarnation at work with regard to Computer Science. Everything old is new again (again), but just a little bit better. That, in and of itself, is no big deal - its the way of all history in all human endeavors.

The amusing part is the swing of arguments (and arguers) as various design patterns come in and out of vogue (rembember this story?).

For a while (late 80's, early 90's), proceduralism was all the rage: everything was an application. In the mid to late 90's, of course, we just knew better. HTML and JavaScript (among other code hairball paradigms) taught us very clearly why we need to separate data, business logic, and presentation (the old model/view/controller thing).

And now we have microformats.

I've been spending a fair amount of time discussing microformats lately (we're using them in a to-be-announced product that you can play with here and learn about here), and I thought it worth elucidating on a few of the basic concepts.

First and foremost, microformats are really simple. Simple in the same way that XML is simple - the format merely codifies a few "good ideas" so that everybody doesn't have to reinvent the wheel, differently.

In the case of microformats, the "good idea" is to overlay your presentation format/data with a tagging structure that allows you extract semantic information - i.e., mix presentation and data, but in a way that allows you to still separate the two when required.

Sounds complicated everytime I try to explain it (and I'm not the only one that makes it harder than it should be), but its just an evolution of XML data techniques.

With XML applications systems (data-driven designs), you separate the data that drives the system from the application itself. XML might be used as an input or output, and it standardized the grammar of I/O into simple text blocks annotated with tags and attributes that have a specific syntax (read more about XML) to enable trivial interchange.

You can, for example, take XML data and apply what are called "Style Sheet Transforms" (XSLT) to convert that raw, tagged text data into another XML grammar (for example, to convert to a different tagging structure for a different application), or to a presentation format like HTML or XHTML. XHTML is a forced clean-up of the mess HTML became because of the permissive parsing in early Web browsers, but its really basically the same as HTML - just more machine/parser friendly.

So microformats are essentially reversible XSLT transforms applied to XML data. Microformatted content is XHTML, so a browser (or other HTML display technology) can present it nicely, as the originator of that content intended, but the XHTML is tagged with "span" tags of specific "classes" to enable the extraction of the data from the display format.

Neat, hunh?

So there are microformats for address card info, mail, calendar entries, etc. - all manner of data that you might want to interchange, but where presentation is still important.

Tastes great, and less filling.

It seems overly complex to even call them "microformats", but I guess you have to call them something.