Benjamin Heitmann and Eyal Oren have just announced the 1.0 release of ActiveRDF:

ActiveRDF is a library for accessing RDF data from Ruby programs. ActiveRDF gives you a domain specific language for your RDF model and provides object-oriented access to your RDF resources, classes, properties, etc. ActiveRDF conforms to the RDFS specification (multiple inheritance, multiple class membership, etc.)

ActiveRDF can be used as data layer in Ruby-on-Rails, similar to ActiveRecord. ActiveRDF with Ruby-on-Rails puts the semantic web on rails, and allows you to create semantic web applications rapidly.

With ActiveRDF you can access various sources of RDF data. We support SPARQL endpoints, Redland and RDFLite; (native) adapters for Jena, Sesame2 and YARS are in development.

I played around with some of the earlier releases of ActiveRDF, and while it definitely had some rough edges, I liked the idea and am anxious to see how well it’s working now.

The SIMILE project has announced a new major release of the Piggy Bank extension for the Mozilla Firefox browser. Developer Stefano Mazzocchi has blogged about it here. I’ve only just now downloaded the new version, but it looks like they’ve made some substantial improvements over the original version (which itself was fun to play with).

To install this extension into Firefox, visit the Piggy Bank home page and click the get Piggy Bank link in the upper right-hand corner of the page.

One flaw I’ve noticed with 43 Things since I started using it has to do with how people add new goals to their lists. When I’m going to add a new goal, the first thing I do is search other peoples’ goals looking for similar (if not identical) goals. Unless you’re doing something really unusual, there’s a good chance that someone else is doing it too, and that’s a big part of what makes 43 Things so interesting to me. As discussed in the FAQ, shared goals provide an opportunity to share information, get inspiration and so forth. The problem is that a lot of people apparently don’t search for previously established goals similar to theirs, and so they just make a new entry that duplicates an existing entry but uses a slightly different title.

Here’s an example from this morning. I’ve recently picked up a copy of David Allen’s Getting Things Done, in an attempt to get my act together, and I thought I’d add this as one of my 43 things. When I visit the 43 Things site and search for “gtd”, it finds 17 goals (including “gtd”, “try GTD”, “Learning GTD” and “master GTD”) that contain that acronym in their title . One of those seems to have been declared the “winner”, with 38 people sharing that goal, but a number of other entries that are basically describing the same goal have only one or two people attached to them. It gets worse, though: if I instead search 43 Things for the words “getting things done”, there are a number of other possible matches.

I initially wondered if the tags associated with goals might offer a way out of this mess, but they really don’t. Yes, I can search for goals that have been tagged with gtd, but for the problem at hand that’s not really any different from searching for gtd in the goals’ subject lines: if you don’t do that search before you enter your new goal, you can still manage to enter a “new” goal that’s just a dupe of some other goal. The problem is compounded by the fact that, as far as I can tell, 43 Things doesn’t allow you to edit a goal and associate tags with it unless you’ve already “signed up” for that goal. As noted by Clay Shirkey, the real value of using folksonomies comes from “aggregate interaction”, or to use smaller words, when other people assign tags to your data.

Ed Dumbill has posted a nice short analysis of why he chose RDF instead of plain old XML for DOAP.

When he’s talking about the benefits of using RDF, it’s not really anything I hadn’t heard before when people are extolling the virtues of RDF; but it really helps to see what those benefits mean in the context of a specific application like DOAP. He wanted a decentralized system for describing projects and the relations between them and the people working on them, recognizing that any one source is unlikely to know all of those things about a project. He wanted the DOAP vocabulary to be easily extensible, not only by established ontologies like Dublin Core and FOAF, but by as-yet-unknown vocabularies.

Piggy-Bank is a new extension for the Mozilla Firefox browser that allows you to easily browse the semantic data linked to from regular web pages. I’ve seen some other projects along these lines, but they tend to be focused on a particular flavor of RDF data (such as Joel’s FOAFer extension, or Christopher Schmidt’s DOAP Viewer extension).

I’m still not quite sure how Piggy-Bank works, but at the least it’s scraping web pages for any embedded links that have well-recognized types in the Semantic Web, such as “application/rss+xml” (for RSS feeds) and “application/xml+rdf”. It then follows those links and parses out the “information tidbits” from those sources, and presents that information to you in a sidebar. Piggy-Bank attempts to categorize the tidbits into high-level categories, such as “News” for RSS Channel and Item resources, or “Contacts” for FOAF’s “Person” resources. You can save the tidbits of interest in a local database (“My Piggy Bank”) and search through them later; Piggy-Bank remembers the original source of the data and allows you to annotate them with comments as you desire.

In response to the question, “Why was [Piggy-Bank] built?” the developers offer the simple answer:

“Already many researchers and organizations have gotten excited about the promises by the Semantic Web. Through the deployment of this Piggy-Bank extension, we would like to get end-users excited about the Semantic Web, too.”

I’m not sure that Piggy-Bank is the tipping point that’s going to get end-users “excited” about the Semantic Web, but it certainly was easy to install and use.

There are still a few kinks in the system. For example, I found that a lot of pages that do in fact contain links to bunches of semantic data (such as Bob DuCharme’s rdfdata.org site) aren’t properly “scraped,” presumably since they don’t annotate the links using the expected link types. The developers might reasonably argue that this is by design, and that it would be too costly to follow all possible outgoing hyperlinks to try to determine whether they point to any useful RDF data. Nevertheless, it might prove useful to find ways to relax whatever rules that Piggy-Bank is currently using so that it’s able harvest even more semantic data from pages that aren’t necessarily playing by the rules. Another kink is that (at present) it only seems to handle RSS 1.0 feeds. Again, the developers might reasonably argue that since RSS 1.0 is the only version of RSS that parses as “legitimate” RDF, it’s OK for Piggy-Bank to stumble over the RSS 0.9x and 2.0 flavors. That was little solace to me as I had to wade through a number of my friends’ blogs’ RSS feeds before finding one that was actually available in RSS 1.0 format.

I’m anxious to see where this project goes over the coming year.

Stefano Mazzocchi has reprinted Frank Manola’s parody of the original Semantic Web article by Tim Berners-Lee and friends, from way back in 2001. In the original article we’re treated to a day in the life of “Pete” and “Lucy”, two fictional characters whose lives are made easier by the advent of the Semantic Web. In Frank’s updated version of the story, Pete’s Semantic Web agent has to pause for three hours to download the latest patches for Microsoft Agent before it can proceed in its work.

Semitar is an “almost pure” Ruby library for processing Semantic Web data in RDF and OWL. The “almost” qualification stems from the fact that it uses Redland’s Raptor parser, instead of a pure Ruby RDF parser, in the interest of performance. Semitar is being developed by Rich Kilmer and Chad Fowler, two well-known contributors to the Ruby community.

Also found this link to the PDF’d version of a PowerPoint presentation on Semitar. It’s unclear which parts of Semitar have actually been implemented and which ones are still in the planning stages.

As with the previous post on RDF-Redland, this one’s short on content for now. Can you tell that I’m trying to push out a lot of draft articles that I’ve had sitting in the queue for while? Expect more information about my adventures with Semitar as we get closer and closer to RubyConf.

RDF-Redland is Dominic Sisneros’ project to layer a more object-oriented, Ruby-friendly API on top of the flattened C API provided by the standard Redland installation. Redland is Dave Beckett’s popular library that provides a framework for building RDF-based applications. It supports a variety of RDF parsers and serializers, persistent storage to a number of relational databases, RDQL-based queries and more.

The standard Redland package originally included only a thin wrapper over Redland’s C API as its Ruby interface. As of the latest release of the Redland Language Bindings, a version of Dominic’s library is included, and this helps very much to bring the official Ruby bindings up to par with the existing Python and Perl bindings, which are very good.

This post is unfortunately light on content, but I hope to follow up with more information about how to actually use RDF-Redland in a future post. Of the existing options for processing RDF with Ruby, it is certainly the most mature and capable, as of this writing, and it’s one that I plan to feature in my presentation at the Ruby Conference in October.

Shelley Powers, author of Practical RDF, has posted a new article about what she calls the “RDF Glass Ceiling”. The article comments on the apparent loss of momentum in the RDF world in the year since her book was published.

The follow-up comments from readers are a little more encouraging. Danny Ayers notes that while there hasn’t exactly been an avalanche of new RDF-based projects lately, the number of new people showing up on RDF interest mailing lists and IRC channels has been picking up. He also notes that it’s only been six months since RDF and OWL became official W3C recommendations. Other responses to Shelley’s article seem to reinforce Danny’s opinion that general interest in RDF is steadily picking up steam in a sort-of “grasssroots” way.

A quick follow-up to my previous post about Rena, the Ruby library modeled after Jena. Oliver Bolzer has published his introduction to Rena here.