Tom Morris

Danny Ayers has a great blog post describing how to do GRDDL with non-XSLT algorithms. Quite simple actually. You just wrap the RDF/XML in XSLT elements. What does this mean? Well, if you aren't an XSLT programmer, you can still use GRDDL. You could use server-side JavaScript or you could use something like Java or Python. Similarly, you could write some quite simple bridge code that would pull data from APIs and transform it.

For instance, I could quite simply write some code to just wrap the output of my RDF Twitter API in some XSLT elements, and just create what amounts to a service endpoint. For those of you who don't grok RDF, imagine this: you are on Flickr, you find a page, you send the URI of the page to a service, which then goes to the API, pulls all the data about it and returns you a document containing pure data. Pretty cool.

What else? Well, what about the HTML5 situation? The profile attribute still isn't there, despite being useful. It's down to some form of deluded neo-pragmatism that is no doubt making the maggot-infested bones of Dewey and Pierce et al. bounce around inside their respective graves. But once the HTML WG get an idea in their head, the fact that GRDDL depends on it is no reason to not chuck it away. Apparently. Completely barmy, but, you know, that's that.

One of the solutions we have thought about is using a new link element with @rel = 'profile' instead of head/@profile. But there's another way.

So, this guy Mark Nottingham has been putting an interesting idea out there recently - a LINK header in HTTP. Danny thought of FOAF headers back in 2005. This is another solution if the HTML WG pig-headedly decides that it doesn't want to catch RDFitis. Seems like a good solution, as it'll allow us to use GRDDL for XML and XML-like languages (like tag soup) that don't allow any profile URIs. HTTP transcending HTML? Nice.

Either way will require GRDDL clients (which are HTML and HTTP User Agents, even though some people try not to think about them) to be rewritten to support HTML5 (pragmatism - not politics - strikes again!).

Le Web 3 beta 2 (or whatever they are calling it) has only a few days left on the early-bird price of 750 EUR. After that, it shoots up to 950 EUR. It was so much fun last year, remember! They've promised no more politicians, but I'm not sure whether they've figured out that having the same old faces waffle about Web 2.0 and User-Generated Content is perhaps not worth the asking price last year, let alone the grossly increased asking price this year.

Don't worry, I'll be hanging out on IRC and watching whatever coverage the crappy wi-fi allows the Content-Generating Users to emit, and LOLing away on IRC.

And, with that, it is now almost November. In January, I took a pledge with myself not to spend more than twenty pounds, dollars or euros (allowing for currency fluctuation) getting into any event (note: that is getting into, not overall). The highest I've spent this year is fifteen pounds, going to a talk at Beers and Innovation. Other than that, it's been Geek Dinners and other events that don't cost more than about a fiver.

If you are getting bored with hearing the same old people bang on about the same old crap, come along to Geek Dinners and BarCamps. They are usually free or cheap, and have nice people. We have two Geek Dinners in London this week, and a BarCamp in a few weeks time. Elsewhere in UK and across Europe, there are lots of great events going on.

Diamond Geezer has a great post on rugby:

I've always hated rugby. I probably didn't realise it existed before I was 11, because my enlightened primary school played (proper) football instead. OK, so I may have been rubbish at playing that too, but at least my life wasn't in danger every time I had a PE lesson. My secondary school, alas, believed that rugger was the one true sport. I spent every winter for five years freezing to death in a stripy jersey while boys who'd already hit puberty wrestled with each other in muddy puddles. I spent every match trying hard to keep out of the way, in case the ball might accidentally be thrown in my direction and a horde of lumbering animals launch themselves on top of me. I cowered every time I was selected for the scrum in case some crucial body part of mine be squashed or wrenched off in the grunting mêlé. And I scored a try only once, when my sadistic PE teacher noticed me standing beside the touch line and threw me the ball, no doubt expecting me to fumble it and then be crushed in a pile of adolescent limbs. He was disappointed, but only on this one single miserable occasion.

How dare you describe this important formative part of British schooling? Just as forcing three prayers a day out of me for the first seven years of schooling served only to catalyse my atheism, the whole damp, soggy and miserable experience of making me play rugby for five years has vaccinated me against almost all forms of team sport.

Talking of sports, I found another blog post about the topic:

No, for me, what I have always hated is watching sports, and not so much that, but the huge emphasis placed on sports starting from a very young age. I hated seeing so much time and effort put into sports and sporting events, making small celebrities out of the athletes while at the same time, those who were in school for the actual purpose of school - to be educated, were sidelined.

Now, this has probably handicapped me for life socially, because apparently all men are supposed to be able to relate to each other through talking about sports. But I have no interest in sports and know nothing about any teams or players and never watch any games. This might be perhaps why I don't make many male friends, at least, fewer than average.

Imagine if we celebrated our scientists, engineers and philosophers in the way we celebrate our sportsmen. I'm not necessarily saying we should, just that it's an interesting lens to look at the world through occasionally.

My site occasionally serves invalid XML. This is an unfortunate business. The reasons are quite convoluted, but are to do with the way that you can't use CDATA sections inside attributes (Kosso will understand what I'm talking about).

So sometimes unencoded stuff is sent to the browser, or, as this morning, an unclosed span element.

I decided to fix it by writing some code that would detect whether what's about to be sent is valid XML. Simple enough. Just load it all into a DOM tree, and if it chokes on loading, it's not valid XML - then serve it as text/html to invoke the usually slower XHTML parsers.

Here's the code. It's done with PHP output control and the DOM - so PHP5 only, folks. You do use PHP5, right?

I've been mulling over Semantic Web things for the last few days - and this idea hit me today which I'm calling 'Blocks'. Blocks could potentially be a difficult project to implement, but let me chuck out an idea and see what people think.

I think that people have fallen in to a sad loop with regards to the Semantic Web. The Semantic Web is seen as this deeply scary proposition. It has all this weird stuff - like academics and logicians working on ontologies. Cover that with enough nonsense about "committees" - I mean, urgh! Who wants to be on a committee? We make much better decisions on our own without any expert guidance! Basically, we're stuck in a user education rut.

I'm thinking that what we need to do, then, is build a really simple software product that is a bit like Pipes, but open source.

Basically, imagine a simple library that hackers could import that would just provide basic functionality. Firstly, it could pull data in from some API sources like Twitter, Jaiku, last.fm, digg and Flickr (using the web-based conversion services that have been or are being built), and pull in RDF data from services like dbPedia, Revyu and other participants in the Linked Open Data project. Bascially, map that stuff into simple functions like flickr.getDataForUser("tommorris") etc.

Secondly, it could pull data in a structured way into the graph (yes, the RDF graph - not the graph that all the Silicon Valley finance types are waffling about) and let you process it. This could be as simple as spidering the site and looking for things like microformats, checking for OpenIDs, running rules and so on.

Thirdly, we provide a way of chucking the data back out again in different formats. Obviously, RDF/XML, N3, N-Triples, TriX and the other RDF formats - but also some domain-specific XML formats like RSS/Atom, OPML (for subscription or reading lists), KML (for geodata), even SVG - as well as JSON and YAML, and our humble friend (X)HTML. We'd also be able to push output across networks just as easily as into files - this is the Internet after all.

The idea is that we'd eventually have a sort of standard toolset available so that developers could just download a Semantic Web plugin for their development environment. That means everything from J2EE and Ruby on Rails through to PHP hackers and even kids trying to pimp their MySpace profiles.

Much as Yahoo! makes it easy with Pipes to just connect components together, we need to build some large, 'primitive'-esque chunks that beginner RDF hackers can try out for size. And we'd keep OWL ontologies and reification well away from it all.

I've been playing around with a few ideas - mostly using RDFLib in Python. I wasn't getting very far. RDFLib is nice, but it doesn't seem to support a few nice things like unbound variable filtering (danbri: "not known to be known"), nor does it seem to support a few other SPARQL constructs like CONSTRUCT or DESCRIBE. The only tool that I see that supports the full SPARQL specification is Jena/ARQ - which is a Java library. I have something of an animosity towards Java. It may be because of indoctrination at the hands of Paul Graham, or it may be me having an exceedingly long and complex CLASSPATH. Until I find a better way of doing it, I'm sticking with Java and Jena. Sod static typing.

I'm just in the process of porting the basic infrastructure of some of my little Python hacks over to Jena. Python is great for prototyping in that way (and I've been testing Jython for the same reason...).

I'm not wild about doing it in JavaScript - even though advance is being made by people at the Decentralized Information Group about making a seriously bad-ass JavaScript RDF parser. That's fine for a hack, but if you are going to build a rock-solid site or service, you shouldn't be parsing RDF in the browser but letting the server take the strain. If you don't believe me, Google "bulletproof ajax", read Jeremy's book and then come back. I'll wait.

Blocks will not be a replacement for a good RDF library. In fact, Blocks will require a good RDF library. That's part of the reason to use Jena - because it's actually a good library. Blocks, though, is more of an introductory module - a "here's how you do it" module that you can point to in any language or on any platform.

Also, speaking of RDF libraries - I'd love to know what suggestions people have on the matter of Ruby RDF libraries. I've tried a few and they are all a bit disappointing. Suggestions welcome. Ruby is a great language, and I think decent RDF processing is someting that Ruby needs.

Good news, fellow subjects of the Crown! The BBC are going to be rolling out the pointless iPlayer service on Mac and Linux. Not on my box they aren't. I don't do DRM. No negotiation. No compromise.

But if downloading time limited, digitally encumbered chunks of television you've already paid for through the TV License, it's great news. The rest of us will find... ahem... other methods.

Adobe Flash is at least marginally closer to open, widely-available standards than the current, bitter-tasting cocktail of Windows Media.

But, of course, this is a big step into the Web 2.0 world. Good for the BBC. I'm sure we'll be see Mark Thompson getting shit-faced on tequila at one of Mike Arrington's pool parties soon! Keep checking the Flickr, folks.

I wonder, though, would "it's encrypted, DRMed iPlayer content" be a valid defence for a section 39 notice under the Regulation of Investigatory Powers Act? Worth a try. I mean, "I'm sorry, sir, but I cannot decrypt this file, because if I do, I will implicate myself in my EULA conditions with the British Broadcasting Corporation" could be a possible get out from letting PC Plod read your e-mails. This Web 2.0 thing might be okay after all.

There's a fair bit of controversy at the moment over an event called ArbCamp, which was originally put together as a kind of BarCamp taking place in Ann Arbor, Michigan.

Only they are charging admission and having a keynote. Some of the reactions have been interesting:

Chris Messina: "Since when do *camps have a keynote, title, lead & partner sponsors AND charge for admission?! Did I hear bullshit?"

Mark Maynard: "I'm not a techie, so I should probably just shut the fuck up, but the criticism in this case seems valid. Marketing a for-profit event as "BarCamp-esque" and suggesting that it needed to be done in such a way because Ann Arbor, for whatever reason, can't support a legitimate BarCamp, seems to me to be weak in the extreme."

Alex Rudloff: "This is, quite blatantly, a commercial rip off of whats intended to be a free event model. They're taking advantage of the incredible amount of hard work folks from the community have put into creating the barcamp brand, repackaging it, aligning themselves with the brand by suggesting they have something in common with it, and then selling it for their own purposes. Loosely based on barcamp? Psh. It's the conference equivalent of a gpl violation."

Jeremy Harrington: "ArbCamp has: keynote speakers, high dollar sponsors, admission and a rigid session schedule (at 2pm everyone sits apparently) are of which are contrary to the overall barcamp model. The Ann Arbor folks can certainly run their own conference, but they need to reevaluate the name at a minimum and review the barcamp model if they want to be good citizens."

There are comments attached to these posts, and some more comments on the wiki.

One of the attendees of ArbCamp, Bill Tozier, has a blog post responding, using a fairly off-the-wall analogy to describe his perception of those reacting against what's going on with ArbCamp.

Here's my perspective. I've been to four BarCamps (two in London, one in Brighton and one in Cork, Ireland) and one PodCamp (the original one in Boston). What is interesting about them is that they exist by and for the geek community. They are one of the few places that geeks can be unfathomably geeky. Take a look at the schedule from the second London BarCamp - it's a geeky schedule.

There is space for non-geeky things within a geeky schedule - the schedule included talks about corporate communication, "Education 2.0", SEO and blue-sky talks about, say, the future of music. At the first London BarCamp, we had a wide-ranging chat about "Web 2.0" (whatever that is). A fair few BarCamps have talks about things like VCs and investment (certainly, BarCampLondon2 and the Cork BarCamp had talk about venture capital). At BarCamp Brighton, we had a great session about teenagers and technology - not so much from a descriptive "Are they using MySpace or Facebook this week?" but a normative "What should we do to help nurture the next generation of geeks?"

The reason that geeks have BarCamps is the same reason gay bars exist - because it's supposed to be a welcome atmosphere for a community that's not necessarily seen as acceptable elsewhere. When I'm at a BarCamp (or HackDay, or Geek Dinner), I feel comfortable in being geeky. At an ordinary conference, it often feels a little bit like you need to force yourself to be a bit more normal. If you have a whole group of people who do quite geeky things for work, or just because it's fun - BarCamp is where they can let their hair down, learn new things and show off ideas and technology they are working on. Adding a formal layer of 'conference' on top won't help with this goal.

Having an atmosphere where certain things are seen as acceptable allows people to come out of their shell. That is part of the point of BarCamp - it serves as a community home for geeks. And with that role as community home, certain values come with it.

That's not to say that I don't think that other people should do Camp like events. For instance, I've seen that the banking and finance industry have been organising BarCampBank - there's one in London currently being planned. Cool. I want my bank statements and credit card bills as GPG-encrypted XML files and I want to sign into my bank using an open-source version of RSA SecurID. I want my bank to stop wasting paper telling me stuff that they could e-mail instead. That's the kind of discussion I want to have, and a banking BarCamp seems like a good place to do it.

The problem I have is not that the business people want to join in the conversation, but that often by talking about how important "conversations" are, they dominate the conversation with something that's not very interesting at all - namely, the fact that we are indeed having a conversation about how important having conversations is. Conversation is overrated - building cool shit is where it's at.

As for ArbCamp? I probably would not attend. I hope the geeks in Ann Arbor can run a BarCamp - I see from the wiki that this year was a BarCamp in Grand Rapids. From a bit of Googling, I see ArbCamp was originally planned to be a BarCamp.

We've seen all this before too...

One of the things I find very sad about the state of computing currently is that nobody has really been taught to think about tool appropriateness. It's currently a bloody mess. Schools teach children to build websites... in Excel. I'm not kidding about this. Where they can afford a copy of FrontPage, they teach 'em about frames - where they can't, Excel seems to be a replacement for the whole Web stack - text editor, programming language, server and UI.

At my school, they used to teach graphic design in that wonderful design application, Microsoft PowerPoint. That's industry transferable skills! It's not like there are free alternatives.

No wonder people are growing up without any idea of the structure of documents. It actually takes a lot of work to wean people off the idea "that's a blob of green sans-serif 14pt text" and on to "that's a heading, and what it looks like doesn't necessarily matter at this point" (eventually from there, you progress down the rabbit hole of resources, through to descriptions, and descriptions of those descriptions and eventually to signed descriptions of rules that apply to other descriptions and round and round in circles until your head becomes a ping-pong ball - and, no, you can't make complexity disappear, you just shift it around a bit).

It has become a mantra that we should teach people to use applications. Most people don't meddle with their cars - we have garages for that kind of thing, so we should just teach them how to drive the car and leave all the hard stuff for the mechanic. With computing, that is learned helplessness - because computers are very different things to cars. Cars have only a small number of primitive functions - forwards, reverse, accelerate, brake and position wheels. Add a few support objects around it - gearboxes, clutches and the like. A computer is a general purpose thing. What you do with it is not defined.

Fuck teaching applications. If you were in a school in the early eighties that was lucky enough to have a computer, you'd probably be told that it was absolutely essential that you learn WordStar on CP/M, and that you'd never get a job unless you knew this vital task. Well, sorry to break it to you guys, but WordStar is dead. C and C++ aren't. What does that tell you? Do you honestly think that anyone will still be demanding PowerPoint presentations in twenty years time? And if they still exist, would you want to work for them? I hate to be the one who breaks the bad news, but if you are working away for something like an Advanced VCE in Information and Communications Technology, or an Applied GCSE, or whatever they call it, you are probably wasting your time.

Schools should teach everyone a dynamic scripting language (no prizes for guessing which one I'd choose, but Ruby would do nicely too...). Why? For a couple of reasons. Learning to code is good mental discipline, and teaches people to be logical and consistent. Being able to code saves enormous amounts of time. I've saved hundreds of hours of boring labour because I can write a short Python script that does it for me. Irritating things that get on my nerves every day don't. I can't imagine mousing through eternal menus when I have Quicksilver and iTerm hovering, waiting for my command.

But even if the person leaves the Intro to Programming course and doesn't ever boot up a python shell ever again, they still gain other things. Namely, it'll force people to think about data structurally. This is important, as we are always trying to pull data out of our brain and codify it in a structure. Most people can intuitively tell the difference between a string and a number (although people who aren't either mathematicians or programmers will probably fall when trying to tell the difference between different types of numbers - positive and negative numbers, integers, floats, doubles, shorts/longs and so on).

Hash tables (or key-value pairs, associative arrays), multi-dimensional arrays, hierarchial structures (like outlines) and the way in which we encode and decode these types of things are second nature to most programmers. But if you are trying to create a structured document, it becomes difficult for a person who isn't trained in the differences between these types of things to really understand how to put that kind of data structure into action in their real life. At the very least, documents will be better thought out.

Once you start thinking structurally, how something looks becomes less relevant. I don't like making puffed-up claims, but in a world of celebrity vapidity - which is heavily based on putting looks before substance, thinking about the underlying structure of something before wrapping it in gloss. Well, it's a nice thought. Saving the world from boring, repetitive tasks - and Paris Hilton. It's worth a try.

The kids who learn WordStar - or Microsoft Office - are being sold a bill of goods. This 'pragmatic' approach to computing is an utter waste of time. The 'theoretical' beats it every time. Teach a man to fish... Well, teach a person to code (and all the related good practice - from RTFM, asking smart questions and so on), and they won't end up learning bad technologies. How many Python programmers do you see aching to learn how to use Microsoft Project?

It would also make the vast leap over to the world of open source easier, and could help people understand that they are in charge of technology - and it's them that matters, not the vendor sports, armchair punditry over Microsoft, Google, Apple and so on. Here we are all about love, funking out and writing beautiful (Python) code.

Tantek asked me a while back about why my site has DDMMYYYY datestamps. Well, that's how we do it round these parts.

But, of course, DDMM(YY)YY is just UK convention. My site is now YYYYMMDD (styled with dots, dashes and slashes depending on context). You should rock your date-time stamps and make them compliant with the ISO date format. Makes pesky things like XML Schema (and RELAX NG and everything else that's based on XSDs) and microformats compliance easier.

And, if everyone uses YYYYMMDD, we will have a lot less confusion. Promise.

Just testing TextMate's blogging functionality.

Something I've been playing about with today and yesterday with is the Objective-C bindings for Python, PyObjC. The purpose of this is pretty simple - Python is a great language for writing glue code. One of these instances is a script I wrote a while back to let me use Quicksilver to post tasks to Remember the Milk, the excellent online to-do list manager.

The problem with interacting with some online services is the issue of authentication. Ideally, you don't want to store a password inside your application, nor do you want to store it in a preference file. Reinventing the wheel is boring. OS X already has a password management utility - the Keychain (which has some really cool functions, so open up Keychain Access.app! If you are a Firefox user like myself, 1Passwd is a commercial OS X application that'll hook your Firefox use into a separate Keychain).

After a bit of Googling, I found this blog post with some guides on how to use Keychain in Python. I've experimented a lot with it, so I thought I'd expand this post.

The prerequisites for Keychain hacking are simple. You need PyObjC. You can download a .dmg file from the website if you use the standard version of Python built in to 10.4 (Python 2.4), but if, like me, you use Python 2.5, you should download the source release, untar it and run:

sudo python setup.py install

You can ensure that PyObjC is installed by popping open a python shell and typing import objc. If you get an error, it’s not worked properly.

The other prerequisite is Keychain.framework. This is a bit of a pain to setup. I set it up by opening the Xcode Project file in Xcode and then building it in there. Then I somehow managed to find the framework folder in the Executables panel or something. As it’s open source, I can always put up a downloadable framework folder if it’s not working.

Once you have Keychain.framework installed in /Library/Frameworks, you can check it’s installed by going into a python shell and typing the following:

import objc, new
Keychain = new.module('Keychain')
objc.loadBundle('Keychain', Keychain.__dict__, bundle_path='/Library/Frameworks/Keychain.framework')

This creates a new module called Keychain, which loads in all the Objective-C modules as classes. You can get documentation about these classes in the Framework itself from header files. Those are the files that end in .h. The ones which are most useful are Keychain.h, KeychainItem.h and KeychainSearch.h. You can also get details about these modules from within a python shell, by typing help(Keychain.Keychain), where the second one is the class you want (eg. help(Keychain.KeychainSearch) etc.). The Python documentation gives you some of the details you need for most of the functions, but it doesn’t cover which arguments they take. For that, reading the header files is useful. Also, Google function names, or look at this documentation (which doesn’t always seem adequate).

Now, for building a script like I described above, to access a web service, you can tap into Keychain by letting the user login to a site in Safari (or another WebKit browser that supports Keychain). Once they’ve logged in and stored their password in Keychain, you can access their username and password programatically using the KeychainSearch class. You instantiate the KeychainSearch like this:

search = Keychain.KeychainSearch.new()

I’ve written a template function which you can use to programatically get to the Keychain for web passwords:

def getRememberTheMilkAccount():
  Keychain = new.module('Keychain')
  objc.loadBundle('Keychain', Keychain.__dict__, bundle_path='/Library/Frameworks/Keychain.framework')
  search = Keychain.KeychainSearch.new()
  for i in search.internetSearchResults():
    if str(i).startswith("rememberthemilk.com") is True:
      keyi = i
  return keyi

This function instantiates the Keychain, loads in the Keychain framework, creates a new KeychainSearch called (imaginatively) ‘search’, then loops through all the Internet keys it has searching for one which starts ‘rememberthemilk.com’ (you may need to check that it’s not www.rememberthemilk.com, or whatever it is for the site you are accessing), then if it finds it, returns it.

This will return the Keychain item. The two most useful functions for that are ‘account’ and ‘dataAsString’. Account is the username or email address or whatever you use to sign in to that site, and dataAsString returns the password. When you try and run dataAsString(), Keychain should ask the user for confirmation. This takes a number of steps. Firstly, if they Keychain is locked, the user will be asked to unlock it with a password. Secondly, they will be asked whether they wish to allow Python to access this Keychain item - and they can Deny, Allow Once or Allow Always. It looks like this.

Here’s the code you use to get the data out of the function above:

account = getRememberTheMilkAccount()
username = account.account()
password = account.dataAsString()

Once you have their username and password out of the Keychain, you can start making calls to the relevant APIs. This is scratching the surface of what’s available with the Objective-C APIs that PyObjC makes available to Python users. Ruby users out there have RubyObjC to play with. I did briefly try it out in irb (you can install it with sudo gem install rubyobjc), but didn’t get very far. You can load in the Keychain framework by following the instructions in section 2.2 of this page. Once you’ve installed RubyObjC, you can call the Keychain framework like this:

require 'rubygems'
require 'objc'
ObjC::NSBundle.bundleWithPath_( "/Library/Frameworks/Keychain.framework" ).load
puts ObjC::Keychain.methods

The difference between the Python and Ruby way of doing it is that in Python, Keychain becomes a child of the main Keychain module, while in Ruby, you use the ObjC:: prefix for all the modules. So, instead of Keychain.KeychainSearch, you use ObjC::KeychainSearch. There is more to it than this, and I’ll leave the Rubyists to find out more. RubyObjC, like PyObjC, is quite a complex library to get your head around.

Ian Forrester has been putting together an idea he calls Lightweight Attention Preference Markup, using RDFa. I’m glad to see Ian is experimenting and building with RDF.

The problem I see is that I am not sure what the point is of attention formats. I can see the point of attention, sure. That’s easy. But for me, attention is a set of algorithms which sit above the data layer. When building applications, you try hard to separate out the business process from the database. Attention is broadly about aggregating someone’s actions online and then inferring things based on them.

The sort of things we are aggregating are, for instance, pages which a person has viewed, actions taken inside ‘attention’ applications like RSS feed readers, e-mail and IM clients and now social networks like Facebook, and object-direct social networks like last.fm (for music) and del.icio.us (for bookmarks). Similarly, sites across the network often have common actions like blog posts, posting comments or voting or purchasing. Ideally, an attention engine would be able to pull in data like who I’m talking to, what products I’ve bought on sites like Amazon, what music I’m listening to, who and when I add people to social networking services, and then make rules-based guesses as to how to direct my attention to further my goals.

That’s the idea. But I don’t think that a particular format will solve it. Not a microformat, not Attention.XML, not APML, not a new RDF format, not Ian’s new format. I think that each service will be a new battle (in terms of adoption) and will map to different parts of the semantic/data stack (which includes the full range: JSON/YAML/language-specific array/object representations, ‘plain old’ XML, official microformats, domain-specific and use-specific microformats, the RDF stack, GRDDL etc.).

This is one of the reasons that I’ve been working on RDFizing Twitter and Last.fm, and putting together things like the OpenID detector for FOAF profiles. The co-ordination cost for getting Twitter, Last.fm and OpenID to all talk a common ‘attention’ format is an impossibly high one. Whether you do that work in a W3C committee or a new-fangled place like a wiki, it’s going to be a sucky process.

Instead, in RDF, we have a way to represent all the data in a format that could quite feasibly scale up. Through GRDDL, XSLT and microformats, we have a relatively straight-forward process to move data in. What we get for very little work is the potential of a relational database where all the relationships are URLs.

The problem with hitching data formats to specific use cases is that nobody knows what the use cases will be. Technology doesn’t exist in a vacuum. Look at SMS. Wikipedia puts it quite aptly: “few [people writing the GSM spec] believed that SMS would be used as a means for sending text messages from one mobile user to another”. If the GSM specification writers had written a spec specifically for what they envisioned the primary use case was - namely, operators sending notifications to users - then a future use case could potentially have been walled off.

Nobody foresees the eventual use of technology. Alan Turing could probably not predict the IBM PC, the Macintosh, Quake or the World Wide Web, even though the work of Turing had an enormous effect on making all of the subsequent history of computing possible.

Therefore, when we design specifications, we need to make them open and extensible - at least until we reach omniscience. This is something I think is a flaw in attention metadata formats. I already publish data about which songs I listen to. Last.fm have an API available so you can get the data in XML, or RDF. Why do we need another format to represent that?

The attention ‘value’ that is placed on particular sources or feeds is usually represented as a floating point rating. This is almost like a cryptographic hash - it’s one way. If software A thinks that based on my actions I like one feed more than another and pops that ranking into an APML feed, say, then I still sit unenlightened. Why the ranking? It’s a one-way hash. A different attention tracker is meant to trust this, even though the process that is used to calculate it may as well have been Mystic Meg’s bloody tarot cards.

We can own our attention data all we like, but we need open attention algorithms too, if we want to do anything truly useful with it. If Particls ranks my RSS reading in one way and BlogBridge another, how do I make a decision? Just based on gut feeling? By open attention algorithms, I mean inference, not algorithms in any complex mathematical sense. But statements like “If you read TechCrunch, you are probably interested in Web 2.0, Web 2.0 Startups and Silicon Valley” etc. - we need a common format for these. (“Could be” is an important part of these statements, remember “my TiVo thinks I’m gay”!)

A summary, then. I publish a shedload of data in machine-readable form. My site contains lots of microformats dotted around - from simple things like tags on up. I publish a signed FOAF file. I publish an RSS feed. My pages support GRDDL, and are mostly written in XHTML 1.0. I have an OpenID. I publish more data through third party services like Flickr, last.fm, del.icio.us, Twitter, Jaiku and so on. If you want to play the attention game, work from that. We don’t need to build a new attention infrastructure. We’ve got HTTP, (X)HTML, RDF and microformats. Make your attention inferences from that lot.$

I wrote a post this morning on attention. I’ve had some great responses to it - from Chris Saad in my comments and on Ben Metcalfe’s blog. Both are excellent responses and cleared up a lot of things for me with regards to how and where attention is going.

I still think there’s value for the user in having the ‘rules’ open, perhaps in rule sets. So, for instance:

{ ?p a foaf:Person. ?p att:hasAttention ?a. ?a a att:Attention. ?a att:uri <http://www.techcrunch.com> . } => { ?p att:hasInferredAttention [ a att:AttentionInference; dc:subject "web 2.0 startups"@en . ] . } .

This is an N3 rules statement that says “Person ‘P’ has attention facet ‘A’, with URI (techcrunch) implies an attention inference of the subject ‘web 2.0 startups’”. Imagine if you had big rule sets like this, which you could put up on the Web. I could put up my attention rules in a file, and you could run your attention data through it using a simple utility (currently a command line utility written in Python, but it would be relatively trivial to build GUI applications or web applications on top).

Why not build attention in to open source? Open data combined with open algorithms, because reverse engineering is boring. It doesn’t have to be completely open source - we could also provide APIs, so you, for instance, send a POST request to an API with either your data contained within or a URI, and get back your data annotated with inferences. It’d be nice if we could release the source for these, but commercial providers could also have REST APIs for running data through their inference engines. I’m also mulling over the possibilities of what could be built with RIF.

Attention is a field I am grappling with at the moment while trying to RDFize last.fm. I’m trying to figure out what the best way is, and I’m working on this file at the moment to flesh it out - attention.n3. Just an idea - feedback welcomed.$