SchemaChangeWithOwl

The problem is, how to manage an evolving RDF schema with an established user community.

Danbri has said that versioning of namespaces for an RDF schema is generally a bad idea primarily because of the difficulties encountered by the move from DC version 1.0 to 1.1. FOAF evolves under a static namespace, and has status properties to describe the stability of each of the schema terms.

OWL has some potentially useful versioning properties and classes ...

The owl:[[DeprecatedClass]] and owl:[[DeprecatedProperty]] classes are obviously useful and it is clear how they should be applied.

There is also the owl:versionInfo annotation property, which is intended to be used to describe versions of ontologies, but can be used to describe versions of schema classes or properties.

But here comes the problem. OWL has some properties for making statements about the relationships between versions of ontologies: owl:priorVersion, owl:backwardsCompatibleWith and owl:incompatibleWith. The domain and range for these properties is restricted to owl:Ontology, which is a pain because they possible could be useful for making statements about the relationships between schema elements, and anyway if versioning of namespaces is not practical these properties turn out to be quite useless.

Chaals has had an idea. Let's say you are defining an RDF vocabulary, with help from a community of friends, and you decide to assign this vocabulary the base namespace http://www.foo.org/pants#. You don't want to version this namespace, because of the inconvenience this causes. But you do want to offer discrete, stable, intermediate versions that people can talk about and implement tools over.

So what you do is type each of the terms of the vocabulary as an owl:Ontology ... i.e. you define a vocabulary of single term ontologies. You adhere strictly to the rule that once a term is added to the vocabulary, you don't change anything about it. If you feel like it's wrong, then you deprecate it and add a new term to replace it.

Then you describe snapshot version ontologies, by importing terms from the base vocabulary.

E.g.

<rdf:RDF xmlns:rdf="" xmlns:rdfs="" xmlns:owl="" xmlns="http://www.foo.org/pants#" xml:base="http://www.foo.org/pants">

  <rdf:Description rdf:about="">
    <rdfs:comment>The pants ontology</rdfs:comment>
  </rdf:Description>

  <rdfs:Class rdf:ID="BottomWare">
    <rdf:type rdf:resource="&owl;Ontology"/>
  </rdfs:Class>
 
  <rdfs:Class rdf:ID="Trousers">
    <rdf:type rdf:resource="&owl;Ontology"/>
    <rdfs:subClassOf rdf:resource="#BottomWare"/>
  </rdfs:Class>

  <rdfs:Class rdf:ID="Underpants">
    <rdf:type rdf:resource="&owl;Ontology"/>
    <rdfs:subClassOf rdf:resource="#BottomWare"/>
  </rdfs:Class>

  <rdf:Property rdf:ID="fabric">
    <rdf:type rdf:resource="&owl;Ontology"/>
    <rdfs:domain rdf:resource="#LegWare"/>
    <rdfs:range rdf:resource="#Fabric"/>
  </rdf:Property>

  <rdfs:Class rdf:ID="Fabric">
    <rdf:type rdf:resource="&owl;Ontology"/>
  </rdfs:Class>

  <owl:Ontology rdf:about="http://www.foo.org/pants/1.0">
    <owl:versionInfo>The 1.0 snapshot of the pants ontology</owl:versionInfo>
    <owl:imports rdf:resource="http://www.foo.org/pants#LegWare"/>
    <owl:imports rdf:resource="http://www.foo.org/pants#Trousers"/>
    <owl:imports rdf:resource="http://www.foo.org/pants#Underpants"/>
    <owl:imports rdf:resource="http://www.foo.org/pants#fabric"/>
    <owl:imports rdf:resource="http://www.foo.org/pants#Fabric"/>
  </owl:Ontology>

</rdf:RDF>

So the idea is you get the bost of both worlds - allowing an RDF vocab to evolve under a constant namespace, but still being able to use the versioning features of OWL.

???