Multi-conference report: VO and SW

[Norman Gray]

Roy,

How's it going?

On 2005 Dec 4 , at 22.58, roy at cacr.caltech.edu wrote:

> I would appreciate an elaboration of why it ivo: is bad.

As Tony says, I'm to some extent the messenger here.  Myself, I'm  
probably more persuaded than not that URIs are best when they are  
retrievable, but I'm diffident about saying so too loudly, because I  
do agree that things like ivo: seem to provide the strongest  
counterexamples.  However, I'll make the case as strongly as I can  
here.  And honestly, I _have_ tried to keep this short!



The Web Architecture document seems broadly agreed to be a practical  
rather than theological document, and a description of what in  
retrospect made the web `work'.  It's from that hindsight point of  
view that HTTP was identified as having the following almost  
magically good properties:

   1. everyone with a web server can mint identifiers (ie, it's non- 
exclusive and hugely extensible)

   2. HTTP URLs have all the properties you want in an identifier,  
plus retrievability

   3. HTTP GET has very clean and intelligible semantics, which are  
simple to implement and integrate in other applications (ie, you  
don't need a resolver)

Now, the VO isn't interested in property (1) (for better or for  
worse), so we can skip that.

(2) is essentially the argument that if you want something other than  
a URL for your URI, then you're going to have to make a positive case  
why direct retrievability is a practical disadvantage.

The big difference between URIs and URLs is, as we all know, that the  
former are for labelling concepts, and aren't guaranteed to be  
dereferencable, much less immediately retrievable.  However a long- 
established bit of good practice here is to make your URIs  
retrievable and to provide _something_ useful at the end of it, be it  
a human-readable description of your namespace, or of your ontology,  
or whatever you personally mean by the concept thus labelled.

This argument is therefore flatly contra your:

> Another example is the XML namespace. This is a silly name for it:
> http://www.w3.org/2001/XMLSchema-instance. I would suggest that
> xmlns://www.w3.org/2001/XMLSchema-instance would be better.

The two are precisely equivalent as far as the machines are  
concerned, but the latter has given up the free opportunities for  
documentation or clarification that the former offers, for no real  
benefit.    To get those advantages back, you'd have to expensively  
define the xmlns: scheme, and specify and maintain resolvers for it.

As well as the gratis practicality, the recommendation that URIs  
should be URLs undermines any claim that there is still a useful high- 
level distinction between URIs and URLs, beyond the incidental one  
that some are retrievable and some are not (this goes as far back as  
2001 <http://www.w3.org/TR/uri-clarification/> with other remarks in  
<http://www.ietf.org/rfc/rfc3305.txt>).

So the response to your objection

> I really dislike this practice of making non-URLs look like URLs,  
> it is
> confusing.

is: `so make them into URLs'.  You're going to have to document your  
`non-URL' somewhere, so it might as well be there.  `But the URI/URL  
specifies a resource, not a namespace', you say: so let the URL  
retrieve the resource.  Why make things hard by adding a resolver?

The answer is, of course, because we want the IVOA Registry  
infrastructure to get in on the act, and the "ivo:" string means  
`don't ask me, find a resolver and ask it'.  (I'm not in the least  
disputing that the Registry has to be involved; the issue is how to  
do it as cheaply as possible).

That means that the question really is whether the costs of mandating  
a resolver are small enough to justify the benefits obtained.  Those  
costs, remember, include writing an RFC for "ivo:" and getting it  
approved by the IETF, designing an API and/or protocol for the  
resolver(s), and writing the resolver servers themselves.  The  
benefits of the indirection are that

   1. abstraction helps persistence by decoupling the identifier from  
its retrieval
   2. the indirection means you `de-brand' the resolution -- you  
can't easily detect who's serving you the actual resource.

Point (1) is less persuasive than it sounds: domain names like cds.u- 
strasbg.fr will change or fail on roughly the same timescale that  
resolution servers will change or fail, so that you haven't  
fundamentally improved your reliability by the order of magnitude or  
so that would justify the extra costs.  (2) is only an advantage if  
you have no easy fallback.

This is where the ARK scheme that I mentioned seems to hit all the  
sweet spots, and seems to cheaply provide the identifier properties  
we want.

ARK IDs are HTTP URLs and are, it seems, intended to be passed around  
as such.  However the "ark:.*" string within that URL is the  
persistent bit, and can either be chopped out of the URL (if you want  
the de-branding for some reason), or chopped out and reattached to  
the resolver of your choice.

In some sense, therefore, ARKs are just like the ivo: identifiers,  
except that the resolution mechanism is explicitly specified as  
`append this to the HTTP URL for a resolver service'.  There are a  
few other bells and whistles to do with the '?' and '??' stuff I  
mentioned, but that's basically it; extremely simple.  The cost of  
this is that ARK comparison becomes a bit more expensive (you have to  
strip the resolver prefix, or handle the suffix separately).

The benefits are that there's no RFC to write, no API to write, and  
all the costs are removed from the client end (so you can dereference  
an ARK using wget!) because you don't need any further tools (see  
<http://www.doi.org/tools.html>).  Plus you regain all the library,  
application and intelligibility benefits of using HTTP, and you get  
BIND and Apache to do the heavy lifting (getting someone else to do  
the work is always a good thing).

DOIs and Handles appear to be like ivo:, but are arguably like ARKs  
in many cases.  Pace bells and whistles, gongs, tubas and son et  
lumiere in the DOI API, you can basically resolve DOIs by appending  
them to the URL http://dx.doi.org (roll out the 80/20 arguments).

I quoted an RFC above.  The RFC persistent ID is a string of the form  
'^RFC[0-9]*$', but to resolve one, you can transform it into the HTTP  
URL http://www.ietf.org/rfc/<lowercased-RFC-number>.txt.  Conversely,  
given that URL, you can extract the document ID and use your own RFC  
resolver, or I can save you the trouble by quoting it convolved with  
its resolver.

In this last case, as with the ARKs, there is nothing _lost_ by  
quoting it as an HTTP URL, but there's a lot that's gained in terms  
of simplicity and usability.  It means that

     % curl http://www.ivoa.net/ivo-resolver/ivo:/blah | xsltproc  
grokVOTable.xsl | ...

...is a VO-enabled application.



OK, _I_ at least am more convinced than I was at the top of the  
page.  How about you, Roy?

All the best,

Norman


-- 
------------------------------------------------------------------------ 
----
Norman Gray  /  http://nxg.me.uk
eurovotech.org  /  University of Leicester, UK