All I know about RDF/OWL I learned in preschool

I don’t want to seem pretentious, but back in preschool I was a star student. At least when it came to potatoes. I am not sure what it’s called in US preschools, but what we meant by a potato, in my French classroom, was an oval shape in which you put objects. The typical example had two overlapping ovals, one for green things and the other for animals. A green armchair goes in the non-overlapping part of the “green” oval. A lion goes in the non-overlapping part of the “animal” oval. A green frog goes in the intersection. A non-green bus goes outside of both ovals. Etc.

As you probably remember, there are many variations on this, including cases where more than two ovals overlap. The hardest part was when we had to draw the ovals ourselves as opposed to positioning objects in pre-drawn ovals: we had to decide whether to make these ovals overlap or not. Typically they would first be drawn separately until an object that belonged to both would come up, prompting some head-scratching and, hopefully, a redrawing of the boundaries. Some ovals were even entirely contained within a larger oval! Hours of fun! I loved it.

[Side note: meanwhile, of course, the cool kids were punching one another in the face or stealing somebody’s lunch money. But they are now stuck with boring million-dollar-a-year jobs as cosmetic surgeons or Wall Street bankers (respectively) while I enjoy the glamorous occupation of modeling IT systems. Who’s laughing now?]

To a large extent, these potatoes really are all you need to understand about RDFS and OWL classes. OO people, especially, are worried about “multiple inheritance”. But we are not talking about programmatic objects here, in which inheritance brings methods with it. Just about intersecting potatoes. Subclassing is just putting a potato inside another one. Unions and intersections are just misshaped potatoes made by following the contours of existing potatoes. How hard can all that be?

Sure there are these “properties” you’ve heard about, but that’s just adding an arrow to show that the lion is sitting on the armchair. Or eating the frog.

Just don’t bring up the fact that these arrows can themselves be classified inside their own potatoes, or the school bully (Alex Emmel) will get you.


Filed under Everything, OWL, RDF, Semantic tech

4 Responses to All I know about RDF/OWL I learned in preschool

  1. I’ve always heard them referred to as Venn Diagrams. Though, I thought I was pretty slick in preschool and we never did any of that- not that I can remember nyway.

    Whats wrong with multiple inheritance, anyway? It’s one of those things that makes OO programming interesting… [I’m going to hell, aren’t I?]

  2. Yes Beril, they are indeed Venn diagrams. But that’s not how we called them in preschool. I still like to think of them as “potatoes” because, while a lot of the discussions around the semantic web focus on its complexity, I like to remember the simplicity of its principles.

    BTW, you’re not going to hell, you are there already… ;-)

  3. Stu

    One thing that I fear will eternally confound OO folks is that their version of inheritance leads to odd results, like Ellipses inheriting from Circles, instead of the other way around. Whereas OWL’s notion of “type inheritance” is really about constraints (like sets).

    Which leads to the bigger deal for everyone: the open world assumption. You get into some weird results when you think in terms of “type checking” being a way to prevent you from doing bad things. In OWL, its just about enabling inference. Except for blatant non-satisfiability, you’ll need a pile of SPARQL queries (for example) to actually do your validation and constraint checking on inputs if you want to prevent someone from adding adding problem triples to a particular graph.

    There are other things that are odd about this world, like non-unique-names, and graph provenance, but I think there are reasonable analogies in the OO world to these things. It’s about time we took this technology for a real spin on the enterprise road….

  4. Pingback: William Vambenepe’s blog » Blog Archive » First in-depth look at Microsoft’s Oslo and the “M” modeling language