Slashdot Mirror

I totally agree with Peter Norvig.

There has been a lot of enthusiasts but also a bunch of stumbling amateurs in AI all around the Semantic Web project, and this has not been a good thing.

They are reinventing the wheel. RDF is nothing more than knowledge representation 101.
Don't forget that Russell & Norvig's book devotes 5 out of its 26 chapters on KR.

And now with the DAML language they are reinventing Prolog interpreters.

From their Website - Why use DAML?
http://www.daml.org/2002/04/why.html

(motherOf subProperty parentOf)
(Mary motherOf Bill)

when stated in DAML, allows you to conclude

(Mary parentOf Bill)

Check this from an introductory course in Prolog
http://www.cs.wisc.edu/~noto/cs540/lecture/14-prol og.html

fatherOf(keith, duane).
motherOf(keith, diana).
adoptedBy(webster, mrPapadapolis).
parentOf(X, Y) :- adoptedBy(X, Y).
parentOf(X, Y) :- fatherOf(X, Y).
parentOf(X, Y) :- motherOf(X, Y).

Given a query, parentOf(keith, X)., Prolog will:

?- parentOf(keith, X).

X = duane ;

X = diana ;

LOL ;-)

I see, maybe two real innovations : URI (Uniform Resource Identifier) and Digital Signatures and Web of Trusts.

This is why groups come up with schemas and ontologies to share.

...check out various tools on SemWebCentral.

For example, you can browse the GForge project listing using OWL - more precisely, using an HTMLized version of the ObjectViewer.

> Information is more like a web of relationships.

Yup. You might be interested in the Ontologic Web Language - you can see, for example, an OWL representation of the projects on SemWebCentral.

....that is, the Ontological Web Language, you might be interested in SemWebCentral, a new project hosting site for Semantic Web projects that just opened up.

Many of the tools from the DAML project have already moved over to SemWebCentral; it's definitely worth a look.

> The military is funding the semantic
> web technologies

Quite right. Speaking of which, here's a new project site for semantic web projects that just came online about a week ago.

Nothing much there yet, but stuff from the DAML site will start migrating that way soon...

The other very important problem of LDAP is that it's for hierarchies/ However, the real world information in the best case of scenaria is DAG.

Besides, LDAP is way too slow and its query language is way too primitive.

I believe that another database paradigm should be used to roam user's personal information. And I am more convienced that RDF is a solution when non-tree info doesn't go to "raw" XML, neither to LDAP.

I agree that Jabber is a good idea to start. What's good in Jabber? SOAP. That's it. Well, today XML is a key. As I mentioned, PIM requires not a "raw" XML - but rather its RDF dialect. Perhaps some RDF database with RDF-oriented query language and web/SOAP interfaces will serve well if user profile info is defined well in RDF ontologies.

Here are some links I found about RDF:

• rdfDB : An RDF Database
• Redland RDF Database Demo
• Redfoot is an extensible RDF server written in Python for building a Semantic Web of P2P nodes.
• RDF SQL HOWTO, a part of installing a W3C-Perllib Annotation server
• RDF Query Languages: A state-of-the-art
• RDF Query and Inference, a part of 4Suite Server
• RDF Query Specification (old)
• DAML: The DARPA Agent Markup Language (very related to RDF and Ontologies)
• you can also find lots of links to RDF wrapping of calendars, bookmarks and addressbooks.

Do you expect widespread usage of RDF/DAML/OWL/TopicMaps for explicit meta-data annotation of web resources, or will it be used only in small circles of specialized content providers like academia, or maybe not at all?

How will Google react? Do you plan to use meta-data provided by web resources if found, and how will you decide if it isn't just made up to get people on some bogus pr0n site (like with those <meta>-Tags today)? Will it someday render the brute-force approach of full-text-indexing obsolete?

Tired from semantical hard-coding? Try RDF-schema and ontologies.

• Here are some links for further education:
• RGML (RDF Graph Modeling Language)
• (RDF) Model and Syntax Specification
• The DARPA Agent Markup Language

< shameless plug>
There's an idea called the semantic web, that in theory will fix this. The idea is to make pages machine readable so that John Lewis the department store doesn't look the same as John Lewis the person. In theory using the language daml you could search for all John Lewises that are people, and live in whatever place. Or any other useful identifying info like that.
&lt/shameless plug&gt

Marking up pages with information about the meaning of the terms on them is the main thrust of the work on semantic web - see http://www.daml.org/ (for DAML - the DARPA Agent Markup Language), http://www.semanticweb.org/ (One of the main information sources) and finally the new W3C activity on the subject: http://www.w3.org/2001/sw/.

How far, how fast it will go is another matter but there's certainly a lot of interest in creating a more "machine readable" web.

XML Schema tries hard to provide a strong notion of type

Although that's a valid point (and I haven't written DTDs in over 2 years, in favour of schema) it's not the issue I was talking about. Look at the Infoset draft or the recent Processing Model workshop. You can barely tell the difference between reading infoset and the syntax spec, because XML just doesn't put enough distance between semantics of the content and its representation in a document.

XML doesn't "represent" anything. It never has done, it never will, and all attempts to pretend that it does will end in failure. XML (and XML Schema) is a low-level transport and manipulation platform, but it doesn't have the ability to do any form of abstract representation. Its structure and implied semantic meaning are so closely fastened together that it's impossible to squeeze a gap between them. "Representation" is the act of stretching this gap, between structure and implied meaning, so as to infer a higher level meaning.

The problem is fundamental to XML, and won't be fixed by tools at this level. There's no abstraction in XML; any attempt to indicate semantics also drags along its structural baggage, because that's the only way XML-Schema allows you to work. No number of "sideways" solutions to this; namespacing to allow parallel co-existence, BizTalk to allow sharing of schemas, will fix this - XML just doesn't offer any "upwards" in a semantic direction.

To separate two authors with the same name you need more information to make a key.

Again, I agree with you in general, but that's not quite the issue I was thinking of. Clearly we need more structure to distinguish them, although in fact we don;t need any more information (RDF can do this entirely within the document structure, with no need to start "allocating author indexes" or similar).

The symptom of this problem, in the XML world, though is an over-dependence on flat text comparisons. It's like search engines that only compare at the text level and can't tell "goat sex" from animal husbandry or a Slashdot Troll. Because XML has nothing useful beyond the text node, that's what gets used. If it's easy to do it all just by comparing author names, then that's what lazy coders do. Disambiguation between resources like this needs a simple and lightweight mechanism, because if it isn't, no-one will use it. RDF manages it with rdf:resource and rdf:about attributes. In XML then you'd have to build some identifying system at the application level (so a generic parser can't understand it) and impose its use on your data. No wonder people stick with just using the names and ignoring truly identifying relationships with resources.

ID & IDREF are just broken. If you want to do it that way, build a proper architecture for doing it and join the RDF WG.

...the 300 page monster that is XML Schema.

Tell me about it 8-(

Compare the XML Schema spec, the SMIL spec, and the even more gargantuan MPEG-7 spec. Now take a look at DAML and see that complexity can be described, without needing a spec like a phone book.

• DTDs suck.
• XML Schema doesn't suck.

As to why DTDs are suck-worthy, then:

• They're expressed in their own syntax, which no-one understands.
  XML Schema is expressed in XML.
• Because XML Schema is in XML, it's machine-processable by a whole bunch of simple tools. It's trivial to write a database data-model -> XML Schema export tool.
• DTDs are poor on complex structures.
• DTDs don't do data-typing
• DTDs are very poor when complexity meets data typing. XML Schema can support structured types in a manner that's akin to a struct.

XML Schema is quite a good TR for datatyping within XML, but it's still very limited at expressing large-scale structure (this is an XML limitation, not an XML Schema one) and does nothing for semantics or ontologies.

We still need RDF, and RDF still needs schema expression languages that are smarter than XML Schema. Current practice seems to be that RDF Schema is dead, DAML is the way forward and DAML gets its low-level data-typing from from XML Schema. Incidentally, this is a very good example of why XML Schemas structured types are dead handy, and usefully different from the normal XML structure expression. There's a couple of interesting papers by Jane Hunter and Carl Lagoze on XML, RDF and various schemas that describe some of the issues involved in different schema requirements, different expression languages, and how to compare them.

Microsoft have done what they usually do with XML: Build an excellent implementation before the W3C got there, get flamed to hell by the Slashdot weenies, then bring it quickly back into line once there's a standard worth using. We all like to beat on Bill, but for a few things (and XML is a big one) Microsoft deserve a lot of credit for some really good work.

We don't need standards for defining the information (that's EDI, or even XML), what we need instead are standards for how the information will be defined. It's much more useful (in a broad sense) to have a language for expressing semantics and ontologies than it is to have a published standard for "invoices" and "patient records".

Take a look at DAML for more.

doomed to failure until someone implements something like the Dewey Decimal System for web pages

Yes, we're stuffed -- but Dewey Decimal isn't the answer (we can do a lot better than that).

There's an initiative around that's gaining considerable momentum - the Semantic Web. It starts from one bright idea by one guy, but as the guy in question is Tim B-L, then he gets listened to. There are solutions to all this. We've barely started on what we could easily achieve for indexing the web, without even trying for the really hard stuff.

Once basic semantic level indexing becoms commonplace, through tools like Dublin Core, then take a look at ontological descriptions and projects like DAML.

There's a huge amount happening in this field research-wise, it just hasn't hit the punter's web yet.

Don't forget the WEB in semantic web. In my vision (and I've written about it in several places including here. ) users create their own term libraries (or, more precisely, ontologies) either from scratch or by extending existing ones. These can be networked together by including terms from other ontologies via explicit URI use, can include declaring equivalences between terms (i.e. xxx:foo :equiv yyy:bar), including ontologies in others, and similar such linking. This creates a wide, complex, ugly graph of inconsistent knowledge -- hey, that's what we have on the regular web!!

This can really work -- we've been playing with ontologies on the web for a while now, and if RDF terms get anchored in ontologies, and these get linked together, a powerful web of semantics can evolve.

Don't believe it can happen? DARPA (remember the ARPAnet? That was us) is supporting an effort, in close cooperation with the European Union Semantic Web effort, to bring this to fruition. To learn more about this effort, or to be able to try it yourself, check out the DARPA Agent Markup Language

Jim Hendler
Chief Scientist, Information Systems Office
DARPA
jhendler@darpa.mil

I see your point, but semantics are never enforceable anyway.

Who cares ? If you're publishing the latest fat stock prices, then it's in the user's interests to get it right. Semantic publishing needs a reliable means of making them available to those who want them, it doesn't need to follow them up and enforce getting it right.

you haven't told me how RDF gets around this

Take a look at RDF Schema.

Of course, semantics aren't enough on their own. It's not too useful to know where the "creator" value is in two schemas, if you can't distinguish between one's "author" and the other's "translator". This is where an ontological understanding is needed, and there's a couple of projects out there working on that too; DAML & OIL.