
The Glorious And Infinitely Extensible Semantic Web With Unicorns And Ponies - blasdel
http://diveintomark.org/archives/2009/10/05/distributed-unicorns-and-ponies
======
omouse
So what they want is something like Java Applets or ActiveX? Sounds reasonable
actually. Everything's a fucking hack on the Web already, it can't hurt to
stuff more shit into Web browsers :)

~~~
cpr
No, they just want to add their own custom HTML markup (for proprietary
features) and have others ignore it but leave it alone if they don't
understand it.

------
elblanco
I still have yet to see a decent semantic system (I've seen dozens) that
worked as they were promised to work...and that's with absolutely clean, lab
built data and rules.

It seems that the amount of work required to build the appropriate ontologies
is > the amount of work that goes into building the content...reference Cyc as
an example.

~~~
blasdel
RDF was really fucking terrific: An Entity-Attribute-Value tuplespace where
all three members can (and should, except for tail values) be references,
forming a directed graph.

Unfortunately it was buried under a pile of awful XML syntax, boiling off the
cleverness by making its graph nature incredibly non-obvious. The W3C poisoned
the well by making it synonymous with their magic semweb bullshit parade (fuck
you TimBL, why'd you have to turn into Ted Nelson?).

Then it had the great misfortune of having its first real-world use be in the
epic clusterfuck of Netscape's RSS, to be embraced / extended / extinguished
by Dave Winer. What a shitty way to die...

~~~
elblanco
It's amazing to me to still see the RDF semantic web drum beating even after
its proven itself to be a failure. It's not that the idea is bad, or even that
the syntax lacks sugar, but it fails on three fronts:

1) People have to use it. It is completely possible to build pretty much any
modern service you want, without RDF. The only thing RDF buys you for your
trouble is some vague hand waving about joining the semantic web, for which no
really useful services exist as exemplars of why you'd take the time and
expense of building the RDF meta-data in the first place.

2) It's easier to do it the many wrong ways than it is to do it the couple of
right ways. So I bothered to build a triple that says "the sky/has the
color/blue" and somebody else does "the sky/is/blue" and somebody else does
"the sky/is/sky-blue" and on and on. I've quickly arrived back at the same
problem that the semantic web was supposed to solve, finding information. But
instead of information, now I have an infinite list of qualities of the sky to
deal with.

3) On single documents, the RDF data is generally crud. Other meta-data (e.g.
topics, key words, summaries, entities, etc.) are far more useful than a bunch
of ham-handed XML jamming up the meta-data of my document.

The field itself lies at a certain kind of problem. The claim is "if we have
enough semantically described data, we can do all kinds of great reasoning
things with them". The problem is that there will never be enough semantically
described data. At least not in the direction the field is going. Spending
millions of man years building out triple-store databases just isn't really a
terribly useful endeavor. Particularly when all I want to do is a find a web
page about dancing dogs and dudes getting kicked in the nuts. The field itself
describes all of its problems as "we just need more data". It's like the
uncanny valley hypothesis. "These robots aren't human enough yet because we
just haven't spent enough time making them real". When ultimately nobody cares
if their robot house maid looks like a human, they just want it to take out
the trash.

Even if, by some miracle the world went mad for a year and RDF'd all of its
web output. The result will _still_ be only marginally more useful than the
search systems we have today.

~~~
blasdel
We vehemently agree -- I hate the _Semantic Web_ bullshit just as much as you
do (do re-read my comment).

What I like is using those triple-store databases for organizing the results
of old-fashioned non-semantic crawling. Its graph model fits the problem
perfectly, but unfortunately it's dead forever because of the original
obfuscatory XML format (don't use crappy trees to represent graphs!) and the
W3C's endless shenanigans.

