Twitter Annotations vs. Flickr Machine Tags

One of the announcements that came out of Twitter’s Chirp conference is Annotations.

Shortly after, Chris Messina said on Twitter:

Soooo... Twitter Annotations are just machine tags? I could live with that. Good luck with those namespaces though! /cc @noradio #anarchy
Chris Messina™

Let’s explore that for a second. Why is Chris Messina bringing up Machine Tags in this context?

Machine Tags are a term coined by Flickr back in January 2007.

The Flickr folks (following the prior art by the folks) defined Machine Tags in this manner:

# What are machine tags?

Machine tags are tags that use a special syntax to define extra information
about a tag.

Machine tags have a namespace, a predicate and a value. The namespace defines a class or a facet that a tag belongs to (‘geo’, ‘flickr’, etc.) The predicate is name of the property for a namespace (‘latitude’, ‘user’, etc.) The value is, well, the value.

Like tags, there are no rules for machine tags beyond the syntax to specify the parts of a machine tag.

To support Machine Tags, Flickr did the following:

  • Machine tags could be added to a photo on Flickr either manually by users or through the API
  • By default, Machine Tags were hidden from the user, but Flickr provided an easy way for users to view them if interested.
  • Flickr announced several officially supported Machine Tags that had specific semantics and UI/functionality implications (like geo:, upcoming:event, and more). 3rd party developers created tools that created and consumed the official machine tags, as well as their own custom machine tags.


The nice thing about Flickr Machine Tags is they were defined and used by Flickr users before Flickr sanctioned them. When they did sanction them, they used the exact format that was already used by the community, and the previously-used Machine Tags just became easier to use.

For many people, one of Twitter’s original charms was that the the evolution of the platform was driven by the users. @mention, @reply, #hashtags, Retweet – these are all features that were essentially created by the users of Twitter – as a convention – and later adopted into the core platform.

#Hashtags are similar to Flickr tags. In fact, the Hashtags Wiki explains Hashtags: “They’re like tags on Flickr, only added inline to your post.“.

Hashtags are also already sanctioned by Twitter itself – #hashtags become links in tweets which navigate to the Twitter search results page for that #hashtag:

#hashtags in a tweet lead to search on the hashtag

In fact, just like with Flickr Machine Tags, Twitter itself already started attaching specific semantics and functionality to specific hashtags. For example, the #worldcup hashtag and each of the 3-letters country names hashtags trigger a specific experience on


Now, with Twitter #hashtags and Flickr Machine tags in context, let’s look again at Twitter Annotations. This is how Marcel Molina, the Twitter engineer CCed by Chris Messina in his tweet (@noradio), defines them in “Early look at Annotations“:

First off let’s be clearer about what an annotation is. An annotation is a
namespace, key, value triple. A tweet can have one or more annotations. Namespaces can have one or more key/value pairs.

This sounds awfully a lot like Flickr Machine Tags, doesn’t it?

However, unlike Flickr Machine Tags, which are essentially specially-formatted tags, Twitter Annotations are implemented using an XML format which can be read and written only through API calls:


That’s only slightly less readable than, say #iso:isbn=030759243X, right? :)

In another universe perhaps we could have had Twitter Machine Tags instead of Twitter Annotations.

Twitter Machine Tags would have been a natural evolution of Hashtags:

  • Like Twitter Annotations, they wouldn’t be counted toward the 140 characters limit.
  • Like Flickr Machine Tags, Twitter Machine Tags could be hidden by default, but users could still request to see them – in the spirit of Microformats.
  • Twitter Machine Tags would be at least partially accessible – both for read and for write – to older Twitter Clients (unlike Twitter Annotations which will be completely invisible to older clients).
  • Twitter users would be completely comfortable with them. They’d be understandable. They’d evolve quicker, through an iterative process between developers and users. They’d be transparent.

In that alternate universe, Twitter users would have had another cool anecdote to tell, about how yet another one of their inventions went into the core platform.

Oh well.