(Warning: extreme library geekery ahead. Duck.)
The Handle system never seemed like a big deal to me. Distributed namespaces, URLs that don’t die, yawn, we have all that already, it’s called DNS and responsible webmasters.
Today I know different, thanks to a staff meeting at work. What I didn’t know was that there’s an entire protocol hiding behind handles, and it’s both frighteningly elegant and frighteningly capable, two very good things in a protocol.
I saw an authorization system built on nothing but handles and handle resolution. Did both password and public/private key auth. Was pretty gosh-darn sweet.
I saw a sort of a mod_rewrite analogue built on handles, one that could manage variable insertion. It made my brain hurt, actually (redirection limit passed! abort, retry, fail?), but I can certainly imagine uses.
And I saw a primitive content-negotiation system based on handles, and saw that it wouldn’t take much effort to make the system not primitive at all.
The one drawback is that you can’t query a handle server. (You can’t, for example, say “Tell me all the handles you know about with this string in the URL.”) You feed a handle server a handle, it resolves it for you; that’s all it can do (for decidedly wide-ranging values of “resolve”). Apparently MPOW is building a database specifically to add query capabilities to what handle servers can already do natively.
Even so, handles are awesome. If all you know about them is DSpace, then you know what I knew before today, which was basically nothing; DSpace doesn’t implement the entire protocol. (Wish it did. Could solve a lot of nagging problems, especially in the content-negotiation space.) My brain is all ’splodey, but in a good way for once.
