cygri’s notes on web data

There’s a cool video tutorial for Core Data at Apple’s developer site.

Core Data is a part of the Apple technology toolbox that lets developers define an application data model without writing code. Basically, all they have to do is define an entity/relationship diagram in Xcode (Apple’s “Eclipse for Objective-C”), and they get an object model, GUI bindings, load/save, XML import/export and fulltext search for free. The guy in the tutorial cooks up a simple application with a nice Cocoa GUI in ten minutes or so, which certainly makes for a good demo.

The big picture: I don’t have much interest in actually working with Core Data. The desktop application is a dying breed, and especially data-driven applications belong on the server side.

But Core Data is an example of an important trend in software development: It reduces development cost by building on a high-level data model. Lots of infrastructure work like persistence, serialization, API and GUI access to the data, validation and so forth can be partially or completely automated once you have explicitly mapped out your domain.

Another popular example is Ruby on Rails with its ActiveRecord framework. With ActiveRecord, developers define the data model using a database schema with some conventions and a bit of declarative Ruby code. The scaffolding features of Rails, great for quickly getting a prototype up and running, are one of those nice things you get for free with a high-level data model.

Can RDF be a vendor-independent Core Data? That question is the main reason for my involvement with RDF. It may have the potential to become a standardized data model that transcends programming languages, development environments, and could even ship objects across the web.

In a perfect world, I would define a data model for my application, publish it as RDFS and OWL, someone else could import the data model into their own application, and access my data almost transparently, with RDF or or SPARQL in the background. Man, that would rock.

One good-looking project that goes into this direction is ActiveRDF, a framework that provides very natural access to RDF data from Ruby applications, including Ruby on Rails webapps.

Definitely something to watch.

Phil Jones, in my comments:

I think the difficulty in RDF comes from […] confusion with the aims of upper-case SemWeb, means that it’s hard to find documentation that doesn’t throw you into the deep-end. (Maybe someone should produce a “how to hack RDF in 10 minutes without thinking about what it really means” tutorial.)

Good point.

Leo:

Note that an RDF database server (with inference) will probably look like this.

Haha. So true.

You don’t have a FOAF file yet? No? Then go create one!

You have a FOAF file, but it doesn’t have geo coordinates? Then go add them!

This link leads to a little service that helps you locate the latitude and longitude of the place where you live. I’ve built it today. It’s based on the Google Maps API, which is a lovely piece of technology, by the way.

So, there’s no more excuse! Add those coordinates, then view your profile on Alexandre Passant’s FOAFMap.net. Here’s mine.

(Update: There’s another FOAF geolocation service that determines the location from your street address.)

(Update2: Now with street maps for most of Europe!)

Dan Brickley experiments with using SPARQL queries to check on the vocabularies used in an RDF file.

Here’s a query that checks my FOAF file for properties that are in the FOAF namespace, but not declared in the FOAF RDFS file.

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX owl: <http://www.w3.org/2002/07/owl#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
SELECT DISTINCT ?property
FROM <http://richard.cyganiak.de/foaf.rdf>
FROM NAMED foaf:
WHERE {
    ?s ?property ?o
    GRAPH foaf: {
        OPTIONAL {
            ?property a ?t
            FILTER (?t = owl:ObjectProperty || ?t = owl:DatatypeProperty
                || ?t = rdf:Property || ?t = owl:FunctionalProperty
                || ?t = owl:InverseFunctionalProperty)
        }
    }
    FILTER (!BOUND(?t))
    FILTER (REGEX(STR(?property), "^http://xmlns\\.com/foaf/0\\.1/"))
}

This query actually finds some stuff — here are the results as of today:

-------------------------
| property              |
=========================
| foaf:withOrganization |
| foaf:hpmepage         |
| foaf:linkedWith       |
-------------------------

One’s a typo, and I’ve no idea how I got the idea that the other two were in FOAF.

SPARQL: SPellchecker And RDF Query Language!