- From: Sergey Melnik <melnik@DB.Stanford.EDU>
- Date: Sun, 21 Nov 1999 14:46:56 -0800
- 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 UTC