Learn OWL and RDFS


RDFS vs. Owl

We introduced RDFS and OWL as data modeling languages for describing RDF data. So which should you use? Simply put, both are used extensively in practice, but OWL is the primary modeling language in Semantic Web applications. We recommend using OWL as it builds on RDFS and provides more expressivity. 

This article provides a more thorough comparison of the two modeling languages.


Today’s Lesson

RDFS allows you to express the relationships between things by standardizing on a flexible, triple-based format and then providing a comparatively smaller vocabulary (such as rdf:type or rdfs:subClassOf) which can be used to say things about concepts in your area(s) of interest.

OWL is similar, but bigger, better, and badder. OWL lets you say much more about your data model; it shows you how to work efficiently with database queries and automatic reasoners; and it provides useful annotations for bringing your data models into the real world.

Said another way: if RDFS is the stuff that passes for coffee in the American Northeast, OWL is a hot cup of Italian espresso.

First Difference: Vocabulary

Of the differences between RDFS and OWL, arguably the most important is just that OWL provides a much larger vocabulary.

For example, OWL includes all your old friends from RDFS such as rdfs:type, rdfs:domain, and rdfs:subPropertyOf. However, OWL also gives you new and better friends! For example, OWL lets you describe you data in terms of set operations:

Example:Mother    owl:unionOf     (Example:Parent, Example:Woman)

It lets you define equivalences across databases:

AcmeCompany:JohnSmith  owl:sameAs    PersonalDatabase:JohnQSmith

It lets you restrict property values:

Example:MyState     owl:allValuesFrom     (State:NewYork, State:California, …)

We won’t cover any of these predicates right now because, in fact, OWL provides so much new, sophisticated vocabulary to use in data modeling and reasoning that gets its own lesson!

Second Difference: Logical Consistency

Another major difference, in contrast to RDFS, OWL tells you how you can and cannot use certain vocabulary. In other words, whereas RDFS provides no real constraint mechanisms, OWL does.

For example, in RDFS, anything you desire can be an instance of rdfs:Class. You might decide to say that Beagle is an rdfs:Class and then say that Fido is an instance of Beagle:

Example: Beagle    rdf:Type    rdfs:Class

Example:Fido    rdf:Type    Example: Beagle

Next, you might decide that you would like to say things about beagles, perhaps you want to say that Beagle is an instance of dogs bred in England:

Example:Beagle    rdf:Type    Example:BreedsBredInEngland

Example: BreedsBredInEngland    rdf:Type    rdfs:Class

The interesting thing in this example is that Example:Beagle is being used as both a class and an instance. Beagle is a class of which Fido is a member; but Beagle is itself a member of another class: Things Bred in England.

In RDFS, all this is perfectly legal because RDFS doesn’t really constrain which statements you can and cannot insert. In OWL, by contrast, or at least in some flavors of OWL, the above statements are actually not legal (i.e., they are logically inconsistent). While one can model this in OWL, a simple consistency check will reveal the inconsistency. That is, you are logically inconsistent to say that something can be both a class and an instance.

This is then a second major difference between RDFS and OWL. RDFS enables a free-for-all, anything goes kind of world full of the Wild West, Speak-Easies, and Salvador Dali. The world of OWL enables more logical rigor.

Constraints and Computability

Why does OWL concern itself with logic and constraints? From a technical point of view, the reason is related to computing power required to implement the kinds of inferences which all this new vocabulary enables.

For example, if I know that Example:Frank is of rdf:type Example:Human, and Example:Human is a rdfs:subClassOf Example:Animal, then I can now infer that Example:Frank is also of type Example:Animal.

It turns out that some kinds of inferences can be computed quickly. Others can take a REALLY long time to run even on today’s fastest computers. Other kinds of inferences will never be solvable by ANY computer.

Unlike RDFS, OWL lets you decide how expressive you want to be, given the computational realities involved. In fact, OWL allows you to restrict your data modeling options to those that enable faster search queries; those that enable conceptual reasoning; or those that can be easily implemented with rules engines. For more details, see the lesson on Flavors of OWL.

From a knowledge representation perspective, OWL seeks to model data in an unambiguous, machine understandable manner to promote data interoperability and greater automation. Providing mechanisms for modelers to validate their ontologies for logical consistency promotes model durability and deeper interoperability. To be sure, one can still “say anything about anything,” but OWL provides a means to check for logical consistency and a means to apply constraints.

Third Difference: Annotations, the meta-meta-data

Suppose that you’ve spent the last hour building an ontology that describes your radio manufacturing business. During lunch, your task is to build an ontology for your clock manufacturing business. This afternoon, after a nice coffee, your boss now tells you that you’ll have to build an ontology for your highly profitable clock-radio business. Is there a way to easily reuse the morning’s work?

OWL makes doing things like this exceedingly easy. Owl:Import is what you would use in the clock-radio situation, but OWL also gives you a rich variety of annotations such as owl:versionInfo, owl:backwardsCompatibleWith, and owl:deprecatedProperty, which can easily be used link data models together into a mutually coherent network of ontologies.

Unlike RDFS, OWL is sure to satisfy all of your meta-meta-data-modeling needs.


OWL gives you a more expressive vocabulary to use, which makes empowers you to develop expressive and rigorous data models. OWL allows you to tailor what you say based on the computational realities and application requirements, such as queries, rules, policy enforcement, etc. Further, OWL allows you to easily express relationships between different ontologies using a standard annotation framework.

All these are advantages as compared to RDFS, and are typically worth the extra effort it takes to familiarize yourself with them.

You’ll still see RDFS used – often for older data models or smaller ontologies – so it’s useful to have a familiarity with it.  For yourself, stick to OWL. Next lesson: Flavors of OWL