W3C home > Mailing lists > Public > www-rdf-comments@w3.org > October to December 2003

Re: Internal DTD Examples Invalidate the RDF/XML Documents

From: Frank Manola <fmanola@acm.org>
Date: Fri, 03 Oct 2003 14:10:40 -0400
Message-ID: <3F7DBBA0.7040702@acm.org>
To: dennis.hamilton@acm.org
Cc: www-rdf-comments@w3.org

Dennis E. Hamilton wrote:

> I apologize for yelling.  I capitalized that part because my message was a bit lengthy and I wanted to make sure you saw what I took as a key point.

No problem.  I understood your point (I think;  see below if you agree!).

> What I make of this is that it is a matter of out-of-band (application) agreement whether the presence of a Document Type Declaration is a signal that the document should be validatable or is not intended to be validatable (like the presence of a digital signature is a signal that the signature should be verifiable, in some circles at least).  So, if intentional non-validatability is part of the practice with RDF (e.g., as with the OWL RDF Schema), I believe that agreement should be made explicit.  
> Somewhere around here, I keep running into the expression "precise meaning."  I guess we should provide that wherever it is found to be missing.

I share your desire for precise meaning.  However, I do want to make 
clear that I don't really agree with an interpretation (whether this is 
what you're saying or not) that somehow RDF and OWL are engaging in some 
kind of non-standard practice in the use of document type declarations 
just for specifying entities (i.e., document type declarations that are 
not complete enough to permit validation by a validating XML processor). 
  I read nothing in the XML specs that says that a validating XML 
processor can decide for itself whether or not validation should be 
performed based on whether a document type declaration is present or not 
(that doesn't preclude there being an explicit flag to tell an otherwise 
validating processor not to validate;  but in that case the processor 
isn't making the decision, the user or calling application is).  I think 
the XML specs explicitly provide for the use of document type 
declarations in XML that is not supposed to be validated, and I think 
the problem really lies in people wanting to use validating processors 
for arbitrary XML languages (especially when those processors think they 
can decide for themselves to validate some XML and not other XML).

Also, it seems to me that when you say "if intentional 
non-validatability is part of the practice with RDF...I believe that 
agreement should be made explicit", this suggests that it wasn't already 
pretty clear that RDF/XML (in the general case;  not specially-designed 
subsets) wasn't intended to be XML-validatable.  I would have thought 
that the absence of any DTD in any of the RDF specs (including the 1999 
RDF Model and Syntax) against which to validate RDF/XML would have made 
it pretty clear that validatability wasn't intended, since it would be 
impossible to do XML validation of RDF/XML without a DTD.  (Note that, 
once again, I'm assuming that if you submit RDF/XML to a validating 
processor lacking a switch to turn validation off, it's supposed to 
actually try to validate it.  If such an XML validating processor is 
handed a piece of XML without a DTD, it should return an error that 
there isn't one, along with all the other errors about undefined 
elements and so on).

However, all that notwithstanding, I've taken an editorial action to try 
to make this more explicit in the Primer.  What I propose to do is:

a.  In the example in section 3 where entities are first introduced, 
briefly note that the use of a document type declaration here is just to 
declare entities (and not to provide a complete syntactic specification 
for RDF/XML), that the use of entities (and document type declarations) 
is optional, and that this does *not* mean that RDF/XML can be validated 
by a validating XML processor.  And then point the reader to Appendix B.

b.  In Appendix B, get into somewhat more detail (but not much);  in 
particular, briefly mention the difference between well-formed and valid 
XML, note that RDF/XML only has to be well-formed, that for various 
reasons (not just the QName point you mentioned) it's hard to write a 
DTD for full RDF/XML, and hence XML validation is generally not expected.

Does that make sense?


> 	-	-	-	-	-	-	-	-	-	-	-	-
> Meanwhile, I think I need to look at XML 1.0 and 1.1 more carefully and see whether this is a conversation that I should take up on an XML list. I will also look at the WS-I work to see if this kind of disconnect is a concern or not in the profiles for interoperability.
> 	-	-	-	-	-	-	-	-	-	-	-	-
> I am not sure about the logic that says an unvalidatable DTD  in an interoperability situation is a good thing just to obtain entity definitions.  In the specific case of RDF, it seems to be about wanting to fake QNames where a URI is required.  This (and its reverse, in the case of property elements, that leads to contortions for establishing a namespace so that the necessary QName can be written) seems so inherent to RDF that maybe an RDF-specific, abstracted, but XML-consistent solution would be more appropriate than relying on (XML) preprocessing.  I think that question is already on the table, however.  I'd be surprised to see such a dramatic change to RDF at this point.  The QName-URI mapping game seems pretty bolted in.  -- [;<)
> -- Dennis.
> -----Original Message-----
> From: Frank Manola [mailto:fmanola@acm.org]
> Sent: Friday, October 03, 2003 07:38
> To: dennis.hamilton@acm.org
> Cc: www-rdf-comments@w3.org
> Subject: Re: Internal DTD Examples Invalidate the RDF/XML Documents
> [ ... ]
>>3.	I think that is the disconnect for me. 
>>It is simply very peculiar to have a practice that involves using a Document Type Declaration that establishes a DTD for which there are no XML valid documents.
>>SOMEHOW, THE PRACTICE NEEDS TO BE MADE EXPLICIT.  It is weird to think that someone won't try the technique in the examples (I did), and it is even more startling to have an XML editor complain when fed the OWL RDF Schema. 
> You needn't yell.  I'm certainly willing to make the Primer clearer 
> about what's going on here (that's why I asked if you thought further 
> discussion was needed).  However, as I noted above I don't think this is 
> as peculiar as you think it is, and I think it is something explicitly 
> provided for in XML.  That is, XML explicitly provides for using 
> document type declarations in documents that aren't intended to be 
> validated.
Received on Friday, 3 October 2003 13:44:28 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 22:44:04 UTC