W3C home > Mailing lists > Public > www-rdf-interest@w3.org > November 1999

Re: Simpler syntax for RDF / Counter-proposal

From: Sergey Melnik <melnik@DB.Stanford.EDU>
Date: Sun, 21 Nov 1999 14:46:56 -0800
Message-ID: <38387660.3655C98A@db.stanford.edu>
To: Tim Berners-Lee <timbl@w3.org>
CC: www-rdf-interest@w3.org
Tim,

> I used rdf:fyi break out of rdf parsing and insert something in another
> language -- how would you do that?

I think the point here is not to insert something in another language,
but in the same language. Once we have a mechanism to distinguish
between RDF namespaces and the rest (see below), the RDF parser would
ignore irrelevant XML anyway. Note that the efficiency savings by
introducing rdf:fyi are minimal since the XML parser still has to go
through the subtree. I believe, the problem that rdf:fyi addresses is
how to insert RDF-like XML into an XML document transparently for the
RDF processor. For example, if your XML document contains XSL specs that
specify how to transform native XML pieces into RDF/XML, one might want
to shield the translation specification from the RDF processor. In such
case, rdf:fyi could be absolutely necessary. Is that a plausible use
case? Since there are no examples using rdf:fyi on your page [1], I
don't know what exactly you might have had in mind.

> We both had the problem of how to know that other namepsaces (or element by
> element) are RDF-transparent.  Some other spec I read rcently (XSLT?) simply
> listed the prefixes in the documentwhich assumptions coulnd be made about
> 
> <rdf:prefixes   transparent="HTML, SVG"  opaque="logic">
> 
> Element by element couldbe done by using eth URI for the element type in the
> schema (whatever that is).  Or (more messy) it could be an attribute stuck
> on the element...

I have another idea: the namespace handling mechanism used by XML is
reflected in the XML model, i.e. the namespace declaration attributes is
explicitly captured in the XML tree. A namespace-enabled XML processor
may expand namespace shortcuts and toss away the original declarations.
In analogy to that, I would propose operating on a similar level of the
syntax/model distinction: we could capture the properties of namespaces
in RDF. Using the syntax of [2], one could say:

<rdf:RDFNamespace rdf:instance="http://www.w3.org/TR/WD-rdf-schema#"/>

The above states that the resource "http://www.w3.org/TR/WD-rdf-schema#"
is of type RDFNamespace. The advantage of such approach is that we move
away from the (messy) syntax and gain useful evolvability properties of
RDF. Thus, we could say anything we want about the namespaces if needed
in the future.

Since the RDF parser has the built-in knowledge about the "rdf:"
namespace, we have a natural bootstrapping mechanism. Furthermore, all
properties, classes etc. generated by the RDF parser must have
originated from "RDFNamespace"s, i.e. this information need not be
explicitly stored in the resulting RDF model. However, the serializer
would have to insert statements like the above in the RDF output. What
do you think?

> However, in teh end the semantic web needs, for sanity,
> a langauge powerful enough to unite all of them , including turing complete
> langauges.

That's again a philosophical issue, but let me tell you my opinion to
this. The ground level of the Semantic Web are facts (RDF statements).
On top of facts we build rules that process facts, rules that manipulate
rules etc. ad infinitum. Thus, you are absolutely right in that we need
the "final instance" has gives the machine a built-in understanding of
the highest-level languages. The language in that today's computers
"think" and exchange their knowledge is Java bytecode. Speaking frankly,
for me it is questionable whether predicate logic could establish itself
as the next-below-the-highest language. I just don't see enough
incentives for using PL since it is just slightly better processable by
the machines than an imperative Java program, but introduces significant
entry barriers for non-PL-savvy people. In my work [3], I compose
"programs" using sets of declarative languages built on top of RDF. The
"machine understanding" of this languages is achieved by means of
interpreters that can be downloaded as mobile code and plugged together.
Thus, I can build language hierarchies that are always terminated by
bytecode without the intermediate step of PL.

Sergey

[1] http://www.w3.org/DesignIssues/Syntax
[2] http://www-db.stanford.edu/~melnik/rdf/syntax.html
[3] http://www-diglib.stanford.edu/diglib/ginf/
Received on Sunday, 21 November 1999 17:42:04 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:51:42 GMT