Microformats Proposal for Reputation and Trust Metrics

by Charles Iliya Krempeaux, published on Mon Sep 12th, 2005

I've known about the Microformats movement for a while. (Probably before it first started gaining traction.) But I was only really sitting on the sidelines watching things develop. In fact, it was only really recently that I really understood Microformats. (The confusion wasn't really what a Microformat was but more what a Microformat wasn't. I thought they included much much more than they actually do. Like XML namspace based paradigms like the XML modules commonly used with RSS, Atom, and RDF. They don't.)

One of the key points of Microformats is who they are made to be accessible by. This is NOT a technology that requires you to have a B.Sc. in Mathematics to use. This is NOT a technology that requires you to be a Computer Scientist to use. This is NOT even a technology that requires you to be a software engineer to use. Microformats are meant to be accessible to people with only basic HTML knowledge. If you know more than this -- if you have more than basic HTML knowledge -- then great. Good for you. It will be super easy for you to make use of them. But... let me stress again that you only need basic HTML knowledge to use them. If markup like the following makes sense to you, then you should be comfortable using Microformats in your in your day to day web development work:

    This is <b>bold</b> and this is a <a href="http://changelog.ca/">link</a>.

(This accessibility is in part enforced by requiring that all Microformats to be in pure-HTML... well pure-XHTML... but you get the idea.)

The other key point to Microformats is that machines can figure out what you are trying to say too. Machines can figure out what you mean. And that is powerful!

This article proposes 3 new Microformats that together and with other Microformats and possibly other non-Microformat technologies let people and machines deduce trust metrics and answer questions with degrees of certainty. Yeah, I know, it sounds complex. But the whole concept is actually pretty simple and probably intuitive. Basically, it let's me and you (and machines) get answers to questions like:

  • What music do my friends "like" to listen to?
  • What people are "knowledgeable" about car engines?
  • What people, that one of my friends knows personally, is "knowledgeable" about car engines?
  • What are some "good" rap songs that I have never heard before?
  • Who "should" I be listening to about RSS?
  • What are some "good" places to eat in Surrey?
  • Was The Island a "good" movie?
  • What's "good" on TV?
  • Know of any new "good" jokes?
  • Where's a "good" place to get my car serviced in Kitsilano?
  • If I want to drive from Surrey to Langley what's the "best" way to take to avoid traffic, speed traps and all the other crap?
  • Is it "safe" to order this t-shirt online, from this guy in Texas?
  • What music is "popular" among people who go to Guildford Park Secondary School?
  • How many people would "like" to hear the song Back Then by Mike Jones played today?
  • How much "support", in the Surrey-North riding, does this proposed bill have for becoming law?
  • Who would "like" this law to be repealed?
  • How many of my friends would "like" this law to be repealed too?
  • What "good" apartments are for rent in Kitsilano?
  • Who "should" I allow to post comments to my artilces without poisoning their links with rel-nofollow?

And it let's you answer these questions by "asking" your friends, co-workers, acquaintances, colleagues, fellow-members, and peers. Which is how most do it in "real life". (We tend to ask people who we know. Or ask people who we think know something about the topic our question is on. Or directly or indirectly get information from a friend-of-a-friend. Etc.) Technically though, we are not really verbally "asking", but using Microformats (and possibly other technologies) to figure out these answers. Also, it let's you "judge" how much value you put on each person's opinion or advice.

Of course, this list is not even close to being complete. I'm only scrathing the surface. There are an infinite number of questions that can be answered. And others will likely use this technology in some very creative and important ways to have questions that are meaningful to them or others to be answered. But, hopefully this list will give you an idea of what trust metrics are about.

Example Microformats

For the uninitiated, let me show you a simple example. (For those that already know Microformats, feel free to skip over this example. I'm trying to make this article accessible to those unfamiliar with Microformats too.)

        Yesterday I was hanging out with a friend of mine:
        <a rel="friend met" href="http://www.chetwoodside.com/">Chet Woodside</a>.

(Sorry Chet for using you as an example :-) )

For the purpose of this example, let's say that this link appears on my home page (and blog): http://changelog.ca/. (You'll see why it matters where a link like this appears a little further on in this article.)

The keen may have noticed something they may have either never seen before or something they may have not seen used very often. Here's the same code again with the code of interest emphasized.

        Yesterday I was hanging out with a friend of mine:
        <a rel="friend met" href="http://www.chetwoodside.com/">Chet Woodside</a>.

The emphasized part of the code is the rel attribute. Most people probably never even knew that a hyperlink had this attribute. (Trust me though, it's had the rel attribute for a very long time. It's just that it wasn't very popular to use... until now. And don't worry, I didn't really know it had it either until rel-nofollow came out and I started doing some digging.)

The rel attribute is used to describe relations between the page or part of the page that the link is in -- in this case http://changelog.ca/ -- and what is being linked to -- in this case http://www.chetwoodside.com/. (In my head I think of "rel" as being short for "relation" or "relationship"... but I'm not sure if that is what the HTML specification says. But it helps me form a working conceptual model. And may help you too.)

Many Microformats make use of rel attribute. (So there's alot more stuff you can put in there besides just friend and met.) Also, just so you know, there's another attribute that Microformats make use of. It's the rev attribute; which is also an attribute of hyperlinks. And has also been around for a very long time. The rev attribute desribes relations in the opposite direction from the rel attribute. In fact one of the 3 Microformats that this article proposes uses the rev attribute. While the other 2 use the rel attribute. (In my head I think of "rev" as being short for "reverse-relation" or "reverse-relationship"... but again, I'm not sure that is what the HTML specification says. But this also helps me form a working conceptual model. And may also help you too.)

Those 2 values in the rel attribute are part of a Microformat called XFN (XHTML Friends Network). XFN is a simple way of representing human relations using links. (And most importantly, machines can understand this, in addition to humans.) In our example we have listed 2 XFN relations: friend and met. (Note that with the rel and rev attributes, when you want to have a list of things you don't use commas or anything like that, you just put spaces between them. Or in other words, in techno-speak, the rel and rev attributes contain a space-separated-list.)

So let's look at how both humans and machines can get semantics from this. (I.e., let's see how both humans and machines can understand what you are trying to say... what you mean.)

When most human like you read this (in a web browser) they see the emphasized parts below:

        Yesterday I was hanging out with a friend of mine:
        <a rel="friend met" href="http://www.chetwoodside.com/">Chet Woodside</a>.

Which you, as a human, can deduce all sorts of things from. You know that I am "Charles Iliya Krempeaux" since you are reading something I wrote. You know that "Chet Woodside" is a friend or mine (since I say it in that sentence). You know that I've met him in real life (since I said we were hanging out).

Here's what a machine gets out of this. When a machine reads this it sees the emphasized parts below:

        Yesterday I was hanging out with a friend of mine:
        <a rel="friend met" href="http://www.chetwoodside.com/">Chet Woodside</a>.

Which tells the machine all sorts of things. It would know that the I am represented by the URL http://changelog.ca/. (Note, there's a bit of a subtle technical issue with that last statement. But to keep things simple for this example, we'll ignore it for now, and deal with it later in this article. But anyways....) It knows there is a person represented by the URL http://www.chetwoodside.com/ that I am friends with (because we have that friend Microformat in the rel attribute). It knows that I have met that person in real life too (because we have the met Microformat in the rel attribute.).

If any of that example doesn't completely make sense yet, don't worry. It's explained more later on in this article. For now it's just important to get a feel for what Microformats are.

The Story

After understanding what Microformats really were I began to understand the power of them. And started applying them to my work. One of the topics I am interested in is: reputation and trust metrics; some call this the web of trust. (If you're thinking that this is starting to sound really complex, don't worry. It's really not. Refer back to that list of questions, at the beginning of this article, to see what this is about.)

I think Advogato's trust metric is what originally got me thinking about this. That and thinking about how to design P2P systems. (Note, I'm not just talking about music sharing here. But P2P in general.) (Just to put some perspective on this, that was back in the day when I was still in University getting my Computer Science B.Sc. and still a kid.) I obviously wasn't the only person thinking along these lines. I remember Bram Cohen wrote an article on Distributed Trust System that put to words some of the things I and others were thinking (on Advogato). (This is one of those projects I've been trying to work on for years, but could never really find the time to finish it.)

Initially (before getting into Microformats) I started trying to develop a paradigm for this using various technologies. I worked at creating a new standalone XML markup. I worked at creating an XML module that could be brought into other XML technologies like RSS and Atom. And even considered learning RDF to do this. It's funny actually; I've been a XUL developer for a very very long time. And have used RDF with my XUL applications (since RDF use is built in and sometimes required), but have never really learnt RDF. I can appreciate why some people say that RDF markup is difficult to learn and work with. And this is coming from a Mathematician turned Computer Scientist. I have a very good grasp of graph theory and all that. It's just that the notation -- it's XML serialization -- doesn't lend itself to making things obvious or to presenting its conceptual model to the uninitiated IMO. (Which doesn't, of course, make it bad. But makes it difficult to get quick wide spread adoption.) But I'm digressing. (Back to trust metrics and Microformats.)

I went though several iterations and several different version of these prototype technologies. Examing each for developer usability, applying use cases to each, and looking at the algorithmic complexities that each of these brought. Eventually, after not touching things for a while, I came at the problem from a new perspective and basically tried solving the problem from scratch using Microformats. In doing this I came to my current design which is (what I believe to be) elegant in its simplicity since it fits in so nicely with current patterns. And allows it to be used by a much larger audience. (Although it doesn't include all the power of my other designs. But that's OK. Things may end up being better since I believe that Microformats may end up producing some nice emergent social properties.)

This trust metric proposal introduces 3 new Microformats:

  1. rev-tag
  2. rel-peer
  3. rel-meme

When used together, and with other Microformats and even other non-Microformat technologies (like RSS, Atom, FOAF, etc) can provide you with trust metrics. (Just to say it explicitly, at the time of the writing of this article, I really don't know much about FOAF other than it is something like XFN but based on RDF. So don't in any way take me as being knowledgeable about it.)

The key to understanding all this is pretty easy. And can be summarized with just 2 points. (If you had trouble understanding that original example in this article, this may help.)

  1. Online you are represented by a URL. For example http://changelog.ca/ is the URL of my weblog. But as far as software like webcrawlers are concerned, it is me.

    This is how the whole concept of XFN works. If I put:

        <a rel="friend met" href="http://www.chetwoodside.com/">Chet Woodside</a>

    onto http://changelog.ca/, then I am saying that the person represented by the URL http://www.chetwoodside.com/ is someone I consider a friend and is someone I have met (in real life). (Note, there are 2 people being represented by URLs here. Me, by the http://changelog.ca/ URL... because the link in the code above is being put on that page... and Chet by the http://www.chetwoodside.com/ URL.) Or in other words (this is saying):

    I consider Chet to be my friend and I have met him (in real life).

    Here's another XFN example. (I'm including this because after being told all that I'd be asking, "what if I have more than one homepage". And here's what you do.)

        <a rel="me" href="http://www.sfu.ca/~ckrempea/">My Old University Homepage</a>

    (There are more XFN relations than just these, which I won't get into in this article).

    As you will see, rel-peer and rev-tag also use URLs to represent people; and some what implicitly, rel-meme does too.

  2. Ideas and topics are represented by URLs too.

    This is what rel-tag is about. If I put:

        <a rel="tag" href="http://changelog.ca/topic/IPradio">IPradio</a>

    in an article I wrote, like this one, http://changelog.ca/log/2005/07/27/why-cant-i-hear-the-music-i-like-on-the-radio--bribing-payoffs-and-scandals--wimax-802.16-may-be-the-answer, then I am saying that that article has something to do with the the idea or topic represented by http://changelog.ca/topic/IPradio. Or in other words:

    This thing has something to do with IPradio.

    (Just to not wash it over. I think it is important to link an article to it's author. And link the author to the article. The former can be done with the rel-author proposal I remember seeing somewhere. And the later could be done with rev-author... which I haven't heard about anyone else proposing, but I think would be a good thing to adopt too.)

    As you will see rev-tag and rel-meme also use URLs to represent ideas and topics. And some what implicitly, rel-peer does too.

Microformat #1: rev-tag

Let's look at rev-tag first. rev-tag is the counterpart of rel-tag. If I had:

    <a rel="tag" href="http://changelog.ca/topic/IPradio">IPradio</a>

then I would be saying that:

This thing, that that link is in, has something to do with the idea or topic represented by the URL http://changelog.ca/topic/IPradio.
Or in English:
This thing has something to do with "IPradio".

That's powerful. I can relate things to ideas or topics and machine's can read and understand that too! But when you go to that URL (that represents that idea or topic) how you know all the stuff there is stuff I've said‽ How do you know that all stuff there is stuff I asserted‽ How do you know the Microformats used there were created by me‽ That's where rev-tag comes into play.

If a page has a rev-tag link on it, like this:

    <a rev="tag" href="http://changelog.ca/">ChangeLog.ca</a>

then it is saying 3 things:

  1. The current page (and its URL) represents an idea or topic.

  2. The URL for the rev-tag link -- in this case http://changelog.ca/ -- represents a person. (Or maybe a group of people or an organization.)

  3. All the sematics on the page are asserted by the person pointed to by the rev-tag and are related to the ideas and topics that the page (and its URL) represent. (For example any rel-peer Microformats on the page are asserted by the person pointed to with rev-tag and have to do with the ideas and topics that the page represents.)

rel-tag and rev-tag work together to establish that a page represents my thoughs and my assertions on an idea or topic. (And can work together to help prevent lying and semantic web SPAM.) So, you should always see corresponding links going both ways.

Microformat #2: rel-peer

There's some things I might like to be able to "say" (via Microformats).

  • Tim Bray is knowledgeable about RSS.
  • Chet Woodside is a good graphics artist.
  • Joe Blow has good tastes in rap music.

(We'll show how the first one is done, via rel-peer. All the rest are basically the same though.)

Initially I had many rel values for this. Many different dimensions to measure things on. Many grades within each dimension. But, in the end, for purposes of simplicity, I boilded all this down to one concept. A peer.

But what is a peer‽ Well, think "academic peers". Think "peer-to-peer" (P2P). Think "peer-pressure". Think "peer-review". Think "jury of your peers". A peer is basically someone that you recognize as participating in a "group" (that you may or may not be part of).

Now that we have this concept of a URL representing an idea or topic, we can make assertions about ideas and topics. (By putting Microformats on that idea or topic page. Or by linking to that idea or topic page.) rel-peer is one such assertion. (And is used by putting this Microformat on idea and topic pages.)

For instance, on the page http://changelog.ca/topic/RSS I could put the following code:

    <a rel="peer" href="http://www.tbray.org/ongoing/">Tim Bray's ongoing</a>

Since http://changelog.ca/ has a rel-tag going to http://changelog.ca/topic/RSS, we know that http://changelog.ca/topic/RSS represents an idea or topic. Also, since http://changelog.ca/topic/RSS has a rev-tag going to http://changelog.ca/, in addition to confirming that this page in fact represents an idea or topic, we know that the stuff there is stuff I am asserting. And thus, having the code above says that I am asserting that the person represented by the URL http://www.tbray.org/ongoing/ -- Tim Bray -- is a peer in the idea or topic represented by the URL http://changelog.ca/topic/RSS -- RSS. (Just a note, currently, with these Microformats, I have not "said" that I am a peer for this idea or topic. Just because have an idea or topic page does NOT mean that I am asserting myself as a peer of it. I'm still thinking about the best way to handle this.)

One of the nice things you get out of this is that you get smarter blogrolls. I can blogroll per idea and topic. You can also use this to answer some of those questions at the beginning of the article. But you'll also need the next proposed Microformat to help you.

Microformat #3: rel-meme

So far I've being throwing around the words: idea and topic. Really though, there is one word that describes this well. It's: meme. (Which is why this Microformat is call rel-meme, instead of rel-idea-or-topic.)

You can use this Microformat to connect one of your meme URLs -- idea or topic URLs -- with someone elses. (And can do analysis on the graph you get from interconnecting meme-pages.)

For example, on my RSS meme page -- http://changelog.ca/topic/RSS -- I could put a rel-meme link like the following:

    <a rel="meme" href="http://www.feedblog.org/rss/index.html">Kevin Burton's RSS Page</a>

Here's another example that illustrates one of its useful features. On my IPradio page -- http://changelog.ca/topic/IPradio -- I could put a rel-meme link to like the following:

    <a rel="meme" href="http://del.icio.us/tag/podcasting">podcasting at del.icio.us</a>

Note that what I call IPradio many others call podcasting. rel-meme helps you show that 2 ideas are the same even if people use different names for them. (This type of thing is actually very very common.)

rel-meme could potentially even be used to cross language and cultural boundaries. For example on my meme-page about the GIMP -- http://changelog.ca/topic/GIMP -- I could put:

    <a rel="meme" hreflang="fr" href="http://blogmarks.net/tag/GIMP">GIMP links in French</a>

(OK, that might be a bad example. The site isn't actually in French. But there are alot of French users, and you can see that alot of the text people write is in French. Hopefully you'll understand the example despite that.)

You could even use it to link up your own meme-pages. For example, if you used various free online services.

Just remember though, all this is done so that questions like those listed in the beginning of this article can be answered.

This is a Proposal

Just to say it explicitly, this is NOT a standard. This is a first draft. I'd like to get input and feedback, regarding this, from others. I plan to look into how to put this up for peer-review over at Microformats.org. And I should analyze and think about this more.

I think I need to give more thought to SPAM and lying, For example, imagine if I allowed others to post HTML comments on http://changelog.ca/ and they created some links with with XFN in it. Well, it could totally change the advice and opinions others get from me. Also, what happens if someone hijacks someone homepage‽

I can actually see a market forming from this. (Well, there's many markets that can form, but I won't list any more than this one here. This article is long enough as it is. And I'm sure I'll blog about those things later. But anyways....) There could be a new advertising model of the future. (Which may or may not coexist with current advertising models.) It would be where people all of a sudden become salesmen. And endorse people, organizations, products, etc, through these semantic means. If someone wants their song to get heard by alot of people, they pay people to add it to their public playlists. If someone wants people to come see their movie, they pay others to give it "good" reviews. If someone wants to get alot of word-of-mouth recommondations, they pay others to add them as an XFN friend. I think (at least for now) this type of thing can be handled the same way it is handled in the real world. You pick and choose who you listen to, who you trust, and who you take advice from for each topic. (Of course, just like in real life, there will be people who just choose to believe whatever their told.)

Also, I should probably take a closer look at FOAF and RDF. I get the impression that they are somewhat related to what I'm working on. (Although I think supporting Microformats is the right way to go with this.)

And there are alot more Microformats I'd like to see (which I don't try to argure for in this article). Like rel-member and rev-member (for being part of a group, organization, club, political party, for being an employee of a company, or even a member of a workers' union). Also, I'd like to see Microformats for digital signatures and provable identity. And need to put more thought into privacy. (Of course that all needs to be done in a way that makes it very usable.)


So what does all this amount to, and how does it help us with the trust metrics‽ Here's how it works:

  1. Everyone creates a "homepage" or a "blog" or something (with a URL) that represents them. (And yes you can have more than one.) I have http://changelog.ca/, Chet Woodside has http://www.chetwoodside.com/, Kevin Burton has http://www.feedblog.org/, etc.

  2. You use XFN to express your personal relationship with people.

  3. You create meme pages, and use rel-tag and rev-tag.

  4. On those meme pages you use rel-peer to link to people you consider peer's for that meme.

  5. On those meme pages you use rel-meme to link to other people's meme pages.

I could write another article on how to do this in a usable way, so I'll just leave this point at that since short of doing that wouldn't do it justice. (And I'm sure that after all that reading, no one wants to hear it right now :-) )

Note, I haven't talked about any algorithms for "figuring out" any of those questions listed in the beginning of this article. Assuming that all goes well with this proposal, I'll do so in future articles.

One other point, I think it is important to implement these technologies in RSS and Atom. All of these rel and rev Microformats can easily be implemented with the Atom <link> element and in RSS if we use Atomic RSS.


No known comments. (There may be some out there though.)

New Comments

Want to write a comment to this post on your own blog? Then use the HTML code below to link to this article....

Or better yet, use the quote-o-matic below by "selecting" the part of the text (in the article) that you want to quote, and then use the HTML code that will get generated below to link to this article....