RDF in Drupal 7 code sprint

RDF is a W3C standard to add semantics to the data of your site and enable interoperability on the Web. Think of it as RSS on steroids. Watch this great video Intro to the Semantic Web

It looks like if you have to ask, you don't belong. Continuing with the strong drupal tradition of writing new code without backward compatibility, we can now release Drupal 7 years ahead of documentation for Drupal 6. In fact, you can forget about 6 documentation entirely - read the code, that should be enough.

If it's worth anything to you, Dries has given a presentation about RDF and explained his reasoning why he supports it. Tim Berners Lee supports it. Here's what he said:

I have a dream for the Web [in which computers] become capable of analyzing all the data on the Web – the content, links, and transactions between people and computers. A ‘Semantic Web’, which should make this possible, has yet to emerge, but when it does, the day-to-day mechanisms of trade, bureaucracy and our daily lives will be handled by machines talking to machines. The ‘intelligent agents’ people have touted for ages will finally materialize.

I totally understand this reaction. As technologies go, RDF is dry as dust. It's one step removed from all the cool stuff that it enables, so people don't get excited about it.

As someone who is trying to marry science and semantics -- that is, change current scientific methods so that automated processes can _understand_ them, in a computational sense at least -- I am wildly enthusiastic about this work. I am convinced it will be the most important contribution of Drupal to its users, the users of Drupal sites, and to information technology in general, in this decade at least.

Many of the other links provide the additional information that you are asking for, and I probably can't improve upon them in a post. But I will give a use case from our community (since I wasn't sure where to leave my use case anyway). Those of you who like text more than video may find it helpful. This use case relates the more semantic-oriented technologies of this change to the practical Drupal web site technologies.

Right now we[1] collect references to other documents on the web about science data management. We are starting to categorize and rate them, using custom fields we created for each kind of reference. Anyone who wants to find and use these ratings has to go to the Drupal site, look up each page, and grab that data. The ratings themselves are terms that come from vocabularies we maintain on another 'vocabulary repository' system [2]. We will probably add the ratings data to a custom-built table, but that will cost development time and still require people navigate to the table and view it, or copy/paste it, to use it for their own purposes. They can only use what we can provide by developing custom software. They can't automate it because if we change our format, or the name we used for the title of a category, their automated scraping of our page will break. They can't tell what the rating words mean unless we also specifically add taxonomies to Drupal that match our rating taxonomies on our own vocabulary system (or build additional tools to do that automatically, which we might have to do). They can't relate the ratings on our site easily to the ratings on another site, or know that our John Doe that rated this Content Standard is the same John Doe that rated it differently on another site.

In the brave new world of RDF in Drupal, here's how I hope it will work:

1. We create the page for rating, say, Content Standards. Our page will define for every category (Drupal field): a title; the vocabulary (from our vocabulary repository, but ideally this information is automatically aligned with Drupal taxonomies, ahem :-)) to use in filling out the field; and the RDF-encoded concept that corresponds to the title. In practice, this last means that we use terms from a vocabulary of concepts, like 'overall rating' and 'version reviewed' that we and Google and everyone else understand. Creating this page was easy and straightforward because it's all integrated in Drupal core.
2. Members of our team make a page by filling out every field of information for a given Content Standard. They are prompted for the allowed terms to fill out each field. If they don't know what the field title means, they click on a help link that references the corresponding RDF-encoded concept ("version reviewed: the version string assigned by the information provider to the particular release of the information", and possibly much more). Note: Much of this is possible with Drupal taxonomies today, if you use them, but they are embedded inside your Drupal server, not widely accessible and exchangeable.
3. In each presented Content Standard page, Drupal automagically provides the RDF metadata associated with that information.
4. Anyone who wants to write an application that makes use of our data -- say, tracks the change in overall rating against the different versions reviewed -- can use the RDF information embedded in our web page to do so. Even if we change the format of the web page, and the title of the fields that the user sees, their application will still work. *And*, it will be able to explain to the user exactly what all these ratings mean that we're using, because we have defined those terms, and Drupal and the application understand how to use RDF to find the definitions. (Note to semantic web folks: Glossing over some URI dereferencing issues there.)
5. Someone who isn't on our development team may not be inspired to write an application that lets a scientist find the perfect content standard for their needs, by using our ratings and information to automatically select content standards based on the scientist's input. This multiplies the value of our work, potentially a lot, without requiring any additional labor or agreement on our part. (Because the interface to the data is exposed automatically through RDF.)
6. All the big players (Google, Yahoo, countless semantic tool developers) that write applications that crawl the web looking for information they understand ("look! there's an 'overall rating' for a 'web resource' that goes by the 'resource name' of -FGDC Content Standard- and it has an 'update date' that's less then a month old!) will now understand much, much more about what's on our web site, and can represent that information in their own contexts.
7. If we ever decide to add a concept to one of our vocabularies -- say we add 'paradigm-changing' to our overall ratings vocabulary -- this 5-minute change automatically ripples through ALL these applications. Everyone can use it on our Drupal site to rate a Content Standard, every application will understand it is a term in the 'overall rating' scheme defined by RatingsRUs, and everyone who sees 'paradigm-changing' as a rating for a Content Standard, even if they have no idea where our site is or who created that Content Standard page, can immediately find out what what term means.
8. Because ALL these terms and vocabularies are controlled and connected in well defined ways (thanks to RDF), we can understand that our 'paradigm-changing' rating actually means exactly the same thing as Google's '*****' and Consumer Reports' '10'. Similarly for names (thanks to an RDF vocabulary called Friend-of-a-Friend, or FOAF).
9. Someday, automated systems can use all this knowledge to perform human-like reasoning automatically across all the data, concluding for example that the MMI rating system gives web content lower but more consistent ratings, while the Consumer Reports system gives higher ratings with more variation.

   I will donate some of my own money to make this happen, although the benefit will go to my work life. If someone from the project finds this use case interesting they are welcome to contact me about it.

   [1] Marine Metadata Interoperability project, http://marinemetadata.org
   [2] MMI Ontology Registry and Repository, http://mmisw.org/or

While you're thinking about how RDF might empower what EPIC called "fact-stripping robots," give some attention to YQL Execute as well. The potential interaction of the two is mind-boggling.

I think some seasoned web developers might not be excited about RDF because they may not all come from a data or information architecture background.

Have a look at http://www.london-gazette.co.uk/

All the Corporate Insolvency notices (and may others) contain large amounts of RDF triples encoded as RDFa. The documents are self describing, in combination with the ontologies pointed to by the CURIEs, a machine can infer all sorts of information such as comany name, number, nature of business, directors, the court hearing date, place, which administrators were appointed, which company they worked for and at which office, and so on.

Phil

The RDF API module is not going into core and there won't be similar memory issues in core. We are working to make the RDF in core as lightweight as possible.

Right now I wouldn't expect RDF integration to have a very large impact on traffic to your site. However, just two days ago Google announced support for RDF and Microformats in regular search. Yahoo already has this capability featured in Search Monkey.

http://googlewebmastercentral.blogspot.com/2009/05/introducing-rich-snip...
http://developer.yahoo.com/searchmonkey/

So expect this to be a hot topic in the coming months/years. It's awesome that we're identifying this tremendous opportunity and making progress toward supporting it! (I donated, you should too)