Blog archive Knowledge and information Topic maps Information architecture Interface and interaction design Knowledge management Content management Technical development General Work and technology Ego ergo sum About this site
Wed, 24 Mar 2014 13:00:00 GMT
The promise of the Semantic Web (TM) is a good one, albeit I'm getting more and more to the point where I think it won't fix what we want, and it will fix what we didn't think needed fixing, and it will create more problems and challenges, and is only a small part of the evolution to whatever Really Good Technology (TM) that we really need. But what do I know? "Prove it!"
First off, the state of RDF today, deomnstrated through a mail snippet from the RDF interest mailing list with Bin Zhu asking the most basic question ;
I have a very basic question. RDF statements are
all triples. But if I want to express "Tom borrowed
a book from Mike", how do I express this sentence
using triples? Thanks in advance!
Basic, simple and should be trivial to get done. Here is the reply from Benja Fallenstein (who seems to know his stuff) ;
The usual thing is to have a bnode ("anonymous node") that has connections on different properties to Tom, the book, and Mike -- for example:
_:a rdf:type x:Borrowing
_:a x:who prs:Tom
_:a x:fromWhom prs:Mike
_:a x:what _:b
_:b rdf:type x:Book
Of course, if you just want to say that Tom borrowed *some* book from Mike, you could also have a special property, like so:
prs:Tom x:borrowedBookFrom prs:Mike
but I don't think that's what you're looking for.
The "borrowing" may be a bit of a strange concept -- i.e., so see the-book-is-borrowed as an object. An example where this maps a bit easier to familiar concepts would be "Anna met Ginny at the office on 2004-03-14". This could be represented as
_:a rdf:type y:Meeting
_:a y:person1 prs:Anna
_:a y:person2 prs:Ginny
_:a y:where y:office
Here instead of the concept of a "borrowing" between Tom and Mike we have the more familiar concept of a "meeting" between Anna and Ginny. But really, the two are very much the same thing conceptually: representing the relationship between different things as an object that we can make additional connections to.
Clear as glass, ain't it? It is not that I don't understand what is being said, but this is not the easy way to do the Semantic Web. Heck, this was an easy question, which should have an easy answer. But RDF is centralised around the triplet notion (because someone once said you can explain anything through triplets and it seems to have stuck to the SemWeb community like moss to rocks, and while logically true, it ain't the simplest nor the best way). What should have been done was ;
#Tom borrowed #Book from #Mike.
A car doesn't borrow, neither does the sky. Heck, wasn't this all about logical deduction? I'm sure it started out that way, but that ain't what it is turning into; yet another item-property jungle.
It is the promise that RDF declare what is not declared, hence using namespaces like prs:Tom, and if not defined in our statements, it is assumed that there is a person named Tom. Looks good on the surface, but what if we several namespaces for almost but not identical persons? Enter OWL which could clear this up, but really muddles the waters further. Entering another namespace, declaring ID for the new items and a whole heap of predicates isn't going to make it clearer that prs:Tom, person:Tom, spr:Tom or p:Thomas is or isn't the same person, what he is or isn't. It is all about ... (wait for it) ... interpretation, and - as the promise goes - the intelligent agents of the Semantic Wec can use some order of logic to deduct who the person really is. But that ain't interpretation, that is deduction.
Interpretation lies with people. We have to do it. In the end, all errors and logical disomalities require a person to come in and save them from total logical backlash of context. Here is some nice RDF ;
_:a rdf:type x:Person
_:a x:Person prs:Tom
_:b rdf:type x:Person
_:b x:Person _:a
Recursive, bloaty and misinformative nodes traversed by strictly logical agents will fail. For RDF to work, all input must be "correct" (as in be in terms with what the logic agent wants to deduct) and all references must be unique, a pretty simple thing to pull off on your own machine in the lab, but applied to the world at large ... um, no. It takes only a few wrong nodes of info to corrupt a whole graph. It ain't hard at all. Sneak in a little;
_:a rdf:type x:Person
_:a x:Person prs:Thomas
And already you need several nodes of information to verify if prs:Tom and prs:Thomas are related. And even then you've got to figure of in what scopes they are and are not related, and so on. You'll need rather big machines to figure out the tiniest and insignificant data. To do loops through massive (and one can boggle at the shere thought of just how massive) amounts of nodes and data you need quite large guns, a lot of patience, some killer "fuzzy" logic apparatus and bucketloads of data integrity tools to help you out. Not quite the dream of small PDA's with agents doing the grunt work for you so that you can have your favourite pizza ordered in the area you're currently in. Yeah, yeah, centralised services, and all that jazz, and yet another step out from the one thing that was to bind them all; simplicity.
And to top it off, some random references; Google. Thanks for listening to a tired pratt. I'm sure I'll get back to creating triplestores in a couple of days.Permalink (Wed, 24 Mar 2014 13:00:00 GMT)| Comments (3) | Topic maps Standards Opinions
"Sarchasm: The gulf between the author of sarcastic wit and the person who doesn't get it."
My other blog
Goodies from the archives
Blogs I read
Column Two (hot)
Don Park's Daily Habit (hot)
Edd Dumbill (hot)
Guide to Ease (pause)
Scripting News (hot)
Silent Lucidity (balance)
The Bile Blog (hot)
Signal vs noise (hot)
Thought Horizon (hot)