Re[2]: "If the Semantic Web were ever going to fail..."

As a bit of further explanation, here is another TimBL quote:-

Most of the applications for the representation of metadata can be handled
by RDF at this level. Examples include card index information (the Dubblin
Core) [...] We are talking about the representation of data here, which is
typically simple: not languages for expressing queries or inference rules.
RDF documents at this level do not have great power, and sometimes it is
less than evident why one should bother to map an application in RDF. The
answer is that we expect this data, while limited and simple within an
application, to be combined, later, with data from other applications into
a Web.
]]] -

Dublin Core is indeed a flat langauge. It requires no XML Schema, only an
RDF Schema to declare its properties (which it hasn't got). RSS is a little
different in that it has a "Schema" in the form of a prose definition.
However, the syntax defined in the spec. is only really a semi-stucture,
and XML Schemas don't really cover it. Maybe Schematron does (I have been
told so), but I'm not sure. What matters is that Dublin Core and RSS have
*nothing* in the way of Schemas, and they can just about cope with that
fact. Anything with a bit more expressive power than that will need a
Schema though, and if we don't even have Schemas for the simple langauges,
what hope do we have for the complicated stuff?
This next quote is great:-

We next need a schema layer to declare the existence of new property. We
need at the same time to say a little more about it. We want to be able to
constrain the way it used. Typically we want to constrain the types of
object it can apply to. These meta-assertions make it possible to do
rudimentary checks on a document. Much as in SGML the "DTD" allows one to
check whether elements have been used in appropriate positions, so in RDF a
schema will allow us to check that, for example, a driver's licence has the
name of a person, and not a model of car, as its "name".
It is not clear to me exactly what primitives have to be introduced, and
whether much useful language can be defined at this level without also
defining the next level. There is currently a RDF Schema working group in
this area. The schema language typically makes simple assertions about
permitted combinations.
]]] - ibid.

I'm not even sure what to make of that: it seems here that RDF Schema is a
method for making simple assertions about "permitted combinations", which
doesn't seem right to me.
Anyway, as I've stated before, this might not be the downfall of the
Semantic Web, only a big snag. As far as I know, we have Dublin Core and
RSS in RDF, and DAML as an ontology langauge etc. The next big langauge is
going to have complicated structures, but no Schema langauge (RDF and XML
Schemas are both in CR at the moment I believe) with which to define it.
RDF Schema have almost been abandoned it seems.

Maybe these are best descibed as "teething problems"...we SW as I see it is
way too underdeveloped for anyone to create anything of great import. I
tremble now when I think of the future of EDL (see ). At the moment no-one really has a clue what
type of Schema we can use to define and validate our data, but at the end
of the day I trust the geniuses in the WAI to hack something up independant
of RDF IG and XML-DEV. If none of us can manage it, we might have to
boycott RDF altogether (I have had a hard time flogging the RDF horse) and
use an XML syntax instead. If I can see no way through this current RDF
stalemate, then I might even recommend that myself, and that would be a
great shame: RDF is meant to be *suited* for applications like EDL, but due
to it's lack of Schema definitions...

Kindest Regards,
Sean B. Palmer [ERT/GL/PF]
"Perhaps, but let's not get bogged down in semantics."
   - Homer J. Simpson, BABF07.

Received on Tuesday, 19 December 2000 18:07:17 UTC