Microformats: inline annotation vs. binding

Hey readers, help me guide my scattered thought processes.
I’ve been thinking lately about microformats, which are typically characterized by inline annotation through existing class attributes in XHTML. You put the rel=”self” or whatever right into the document, on the element you’re talking about.
Another approach, that used by CSS itself, is to keep all the extra information bunched together in a different place. There’s all kinds of phrases, usually beginning with “separation of” to describe this pattern. And to do so requires a specific way to connect the external information, typcially called a binding. For CSS, it’s Selectors.
OK, so far so good. Except that it’s possible, and common in some cases, to have style attributes, taking CSS in the inline annotation direction. The lines are blurrier than they might seem at first.

So, Yahoo! has started publicly supporting microformats, which is great, because they are the ones generating the pages. What if you want to make a microformat out of 3rd party XHTML without touching it?
Here’s my questions. Feel free to comment below. I’m travelling, but I’ll try to moderate asap.

  1. In the specific case of CSS, how do you decide inline vs. binding?
  2. Are any microformat efforts currently looking at a binding approach vs. inline annotation? Which ones?
  3. What general principles should readers keep in mind for this discussion?

Thanks! -m

5 Responses to “Microformats: inline annotation vs. binding”

  1. Phil Wilson http://philwilson.org/blog/

    If I’m reading you correctly, which I’m not sure I am, then I think the analogy of CSS is a bad one.

    In CSS you use selectors to bind (X)HTML elements to style rules. With microformats the selector *is* the rule in that the value of the class attribute defines the precise semantic meaning of the element and/or its contents, and so such a separation isn’t really possible (it’s possible there are one or two edge cases where it *might* apply however, such as dates, times and mf reference and embedding).

    Returning to your first question: you decide on inline vs. binding exactly by how much “separation of …” you want and how much presentation you want embedded in your data. In the same way, you have to decide on how you write your JavaScript – do you inline it in the page, or use unobtrusive JS techniques to put it somewhere else and bind it at page display time?

    I look forward to being told I’m talking rubbish :)

  2. Dan Sickles

    XBL appears to be more for behavior binding but perhaps something similar could work for content:

    http://www.mozilla.org/projects/xbl/xbl.html

  3. Danny http://dannyayers.com

    Interesting question. I think Phil’s right about there being a qualitative difference between the use of things like the HTML class attribute for style selection and their use in microformats. But it does seem quite blurred.

    There is a kind of binding used with microformats already – the profile URI identifies the microformat in use, and the individual annotations are interpreted with reference to that. When CSS is applied you get a projection of the content that is a view, when the microformat interpretation is applied you get a projection that is a bunch of structured data.

    But maybe in the general case it is more useful to consider microformats as annotations, because the microformat is just an overlay. When microformats are used alongside some external model (e.g. with GRDDL), then there is a binding (with RDF).

  4. Phil Wilson http://philwilson.org/blog/

    “But maybe in the general case it is more useful to consider microformats as annotations, because the microformat is just an overlay. When microformats are used alongside some external model (e.g. with GRDDL), then there is a binding (with RDF).”

    +1

  5. Phil Wilson http://philwilson.org/blog/

    I totally forgot before, but it might be worth keeping an eye on http://microtemplates.org/ which is an IBM project for binding presentation (but also potentially meaning) to microformats using JSON.