Question

I have read here* that ontologies (RDF’s in nature) are data-driven because one can work with a small ontology and use it for an application, and later… integrate additional concepts to the same ontology to make it more robust.

My concern is how can a certain triple become more robust in the future? For example.

School : Class
Properties:
has Name : String
has Area : float
has Type : String // can be** , choices are Specialist, Faith, Free etc.

at this point, instantiating School will give us…

School X : School
has Name = School X : String
has Area = 20000.00 : float
has Type = Specialist : String                    <<--------------------------

The triple I am interested in is

SchoolX  hasType Specialist^^string

what if later on I found out that the word Specialist has several properties underneath it, and so I have decided to create a Specialist : Class

Specialist : Class                                <<--------------------------
has Specialization : String // can be**
followsNationalCurriculum : boolean
...and so forth

say,

MusicSpc : Specialist
has Specialization = Music : String
followsNationalCurriculum = true
etc.

my question is.

1. For those individuals that used hasType=Specialist^^string, how do you implement that the string literal “Specialist” in the older ontology must be connected to an instance of the Specialist(Cls) in the new ontology? Do you do it in Jena or OWL/RDF?
2. In connection with (1), I know in Java that overloading a method can prove useful at times. Is overloading good for ontologies? s.t. hasType : String, hasType : Specialist(Cls)? And do I declare it in OWL/RDF that the URI=namespace#hasType is both a Datatype and an Object property?

I hope someone will help me on this.

References:

• https://www.mkbergman.com/483/advantages-and-myths-of-rdf/
• https://www.gov.uk/types-of-school/overview

Answer 1

Regarding your first question, there are ways to update your data, for example, you could use a SPARQL 1.1 update operation to update your data, in this specific case:

DELETE { ?x :hasType "Specialist"@en }
INSERT { ?x :hasType :Specialist } 
WHERE { ?x :hasType "Specialist"@en } 

As for your second question: you can “overload” properties in this sense in RDF(S): any property can have both strings and invidual resources as values. Whether that is a wise thing to do is a different matter, as it will become harder to effectively query and process your data. You’re probably better off with not overloading it – also because in OWL (at least OWL DL), you can’t do this: a property can be either a DatatypeProperty or an ObjectProperty, but not both.

Generally speaking: if you are in doubt whether a property should have a string value or a more complex value, choose a complex value, right from the start. That way your ontology is designed to be extendable in the future and you won’t have to worry too much about jumping through hoops to update. In your example case, you already know that your value set for :hasType is a fixed set of types, that is, classes of things. Don’t use string values for such constructions, but introduce actual classes for these things