Internet Alchemy

Finally got the website up for the FriendSpace demo. FriendSpace is a proof of concept collaboration service demonstrating how it is possible to use FOAF to build services where the user retains control over all their personal information. Many more details in our position paper for the Galway workshop. We need some people to help try it out. If you want to take part, add the following to your FOAF file and register your FOAF with us.

<foaf:interest rdf:resource="http://www.friendspace.com/groups/galway-foaf-2004"/>

Patrick Stickler’s Concise Bounded Descriptions are shaping up to be pretty useful, especially when aggregating RDF from disparate sources. The specification now has its own page and I notice that Patrick has refined the rules for including blank nodes in the CBD. Now, if the blank node has any owl:InverseFunctionalProperty predicates, only those are included in the CBD and everything else is dropped. This makes smushing much much easier since you have less issues around resolving property conflicts, e.g. people’s names in foaf:knows relationships.

When programming in .NET there’s a useful little idiom that can assist with some renaming refactorings. In his book, Fowler lists the steps needed to rename a method safely. Step 6 is “Find all references to the old method name and change them to refer to the new one”.

I wondered if there was any way to automate this rather than doing this by hand. The answer is simple: label the old method with an Obsolete attribute. The compiler now issues a warning for each use of the method enabling me to quickly press F4 (I’m using Scite) to step through all the method calls. Here’s what it looks like. The second parameter of the attribute should be set to false so that only a warning is issued. (After all this is a behaviour preserving refactoring, not an error).

[Obsolete("Prefer to use Arc version of this method", false)]
public void addProperty(string uriRef, string literalValue) {
  PlainLiteralNode theObject = new PlainLiteralNode(literalValue);
  ResourceDescription desc = new ResourceDescription(theObject);
  addProperty(new UriRef(uriRef), desc);
}

Dan Brickley comes out with a stonking good post to atom-syntax succintly listing all the reasons why RSS 1.0 adopted the RDF model:

• (fairly) predictable XML notation; RSS 1.0 defined a profile of the RDF/XML syntax, so that namespace-extended feeds all shared a basic structure. (rather than allowing all RDF’s syntactic variations).
• Supported free combination of independently developed descriptive vocabulary (manifested as RDF/XML-based namespaces). RSS 1.0 feeds can carry extra markup describing things in the world beyond
  syndication, such as people, places, movies, bank accounts. Element
  names in the markup correspond to classes (categories) and properties
  (fields, relations etc) defined by any RDF vocabulary that proves
  useful.
• The external vocabularies a feed draws upon do not need to be defined
  with RSS 1.0 (or Atom or newsfeed syndication) in mind. Or be tightly
  coordinated amongst themselves. There is a tightly-defined model and
  simple-minded (additive) model for explaining how these independent
  namespaces interact when deployed together.

Dare Obasanjo then misses the point entirely, failing to see that just allowing arbitrary namespaced elements in RSS is not the same as adopting a well thought out data model.