[uf-discuss] Comments from IBM/Lotus rep about Microformats

[S. Sriram]

From: "Bruce D'Arcus" <bdarcus.lists at gmail.com>
> 
> The issue isn't really microformats vs. RDF (except as RDF provides a
> model), but microformats vs. RDFa.
>
[snip] 
> So while it might be comforting to dismiss RDFa and "it's not our
> problem", I don't think it's good strategy.
> 

I agree..

Parsing
Per [1] RDFa is akin to a language for microformats, as opposed to 
the current microformats which are a 'particular' defined set of class 
names in a defined order. A 'language parser' could parse all combinations
of 'syntactically' correct RDFa, whereas  with microformats each
particular format requires a particular parser.

Rendering
Now when it comes to rendering the 'parsed output', knowing
what the parsed output is, is necessary. This is where the
need is to understand the 'particular output' *OR* have a
generic container (an hItem or a micro-microformat for an item)
so all-purpose renderers can view 'unknown/particular' parsed
output as a blackbox.

Distributed parsing
Allows for custom microformats to be developed with their
associated custom parsers and the output passed to the rendering 
engine. (possibly discovered by distributed rendering)
Note: This does not need any 'approval process' as all publishers 
are free to do this today i.e. build a custom microformat,
markup their pages appropriately, build a browser plug-in that
understands this and build a cutom renderer.

In other words, in the absence of a language parser (which can 
parse all combinations of a syntactically correct RDFa) the other 
way to accomodate custom microformats (elias's need) is through
distributed parsing.

Another way to look at it is that microformats (with defined
formats == known rendering) are aggregator-friendly, where RDFa and
distributed parsing/rendering are more user/institution friendly
which may explain where google/technorati(aggregator) v. ibm(institution)
are coming from.

My own feeling is that a model which includes both
1. a uf-language (RDFa) and
2. canned formats (microformats)
allows for greater flexibility, with canned formats allowing 
for aggregators/multiple tool vendors, where custom format developers would
have the burden/opportunity of rolling their own renderers. 

[1] http://www.w3.org/TR/xhtml-rdfa-primer/
S. Sriram