In information management, a wrapper is a program that translates tagged data into relational form, so that databases can deal with it. We’re interested in this because some of that tagged data includes subject terms, keywords, or whatever you want to call taxonomy terms that have been used to describe documents.

One forerunner of present-day wrappers was an attempt by the Internet Engineering Task Force (IETF) to develop standards for World Wide Web resources. They came up with uniform resource characteristics (URCs). IETF defined a URC as “a set of meta-level information about a resource. Some examples of such meta-information are: owner, encoding, access restrictions (perhaps for particular instances), cost.”

The URCs  concisely defined how a URL or a URN or a UID or any of those unique items could be uniformly defined so that everybody would do it the same way. The idea was that with a simple batch of metadata you could connect everything. It languished for about 10 years.

As the URCs faded, attention shifted to the Resource Description Framework (RDF), a wrapper that you could put around something like the Dublin Core. It has become much more involved and much fancier over the years.

Originally, it was a self-documenting format. RDF was the framework to describe whatever was there. So, if you sent me an RDF file, what you would be doing is sending me the file and sending me the DTD that went with it so that I could interpret the data.  A nice clean wrapper explained what was in there.

Basically, RDF is a way of putting a wrapper around the information so that you can see and interpret what someone has sent to you. It is a nice framework for doing that. However, it has taken on a different life now.

The syntax is pretty straightforward because it follows the XML syntax.

The schemas originally were tied to something like, but not necessarily, the Dublin Core.

So, an RDF does not have to be Dublin Core; it can be something completely separate. In fact, when W3C came out with the Simple Knowledge Organization System (SKOS), which was an export format for taxonomies, they were using that as a formal language to describe the way that taxonomies or vocabularies were exported. Unfortunately, they did not include everything in the first edition that one might need, so you couldn’t have multiple broader terms, you couldn’t have synonyms, you couldn’t have related terms. Very limiting. However, you could have a broader or narrower term. It was for classification systems, not for taxonomies. The new edition of SKOS does include options so that you can export null information.

Here’s an RDF wrapper on a set of information, just to show you what the format looks like:

  • <rdf:RDF
  •   xmlns:rdf=”http://www.w3.org/TR/WD-rdf-syntax#”
  •   xmlns:dc=”http://purl.org/dc/elements/1.0/”
  •   xmlns:dcq=”http://purl.org/dc/qualifiers/1.0/”>
  •   <rdf:Description about=”urn:issn:1361-3197″>
  •     <dc:Title>Ariadne</dc:Title>
  •     <dc:Subject>
  •       journal; magazine; elib; electronic libraries; digital libraries;
  •       networking; Web; IT; higher education
  •     </dc:Subject>
  •     <dc:Description>
  •       A print magazine of Internet issues for librarians
  •       and information specialists
  •     </dc:Description>
  •     <dc:Publisher>
  •       Information Services, University of Abertay, Dundee
  •     </dc:Publisher>
  •     <dc:Type>Text.Serial.Magazine</dc:Type>
  •     <dc:Relation>
  •       <rdf:Description>
  •         <dcq:RelationType
  •           rdf:resource=”http://purl.org/dc/vocabularies/AgentTypes/v1.0/IsBasisFor”/>
  •         <rdf:value resource=”http://www.ariadne.ac.uk/”/>
  •       </rdf:Description>
  •     </dc:Relation>
  •   </rdf:Description>
  • </rdf:RDF>

I won’t dwell on how this works. The example above shows the different pieces of the RDF. It is a very standard export for exchanging vocabularies.

RDF schemas are similar to XML schemas. A schema defines the meaning, characteristics, and relationships of a set of properties. This may include constraints on potential values and the inheritance of properties from other schemas.

With RDF, a resource is anything that can have a uniform resource identifier (URI). This includes all Web pages, and segments of an XML document.

An RDF PropertyType is a resource that has a name and can be used as a Property. This can be Author or Title.

An RDF Property is the combination of a Resource, a PropertyType, and a value. For instance, “The Author of http://www.accessinn.com/offkey.htm is Marjorie Hlava.” The value, in this case, is “Marjorie Hlava”. Resources have Properties, and Properties have Values.

Practical uses of RDF include the following:

Recently, RDF has expanded to include triples for linked data. So, a lot of you will hear about RDF and immediately think of triples and linked data. However, in order to support these triples, RDF first needed to be defined as a wrapper. So, now it is a wrapper for object/predicate/subject or subject/predicate/object. You can show the relationship of terms.

RDF is a really cool way to define related term instances. You can have more than one kind of related term. You can do it in an RDF export. You can say “Linda was president of ASIS&T.” You can infer other relationships and indicate that “Marjorie Hlava is a member of ASIS&T.”  We can talk about the different objects and their relationships. These can get very complex. The basis of it – RDF was first a wrapper and now has extended that wrapper and the way the syntax works so that you can talk about it in terms of triples. It has expanded that part of the RDF syntax.

Marjorie M.K. Hlava, President, Access Innovations

 

Note: The above posting is one of a series based on a presentation, The Theory of Knowledge, given at the Data Harmony Users Group meeting in February of 2011. The presentation covered the theory of knowledge as it relates to search and taxonomies.