I worked up and have been giving a new talk recently about the directions I think library services should go. As far as I could tell, they were quite well received by both technical and non-technical audiences alike, and I've been exchanging messages with several people offline about it in one way or another.

The more I think about it, the more I'm convinced that this direction, stumbled into with gentle nudges and nudzhes alike from people like Ed and Jeremy and Terry, is the right next set of steps to take. I'm not sure how the outcome of it all will turn out, but I don't think we can afford not to try, and soon. The best thing about it all is that it's all inexpensively accomplished, or at least prototyped, and we should be able to find out quickly whether it's Good (tm) or not.

The thing is, it would be better to engage a *lot* of people on these topics, and this kind of project, because we'll only see if it works if it can be taken up quickly and broadly. So this is the first of a series on ZeroConfMetaOpenSearch, introducing the plan one piece at a time, spinning out what's more compactly worded in those slides.

Where to start?

Imho the best place to start is with a challenge. Have you ever used iTunes? More specifically, have you ever used its music sharing function? It's awesome. You can see what other people near you are listening to, and you can listen to their stuff, and they can find and listen to yours. The best part about it is that once you enable the feature in your iTunes preferences, it Just Works (tm). There's no configuration needed - the protocol works on top of a local-net service discovery protocol that is the most magical protocol this side of HTTP itself.

So the challenge is: what are we going to say when our library patrons start asking us: "why can't we share our personal libraries with your big library as easily as we can share music with iTunes?"

Got an answer?

There is no good answer, because there's no reason we can't apply a glossy sheen to our sloppy mess-o-OPACs and metasearches to play very nicely with others, just like iTunes does. (Actually, afaik, delicious library already does use the same networking protocol for this exact purpose, but, we don't all have that, do we.)

When I say "there's no reason why we can't", what I really mean is that everything we need to do it is already sitting around waiting for us to plug in. Just like on the front page of today's WSJ, featuring how the Zimbra folks assembled their Exchange-competitor largely out of FLOSS components, nearly all the components we need are already available. But the key thing is that they have to plug in easily, cheaply, and *universally*, with no "first we need a new standard to do X" step. And they cannot require end-users to have to plug anything in or install or configure anything. To accomplish this, what we really should be doing is using the best existing standards, even if they're (gasp!) not from the library community.

In the talk I use these three tests to judge whether a new approach adequately meets these objectives:

1. Is it *simple*? i.e., can any competent coder grok it in a quick sitting, and churn out compliant apps in a few hours?
2. Does it require a new specification? We don't have time form more committees, I fear... we have to move forward with what's already here.
3. Does it Just Work? Do normal people have to actually follow any kind of elaborate instructions to make it happen, or stand on their head, or sign something, or offer sacrifices and pay for a warranty with a mail-in rebate? 'Cuz those are right out.

iTunes meets all the needs above (we could quibble about DAAP and #2, but, it's zeroconf and HTTP that make DAAP possible as much as DAAP itself). We have to, too.

Where is this all leading? Essentially, to the three points listed here. In the next few posts, I'll spin out toward each one with a little more detail, and will hopefully draw some of you into the discussion along the way.

Next time, I'll evaluate how COinS and unAPI stack up against the three tests listed above. (Then we'll get into the collapsing of metasearch and resolver interfaces into a single interface, and after that how OpenSearch could layer usefully over all of that, and then I'll close with the ZeroConf piece and why it ties everything together so neatly.)

But first things first: shouldn't our whole libraries be as easy to connect and share as iTunes?