Mary Hodder led an open space discussion of i-tags at today's Internet Identity Workshop. Mary wanted to figure out a good way for bloggers to both engage in tagging and establish the 'trusted tags' that could support linking. Many companies need an open source way for users to create tags that can be pulled into a variety of online systems.
rel="tag" is a commonly used microformat that Technorati developed, but it also comes from a pre-Technorati blogging standard. What are some other microformat solutions? Mary started a video remix community (Dabble) recently, and found there was as lot of interest in creating taggable Creative Commons licenses. (Disclosure note: Omidyar Network is a funder of Creative Commons.) Dabble's audience needed three pieces of information in order to use these licenses: who made the object, an understanding of the licensing, and trust on the identity attached to the media.
Mary needed to answer a big question: How can you connect identity with tagging? You need a network where both you and the media have a unique ID. Andy Dale from ooTao has been working with Mary on the HTML, and Drummond Reed from Cordance has been contributing to the XML. Between the three of them, they've worked up a number of use cases.
There have been three revisions to i-tags over the last few months. The current rev is surprisingly simple. You set up two definitions within the HTML of the i-tag, each of which can be easily read by crawlers and added to Internet databases. (Part of the tag is machine-readable XRI, and part is human-readable text.) These are the definitions that you establish:
- Describe the tag itself
- Describe the subject of the tag
There are a number of descriptive fields that you flesh out for each of these descriptions. For example, to describe the tag itself, you would provide data for these fields, which can then easily be sucked into Internet databases:
- ID: what kind of tag it is
- Subject: what is the subject of the content (e.g., blog post)
- Author: who is the person that applied the tag (may or may not be the author)
- Publisher: where was this content published
- Verifier: what organization/individual verified that the tags are real tags, and that the publisher is valid for that author
- Date: when was the content tagged
The Self-Tag method allows authors/publishers to both claim their blog and support third-party verification. Publishers can self-tag the blog itself, providing a claim that all of these entities are related. All of the i-tag data fields are provided in a self-tag, but they are attached to the blog itself rather than the blog post. You can ask the verifier to not only send you the self-tag that verifies that the i-tag is authentic, but also to send you a verifier tag that proves that the verifier is a trusted source.
Some questions were left unanswered, and it's clear that they will inform the development of the fourth revision:
- How do you handle double tagging?
- What happens when the verifier is missing or unreachable?
- What happens if you don't trust the verifier that the tagger used?
- What happens if the self-tag values change on a site, but the preexisting i-tag values don't?
- How do you prevent people from tampering with the tag or its verifier? How can you bind the tag to its object?
- What happens if the content on a tagged page changes? (This one isn't any different from current tagging issues.)
- What happens if tagged content is deleted from its server?
- What if two tags on the same object contradict one another?
Like I said, the basic implementation is a reasonably elegant draft. Most of the debate in the room was about semantics (e.g., "author" vs. "tagger"), where the tags lived, and how the tags were verified. Not about the tagging itself.
Tags: christine herron christine.net space jockeys identity iiw2006 technology i-tag
