Metadata on the Web: on the integration of RDF and Topic Maps

elbowsspurgalledInternet και Εφαρμογές Web

21 Οκτ 2013 (πριν από 3 χρόνια και 9 μήνες)

98 εμφανίσεις

Metadata on the Web: on the integration

of RDF and Topic Maps

R. Gentilucci

Department of Computer Science

University of Bologna

Mura A. Zamboni, 7

40127 Bologna BO

gentiluc@cs.unibo.it
M. Pirruccio

Department of Computer Science

University of Bologna

M
ura A. Zamboni, 7

40127 Bologna BO

pir
rucci@cs.unibo.it
F. Vitali

Department of Computer Science

University of Bologna

Mura A. Zamboni, 7

40127 Bologna BO

fabio@cs.unibo.it


ABSTRACT

Metainformation provide an additional layer of abstraction on
web documents that can be used for sophisticated applications
relying on the precise semantic characterization of their content.
Two leading standards, RDF and Topic
Maps, compete as the
model through which to express metadata. These two models are
sufficiently different as to make back and forth conversion a
difficult and imprecise task. In this paper we introduce META, a
set of integrated tools that help in editing,
navigating and
converting metadata expressed in either language.

Categories and Subject Descriptors

H.5.4 [
Information Interfaces and Presentation
]:
Hypertext/Hypermedia:
Navigation

General Terms

Languages

Keywords

RDF, Topic Maps, metadata conversion tool
s, metadata editing
tools, metadata navigation tools

1.

INTRODUCTION

The Semantic Web [1] is an on
-
going large
-
scale effort to
improve the current architecture of the World Wide Web by
adding a semantic infrastructure to web resources that can be used
for sop
histicated data
-
oriented applications. At its basis we can
identify metadata, or information about information, that
unambiguously specify machine
-
understandable facts about web
resources.

Through metadata we can select something (most often a web
-
accessab
le resource such as a document or process) and associate
it some information, e.g. a description, classification data or any
other attribute. With metadata we can also establish explicit
relationships between the resources we describe. This allows us to
ex
plicitly define the nature of attributes and relationships in terms
of the metadata language itself, so that it is possible to add
semantic to the things being described. Furthermore, since the
semantic layer that characterize the Semantic Web is built apa
rt
from the information resources that are linked by metadata, the

Copyright is held by the author/owner(s).

WWW 2003
, May 20
-
24, 2003, Budapest,

Hungary.

ACM xxx.

addition of semantic contents can be performed without any
editing of the original resources.

Even though it is possible to create metadata documents semi
-
automatically, a more precise appr
oach requires human
intervention. Much of the information that can be usefully
specified for a resource simply cannot be extracted without some
kind of human interpretation. Also the metadata that is to be
recorded about a resource is often derived from a
vocabulary of
interesting categories that are relevant for subsequent processes.
These vocabularies, called
ontologies
, can be required to adhere
to standards that can only be applied by humans. Once this
necessarily intelligent work has been performed, on
e of the
biggest claims that the Semantic Web makes is that by formalizing
the expression of the semantics of the information every automatic
application will be able to manage, understand and reason on it.

There are two competing models by which we can ex
press
metadata: RDF (Resource Description Framework) [2] is a W3C
recommendation and by design is meant to lay at the basis of the
W3C's vision of the Semantic Web; Topic Maps [5] is the 13250
ISO standard, and although developed independently of the W3C
i
t has several properties that make it an interesting alternative to
RDF. An important characteristic of both models is the fact that
they allow a serialization in XML, which makes metadata
specifications web resources themselves, amenable of further
commen
ting and descriptions by additional metadata layers, and
so on. The model is therefore repeatable and stackable, so that a
complex web of descriptions, descriptions of descriptions and so
on can be fruitfully generated.

The two languages are rather differe
nt even in their basic
concepts, and the choice of one model can have far
-
reaching
consequences both on the kind of statements that can be expressed
on a resource, and, more importantly, on the long
-
term usefulness
of these statements. Very few tools exist

so far that provide
conversion from and to each model, and most of them suffer of
serious drawbacks. Furthermore, the abstractness and complexity
of the topic surely have not worked towards the generation of
easy
-
to
-
use tools for the generation and examin
ation of metadata
documents. For instance editors for metadata collections are
mostly either limited in scope (to a single vocabulary, for
instance), or do nothing to hide the intrinsic complexity of the
syntax of the chosen syntax.

To partially overcome t
hese difficulties, we set to developing
META, three integrated tools for the coherent management of
metadata, both for RDF and Topic Maps. META is composed of a
metadata editor, of a metadata navigator, and of a bidirectional
converter from RDF to Topic Ma
ps and vice versa.

In this paper we present our approach to the bidirectional
conversion of RDF and Topic maps, and show how the use of
schemas and the adoption of Published Subject Identifiers (PSI)
in Topic Maps and standard predicates in RDF can lead to

a
painless integration of the two languages. This integration is also
instrumental in the creation of a single editing tool and a single
navigation tool that can be used for metadata collections
expressed in both languages.

In the next section we summariz
e the characteristics of both RDF
and Topic Maps, and summarize a few related works in the field
of conversion and editing of metadata collections. In section
\
ref{meta} we introduce our approach to the conversion of RDF
into Topic Maps and vice versa. The

following subsections are
dedicated to the description of the tools. Section
\
ref{conclusion}
contains some conclusions and a possible evolution path of our
research.

2.

METADATA STANDARDS

2.1

RDF and RDFS: an introduction

RDF (Resource Description Framework) is

a W3C
recommendation for the expression of metadata on any kind of
targets, from real life objects to abstract entities, but particularly
useful for Web resources such as documents or server
-
side
processes. The fundamental model of RDF is composed of thre
e
concepts:
Resources
,
Properties

and
Statements
. A resource is
what is being described through metadata, and it is identified by
an URI. A property is an attribute we want to associate to the
resource. The statement is a triple composed of the resource we

want to describe, the property and its value. Property values can
either be literals (i.e., strings) or other resources, which can
possibly introduce in further and more abstract levels of
indirection.

For instance, the sentence “Mario is the author of
ht
tp://www.mario.org” is a
statement

in which
“http://www.mario.org” is the
resource

that we are describing,
“being the author of” is the
property

we are associating to it and
“Mario” is the literal value of this property. We can graphically
express this sta
tement as shown in Figure 1.


Figure
1
. A simple RDF model

This graph can be serialized in XML. Two equivalent syntaxes are
presented in [3], an abbreviated and a full syntax, although in this
paper we w
ill not make this distinction.

<
rdf:Description rdf:about="http://www.mario.org">


<s:author>Mario</s:author>

</rdf:Description>

Other important syntax elements in RDF are containers, i.e.,
structures containing collections of resources. Statements can b
e
made to refer to collections, or collections can be used as values
for properties. The RDF model defines three types of containers:
bags
, i.e., sets with repeatable elements,
sequences
, i.e., sets with
a specified order on their elements, and
alternative
s
, i.e., sets
among which to extract one value as the relevant one.

RDF Schema (or RDFS for short) is a W3C working draft [2]
aimed at defining a description language for vocabularies in RDF.
An RDF schema (not to be confused with XML Schema) defines
class
es of resources and types of relationship that can be used in
RDF statements. RDF Schema makes it possible, for example, to
validate a value of a property or to constraint its range and domain
of applicability.

Using RDF Schema we can add other properties
to the metadata
defined in the previous example, for instance defining the web
page as class, adding some constraints on it (the values for the
author relation need to be literals, while the domain of values for
it are web pages) and applying this class as

type for the metadata
about http://www.mario.org.

author

http://www.mario.org

Mario

<rdf:Description rdf:ID="webpage">


<rdf:type rdf:resource="http://www.w3.org/2000/01/rdf
-
schema#Class"/>

</rdf:Description>


<rdf:Property rdf:ID="author">


<rdfs:domain rdf:resource="#webpage"/>


<
rdfs:range
rdf:resource="http://www.w3.org/2000/01/rdf
-
schema#Literal"/>

</rdf:Property>


<rdf:Description rdf:about="http://www.mario.org">


<rdf:type rdf:resource="#webpage"/>


<s:author>Mario</s:author>

</rdf:Description>

2.2

Topic Maps: an introduction

Topic maps, defined by the ISO 13250 standard, is a model for
describing knowledge structures and associating them with any
kind of information resources. The most important concepts of
Topic Maps are
Topics
,
Occurrences

and
Associations
.

Topics represent

any kind of thing we are interested in describing:
in order to associate metadata to some entity (a web page, a book,
a person, etc.), we create a topic and we specify as its subject a
URN suitable to identify this entity. In order to associate
attributes

to our subjects, we use occurrences structures to specify
name
-
value pairs to the topics. Through associations we can
define relationships among different topics. Associations are
inherently bidirectional: in order to distinguish the different roles
of ea
ch member in the association we need to create topics whose
sole purpose is to represent a so
-
called
association role type
.

In fact, the real means through which we add semantics in Topic
Maps is the type system. For instance, we can make any of the
previo
us concepts (topics, occurrences and associations) instances
of classes, which are nothing but other topics purposely created
for typing. We can also define entire hierarchies and therefore
define implicit relationships among topics (or associations,
occur
rences) that are instances of related classes.

To separate classes from instances, although there are no formal
rules to enforce this issue yet, we can use
Published Subject
Identifiers

(PSIs): these are subjects whose semantics, established
by the organiz
ations promoting the standard, is well known and
suitable to type topics with class roles. So, for example, beside
defining the hierarchy of topic types, we can also define any
occurrence type that can be used to specify any kind of attribute
that can be a
pplied.

Topic maps does not have any XML serialization language
specified. One of them, though, XML for Topic maps (or XTM)
seems to be the best candidate to become it. The sentence “Mario
is the author of http://www.mario.org” can be written in XTM as
fol
low.

<topic id="tt
-
person">


<baseName>


<baseNameString>Person<baseNameString>


<baseName>

</topic>


<topic id="tt
-
webpage">


<baseName>


<baseNameString>Web Page</baseNameString>


</baseName>

</topic>


<topic id="mario">


<instanceOf>


<topicRef xlink:href="#tt
-
person"/>


</instanceOf>


<baseName>


<baseNameString>Mario</baseNameString>


</baseName>

</topic>


<topic id="page">


<instanceOf>


<topicRef xlink:href="#tt
-
webpage">


</instanceOf>


<subjectIdentity
>


<subjectIndicatorRef
xlink:href="http://www.mario.org"/>


</subjectIdentity>

</topic>


<topic id="at
-
author">


<baseName>


<baseNameString>Author</baseNameString>


</baseName>

</topic>


<association id="assoc001">


<instanceOf>


<
topicRef xlink:href="#at
-
author">


</instanceOf>


<member>


<roleSpec>


<topicRef xlink:href="#tt
-
webpage"/>


</roleSpec>


<topicRef xlink:href="#page"/>


</member>


<member>


<roleSpec>


<topicRef xlink:href="#t
t
-
person"/>


</roleSpec>


<topicRef xlink:href="#mario"/>


</member>

</association>


We have defined two topic types
tt
-
person

and
tt
-
webpage
, used
to add type to the topics
mario

and
page
: by this we state that the
topic corresponding to the s
tring Mario is describing a person and
the topic whose subject is http://www.mario.org represents a web
page. Then we define the association type
at
-
author
, used to add a
type to the association between
mario

and
page
. Every member of
this association spec
ifies the role it assumes. In this case the role
and the type of the topic are the same.

2.3

Converting between RDF and Topic Maps

Both models are suitable to solve the knowledge management
problem, but the idea that inspired them was different. RDF has
been d
eveloped with the Semantic Web in mind, while Topic
Maps was born as a means to create a practical way to build
indexes of information resources. Nonetheless, both standards try
to achieve a practical and compact way to describe and relate
generic entities
.

In particular, both RDF and Topic Maps:



Allow the definition of abstract and concrete entities.



Have a type system to build hierarchies.



Allow to define semantic relationships between entities
(more precisely, they allow to define typed relationships).



A
llow a labeled
-
arc graph representation of relationships and
classes.

The most significant difference between the two is the expressive
power of the respective constructs: while Topic Maps offers a
more sophisticated set of basic constructs to use in the d
efinition
of metadata, RDF is easily extensible: the issue is therefore
between using the predefined set of predicates, as opposed to
having each user redefine new ones for the same purposes.

The problem of finding a mechanism that allows us to go back
and

forth between the two languages is therefore an important
one, and needs to be studied carefully. In the next section we
provide a short introduction to our approach, while here we list a
few existing tentative in the literature.

[19] is the first attempt

to offer integration between the two
languages. The strategy followed is very straightforward, as it is
based on the definition of PSIs to represent RDF concepts for the
RDF to Topic Map conversion, and the definition of RDF
predicates to represent Topic
Maps constructs in the other
direction. The definition of the mapping is not completely
defined, as it leaves unanswered issues of some importance for a
practical use of the mechanism.

In [20] the authors define a mapping model from Topic Maps to
RDF based

on the “Topicmaps.net's Processing Model for XTM
1.0” presented in [23], which defines a set of rules for processing
Topic Map documents in order to reconstitute the meaning of the
information they are intended to convey to their recipients.
Basically [20
] defines an RDF schema that represents the Topic
Map model with RDF statements. The approach, as claimed by
the authors, is complete and reversible. The paper does not
mention anything about the other direction of conversion.

Also [21] is based on [23] an
d it introduces some of the ideas we
have exploited in our work, such as the possible representation of
Topic Map association, scoped names and occurrences with
resources, instead of properties as they are usually conceived.
Neither this work, on the other

hand, takes into account the other
direction of the mapping.

The common drawback of all the works here listed is in our
opinion the rather awkward aspect assumed by the documents that
come out of the conversion. Even if preserving information means
that i
t is sometimes necessary to expect the applications managing
these documents to have some prior knowledge of the conversion
schema to work correctly, we found the readability of the
documents produced as an important aspect of the conversion
process.

The m
ost evolved work in the integration context is represented
by [22]. It moves its steps from the previously discussed papers
and proposes solution similar to ours.

In particular, for RDF to Topic Maps conversions, [22] draws the
conclusion that a generalize
d mapping for any RDF model is not
possible because of the many suitable alternatives that could be
chosen, and then it follows a complete mapping strategy guided
by a file which contains the rules for the translation of every
single RDF property. Each ent
ry in the mapping file corresponds
to an RDF property of the source document and it defines the
mapping into Topic Map constructs. This is similar to our
approach but it does not take into account the similarities of
standard RDF and RDFS predicates with T
opic Map constructs,
forcing the mapping to be defined even when it is clearly implied
by the common meaning of the constructs of both languages.

For Topic Maps to RDF conversions, on the other hand, [22]
suggests two different approaches. One is yet again

the
straightforward modeling of each Topic Map construct into RDF
classes and predicates, already proposed by [20] and [21]. The
main drawback of this approach, as mentioned, is that the result is
very different from a native RDF document.

The other appro
ach suggested makes again use of a mapping file
to guide the translation on a case by case basis. To accomplish
this, because of the lack of a standard Topic Maps Query
Language (TMQL), yet to be defined, he makes use of a
proprietary query language to ext
ract information and producing
RDF statements in accordance to the rules to be applied when a
match occurs. The results achieved are very good, but again the
translation is completely rule
-
driven and it does not make use of
implicit model
-
based commonaliti
es.

3.

META: A TOOL FOR METADATA
CONVERSION, EDITING AND
NAVIGATION

In this section we present META, a collection of three tools that
we developed in order to contribute to the metadata management
problem. The main objective we pursued was to provide a high
-
l
evel view of metadata technologies, by which even users without
specific technical knowledge of RDF and Topic Maps were able
to create, edit and browse these kinds of documents.

This is accomplished by hiding all of the syntax details of these
languages. U
sers are faced with simple GUIs which allow them to
leverage the power of the underlying technologies. To accomplish
this task, because of the rather low level of maturity reached by
these standards, we have been forced to extend them in some
aspects that
we will discuss in the next paragraphs.



The converter
: the presence of two different standards makes
the integration a primary concern. In order to avoid a
partitioning of knowledge management systems based on
metadata we built a conversion tool. The trans
lation provided
by the converter follows generic rules (described in the next
section) and in some cases it may not be the desired one. So,
in order to obtain a more customized translation, users who
know RDF and Topic Maps can pilot the conversion
sequenc
e.



The editor
: editors currently available for XTM or RDF are
essentially XML editors based on the grammar of the
languages. Even if tools like these make easy the creation of
metadata documents, the users must be experts in the original
languages, and kno
w the concepts behind each of their
constructs. We developed an editor that takes advantage of
schema information of the particular context, through which
we can reach a higher degree of transparency because users
are not forced to obey directly to the syn
tax constraints.



The navigator
: the main target in developing this tool was to
provide a uniform view of the document written in RDF and
Topic Maps. Moreover, as for the editor, we hid the internal
structure of these documents, so that users are not forced

to
know the syntax of the specification languages nor the
meaning of each XML tag.

3.1

META: the converter

For interoperability between applications using different standards
it would be useful having a conversion model between XTM and
the RDF/XML syntax. The

basic idea behind our work has not
been to develop a new model that could be used to unify the two,
but to find the way to translate the concepts expressed in one
format into the other. Unfortunately, because of the different
nature and history of RDF and

Topic Maps, that has not been
always easy or even possible.

Basically there are two different approaches to tackle this
problem. The first is to describe one model in terms of the other.
This has the problem that the converted document is necessarily
very

different from the one that would have been written directly
in the destination language, and hardly readable. The second
approach tries to identify, wherever possible, the semantic
equivalence of the respective constructs, and define a model
-
to
-
model map
ping. The problem with this approach is that this is not
always possible, and often requires some case
-
by
-
case approaches
that may have no general usefulness.

We have considered that the best approach is a hybrid of the two.
For example, if we have to tran
slate the
scope

element from a
Topic Map, we could define an RDF predicate to which associate
the same meaning, and apply it to the corresponding entity.

We can summarize the fundamental issues of a conversion schema
as:



Semantic completeness
: how much of
the information is
preserved in the transformed document.



Readability
: how close is the document produced after the
translation process to what it would be if it was written using
the native language.



Reversibility
: how different from the original is a doc
ument
that is converted twice.

3.1.1

Topics, resources, URIs and names

In a natural model
-
to
-
model mapping, topics can be seen as RDF
resources, and vice versa. However the mapping is not trivial, as
the correct identification of the entity can vary in a case by

case
basis. Topic Maps uses
subjectIdentity
s to annotate the subject of
a description, which can be either an addressable resource
(indicated in XTM by a specific tag), or a subject indicator (a URI
referring to a resource that indicates to a human what t
he subject
of the topic is). On the other hand RDF uses a unique URL to
refer to the subject of a description, indicated by the attribute
rdf:about
, or, for abstract resources, by
rdf:ID
.

So, to pass from Topic Maps to RDF the straightforward solution
is t
o use subject resources as the URL for statement subjects, and
to create a random ID for those topics that do not have a resource
as subject, and eventually to specify the
subjectIndicator

with a
new predicate to which assign the same meaning.

This seems t
o be the most reasonable solution, and we choose the
standard predicate
rdf:isDefinedBy

for this purpose. For the
opposite sense of translation we choose essentially the same
behavior, but we have considered that, when
rdf:ID

is used to
define an abstract
resource, this has usually also a naming
functionality. So we choose to include its value among the
baseName
s of the topic.

XTM defines also an alternative form of a base name, called
variant
, meant for particular computational purposes, such as
sorting or

display. Beside any consideration about the real
usefulness of variants, they represent a form of structured
information, in that they are attributes with associated
information, their context (or
scope
). This type of information is
not directly expressed

in RDF, because the subject
-
predicate
-
object paradigm does not allow adding attributes to the property.

To map variants, therefore, we decided to create an abstract RDF
resource whose only purpose is to enclose all the information
about the variant name,
and a specific predicate to associate the
variant resource to the subject.

This technique has the advantage of preserving all the information
of a Topic Map, although it compromise the readability of the
RDF document and requires the application to know th
e schema
used for the translation.

3.1.2

Relations, associations, occurrences

The way RDF and Topic Maps allow to assert relationships
between entities is very different. RDF uses properties, which
implies that relations are inherently unidirectional and binary.

Topic Maps has a more sophisticated construct, the association,
that allows us to specify relations with multiple entities involved
in a bidirectional way; we can disambiguate the nature of the
relation by specifying the role played by each member of the
association, which is itself a topic with typing purpose. The
problem of the translation can be addressed in several ways.

The first and more natural way is to assume a model
-
to
-
model
mapping with predicates and associations types. The problem
arises in th
e treatment of
n
-
ary associations that have to be
translated into unidirectional predicates. Assuming the translation
of association types into predicates, we need to add
(n
-
1)

statements to each entity involved in the association, relating the
subject to
all of the other members, which results in
n(n
-
1)

statements added to the model.

Another approach is represented by the use of bags. This suggests
the creation of an abstract entity for each association, typed with
an appropriate RDF class which correspond
s to the association
type. This abstract entity is related, with a suitable predicate
defined in a translation schema, to another abstract entity with
rdf:Bag

as type, which lists every original association member.
Furthermore, we can make each list item o
f the resulting bag
another abstract entity, in order not to lose the role member
information.

An example is necessary: assuming that the referenced topics are
defined elsewhere in the document, the association presented in
the previous example can be tran
slated as:

<rdf:Description rdf:ID="assoc001">


<rdf:type rdf:resource="#at
-
author"/>


<tm2rdf:association rdf:resource="#members_assoc001"/>

</rdf:Description>


<rdf:Description rdf:ID="members_assoc001">


<rdf:type rdf:resource="http://www.w3.org/1999
/02/22
-
rdf
-
syntax
-
ns#Bag"/>


<rdf:_1 rdf:resource="#page_assoc001"/>


<rdf:_2 rdf:resource="#mario_assoc001"/>

</rdf:Description>


<rdf:Description rdf:ID="page_assoc001">


<rdf:type rdf:resource="#tt
-
webpage"/>


<rdfs:isDefinedBy rdf:resource="#page"/
>

</rdf:Description>


<rdf:Description rdf:ID="mario_assoc001">


<rdf:type rdf:resource="#tt
-
person"/>


<rdfs:isDefinedBy rdf:resource="#mario"/>

</rdf:Description>


The drawbacks here are low readability and the use of a particular
RDF schema instance,
which forces all applications to know it for
a correct understanding of the converted statements. On the other
hand, this conversion is always applicable, and so it represents the
default behavior of our tool.

The other side of the mapping, from RDF to Top
ic Maps, is also
difficult. The problem here lies in the correct identification of the
predicates' nature. Unless RDF Schema information are available
for the original document, specifying the range and domain of
each of them, it is not always possible to
understand effectively if
a statement relates two entities or if the object of the statement can
be considered an attribute of the subject. Anyway, assuming that
this is not the case, the predicate
-
association type mapping is
immediate. The role member can

be deduced by the constraint
information relative to the predicate, disambiguating the produced
association.

It is worth noting that, in the absence of schema information about
the properties, their nature has to be deduced by the context. This
follows fr
om the lack of a clear separation between relations and
attribute in the RDF standard.

The solution we propose uses a default behavior, which can be
tailored to treat predicate as association and vice versa. In this
manner the user can pilot the translatio
n in finer grained level, as
shown in [16].

Topic Maps has the notion of occurrences, which are used to
associate name
-
value pairs to topics. The value of the occurrence
may be a resource identified by its URL. RDF, as discussed
before, uses predicates for

this purpose, too. Here again the main
problem lies in the recognition of the nature of attribute of a
property. RDF does not have a construct to reify resources, so it is
sometime hard to tell the differences between a relation involving
two resources an
d an attribute, unless the value of a property is a
literal value.

The RDF and RDFS specification give us a useful set of
predefined predicates, and these can be mapped to occurrences or
relations as appropriate, but for user
-
defined predicates we have
to
rely on schema information. Particularly, eventual information
about range and domain can be exploited. That is, if we are told
that the range of a user defined predicate is a particular
rdfs:Class
,
we can assume the predicate is intended to establish rela
tions
between entities, while otherwise it is possible to assume the
attribute nature of the property. The behavior of our engine (when
converting RDF to Topic Maps) follows this rule, mapping
predicates to occurrence types if nothing is known about the ra
nge
of the predicate itself, and resolving it otherwise to an association
type as explained in the previous paragraph.

The other side of mapping does not present particular problems,
resolving occurrence types in predicates.

[ESEMPIO]

3.1.3

Type systems

Both sta
ndards have a fairly complete type system that allows the
creation of class
-
instance and superclass
-
subclass relations with
entities.

RDF/RDFS does this with the predefined
rdf:type

predicate,
relating an instance with its class, and
rdfs:subClassOf

which
relates a subclass with its superclass. Topic Maps allows the
typing of topics with other topics with class functionality.
Unfortunately, there is no standard way to declare the class (or
topic type, as it is usually said) nature of topics. However, this c
an
be done using a PSI. On the other hand, the superclass
-
subclass
relation is easily rendered with an explicit association. With the
mapping we have considered so far, these translations do not seem
to present particular problems.

3.2

META: the editor

Editors

available nowadays for XTM or RDF are essentially XML
editors based on the grammar of one of the two languages. Even if
tools like these make easy the creation of metadata documents, the
users must know the concepts behind each of these paradigms.

[LISTA
DI EDITOR]

In our opinion, by taking advantage of schema information of a
particular context it is possible to reach a higher degree of
transparency, since users are not forced to obey directly to the
syntax constraints. The idea is to allow the creation o
f metadata
resources which can be typed using the type systems defined in a
schema. So, once the type is chosen, the editing permits the
insertion of only the attributes and the relations expected.

With the META editor we show how it is possible to offer a

common view of metadata technologies, hiding the syntactical
aspects that inexpert users could ignore. The editor is schema
dependent: to create new documents, users must choose a
particular schema among those that are provided. The format of
new document
s depends on the metadata language used to write
the schema. The binding information of each document with the
respective schema is kept within the document itself.

The following screenshot shows an entity of type
Person
. It is
possible to note its names,
the relations it takes part to and its
attributes. The left area of the editor contains an ordered list of all
the available entities defined in the loaded document.

Figure
2
. META: the editor

To offer a common interface for the e
diting of documents in the
two formats, we have followed the same guidelines described for
the conversion tool. Essentially we have unified the view of
metadata with the concepts of
type
,
attributes

and
relations
.
Adding a new entity to a document implies
to choose a type for it.
Consequently all and only the attributes and the relations that the
schema defined as applicable to an instance of the chosen type are
available to the user.

In order to make this approach work, a complete definition of the
schema
is necessary. In particular, all the attributes and relations
have to be constrained to their pertaining types. Thus, type system
has to be defined accordingly, exploiting the hierarchical feature it
provides.

While RDF Schema provides all the necessary pr
imitives for this
task, Topic Maps has not an equivalent constraint language yet. A
language called TMCL is under development by the ISO, but no
document has been produced yet. A “low bar” proposal for the
Topic Map Constraint Language has been published i
n [17]. This
document defines the requirements for what TMCL is supposed to
provide, and it offers a starting point example. In the absence of a
standard, we have used the proposal concepts, and we have
slightly extended them with what we needed to accompl
ish our
task. In fact, this implementation of the constraint language
addresses all the issues required to define the applicability
constraints of occurrences and associations in a Topic Map
schema. The main feature of this implementation is the use of
XTM

itself to define schemas. Basically, it uses a
template

mechanism to define the types, the occurrences and the
association pertaining to them.

We can define occurrence types, which represent our attributes, as
topic typed with a PSI introduced for this pu
rpose. Then we can
define a topic type as a template, specifying in its XTM context all

of the occurrence types we may apply to instances of that type.

For association types (i.e., our relations), we can again define
topics typed by the PSI which represent
s association classes, and
then define all of the association templates, instantiating them
with one of these topics. The members of an association template
are interpreted as the topic types that an association instance may
have for each role.

With Topic
Maps we are allowed to specify multiple members for
each association. In this case the editor will constrain the user
who wants to instantiate this association to specify an instance
entity for each one.

3.3

META: the navigator

Many search engines provide a ca
talogue of web pages, indexed
according to their content. In this way a semantic tree can be used
to reach the relevant resources. Unfortunately these catalogues
allow only navigation by
subjects

and cannot express other
possible relationships among these
documents. In other words we
loose all the semantic connections that cannot be captured by the
indexing system but can be expressed using metadata
technologies.

Moreover often the resource content is the final destination of the
semantic navigation: the us
er cannot access other metadata
relative to the resource (such as the date, the author or the
bibliography) without opening and reading it. All this information
could be contained in a metadata block associated to the
document and accessed through a semant
ic navigator, allowing a
richer search and access.

[LISTA DI NAVIGATORI]

Our main objective in developing the navigation tool is to provide
a uniform view of documents written in RDF and Topic Maps.
Since we hide the internal structure of these documents,
users are
not forced to know the syntax of the specification languages nor
the meaning of each XML tag.

The following screenshot shows the navigator browsing the
categories of Java languages. We can see three different sections:



The main categories defined

in the opened document.



The subcategories of the select main category.



The available instances for the current category.


Figure
3
. META: the navigator. Categories browsing

As specified in the previous section, we limited the met
adata that
can be applied to a resource to either an attribute (a property
whose value is a literal or a link to a resource, such as the title of a
book) or a relation (i.e., associations among two or more typed
entities).

The following screenshot shows th
e details for a resource of type
Person
. It is possible to note the names, the relations it takes part
to and the attributes. Clicking on the other members of the
relations here listed it is possible to view the details of the
selected item.


Figure
4
. META: the navigator. Entity browsing

Attributes and relations are typed. Every type used for this
purpose must have a human readable name in order to be properly
presented to the user.

Both RDF and Topic Maps natively support a set o
f attributes as
the type of a resource, its name and a link to a resource which is
the subject of the metadata entity. So the standard XML tags are
used to represent these attributes.

The attributes defined in schemas need to be interpreted by the
navigato
r in order to be properly displayed to the user. In most
cases this tool will not know their meaning. For example, if we
define the attribute
photo

for the class
person

and the attribute
cover

for the class
book

the navigation software should recognize
the
m as links to images and show them as graphic elements. So it
should be necessary the standardization of ontologies and the use
of public schemas which define the most common entities (such
as the Dublin Core [18]). In this way the documents management
sho
uld be even more standardized and the presentation should be
more effective. In order to support this features we developed a
small set of public subjects which can be used to type attributes
regarding multimedia contents as images, audio or video
resource
s.

Every RDF property defined in a schema is interpreted as:



A relation if in its definition the predicate
rfds:range

has a
typed entity (of type
rdfs:Class
) as value.



An attribute otherwise.

Whereas in XTM:



Every
association

element corresponds to a relat
ion among
its
member
s. Every association is typed with an association
-
type topic whose name will used to display it.



Every
occurrence

element of a topic is mapped to an
attribute.

4.

CONCLUSIONS

At this stage of their evolution, neither RDF nor Topic Maps see
m
able to overcome the competing language. For this reason, relying
on just one of them for the specification of long
-
lasting metadata
about Web resources may end up being an ill
-
fated decision were
the other one the eventual
de facto

starndard.

Unfortuna
tely, converting from one format to the other is not as
painless as it should be. Many natural constructs in RDF have no
corresponding structure in Topic maps and viceversa. We have
shown that in many cases the result of automatic conversion end
up being p
articularly awkward and hard to read.

META, with its collection of three tools for the management of
metainformation both in RDF and Topic Maps, could be an
important step in providing easy integration of the two languages.

Of course, we have found out t
hat the conversion is eased by an
appropriate choice of constructs in the original language, and by
the sistematic use of schemas whenever possible.

At the moment, the META editor does not provide any facility for
the specification of schemas, which have
to be provided in
advance. This is due to the fact that neither RDF nor Topic Maps
have a stable document for the description and specification of
schemas for their languages. We believe that a tool for the visual
specification of schemas is an indispensab
le addition to the
current set of tools, and we plan to work on such an improvement
in the next future.

At the moment, anyhow, the current set of tools seems able to
provide much more sophisticated and integrated functionalities
than other existing applic
ations.

5.

REFERENCES

[1]

Tim Berners
-
Lee, James Hendler and Ora Lassila, The
Semantic Web,
Scientific American 284,5

(May 2001), 35
-
43.

[2]

World Wide Web Consortium: Resource Description
Framework (RDF) Model and Syntax Specification, W3C
Recommendation 22 Februa
ry 1999,
http://www.w3.org/TR/1999/REC
-
rdf
-
syntax
-
19990222/

[3]

World Wide Web Consortium: RDF/XML Syntax
Specification (Revised), W3C Working Draft 25 March
2002, http://www.w3.org/TR/rdf
-
syntax
-
grammar

[4]

World Wide Web Consortium: RDF Vocabulary Description
La
nguage 1.0: RDF Schema, W3C Working Draft 30 April
2002, http://www.w3.org/TR/rdf
-
schema

[5]

Joint Technical Committee 1 JTC1, ISO/IEC 13250 Topic
Maps, 3 December 1999,
http://www.y12.doe.gov/sgml/sc34/document/0129.pdf

[6]

HP Labs, HPL Semantic Web activity: Jen
a Toolkit,
http://www.hpl.hp.com/semweb/jena
-
top.html

[7]

The Resource Discovery Unit, Reggie
-

The Metadata Editor,
http://metadata.net/dstc

[8]

Intellidimension Inc., RDF Gateway,
http://www.intellidimension.com

[9]

UKOLN, DC
-
dot Java,
ftp://ftp.ukoln.ac.uk/metadata
/tools/dcdot/java

[10]

Spirit, Metabrowser, http://metabrowser.spirit.net.au

[11]

Khalil Ahmed, Topic Maps 4 Java, http://www.tm4j.org

[12]

Techquila, MDF
-

A Metadata Processing Framework,
http://www.techquila.com/mdf.html

[13]

Christoph Fröhlich and Niko Schmuck, TMNav,
htt
p://www.tm4j.org

[14]

Ontopia AS, Omnigator,
http://www.ontopia.net/omnigator/models/index.jsp

[15]

Empolis UK ltd, K42, http://k42.empolis.co.uk

[16]

Riccardo Gentilucci and Marco Pirruccio, Metadata on the
Web: on the integration of RDF and Topic Maps, UBLNCS,
Universi
ty of Bologna Technical Report, 2002, in print.

[17]

Steve Pepper, Draft requirements, examples, and a “low bar”
proposal for Topic Map Constraint Language, 2001,
http://www.y12.doe.gov/sgml/sc34/document/0226.htm

[18]

DCMI, Dublin Core Metadata Initiative,
http://
dublincore.org

[19]

Graham Moore, RDF and TopicMaps: An Exercise in
Convergence, XML Europe 2001 in Berlin,
http://www.topicmaps.com/topicmapsrdf.pdf

[20]

Martin Lacher and Stefan Decker, On the integration of
Topic Map data and RDF data, Extreme Markup Languages
20
01, Montreal, Canada,
http://www.semanticweb.org/SWWS/program/full/paper53.p
df

[21]

Nikita Ogievetsky, XML Topic Maps through RDF glasses,
Extreme Markup Languages 2001, Montreal, Canada,
http://www.cogx.com/rdfglasses.html

[22]

Lars Marius Garshol, Topic maps, RDF,

DAML, OIL: A
comparison by Lars Marius Garshol,
http://www.ontopia.net/topicmaps/materials/tmrdfoildaml.ht
ml

[23]

Steven R. Newcomb and Michel Biezunski, Topicmaps.net's
Processing Model for XTM 1.0, version 1.0.2, 25 July 2001,
http://www.topicmaps.net/pmtm4.
htm