utype questions

[Brian Thomas]

Hi all,

This email is NOT meant as a flame, even though I am sure it will be regarded in some 
quarters as such. It is a critique of what I consider to be not very clear thinking. 

> -- Utypes is a system for precise, formal descriptions of data 
> structures so computers can find them.

Perhaps what is really wrong here is that this attempt is trying to find some mechanism to 
re-use  the VOTable to hold complex hierarchical models. There are common, formal, precise
 mechanisms already for computers to read/parse and share and understand data models. The 
W3C (and others) have already dumped a huge amount of effort into doing this (XML/OWL/RDF/URI/
URL/SKOS/UML/XMI,  and so on).

Why is it so important to include the mapping from the row into an object model in the VOTable? 
Why not simply create a stand-alone serialization for the object? My understanding of UTYPES 
is that they must already point to such a model, so why not cut out the middle-man (the mapping 
in the VOTable)? As is being discussed now, this mechanism leaves no/little room for semantic
taging. What other limitations will we find as we begin to road test this new technology?

I would think that either a repository can serve up a table as its published (using current and upcoming
services), and let the end user figure  the mapping, or the VO community can come to some agreement 
(or not) on a model for various structures of data and the repository may offer an additional service 
which provides these objects. IF that service becomes popular/widespread, then the VO community can
then work to standardize it (the service and the model).

If the model spec is done in a manner not contradictory to common practice, then the implementors 
may place additional semantic tags within said data model to indicate semantic content as desired and 
this content may be parsed by commonly available software in a number of languages.

What exactly is gained by having this additional technology (the data model mapping in a table 
serialization)? I just don't see it as being needed, and it complicates serving up data* to the end 
consumer and requires the VO to write additional software which replicates what is already available.

Regards,

-brian


* You will have to develop a middle-layer of software to marshal from the VOTable row to the object
that is unquestionable. But unless you can find a general mechanism for doing this (e.g. a middle layer
which may generally map any row into any object), you are still off-loading the mapping effort onto the 
end-user (URN/URI work against you here for having a general mechanism BTW).  Furthermore, the
end user will still need some software to work with that model, once its marshalled (what mechanism
tells them where to get this software? Will this software even exist? or do they have to marshal every
thing to a common document/object model like DOM?) IF you use the DOM, why not simply cut out
the middleman (VOTable/UTYPE) and send the model in XML for the end user to (easily) parse??