Semantic Web Is Stupid

Yes, I'm riding for a fall here. I expect someone will stick that ol' branch in my spokes and I'll be spitting teeth faster than you can say

 <?xml version="1.0"?>
 <rdf:RDF
 xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 xmlns:stupid="http://www.c2.com/cgi/wiki?SemanticWebIsStupid#">
 <rdf:Description
  rdf:about="http://www.c2.com/cgi/wiki?SemanticWebIsStupid#">
  <stupid:firstname>Jack</stupid:firstname>
  <stupid:secondname>Robinson</stupid:secondname>
 </rdf:Description>
 </rdf:RDF>

Um ... so you see I think English is semantic markup. I think a thesaurus makes a great folksonomy already. I think all that xmlns crap is about as useful for making a successful query as crutches are useful for making fish walk. In other words, I think this whole super-meta-hypertagged <bs/> is rid.iculo.us.

Like I say, I'm riding for a fall. But really, after all this time, I'm sorry, I just don't frickin' get it. Straighten me, someone, 'cause I'm ready. -- Pete

RDF is easier for machines to parse, and it can be made non-ambiguous. Those are the only two things that I know of that really differentiate it from English. -- MichaelSparks

What convinces you it can be made non-ambiguous?

I'm no expert on these things, but from what I can tell, English has two types of ambiguity: words can have multiple meanings, and the grammar is itself ambiguous (in the sense of formal grammars). With RDF, you can control the entire vocabulary, eliminating the first type of ambiguity. And RDF doesn't really have a grammar in the same sense as English, so that precludes it having the second type of ambiguity. Note that I don't claim that this prevents you from making ambiguous statements in RDF; only that the representation of the statements doesn't itself necessarily lead to ambiguity. -- MichaelSparks

As I said, I don't frickin' get it. With regard to the first type of ambiguity, I see that you can control your vocabulary. I see that the words in your vocabulary are human language words, and therefore ambiguous. I see you catching water in a net and squeezing jelly between your fingers.

Now, without grammar, I see more ambiguity, not less. Michael Refute Peter. Peter Refute Michael. Oh, they're the same thing? How about If Michael refutes Peter, Peter will stop trying to refute Michael?

This may seem like abstract KR stuff, but really there are a whole bunch of magillas trying to make over the WikiPedia category system, which works fine, into this kind of ambiguous nonsense, which does not, on the grounds that then they can make lists of pages that mention, say [[Location:Venezuela]]. Including, of course, pages that say things about [[Location:Venezuela]] that are about as relevant to [[Location:Venezuela]] as this paragraph I'm writing right here. [Got a link for this making-over?]

You can fool MarkvShaney like that of course ...

How about getting DeMorgansLaws into RDF ... and if you can do that, then what about the ExcludedMiddle? Dare I mention the FrameProblem? Hmm. If I can express these kinds of things in English, but not in RDF, then RDF is (a) ambiguous and (b) not semantic markup.

While I'm in mid rant, I suggest that any language which does not, at a minimum, ground its terms in some specific empiricism, can not be semantic. And any language whose atoms are URLs can't do that to begin with. -- Pete

I think we may be using the word 'ambiguous' in two different ways. My understanding is that there are two different thoughts that when encoded in a language, have the same encoding, and therefore a reader, when encountering that encoded form, doesn't know which thought it represents. If I'm reading right, you seem to use it to mean that there is one thought that can be encoded more than one way.

You said at one point that "words in [an RDF] vocabulary are human language words", but later you said "language whose atoms are URLs". I think you've answered your own question here. The vocabulary is made of these URLs, not English words. An RDF atom that is named after an English word doesn't inherit meaning from it any more than a C++ class would. In both cases, the meaning of the thing is entirely determined by the formal workings of the language, and the use of an English word is coincidental.

I would love to see DeMorgansLaws and ExcludedMiddle worked into the RDF world. But I think it would happen at the browser or query engine level and not necessarily at the language level. Consider the way RDF is supposed to fit in with the existing Internet. The idea is that various web sites will publish RDF about the things they know about. If there are two sites each publishing some RDF about related things, it might be good to somehow put their knowledge together and draw inferences from the combined pool of knowledge. Which of the two sites should do that work? It doesn't really fit at either of them, and it doesn't fit what they signed up to do, which is passively publish descriptions. So the inference rules have to run somewhere else, like the browser or query engine. Browsing and querying don't generate new knowledge; they only process existing knowledge. So there wouldn't be much need for the language to encode their thought process, if the purpose of the language is to describe knowledge. And with the FrameProblem, RDF itself doesn't need to encode invalidation if it can't encode inference.

-- MichaelSparks

There is nothing semantic about RDF (ResourceDescriptionFramework). All RDF provides is a (cumbersome) way to attach named relations to named entities, where "entity" is that typical meaningless, all-encompassing word you always encounter in conjunction with everything SemanticWeb. If you want clean semantics, they need to be defined, i.e., you need a specific RDF vocabulary, defined using an RdfSchema. If you have that (there are some for specialized purposes, such as DublinCore), you can run queries. See SemanticWebLayerCake for more information.

You can completely forget about De Morgan's laws. RDF does not have logical connectives, no "or", no "and", not even "not". If you want logics, you need to go one step further and you get OWL (WebOntologyLanguage). Again, OWL is nothing more than a (cumbersome) way to express logical formulas. You still need a controlled vocabulary, but with OWL you can define the semantics of your vocabulary by giving suitable axioms. Such an axiomatized vocabulary would be called an ontology, and given a good inference engine you could run queries against it that obey common sense. Alas, neither good inference engines nor usable ontologies exist at the moment.

You still don't "get" it? That's because there is nothing to "get" here. The emperor doesn't wear any clothes.

Well then, Pete, I guess you'll love this. http://downlode.org/Wiki/Scripts/wikiRDF?page=SemanticWebIsStupid -- EarleMartin

Um, yeah. Notice how anyone searching their RSS for disreputable idiocies written by Pete on C2 is SOL? RSS should be based on Google searching, not drop-your-brain-through-the-slot scripts. PutNotThyTrustInProgrammers.

RSS != RDF. Learn the terms before proffering criticism. In fact, the sentence "RSS should be based on Google searching" doesn't make any sense at all, even if you substitute "RDF" for "RSS", or even "SemanticWeb". By the way, PatchesWelcome.

I'm inclined to agree with the title of this page, though for slightly different reasons. If we regard the SemanticWeb as a distributed database, then the following holds true:

XML is an adequate data exchange representation, but a poor storage format for a dynamic database, especially if the database is relatively large and/or subject to frequent updates.
In many respects, XML (as a database representation) resurrects all the problems of navigation-oriented heirarchical and network databases that were addressed over three decades ago with the introduction of the RelationalModel.

But ... RDF is relational ... isn't it?

I think this view originates in a rather unclear article by TimBernersLee at http://www.w3.org/DesignIssues/RDB-RDF.html. The presence of relations should not be inferred to mean an implementation of the RelationalModel. RDF tuples may perhaps be used as the basis for an implementation of the RelationalModel, but that neither means it is inherently an implementation of the RelationalModel nor that it is a suitable basis for an implementation of the RelationalModel. An indirect commentary on this can be found at http://www.dbdebunk.com/page/page/1114998.htm

I believe many of the goals of the SemanticWeb could be better accomplished via Internet-wide deployment of publicly-accessible RelationalDatabase management systems or nodes, each employing the following:

A standardized meta-data schema format, to allow the meta-data hosted by a node to be queried in a standard fashion.
A standardized database browsing interface, obtained via an URL -- e.g. db://mysite.com or http://mysite.com/db
A standardized RelationalLanguage, to allow the content hosted by a node to be queried in a standard fashion. Preferrably not SQL (see SqlFlaws) but I'll use a SQL-like syntax for examples on this page, as it is familiar.
Support for cross-node joins. E.g., something like SELECT * FROM db://mysite.com/myTable, db://yoursite.com/yourTable WHERE myTable.column1 = yourTable.columnA
Facilities to express relationship constraints across nodes. E.g., something like CREATE RELATIONSHIP myRelationship ON db://mysite.com/myTable(column1) TO db://yoursite.com/yourTable(columnA) ON UPDATE CASCADE ON DELETE RESTRICT

Dude! Brilliant! Still stupid in my sense, but a lot less stupid in your sense than what's done now ...

The benefits of this approach over current RDF efforts should be self-evident, and includes leveraging the composability of RelationalAlgebra via the query language, plus a standard means of updating (e.g., INSERT, UPDATE, DELETE) content subject to security constraints. Of course, this approach does not preclude storing XML documents as column values, should that be deemed appropriate.

There was once this thing called XDB that tried to do something like this ... not certain what became of it ... -- Pete

I believe you're referring to an XML database component of the Oracle DBMS since version 9i or thereabouts. I'm not aware that it supports distributed database functionality as I've described above, however.

-- DaveVoorhis

Maybe it's a solution looking for a problem. GoldPlating.

CategorySemanticWeb