Distributed Social Networking Software

One of the greatest things about South by Southwest interactive last year, which I just barely made it to, was the incredible creative energy born of like-minded people interacting with each other closely. Out of a conversation with Tantek Γ‡elik regarding linking, social interaction, and leveraging HTML rather fabricating new formats I became involved in what now is known as XFN, or the XHTML Friends Network.

XFN is a standardized method for leveraging the HTML rel attribute to describe relationships between people. More simply, it’s about enhancing how you link to somebody. Together with Tantek and Eric Meyer (and wonderful feedback) we’ve put together some great information and guidelines for using XFN. Check it out and share the link.

As an example of an early XFN application, people who I’ve met in person now automatically have a star beside their name when I link to them. See the “timely dozen” to your right or my portal page.

26 thoughts on “Distributed Social Networking Software

  1. Pingback: Meyerweb: XFN
  2. Pingback: tantek/log: XFN
  3. Hmm… as much I welcome a non RDF alternative to FOAF, is formatting multiple meta-data values as a space delimited string in one attribute value good XML design? Multiple elements within the element would be better and easier to process.
    As for the profile, that’s just a schema that describes more highly grained relationships. This can be done equally well in RDF and FOAF. See the Relationships Schema on SchemaWeb or this FOAF.

  4. yo, so i thought id leave a comment on the entry with the coolest date of the year. πŸ˜‰ good luck with your finals!

  5. Pingback: Tim's Bandwagon
  6. Amit, great! Let me know when you implement XFN and I’ll put a link your way.

    Victor, I understand RDF syntax, how it works, and its purpose in the larger view of machine-parsable semantic richness, but it’s complicated. Way too hard. My mom could do XFN by hand, she wouldn’t know where to begin with FOAF. However there’s no reason you can’t do both. If you have invested the time and effort in making a good FOAF file, XFN should be a breeze. And what’s less parsable about a space-seperated string? I can grab all the XFN values from a page with one line of regex and maybe an explode statement.

  7. And what’s less parsable about a space-seperated string?

    Didn’t God give us XML and XML parsers so that we didn’t have to use tedious regular expressions? And aren’t regular expressions the one thing in the world that’s harder than RDF! Regarding multiple values in attributes, if you want to ignore good XML design practice then so be it. If you want to make it harder to parse XFN then go ahead …

  8. I think I can explain some of why we used a space-separated value list instead of a more complicated nested-element XML syntax.

    We might have represented values as a set of nested elements, and thus followed general XML practices, but that would have had two very significant drawbacks. The first is that it would make the format less human-readable, and that’s a crucial point. It was very important to us that an XFN value be human-readable in a glance, and understandable even by people who have never seen XFN before. The second is that if we’d represented XFN information as elements within the link, it couldn’t have been used in valid HTML documents. That was also very important, because while XML may be the future, HTML is now, and we wanted something that would work in current documents as well as be easily used in future documents.

    Besides, like Matt, I can’t think of too many things that are easier to parse than a space-separated list, and I haven’t been a programmer since the halcyon days of Turbo PASCAL 4.5. (Before Mosaic, that was.) I’m not familiar with good XML design practice when it comes to attribute values, I admit– could you point us to some resources that explain what good and bad XML design practice is, and why the good things are good and the bad things are bad? I’d find such information useful for the future.

  9. Arguing about human readable files is silly. Once upon a time I had to write software that rendered files for graphic display. I couldn’t actually see the pictures as that required using what was then a hideously expensive frame buffer card. So I got pretty good at reading the hex files to make sure the picture was ‘going to look right’.

    Now, fast forward to now and you’d find it utterly ridiculous to do it that way. The tools for drawing pictures do all the dirty work for you. You *NEVER* read the file that contains the GIF, PNG or heck, even SVG or PostScript! At least not unless you a programmer.

    So the same analogy applies here. All the programmer types are whining about ‘view source’ because they’re using shitty tools. Stop using (or start developing) tools that don’t let you SEE the DATA in ways it’s best represented.

    But please, spare us this continued nonsensical arguments about human readability. They’re just wrong.

  10. Bill, I think the driving force behind our decision was simplicity and leveraging HTML. If human readability, ease of implementation, and simple parsing are side effects of that, fantastic.

  11. Pingback: dandruff
  12. Victor said,

    Didn’t God give us XML and XML parsers so that we didn’t have to use tedious regular expressions? And aren’t regular expressions the one thing in the world that’s harder than RDF!

    Insofar as God giving us XML (and parsers) to avoid regular expressions, that’s a bit like discounting the value of modern automobile, since we now have modern jetliners. Different tools, different uses. One of the most pervasive, immature attitudes across the ‘Net is that there is a ONE TRUE way to do things. The trick (and maturity) comes in knowing when to use the right tools for the job at hand. So long as XFN stays true to its purpose — a simple annotation — there is nothing wrong with a simple format; XML loses value as a format when you only have a _very_ simplistic data model to express.

    With regard to the question about how “difficult” RDF is to learn, I would note that in my personal experience it took me a day to get a basic grasp on regexes and practically apply them. RDF, I studied for weeks before I even started to understand what to do with it, much less apply it anywhere. But that’s just me. πŸ™‚

    Bill Kearney suggested that programmers need to stop thinking about readability, and start using good tools. The problem with that (circular) argument is that someone, somewhere, has to WRITE the tools. The more complex a format is (such as RDF), the longer it takes to get bootstrapped, since the population capable of READING and understanding the format and it’s applicability is dramatically restricted. Of course this gets into social dynamics, and I would note that populations capable of understanding highly complex formats are typically disinclined to write tools to help others — they’d rather use of the power of the format than spend time explaining it.

    IMHO, of course. πŸ™‚

  13. Pingback: msquadrat
  14. The more complex a format is (such as RDF), the longer it takes to get bootstrapped, since the population capable of READING and understanding the format and it’s applicability is dramatically restricted.

    RDF is not a format… it’s a data model. The syntax can be XML or ***anything else***.

    N3 is not unreadable and it’s RDF.

  15. Karl, you’re right. To clarify my own views, I think the serialization of RDF in XML is a pain. Generally, I think when people refer to RDF casually they are talking about RDF/XML. Let me know if I’m completely wrong here.

  16. Now you’ve got to grep through all your pages…

    Not if you’re using external entities in your XML source files (all your content is in XML, right?). Just update your entity reference and run your site generation script again. That’s how I do on my blog, anyway. πŸ˜‰

  17. Pingback: Karl & Cow
  18. No Matthew. Because the important is not the syntax, but the model… it’s exactly the point of RDF. :)) And why it’s so practical in many cases. I don’t want to advocate for RDF in specific but the uses of the RDF model for particular applications. I have expressed my ideas on my weblog about XFN.

  19. Pingback: The Queer Dot Net