Slashdot Mirror

The difference is in the underlying data-model. SPARQL queries RDF, which has URIs identifying each column, so you cannot have just "name", you need to have http://xmlns.com/foaf/0.1/name (abbreviated to foaf:name, with a proper prefix defn.)
Also, since RDF is a graph you are not just querying for DB rows, you are querying for paths through the graph, letting you query for things like "the mother of the sister of the creator of the movies with over 9 rating on IMDB" without using a JOIN syntax. (Of course, there is a join there, if thinking in RDBMS terms makes you happy, think of RDF as a large table of rows (i.e. triples) with three columns: (subject, predicate, object))

It should be obvious that SPARQL is NOT trying to invent a new syntax, in fact - the syntax is as close to SQL as possible, only changing the bits that need changing to fit with RDF.

Good lord, you actually have content there. Sweet Zombie Jesus, it's like if MySpace was irradiated with XML-Rays and mutated into a complete XML-based social network specification, which requires everyone to write their own specifications and hand-edit XML files.

That's just ... scary.

"But the big problem is they believed everyone would work together:

• would agree on web standards (hah!)
• would adopt a common vocabulary (you don't say)
• would reliably expose their APIs so anyone could use them (as if)"

One of the features of the W3C's model (based on RDF) is that it doesn't push the idea that everyone should adopt the same vocabulary (or ontology) for a topic or domain. Instead it offers a way to publish vocabularies with some semantics, including how terms in one vocabulary relate to terms in another. In addition, the framework makes it trivial to publish data in which you mix vocabularies, making statements about a person, for example, using terms drawn from FOAF, Dublin Core and others.

The RDF approach was designed with interoperability and extensibility in mind, unlike many other approaches. RDF is showing increasing adoption, showing up in products by Oracle, Adobe and Microsoft, for example.

If this approach doesn't continue to flourish and help realize the envisioned "web of data", and it might not after all, it will have left some key concepts, tested and explored, on the table for the next push. IMHO, the 'semantic web' vision -- a web of data for machines and their users -- is inevitable.

While looking through the help to see whether Microsoft can spell RDF[1] or FOAF[2] (they don't appear to), I came across this[3]:

    "Why do I need to use Passport?"
    "We chose Passport in order to help you consolidate the number of logins you have to manage."

*sigh* here was me thinking passport was dead.

[1] http://www.w3.org/RDF/
[2] http://xmlns.com/foaf/0.1/
[3] http://aggreg8.net/Aggreg8_Help_Pages.htm#registra tion_passport

The representation isn't the problem. The problem is agreeing what the the relationships mean.

That problem is not the problem that RDF addresses. It just gives you the tools so that you can concentrate on solving that problem instead of worrying about all the crap underneath. It's like XML doesn't address semantics, it just gives you tools so you can focus on semantics without worrying about parsing.

What does "#friend" mean? Does it mean the same thing to program X as it does to program Y? How can you tell?

You read the specification for the vocabulary you are working with. For example, here's the FOAF specification.

To use the XML analogy again, the XML specification doesn't tell you what particular element types mean, because that's outside XML's scope. You read the specification for the XML document type, e.g. XHTML, to find out what an element type means.

who gets to decide what #friend means, and whether this is a global or local definition?

You're forgetting that #friend is just shorthand for a URI. It's not a literal string "friend". If Slashdot choose to expose their friend data with URIs like http://slashdot.org/rdf/#friend that doesn't have any bearing on the meaning of Friendster's data if they use URIs like http://friendster.com/rdf/#friend. They are two separate URIs with two separate meanings that the owners of the domain have chosen.

I know, the next thing you are wondering is how this is of value if everybody makes up their own URIs. Well the answer is, if they want interoperability, they don't just make up their own URIs. Just like people using XML get together, agree on concrete definitions and write specifications like XHTML, the same things happen with RDF vocabularies, people get together and decide what they think #friend should mean, write a specification like FOAF, and use the same URIs.

These are questions that I've never heard answered in any believable manner.

Ignore all the hype from PHBs, this isn't about computers magically understanding arbitrary documents. This is about expressing relationships in a standard way. Of course you need some way of agreeing on what relationships mean, which is why people write specifications. RDF doesn't solve that problem, it's outside RDF's scope. RDF is much smaller and more focused than you think, it's not magic.

I don't get the link to FOAF. All the companies mentioned are jealously keeping people locked in, FOAF is an open standard and lets people network across pretty much anything. FOAF is the antithesis of the social networking sites linked.

If you want to learn more about semantic webs and Friend Of A Friend systems (and Enemy Of An Enemy too, no doubt), then starting points would be FOAF Vocabulary Specification and RDF Interest Group You don't always need a central database for this, but it helps.

I just set up a wiki on trust metrics evaluation.

The goal of this project is to review, understand, code and compare on same data all the trust metrics proposed so far.

I'm a PhD student and this is my phd research proposal (Trust-aware Decentralized Recommender Systems) and it is very related to all this concerns (trust, reputation, decentralization, blogs, recommender system, ...)

Personally I think the more promising path to follow is FOAF (Friend Of A Friend) format (see the project blog). There are also 2 extensions (1) (2) to incorporate trust into FOAF files.
By the way, here is my foaf file. You can add me to your "knows" list if you like.

Ok, so now you can check the wiki on trust metrics evaluation and add anything you think should be there and there isn't.
Please, note that I have just opened the wiki and I still have some problem with the installation (there are 2 conflicting python installations and I'm not root of the machine) but the basic functionalities are working. Hope to continue the discussion on the wiki! Paolo

Take an army of the recently-described feral hunting robots . To each robot, add a GPS chip and wireless mesh networking .

Give the people and dogs smart name tags , and have your dogs exchange your "business card" with the other smart name tags. Publish the FOAF url in it, so you can immediately check for compatibility and give the new information to the dogs.

Study the discovered FOAF files , each describing individual traits ("attributes").

Instruct the feral robots to find other people with compatible personalities , but to stay near you. They'll roam around, seeking people whose interests relate to yours.

For bonus points, add solar panels to generate power as it roams around, and electronic boundaries to keep it in safe areas, away from motor traffic.