One of the things that’s been making me happiest recently has been the fact that Jodrell Bank’s telescopes have been Twittering. These big machines, peering into the cosmos, chattering to themselves about where they’re currently pointed – and that chatter is overheard and reproduced on the web. Obligatory screengrab, in case Twitter is down:

It’s cute, and adds to the growing number of non-humans burbling away on Twitter. As I thought about this, it became clear that Twitter isn’t just “the status message turned into communication” (as I usually describe it), but a human-readable messaging bus.

By taking a device that’s already outputting digital data (a telescope) and piping that output in (and this is important) human-readable form to the web, a Jodrell Bank radiotelescope edges closer to becoming, if not a spime or even a blogject then a “thing that IMs”.

(Aside: I like Chris’ ideas about “things that IM”, because it seems a lot simpler and more lightweight than a true blogject or, more complex, a spime.)

Of course, it’s not two-way yet – we can’t address these devices (despite Twitter’s direct messaging) with commands, but we can still frame their output. And the advantage of Twitter is that it takes input and distributes it in all manner of formats – it’s a very cheap SMS gateway, for instance, not to mention an IM gateway.

I talked to Steve about this in the pub last night. Couple the idea of machines using Twitter as a messaging bus, and the new twitter gem for Ruby, which makes posting anything to Twitter much like posting to a Logger, and we banter about servers that tell us when they’re unwell – twittering when load goes above 2, etc. And again, the gateway’s the advantage – getting that information via IM or SMS.

Not to mention that it’s public – what looks like a warning message to me (“My load is a bit high, so I might be slow to respond right now“) is a nice explanatory message to users.

Summary so far: it’s easy to make machines and other devices tweet. This makes them a bit like blogjects, or IMjects.

But what’s really super-interesting is that by letting our machines address us over Twitter, in English, instead of over REST or SOAP or ssh, is that we’re letting them address us in the same space as we address people.

Actually, that’s a misnomer: we’re letting digital representations of machines (the software that converts their data into some form of English string) address digital representations of ourselves. I find that more interesting: we’re no longer necessarily anthropomorphising machines into people, but treating their digital incarnations as readily-understood metaphors. We’ve moved away from anthropomorphising in its strictest sense and towards finding an actual, idea-space representation of machines. That’s… most interesting.

The other thing that happens as more machines enter spaces previously restricted to humans is that the potential for interaction based on overhearing emerges. I used “overheard” very deliberately earlier – to suggest we’re not getting the original message (which, presumably, is in XML or binary or something) but a chinese whisper of it, cast out in public via Twitter. But now imagine if the API is two ways, and telescopes, watching the Twitter timeline can start acting upon the things they overhear. Scheduling software overhearing the Victoria line announcing that it’s broken. My cooker picking up that I’m leaving the office.

Etc, etc, etc. The signal-noise ratio on Twitter is very low, but that makes for lots of potential overhearing – it maximises serendipity. In my notes, I called this a “burble-API”. Burble seems appropriate – low-key muttering that for someone or something might turn out to be useful.

Until that happens, though, we can listen to the telescopes, chattering away to themselves.