I waved my hand at what I am calling Open Tags in a recent post, inspired in part by a Jeff Jarvis’ post, Made For A Distributed World.
I made the case that the current model for html-based tagging is flawed from the distributed world perspective, because it is based on specifying at the time of writing exactly what services are going to manage the tag information. For example, consider this Technorati-based tag:
<a href=”http://technorati.com/tags/thai” rel=”tag”>Thai</a>
That tag denotes that Technorati — at some time in the not too distant future, once Technorati crawls my post — will create a new entry in its database associated with the tag “Thai” that points to the posting I placed the tag in. Which seems to be fine, except for a few key problems:
- I don’t necessarilly know in advance all the services that I would like to have point to the post. For example, I might like to have a bunch of services — a restaurant review service, Technorati, a cigar-oriented service, and a wine review service — all point to the posting.
- And I don’t want top have to clutter up the posting with an expanding list of tags, each associated with a different service, which is an alternative, but a pain in the ass. Note that this is the direction that closed tags will take us!
- One alternative to Technorati-style tagging is to use a bookmarking service like Del.icio.us, and to manually tag all entries there. However, this does not lead to tags being present in the post, so I find that inadequate.
What I really want is a way to define the tags that should be associated with the post — such as “Thai”, “Cohiba Churchill”, “Restaurant”, “Gruet Blanc de Noirs”, and “Reston” — but to defer the identity of the service or services that are supposed to support the tags. (Note for programmers: this is a classic ‘late-binding’ issue as dealt with in many programming languages approaches to type-binding.)
My vision of open tags are designed to avoid the identity of Technorati-style services I might want to index my posts. For example, the Technorati tag “http://technorati.com/tags/thai” denotes Technorati as the service to handle the tag, as well as pointing to a specific page on the Internet generated by the Technorati system either on demand or in advance of an attempt to access it. Instead, my idea of an open tag relies on a relative address, like “/tags/thai”.
<a href=”/tags/thai” rel=”tag”>Thai</a>
A reader of my earlier piece, Randy Charles Morrin, pointed out that this relative address leads to a problem:
The problem with this clean approach, is that if you click on the link, then you are most likely looking at a 404. Get Real!
Randy is right: the browser resolves the relative address in the URL to be a hypothetical address at the Corante server — “http://www.corante.com/getreal/tags/thai” — which doesn’t exist. Hence, a 404 message: file not found.
Note that even with the Technorati-style static tags, you get a similar sort of message from Technorati in the case that the tag has not been created yet: although Technorati provides you, instead, the HTML to stick into your post to create the appropriate tag.
What is lacking for the open tag to work is some retooling at the blogging level: open tagging requires a tool — either independent or integrated into the blogging technology — to create pages corresponding to the open tags, and to manage the information there in a distributed fashion in way that is analogous to what Technorati does in a centralized way.
One option is to rewrite all my MovableType templates to make a direct connection between blog categories and tags. I would then simply map the MovableType category feature to generate the open tags This would work, since I could change my MovableType category archive settings to generate the correct directories: “http://www.corante.com/getreal/tags/thai”, for example.
Note, however, that this doesn’t lead to an integration with Technorati or other tag-based solutions. It simply collapses blog categories and tags. If I want to get today’s Technorati to work, I still need to create URLs that are Technorati specific. But I don’t want to create them at the time of writing the post, either by hand or automatically, because there are going to be many Technorati-ish services in the future and I don’t necessarily know who they are at the time of writing.
This is much like the idea of people writing about your posts: at the time of my writing this there is no way I could possibly know who is going to make a comment about these thoughts on open tags. That’s why we use trackbacks: so that in the future people can comment on what I have written, and the blog technology handles the trackbacks. So tomorrow, or next week, someone reading this piece will scroll to the bottom and be able to see a list of the folks that have riffed on this open tags post. I believe the same mechanism should be used by services like Technorati, instead of the explicit, in-advance tag specification we use today.
Today, MovableType and other blog solutions use pings to inform solutions like Technorati when it’s time to read posts and scavenge their tags, or else we can manually browse Technorati and tell them to do so by providing the URL of our blogs. But that is a dumb model given that we have RSS.
For the open tag model I propose that Technorati-like services request an RSS feed from users that they, in effect, would subscribe to. For example, I could make my MovableType implementation generate “http://www.corante.com/getreal/tags/tagspace.xml”. The services could poll the RSS feed at their preferred cycles, and generate any appropriate entries. Note that these RSS feeds would have to be configured to provide the tags in an easily accessed fashion. And, as I suggested, these services could trackback to the appropriate blog entries, and sent a link to the corresponding entries that they have assimilated into their own tag spaces.
If we shift to open tags, the Technoratis of the tag world will have to either get smarter about what sorts of tags are relevant — perhaps a wine service would only link to posts that include tags that ‘make sense’, like “Gruet Blanc de Noirs” — or else we could give them direction.
Jarvis suggested specifically denoting the identity of the service that should pay attention to the tags, using the “for:dinnerbuzz” type tags. A service, like the Dinnerbuzz restaurant review service, would see that tag in the RSS feed, and would then add the post to its database, using the other tags to identify it as a Reston Virginia Thai restaurant. A trackback ping could be used to send the URL to the various corresponing tag pages at Dinnerbuzz, such as “http://dinnerbuzz/tags/thai’ for example, and these would be associated the entry at my local tag pages.
But this leads us back to hard-coding the identity of the service or services we wish to have tracking our tags, although it would let us use a single set of tags for many services. I believe, in the long run, the services will have to become smart enough to look at the tags and decide whether an entry is relevant. A restaurant review service like the idealized Dinnerbuzz could simply look for the “restaurant” tag, and rely on elements from the restaurant review domain — cities, states, cuisines, “4 out of 5”, and the like — as markers. It might be smart enough to ignore the other tags — “Cohiba Churchill” and “Gruet” for example — that other services might pick up on.
The open tags approach has great value, I believe, but there is a lot working against it. First of all, we have a huge proliferation of closed tagspaces out there in use, such as Technorati, and they don’t work this way. But it’s early days yet, and an enterprising competitor to Technorati could decide to launch a new service based on the open model, to some extent taking advantage of the performance problems that seem to be plaguing Technorati over the past few months.
(Note that Technorati’s performance problems are significantly influenced by the closed model they have adopted: they are forced to read the source of our blog pages, looking for tags buried in URLs. In the open tag model, the tags would be encoded in XML-based RSS feeds, so performance of the tags parsing part might be significantly faster. Other aspects of the implementation would not be faster, but it seems that the backlog is at the blog reading phase.)
In the long run, open tag style services will emerge anyway, since others will see the treasure trove of information buried in Technorati-style tags and will decide to mine it. Realizing that the closed model has all the problems I have sketched out, someone or some group will propose a service that works in the open fashion, at least with regard to sending trackbacks to posts that are deemed relevant since this will lead to traffic at their service. The real problem will be bloggers considering this to be blog trackback spam. A transition to a consistent format for open tags’ RSS is likely to be a later development.
So we should start thinking about the long-tail value of our tags: they are not just for the service we are explicitly using today. Technorati may be long gone five years from now (I hope not!), but some service will be mining years of archived but still relevant opinions about Coldplay’s X & Y, restaurants in Reston, and what’s the best champagne to stand up to a Cohiba cigar.
One interim solution is to collapse categories and tags, as I outlined above, and to redesign your blog templates to generate both open and closed tags. For example, I could have each tag/category listed at the foot of my entries in the following style:
Thai [t] Cohiba Churchill [t] Restaurant [t] Gruet Blanc de Noirs [t] Reston [t]
and each tag would resolve to the local tag/category archive page when clicked, and the associated “[t]” would be the explicitly generated technorati tag. At some time in the future, if and when Technorati either ceases to exist or decides to support the open tags model, I could simply tweak my template to drop the “[t]” element. I plan to adopt this approach, at Get Real and perhaps across Corante as a whole.[I don’t address it in this piece, but I also believe the various bookmarketing services should adopt the trackback elements of the open tag model. That is to say that when someone reads this post tomorrow, and enters it into his Del.icio.us bookmarks with some commentary and tags, Deli.cio.us should ping my blog to create a trackback to that bookmark.]
The world is distributed, and our approach to making sense of it through tags should be as well. We need to anticipate that closed models are inherently at odds with what we are trying to do when we tag our entries. Obviously, if Technorati or some other competitor became super-dominant, and occupied the role of a de facto tagspace monopoly, this would be moot. But that is unlikely, for a wide variety of reasons. We will likely see an explosion of tag-based services, as the value of the blogosphere’s resources expands, and all that frenzy will inevitably lead to an open and distributed model for tags, something like this open tags model I have outlined.