Re: Cambridge Communique

 
 On Wed, 10 Nov 1999, Perry A. Caro wrote:
 
 > Dan Brickley wrote:
 > 
 > > the
 > > Cambridge Communique clarifications about the relationship between RDF
 > > and XML [4]
 > 
 > Pardon the out-of-context digression, but your mention of the Cambridge
 > Communique reminded me that I'm confused by that very document.  I've read
 > it, both at face-value and with an attempt at reading between the lines, and
 > the impression I come away with is that the RDFSchema and XSchema camps have
 > agreed to disagree.
 
 No; we agreed to agree. 
  
 > This strikes me as tragic.
 > 
 > What I'm sure most of us developers want to know is:
 > 
 > * How do we decide which one to use (RDFSchema vs. XSchema)?
 
 The only thing to regret is that we used the same word for different
 things. 
 
 
 <disclaimer>
 This is just my personal gloss on the situation, not an official policy,
 decree or pronouncement of W3C, the RDF WGs or anyone else. ie. don't
 bother trying to read between the lines, it's only whitespace ;-)
 </disclaimer>
 
 
 The Cambridge meeting was very positive, and made genuine progress on
 some tough issues. The 2nd item in the communique is, to my mind, the most
 valuable observation:
 
   2. Many data-oriented applications are being defined which build their own
   data structures on top of an XML document layer, effectively using XML
   documents as a transfer mechanism for structured data; 
 	(from http://www.w3.org/TR/1999/NOTE-schema-arch-19991007)
 
 
 RDF is only one such application layered on top of XML. There are many
 others. One way to think about this is that XML Schema is producing a
 successor to DTDs to allow data-oriented applications to be better served
 by XML. RDF is one of several data-oriented applications that stands to
 benefit from XML Schemas. 
 
 It is clear (see for eg excerpt from the 'XML Schema: Structures' document
 below) that XML Schemas are targetted at describing classes of XML
 documents. The Cambridge Communique notes that such documents are now
 commonly used to transport data between systems that have their own way
 of modelling the world. This isn't just RDF -- other examples include
 various ways of serialising eg Java and CORBA objects using XML. 
 
 XML Schemas are likely to be much used instead of DTDs when using XML for
 database and object-serialization applications. RDF applications are in this
 context analagous to such systems: we will IMHO likely see XML Schemas
 used to facilitate the transportation of data between RDF-based systems.
 
 	(from http://www.w3.org/TR/xmlschema-1/ )
 	The purpose of an XML Schema: Structures schema is to define and 
 	describe a class of XML documents by using
 	these constructs to constrain and document the meaning, usage and
 	relationships of their constituent parts:
 	datatypes, elements and their content, attributes and their values,
 	entities and their contents and notations. Schema
 	constructs may also provide for the specification of additional
 	information such as default values. Schemas are
 	intended to document their own meaning, usage, and function through a
 	common documentation vocabulary. Thus,
 	XML Schema: Structures can be used to define, describe and catalogue XML
 	vocabularies for classes of XML documents. 
 
 
 
 There was much talk at the Cambridge meeting about appropriate mechanisms
 (eg. XSL, or additional declarative annotations) that might be included in
 an XML Schema to facilitate mappings to application data models (RDF and 
 others, eg. OO systems, databases). I believe we'll see placeholders for
 such annotations in XML Schema, but that the content of these annotations
 will be for others to describe, ie. XML Schema anticipates but doesn't
 enumerate these application-specific mapping annotations.
 
 
 RDF is a modelling formalism targetted at describing classes of
 'resources', where resources (roughly) are things that might
 be identified with URIs, ie. everything.  Again, RDF isn't alone in
 this - lots of other XML applications describe stuff. While XML 
 Schema in itself only describes classes of XML document,
 instances of those document types (whether RDF or not) use XML to describe
 pretty much everything. So there's a subtle and interesting connection
 between mechanisms for describing XML document types (ie. XML Schemas) and
 the descriptive conventions of systems that use those document types to
 describe non-XML resources.
 
 Consequently we see in the Communique...:
 
 	An XML Schema schema document will be able to hold declarations for
 	validating instance documents. It should also be able to hold
	declarations for mapping from instance document XML infosets to
 	application-oriented data structures. 
 
 This acknowledges that there are many more data management systems on this
 planet than XML and RDF. XML gives us a universal syntax for shipping
 chunks of data around the network; one much-desired component of this
 picture is the ability to write down in XML declarations some info about
 how to turn the shipped-about data back into other representations. 
 
 > * Are we going to have to live in a world where we have to support both, and
 > have two sets of processors, two sets of specifications, two sets of user
 > guides, converters to/from, etc., etc.?
 
 I believe the Cambridge meeting went a long way towards minimising such
 duplication, confirming that XML Schema constructs will work with RDF, and
 establishing common understanding about what we're collectively trying to
 do. 
 
 The communique says...
 
 	The XML Schema and RDF Schema languages are separate languages
 	based on different data models and do not need to be merged into a
 	single comprehensive language. 
 
 This was the considered technical judgement of a group of people drawn
 from both XML and RDF schema groups. And I think it is true: RDF Schema is
 a vocabulary description system for the Resource Description
 Framework. XML Schemas define and describe classes of XML
 document. These are different, although related, activities.
 
 
 As noted below, the RDF approach to vocabulary description is pretty
 minimalist right now. In essence, all RDF Schemas says is the following:
 
 	"We should use the RDF model to describe RDF vocabularies".
 
 
 This follows quite simply from the approach taken in the core RDF model
 itself and from an axiom of Web architecture mentioned by DanC earlier:
 
  	"The Web works best when anything of value and identity is a first
         class object.  If something does not have a URI, you can't refer
 	to it, and the power of the Web is the less for that."
         -- TimBL, Dec 1996
         http://www.w3.org/DesignIssues/Axioms
 
 
 Since RDF itself (even without Schema) already gives us a nice model for
 describing things with URIs, anybody who has an RDF storage or query
 system pretty much already has implemented an RDF schema management
 system as well. That's the nice thing about using RDF to describe itself.
 
 However, since RDF's current XML syntax is widely considered a little cumbersome,
 RDF *in it's current syntax* does not recommend itself for all descriptive
 tasks (eg. describing XML document types). This doesn't stop us later on
 describing mappings of non-RDF XML syntax into the RDF model, in cases
 where this is considered useful. (The circularity here is that
 better-than-DTDs mechanisms for describing XML document types (ie. XML
 Schema) are just the kind of mechanism that will make it easier to have 
 nicer RDF syntaxes.)
 
 While it may be possible to consider XML Schema documents generally to
 be making RDF statements about XML document types (ie. following the DCD
 approach http://www.w3.org/TR/NOTE-dcd ) I don't believe anyone considers
 this an urgent priority for XML Schema right now.  There are a bunch of
 things that it would be useful to explore; the role of the Cambridge
 meeting was to help people decide which issues were critical, and which
 were opportunities to explore later.
 
 
 
 > Also, I wonder if anyone can confirm my conjecture that the reason RDFSchema
 > is so underspecified is because of the long shadow cast by the impending
 > XSchema?  [It's been at least 6 months since I read RDFSchema, so pardon me
 > if the omissions I list here have been addressed] RDFSchema lacks some
 > obviously useful features, 
 
 The RDF Schema WG discussed a number of features (some visible in the
 first public draft, eg. cardinality constraints) which were
 not present in the final product. Simplicity and extensibility were valued
 above feature richness. Primitive datatyping is the most obvious issue
 that we explicitly left for future work; RDF anticipates URI-identifiable
 datatypes but doesn't enumerate these.
 
 Constraints are an interesting topic: in more complex cases these turn
 out to look a lot like queries expressed over RDF graphs. Rather than
 hardcode a whole range of likely-looking and hopefully useful constraints,
 a decision was made to leave complex constraint machinery to subsequent
 specifications. Instead, RDFSchema describes a mechanism for declaring the
 existence of new forms of constraints, so that older processors know when
 they're meeting new things they don't understand. 
 
 >		[...]like concrete syntax for specifying whether a
 > value is required or optional, or read-only in a named context, etc.  Is it
 > because RDFSchema is waiting until XSchema defines those concepts, and then
 > will incorporate equivalents in a future extension?
 
 The only mechanism that we're relying on XML Schema for are
 URI-identifiable primitive datatyping constructs. I suspect other
 mechanisms from XML Schema will have a natural representation within RDF's
 graph model -- for example the facetting machinery in the datatypes
 spec. So, yes, it makes sense for us to have kept the RDF stuff simple
 while waiting to see what came out of the XML work. 
 
 Hope this helps
 
 Dan
 
 (speaking only with his XML and RDF implementors hat on)

Received on Friday, 12 November 1999 17:47:47 UTC