SUO: RE: Re: W3C approves RDF and OWL as recommendations
> Danny wrote:
> > There is a key point here - it isn't that the lower-level blocks
> > such as the URI naming scheme and the XML language are an optional
> > extra, they are a necessary prerequisite for a WWW ontology language.
Philippe:
> Ok for the URI naming scheme but I have not yet seen any valid argument
> in favor of XML. The idea of re-using existing XML tools is often cited
> but I have not yet seen an example of how classic XML tools (i.e. tools
> processing files based on structural-only information) could be
> pipelined to do knowledge processing work (i.e. re-using one or several
> inter-linked ontologies to do logical/semantic inferences).
> The idea that XML parsers can be re-used does not count: all the
> semantic checking remains to be done and the XML objects often have to
> be converted into other objects for knowledge processing.
> The idea of re-using XSLT for converting a syntax to another does not
> count either: it would only work for simple syntactic transformations
> and not when a large ontology has to be accessed and exploited.
> More elaborate examples are welcome (the W3C site does not give any).
Note that RDF/XML isn't the only syntax for RDF, it's just the one specified
for machine-machine comms. There are others - n3 is good for human use,
NTriples is a kind of canonical view. Both RDF and OWL are expressed as
abstract syntaxes, any number of concrete syntaxes are possible (there's
even another XML 'presentation' syntax for OWL).
But anyhow, it's a fair question, and to some extent one answer would be
"because you can" or even "because everyone else does". That's not entirely
flippant, because XML-based languages are proliferating on the web, and
using something similar (however shallow) to what's already around should
help adoption.
But there are some technical reasons. The strength of each individual point
is open to debate, but taken in combination I think it suggests a good case
for using an XML-based interchange syntax for a knowledge representation
language.
1. Well-formedness
Although as you say semantic checking is a separate issue, the basic
syntax-level checking of XML in parsers is a useful basic check of
integrity.
2. XSLT
XSLT is actually Turing-complete, so plenty more than simple syntactic
transformation is possible. Having said that, those simple transformations
can be extremely useful - there's work ongoing with GRDDL (Gleaning Resource
Descriptions from Dialects of Languages) for systematically extracting
semantic information from XML data such as XHTML documents. (GRDDL's
actually quite elegant, once a stylesheet has been created, it's extremely
easy to use).
3. RDF reuses the XML namespacing mechanism for term disambiguation.
I think you'd probably want to file it under 'anecdotal evidence', but this
kind of thing has probably helped work on OWL-S (for service descriptions),
making it easier to provide grounding to the WSDL language. I suspect XML
also helped as a starting point for extending to places like RuleML.
4. RDF/XML has been designed so that existing XML languages can be simply
modified to have a valid RDF interpretation, for example, say a dairy
product company were using material something like:
<cheeses xmlns="http://cheesy-example.org/ns#";>
<cheese>
<name>Camembert</name>
<texture>runny</texture>
</cheese>
</cheeses>
it's relatively straightforward to turn this into valid RDF/XML syntax:
<cheeses xmlns="http://cheesy-example.org/ns#";
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#";>
<cheese rdf:parseType="Resource">
<name>Camembert</name>
<texture>runny</texture>
</cheese>
</cheeses>
which will be interpreted as the statements:
X is an instance of the class "cheeses"
Y has name "Camembert"
Y has texture "runny"
X has cheese Y
The (domain-specific) definitions of the terms would usually appear
separately in an RDF schema/OWL ontology. Although in many cases it may make
sense to build the RDF based on the conceptual model directly, one advantage
here is that the modified format could be used in existing XML-based
systems. Mileage may vary ;-)
5. XML Schema datatypes
The simple types (integer, date etc) are supported, which although it means
more work in respect of inference, it aids compatibility with existing
domain-specific XML systems, and saves having to define such types
separately.
6. XML Literals
Blocks of XML can be used directly as the object of statements in RDF/XML:
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#";
xmlns:ch="http://cheesy-example.org/ns#";>
<rdf:Description rdf:about="http://example.org/cheese-product1";>
<ch:information rdf:parseType="Literal">
<cheese>
<name>Camembert</name>
<texture>runny</texture>
</cheese>
</ch:information>
</rdf:Description>
</rdf:RDF>
There may be other reasons I've forgotten about, but I think those are the
key ones.
Cheers,
Danny.
[1] http://www.w3.org/2004/01/rdxh/spec
[2] there's an RDF validator here -
http://www.w3.org/RDF/Validator/
it's necessary to check the "RDF is NOT enclosed in <RDF>...</RDF> tags"
box.