r. alexander milowski, geek



MathML Christmas

For users with browsers that support MathML:

y = ln x m - s a r 2

y r 2 = ln x m - s a

e y r 2 = x m - s a

e y r 2 + s a = x m

m e y r 2 + s a = x

m e y r 2 + m s a = x

m e y r 2 = x - m s a

m e r r y = x - m a s

Sorry Chrome users, Google Scrooge says you can't have MathML.

Note: I found this on Facebook being passed around as an image so I converted it to MathML. I'd love to give credit to whomever came up with it.

Problems with Microdata

Given my recent grumbling about Google Blink developers trying to remove XSLT from Chrome, the current state of Microdata vs RDFa makes me think we're creating another level of incompatibilities on the Web. XSLT generally failed client-side on the Web due to the poor implementation within the various browsers. At this point, of course people aren't using it en masse because it just didn't work.

Microdata and its unknown status makes me feel like we're headed for more broken, partial ideas on the Web. We'd get proper adoption of some kind of Semantic Web Annotation if there was one syntax that everyone was using. Yet, the schema.org folks (Google et. al.) keep pushing Microdata. I'd personally prefer RDFa.

It is remarkable that while the W3C members seem to have chosen to only have one specification (RDFa!), schema.org seems to keep chugging along with Microdata. The status of whatever Microdata really is within the W3C or on the Web is really unknown--even to people like myself who try to keep close tabs on such things.

What is Microdata?

Attempting to answer the question What exactly is Microdata? only leads to more questions. First, which specification are we going to use: the 24 May 2011 draft linked to from the schema.org page, the latest draft dated 25 Oct 2012, or the WhatWG draft that can change randomly?

The real problem is that this specification is in limbo as it has been derailed from a recommendation track document. Essentially, there was push back, some very well thought out arguments against Microdata (e.g. by Manu Sporny), and a task force for some kind of unification or co-existence (read Jeni Tennison's blog post about this).

There's a lot of passion packed into this debate and, yet, after all this time, nothing has really changed that much. It is unclear what the status of Microdata is at the W3C and schema.org just plugs on ahead assuming that we all know and want this thing called Microdata.

My Problems with Microdata

While I have huge issues with the process that has led us into this mess, as the implementer of Green Turtle, I have many technical issues when it comes to implementing Microdata (assuming I can pick a spec against which to implement):

  1. Lack of a default vocabulary mechanism. Inferring property value URIs from an overt type (e.g. the itemtype attribute) feels like a pure hack. It works in closed type systems like schema.org but it doesn't in general. RDFa has the vocab attribute that allows an author to declare a default. That feels like a missing feature for Microdata.
  2. Items without types? What's the point of having an untyped item? It isn't useful to schema.org nor to any other comparable use. All a processor knows is that there is an item with some properties whose unique names can't be determined. Of course, this is the red herring of Microdata: oh look, all you really need is a itemscope attribute (unless you want to do something useful and then you need an itemtype attribute too).
  3. No Shorthand Mechanism. Prefixes and default vocabularies are ugly until you have real data with very verbose type and property URIs mixed from different real-world vocabularies. At that point, prefixes to shorten URIs (e.g. CURIEs) seem like a really nice feature.
  4. No Tests!!! A specification without tests guarantees interoperability problems. There are no well-defined, publicly available, and agreed upon tests for Microdata. That's a real problem.
  5. No defined Semantic Web mapping. If Microdata is to exist on the Web, it really needs to play well with others. Specifically, as it is adding semantic annotations to Web pages, it needs to have a well-defined mapping into triples and the Semantic Web. That's a real problem for Microdata because you can annotate items without ever giving a context for identifying the vocabulary. The result is that some Microdata maps to triples well and some does not without a great deal of assumptions.

I could go on but I'll stop there.

Clean Up Your Mess!

Bing, Google, Yahoo, and Yandex ran on ahead with Microdata on schema.org. Because Google is there (and possibly the others too), everyone just assumes Microdata has some legitimacy. Maybe it does or maybe it is a disaster.

I have one thing to say: clean up your mess! If my 8 year old son spills his milk, he gets a towel (sometimes at my suggestion) and cleans up his mess. Google et. al. has spilled the trash can of partially-abandoned specifications onto the Web and they need to get a towel and clean it up.

Green Turtle - Injection and Microdata Options

I've just released version 1.2 of Green Turtle and its Chrome extension.  While there are minor bug fixes, there are three new features:

  1. The way that the script on the Web page and the extension talk to each other has been greatly improved.  By doing so, I got rid of a hack where it used a meta element to pass triples to the extension.  The new method has the additional benefit of supporting other extensions--possibly in other browsers--with the same technique.

  2. Microdata packaging and option.

  3. Script injection.

Microdata Packaging

A packaging of Microdata has been added to both the script and the extension.  The experimental Microdata processor is now included with Green Turtle and can be enabled via a simple switch:

<script type="text/javascript">
GreenTurtle.implementation.processors["microdata"].enabled = true;

Including the above script just after the Green Turtle script will turn on Microdata support (off by default).  You can also disable Turtle processing much the same way (on by default):

<script type="text/javascript">
GreenTurtle.implementation.processors["text/turtle"].enabled = false;

Any Microdata is turned into triples and added the the graph along with any RDFa or Turtle found in the document.  If the Microdata can't be turned into triples, it is just ignored.  It would be really nice if there was a specification for this but there really isn't as of yet.

Microdata is also packaged with the extension and is off by default.  You can enable this feature in the extension options page.


The other big new feature is injection of the processor into documents that don't already have Green Turtle.  When the extension detects a Web page that does not have Green Turtle, it will inject the script from a version stored in the extension.  The result is that document.data and all the APIs are available from the console.  This will enable you to do additional experimentation in the console or for other extensions to use the graph data.

This also provides a more efficient means for handling large documents.  This feature is on by default but you can turn it off in the extension options page.  If you turn it off, it will still try to harvest triples but they won't be available from the console.

Extension Options

The extension now has an options page.  Just go to the Extensions menu item in Chrome and click on the Options link next to Green Turtle.  Checking Enable Microdata will automatically enable Microdata for all injected scripts.  There is also a control for turning off script injection.

[More entries ...]