1. formalizing information models in the form of RDF vocabularies consisting of class definitions and property definitions, where both class names and property names are URIs (representing globally unique identifiers);

2. representing propositional information (in the form of statements about individuals) on the Web, embedded in web pages or in the form of special web data sources.

1. It does not express the constraints that all three properties are mandatory and single-valued, which they are by default in UML.

2. It does not express the constraints that the ISBN property, as a standard identifier (or primary key) attribute, is mandatory and unique.

The propositional information items, or fact statements, expressible with RDF are

Consequently, for a UML object definition like

we obtain several RDF fact statements:

which can also be merged into one rdf:Description element:

<rdf:Description rdf:about=“urn:isbn:006251587X”>
 <rdf:type rdf:resource="http://example.org/ex1#Book"/>
 <ex:isbn>006251587X</ex:isbn>
 <ex:title>Weaving the Web</ex:title>
 <ex:year>2000</ex:year>
</rdf:Description>

There are many use cases for machine-readable data (e.g., about people, events, products, etc.) embedded in web documents. For instance, search engines like Google can use such structured data for providing more meaningful search results.

Structured data, or meta-data, can be embedded in a web document by either adding a JSON-LD script element containing it, or by annotating the document's content, e.g., the HTML elements of a web page, with RDFa.

Very limited annotation approaches, called "microformats" (proposed around 2005), are the historic predecessors of the general annotation language RDFa, which is derived from RDF. Some microfomats, like vCard and vEvent, are still being used today, but they are increasingly replaced with one of the two general formats RDFa and JSON-LD.

The main author of HTML5, Ian Hickson, has proposed an alternative general annotation language, called microdata, with the goal to simplify RDFa and remedy its usability issues (in particular, by dropping its use of XML namespaces). Despite the (rather unfortunate) choice of using different names for the same annotation concepts (like "itemprop" instead of "property"), Hickson's microdata proposal succeeded to show

Since Hickson ended his collaboration with the W3C, the microdata proposal did not succeed to get an official W3C status, and web browsers have discontinued their support for it. However, it triggered a W3C proposal to use the RDFa Lite subset of RDFa, which "can be applied to most simple to moderate structured data markup tasks, without burdening the authors with additional complexities".

We present a simple example for using structured data in a web page. Consider the following HTML fragment:

<p>
 My name is Carly Rae Jepsen. 
 Call me maybe at 1-800-2437715.
</p>

For this content, we may want to code the information that

Using the RDFa attributes typeof, vocab and property, we can code this information by adding the following annotations to the HTML content:

<p typeof="Person" vocab="http://schema.org/">
 My name is <span property="name">Carly Rae Jepsen</span>. 
 Call me maybe at <span property="telephone">1-800-2437715</span>.
<p>

Using JSON-LD, as recommended by Google, we need to add a script element of type "application/ld+json" containing the meta-data:

<script type="application/ld+json">
{
  "@context": "http://schema.org",
  "@type": "Person",
  "name": "Carly Rae Jepsen",
  "telephone": "1-800-2437715"
}
</script>

The propositional information expressed with RDFa annotations and JSON-LD corresponds to the following RDF/XML code:

<rdf:Description xmlns:schema="http://schema.org/">
  <rdf:type rdf:resource="http://schema.org/Person"/>
  <schema:name> Carly Rae Jepsen </schema:name>
  <schema:telephone> 1-800-2437715 </schema:url>
</rdf:Description>

OWL extends RDF by adding many additional language elements for expressing constraints, equalities and derived classes and properties in the context of defining vocabularies. Facts are expressed as in RDF (e.g., with rdf:Description).

OWL provides its own predefined language elements for defining classes and properties:

We only show with the help of an example that an OWL vocabulary can represent a class diagram more faithfully than the corresponding RDF vocabulary by allowing to express certain constraints.

Consider the standard identifier attribute isbn defined in the Book class. In an RDF vocabulary, this attribute is defined in the following way:

<rdf:Property rdf:ID="#isbn">
 <rdfs:domain rdf:resource="#Book"/>
 <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</rdf:Property>

There are two issues with this RDF definition of an attribute:

Using OWL, we can remedy these shortcomings of RDF. The following OWL property definition makes it explicit that the property http://example.org/ex1#isbn is an attribute, while the added OWL restriction defines an "exactly one" cardinality constraint for it:

<owl:DatatypeProperty rdf:ID="#isbn">
 <rdfs:domain rdf:resource="#Book"/>
 <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#string"/>
</owl:DatatypeProperty>
<owl:Restriction>
  <owl:onProperty rdf:resource="#isbn" />
  <owl:cardinality>1</owl:cardinality>
</owl:Restriction>

Since the ISBN attribute of the Book class has been designated as the standard identifier attribute in the UML class diagram above, we should define a uniqueness constraint for it. We can do this by including an owl:hasKey element within the class definition:

<owl:Class rdf:ID="#Book">
 <owl:hasKey rdf:parseType="Collection">
  <owl:ObjectProperty rdf:about="hasSSN">
 </owl:hasKey>
</owl:Class>

Both RDF and OWL have many usability issues. Especially OWL is so difficult to use that most potential users will be discouraged by it.

Because OWL was created by a community that is more concerned with formal logic than with information modeling and is not familiar with the concepts and terminology established in information modeling, they have introduced many new unfamiliar terms for concepts that had already been established and named in information modeling. They have even introduced duplicate names within OWL: an attribute is in most places called "data property", but in some places it is called "datatype property" (specifically in OWL/RDF).

Usability issues of RDF are:

Usability issues of OWL are: