=Paper=
{{Paper
|id=Vol-55/paper-7
|storemode=property
|title=EDUTELLA: Searching and Annotating Resources within an RDF-based P2P Network
|pdfUrl=https://ceur-ws.org/Vol-55/nejdl.pdf
|volume=Vol-55
|dblpUrl=https://dblp.org/rec/conf/sww/NejdlWST02
}}
==EDUTELLA: Searching and Annotating Resources within an RDF-based P2P Network==
https://ceur-ws.org/Vol-55/nejdl.pdf
EDUTELLA: Searching and Annotating Resources
within an RDF-based P2P Network
Wolfgang Nejdl, Boris Wolf Steffen Staab, Julien Tane
L3S and Knowledge Based Systems L3S and Institute AIFB
University of Hannover 76128 Karlsruhe, Germany
30167 Hannover, Germany
fsst,jtag@aifb.uni-karlsruhe.de
fnejdl,wolfg@kbs.uni-hannover.de
ABSTRACT vide for specialized cases, but non-trivial for general applications.
P2P applications for searching and exchanging information over The core concern of our research therefore is to develop a general
the Web have become increasingly popular. This has lead to a num- infrastructure for combining metadata with P2P networks.
ber of (usually thematically) focused communities, which allow In the context of educational resources for example, which we
efficient searching within such communities, and which use spe- are currently focusing on, P2P-based approaches are more flexi-
cific metadata sets to specify the resources stored within the P2P ble than centralized approaches like Client-Server computing, with
network. By concentrating on domain and application specific for- several advantages for the participating institutions. As content
mats for metadata and query languages, however, current P2P net- providers in a P2P network they do not loose control over their
works appear to be fragmenting into non-interoperable niche mar- learning resources but still provide them for use within the net-
kets. This contribution describes the open source project Edutella work. As content consumers, both teachers and students, benefit
which builds upon metadata standards defined for the WWW and from having access not only to a local repository, but to a whole
aims to provide an RDF-based metadata infrastructure for P2P ap- network, using queries over the metadata distributed within the net-
plications, building on the recently announced JXTA Framework. work to retrieve required resources.
We describe one basic service (query) and an Edutella application Recent P2P applications have been very successful for special
(annotation) within this network, both being built on a common cases like exchanging audio files. However, retrieving MP3 coded
query language exchange format, and specify the main architecture audio files using title and author does not need complex query lan-
and APIs of the Edutella P2P network. guages nor complex metadata, so special purpose formats for these
P2P applications have been sufficient. Metadata in Gnutella are
limited to a file name and a path. This is fine for queries looking
1. BACKGROUND for the song “Madonna - Like a Virgin”, but cannot be extended
The advantage of the WWW is that it constitutes a pre- to something like “Introduction to Algebra - Lecture 23”. For ed-
dominantly decentral paradigm storing information resources in ucational resources, queries are more complex and have to build
hypertext like structures. Searching in the WWW, however, typ- upon standards like IEEE-LOM/IMS [2] metadata with up to 100
ically follows a client-server model, viz. browser vs. search engine metadata entries, which might even be complemented by domain
[16], inheriting the corresponding benefits and pitfalls. To name specific extensions.
some problems, search engines cover only a decreasing percentage Furthermore, by concentrating on domain specific formats, cur-
of the information available on the Web and their content is often rent P2P implementations appear to be fragmenting into niche mar-
not up to date because of the time required for crawling of the Web. kets instead of developing unifying mechanisms for future P2P ap-
In contrast, information resources in P2P networks are stored plications.
on numerous peers waiting to be queried for these resources. The In order to facilitate interoperability and reusability of edu-
querying of peer-to-peer networks allows the comprehensive re- cational resources, we need to provide an infrastructure flexible
trieval of up-to-date resources stored at relevant sites. But in order enough to accommodate complex and varying metadata sets, and
to achieve this, it requires a query mechanism using some descrip- avoid creating another special purpose application suitable only for
tion of the resources managed by these peers. a specific application area which is outdated as soon as metadata re-
While in the server/client-based environment of the World Wide quirements and definitions change. The Edutella infrastructure [4]
Web metadata are useful and important, for Peer-to-Peer (P2P) therefore builds on the W3C metadata standard RDF(S) [1], and
environments that come without underlying hypertext structures uses a standard query model suitable for this formalism, based on
metadata are absolutely crucial. Such metadata are easy to pro- Datalog, to exchange queries throughout the Edutella network.
For the local user, the Edutella network transparently pro-
vides access to distributed information resources, and different
Permission to make digital or hard copies of all or part of this work for clients/peers can be used to access, retrieve and update these re-
personal or classroom use is granted without fee provided that copies are sources. The service and the peer that we will describe in more de-
not made or distributed for profit or commercial advantage and that copies tail in this paper are querying and annotating resources distributed
bear this notice and the full citation on the first page. To copy otherwise, to in the Edutella P2P network, respectively.
republish, to post on servers or to redistribute to lists, requires prior specific
permission by the authors.
Query Service. The Edutella query service is the most basic
Submission to Semantic Web Workshop 2002 Honolulu, Hawaii, May 7, service within the Edutella network. Peers register queries they
2002 may be asked through the query service (i.e. by specifying sup-
Copyright by the authors.
ported metadata schemas (e.g. “this peer provides metadata accord- In section 2, we discuss the Edutella query service and the
ing to the LOM 6.1 or DCMI standards”) or by specifying individ- common data model (ECDM), which provides the basis for the
ual properties or even values for these properties (e.g. “this peer Edutella query exchange language and format implementing dis-
provides metadata of the form dc title(X,Y)” or “this peer provides tributed queries over the Edutella network, as well as the basic
metadata of the form dc title(X,’Artificial Intelligence’)”). Queries Edutella API for query and registration/distribution peers. Sec-
are sent through the Edutella network to the subset of peers who tion 3 discusses the annotation application that connects to the
have registered with the service to be interested in this kind of Edutella network in order to exploit existing metadata as well as
query. The resulting RDF models are sent back to the requesting create and provide new metadata to the network.
peer.
Edutella Annotation. In order to be able to meet the require- 2. EDUTELLA QUERY SERVICE
ments of being applicable in a wide range of application scenarios,
the Edutella annotation tool must be independent from a particu- 2.1 The Query Mechanism
lar domain. For instance, it may not just offer annotation for IEEE
The Edutella Query Service is intended to be a standardized
LOM, but rather it must support a wide range of semantic defini-
query exchange mechanism for RDF metadata stored in distributed
tions as it is possible in RDF schema. In order to approach this
RDF repositories and is meant to serve as both query interface for
objective, we investigate two orthogonal dimensions for metadata
individual RDF repositories located at single Edutella peers as well
creation based on which we may emulate all annotation schemes
as query interface for distributed queries spanning multiple RDF
we know of.
repositories. An RDF repository (or knowledge base) consists of
Building on the JXTA P2P Framework. JXTA is an Open
RDF statements (or facts) and describes metadata according to ar-
Source project [5] supported and managed by Sun Microsystems.
bitrary RDFS schemas.
In essence, JXTA is a set of XML based protocols to cover typical
To enable a peer to participate in its network, Edutella uses wrap-
P2P functionality. It provides a Java binding offering a layered ap-
pers based on both a common datamodel and a common query ex-
proach for creating P2P applications (core, services, applications).
change format. For communication within the Edutella network the
In addition to remote service access (such as offered by SOAP),
wrapper translates the local data model into the Edutella common
JXTA provides additional P2P protocols and services, including
data model (ECDM) and vice versa, and connects to the Edutella
peer discovery, peer groups, peer pipes, and peer monitors.
Network using the JXTA P2P primitives, transmitting the queries
Figure 1, reproduced from [5], specifies the different layers
based on the ECDM in RDF/XML form. In order to describe
within the JXTA architecture.
and handle different query capabilities of a particular peer, we de-
fine several RDF-QEL-i exchange language levels with increasing
expressiveness: Currently we have defined language levels RDF-
QEL-1, -2, -3, -4 and -5 (see [11]). The most simple language
(RDF-QEL-1, purely conjunctive queries) can be expressed as un-
reified RDF graph, the more complex ones are more expressive
than RDF itself, and therefore have to be expressed using reified
RDF statements (e.g. RDF-QEL-3 covers relational algebra, RDF-
QEL-4 incorporates Datalog). However, all language levels can be
represented through the same internal ECDM data model.
Figure 1: JXTA Layers
JXTA provides a layered architecture that fits very nicely into the
Edutella application scenarios:
Edutella Services (described in web service languages like
DAML-S or WSDL, etc.) complement the JXTA Service
Layer, building upon the JXTA Core Layer1 , and
Edutella Peers live on the Application Layer, using the func-
tionality provided by these Edutella services as well as pos-
sibly other JXTA services.
On the Edutella Service layer, we define data exchange formats
and protocols (how to exchange queries, query results and other
metadata between Edutella Peers), as well as APIs for advanced
functionality in a library-like manner. Applications like reposito-
ries, annotation tools or GUI interfaces connected to and accessing
the Edutella network are implemented on the application layer.
1
A previous prototype from our group, implemented this summer
to gain experiences with the JXTA and JXTAsearch framework, ex- Figure 2: Knowledge Base as RDF Graph
tended the JXTAsearch service (the prototype and our experiences
with it are described in [13]), but building directly on the JXTA The example presented throughout our paper, we will use a sim-
Core services makes a more flexible design possible. ple RDF knowledge base and a simple query on the knowledge base
depicted in Figure 2. Evaluating the query (plain English) head of rules denote derived predicates. In our example, the query
expression “aibook(X)” asks for all bindings of X, which conform
“Return all resources that are a book having the title to the given Datalog rules and the knowledge base to be queried
’AI’ or that are an AI book.” (cf. below for results).
we get the query results shown in Figure 3, represented as an
RDF-graph.
2.2.2 ECDM Datamodel and Queries
Figure 4 visualizes the ECDM, as implemented in our current
prototype, as UML diagram. Our Java binding relies on JXTA [5]
and makes extensive use of the Stanford RDF API [10]. The imple-
mentation of all classes shown in figure 4 is found in the Java pack-
age net.jxta.edutella.util.datamodel. All classes
whose names start with RDF represent standard RDF concepts
and correspond to their equivalent counterparts within the Stan-
ford RDF API. These are RDFReifiedStatement, RDFNode,
RDFResource, RDFLiteral and RDFModel.
Queries are represented by EduQuery which ag-
gregates an arbitrary number of rules (EduRule) and
query literals (EduLiteral). EduLiterals are either
RDFReifiedStatements (binary predicates / ternary
statement literals, corresponding to reified RDF statements),
EduStatementLiterals (non-ternary statement literals,
which cannot be expressed as ordinary RDF statements), or
EduConditionLiterals (a condition expression on variables
Figure 3: Query Results as RDF Graph such as X> 5).
Technically, it is sufficient to define a single instance of
EduLiteral as query literal. However, by using a set of
2.2 Edutella Common Data Model (ECDM) EduLiteral objects, all query literals together can be interpreted
as the RDF result graph of the EduQuery, as long as the query lit-
2.2.1 Basic Semantics erals are all instances of RDFReifiedStatement.
As common query and datamodel, Edutella peers use Datalog, An EduRule consists of an EduStatementLiteral as its
a non-procedural query language based on Horn clauses without head and an arbitrary number of EduLiterals as its body.
function symbols. A Datalog program can be expressed as a set of EduStatementLiterals can occur within a rule’s body as
rules/implications (where each rule consists of one positive literal well to allow reuse of other rules and recursion.2
in the consequent of the rule (the head), and one or more negative EduVariable objects are ordinary RDF resources with the su-
literals in the antecedent of the rule (the body)), a set of facts (single per class RDFResource. Being of type EduVariable however
positive literals) and the actual query literals (a rule without head, marks a resource to be a variable. An additional attribute allows to
i.e. one or more negative literals). Literals are predicate expres- specify the label of a variable. Variables may occur in all places
sions describing relations between any combination of variables where RDFResources are allowed: As subject, predicate or
and constants such as title(http://www.xyz.com/book.html, ’Arti- object within RDFReifiedStatements as well as arguments
ficial Intelligence’). Disjunction in a query is expressed by a set of of EduStatementLiterals or EduConditionLiterals.
rules with identical head. A Datalog query then is a conjunction of The class EduVariableBinding introduces a further extension
query literals plus a possibly empty set of rules. to EduVariable by providing an actual value for a variable.
Datalog queries easily map to relations and relational query lan- Variable values can be either RDFResource or RDFLiteral
guages like SQL. In terms of relational algebra Datalog is capable objects.
of expressing selection, union, join and projection and hence is a Besides the ECDM data model the Java binding also provides
relationally complete query language. Additional features include a package net.jxta.edutella.util which contains classes
transitive closure and other recursive definitions. for importing queries provided in various languages into the in-
In RDF any statement is considered to be an assertion. We ternal ECDM model or in turn exporting queries from their in-
can view an RDF repository as a set of ground assertions either ternal representation into different syntaxes. The current proto-
using binary predicates as shown above, or as ternary statements type includes the classes SQL (export of SQL queries), Datalog,
“s(S,P,O)”, if we include the predicate as an additional argument. RDFQEL1 and RDFQEL3 (all of them supporting import and ex-
In the following query, we use the binary predicate notation. port of queries). Any peer can plug in additional classes here to
support further query languages (see [11]).
aibook(X) :- title(X, ’AI’), type(X, Book).
aibook(X) :- type(X, AI-Book).
?- aibook(X).
As our query is a disjunction of two conjunctive subqueries,
its Datalog representation is composed of two rules with identical
heads. The literals in the rules’ bodies directly reflect RDF state- 2
Note, that as input format we can even allow arbitrary first order
ments with their subjects being the variable X and their objects logic formulas in the body of rules, which then can be transformed
being bound to constant values such as ’AI’. Literals used in the into a set of rules using the Lloyd-Topor transformation [8].
EduResultSet EduResult EduTupleResult
hasResult
hasResults:EduResult hasBindings:EduVariableBinding
RDFModel
hasResultSet hasBindings
hasHead
EduRule EduVariableBinding
hasHead:EduStatementLiteral variable:Resource
hasBody:EduLiteral EduStatementLiteral value:RDFNode
hasPredicate
hasPredicate:Resource
hasArguments:RDFNode hasArguments
value variable
hasRules hasBody
EduLiteral EduConditionLiteral RDFNode
arg1
negated:boolean op:Operator
arg1:RDFNode arg2
hasQueryLiterals arg2:RDFNode
EduQuery Literal Resource
hasRules:EduRule RDFReifiedStatement object
hasQueryLiterals:EduLiteral subject:Resource
hasResultSet:EduResultSet subject
predicate:Property
object:RDFNode Property
predicate
Figure 4: Edutella Common Data Model (ECDM)
2.2.3 Query Results sent a complete result set for an Edutella query. The individual
As a default, we represent query results as a set of tuples of vari- results may be either EduTupleResult or RDFModel objects
ables with their bindings serialized in XML/RDF-format, as speci- but they are all required to have the same type. When executing a
fied in Figure 4, which follows closely the convention of returning query all query literals are evaluated using the necessary rules. Af-
substitutions for variables occuring in queries to logic programs. ter query execution a EduQuery object references an appropriate
Another possibility, which has been explored recently in Web EduResultSet object pointing to all query results.
related languages focusing on querying semistructured data, is the Classes within net.jxta.edutella.util also allow the
ability to create objects as query results. import and export of query results in various other formats. Cur-
In the simple case of RDF-QEL-1, we can return as answer ob- rently implemented are the classes SQL (for import of results pro-
jects the graph representing the RDF-QEL-1 query itself with all vided as JDBC ResultSets) and GraphViz (for export of
Edutella specific statements removed and all variables instantiated. graph description files in GraphViz format allowing to use the free
The results can be interpreted as the relevant sub graph of the RDF GraphViz tool to visualize query results).
graph we are running our queries against (see Figure 3). When
we use general RDF-QEL-i queries, we assume the structure of the 2.3 Registration Service and Mediators
answer graph to be defined by the subset of binary query literals. The wrapper-mediator approach introduced in [17], divides the
Note, that all variables used in the query literals are assumed to functionality of a data integration system into two kinds of subsys-
be existentially quantified, so if they are not instantiated during the tems. The wrappers provide access to the data in the data sources
query evaluation, they are represented as anonymous nodes in the using a common data model (CDM) and a common query lan-
RDF answer graph. guage. The mediators provide coherent views of the data in the
In the ECDM, EduResult is an abstract super class for dif- data sources by performing semantic reconciliation of the CDM
ferent forms of query result representations. Results may be ei- data representations provided by the wrappers. Both common data
ther represented as tuples (EduTupleResult objects aggregat- model (ECDM) and common query language for the Edutella net-
ing an arbitrary number of EduVariableBindings) or as RDF work have been defined in this paper.
graphs (RDFModel objects). In terms of relational algebra each Our simple “wrapping” mediators (see Figure 5) distribute
EduResult object can be interpreted as one row in the result set queries to the appropriate peer with the restriction that queries can
of a relational database query. Each EduResult object corre- be answered completely by one Edutella peer. Complex ’integrat-
sponds to one match for a query. EduResultSet objects ag- ing’ mediators are discussed in [11].
gregate an arbitrary number of EduResult objects and repre- Registration of peer query capabilities is based on (instantiated)
property statements and schema information, basically telling the
CONSUMER QEL-WRAPPER
W INTER / EBIZ + INTELLIGENTWEB /# COURSE from the class
REGISTRATION SWRC :S EMINAR . (ii), one may instantiate the attributes of
PEER PEER
the first identifier by names like “Siegfried Handschuh” or “Siggi”.
MEDIATOR (iii), one may relate instances, e.g. the first with the second
DISTRIBUTED identifier by the property SWRC : TEACHES.
PEER These types of instantiations may be considered one dimension
QUERIES
in the metadata creation process. Another, orthogonal, dimension
CONSUMER QEL-WRAPPER
is defined by the way annotations are created, used and maintained:
PEER
PEER
REGISTRATIONS 1. Unlinked facts fill fields of the schema. There is no corre-
spondence to the given document that is recognizable by the
machine.
Figure 5: Query Mediator Wrapper
2. Quotations are excerpts from the document. E.g. a name like
“Tim Berners-Lee” may appear in the document and also fill
network, which kind of schema the peer uses, with some possible a field of the RDF schema description.
value constraints. These registration messages have the same syn-
tax as RDF-QEL-1 queries, which are sent from the peer to the reg- 3. References are pointers to parts of the document. We use
istration / query distribution hub. Additionally, the peer announces XPointer to select parts of the document. E.g. one may assert
to the hub, which query level it can handle (RDF-QEL-1, RDF- that a particular cell of a HTML table contains the name of
QEL-2, etc.) Whenever the hub receives queries, it uses these reg- the president of the U.S.A. — and in the right context one
istrations to forward queries to the appropriate peers, merges the might expect that it is updated if it changes.
results, and sends them back as one result set.
By the combination of these two dimensions (and the corre-
The packages net.jxta.edutella.peer,
sponding implications) we may emulate the metadata structure of
net.jxta.edutella.provider,
all the different annotation tools that we currently know of (cf. [6]
net.jxta.edutella.hub, net.jxta.edutella.consumer
for a longer list of free and commercial tools).
contain interfaces to handle the distributed query mechanisms
Possible other registration methods would include specific term 3.2 Architecture
hierarchies which can be used as property value. A simple version
The Edutella annotation service is composed of the Edutella Peer
could be registerPropertyValue().
structure and the KAON tool-suite 4 [9] incorporating the OntoMat
The query message contains not only the query itself but also
Plugin Framework5 and Annotation application [6] (cf. Figure 6).
information about query and result type (e.g. QEL-1, QEL-3 for
queries and RDFModel, EduTupleResult for results). The returned
message contains the original query in addition to its results. Ont-O-Mat Plugin Structure
Ont-O-Mat
Peer
3. EDUTELLA ANNOTATION Config
3.1 RDF(S) Annotation in a Nutshell
In order to easily provide metadata for a particular document, KAON API K-Edutella
the annotation service provides a document viewer. Currently, the JDBC RQL ... Wrapper
document viewer may display HTML pages, an extension for PDF
documents is underway. Local RDF
Furthermore, the annotation service provides a browser for RDF Repository
schema. This means that a corresponding definition, e.g. Dublin
Core in RDFS3 is loaded into the annotation tool and may be Figure 6: Ont-O-Mat as Edutella Peer
browsed. Fields for annotation are displayed according to the
schema definition and may either be filled by typing or by mark- KAON is a Semantic Web tool suite originally created in
ing and dragging information from the document viewer. isolation of Edutella. The OntoMat Framework is part of this
Thereby, annotations and fields for annotations may take quite tool suite and provides a java-based plug in structure which
a number of different guises. In our context an annotation is a allows for loading services dynamically. One such service is
set of instantiations attached to an HTML document. We distin- Ont-O-Mat, which constitutes an annotation tool in the sense
guish (i) instantiations of RDFS classes, (ii) instantiated properties described above. Ont-O-Mat uses the KAON API to query
from one class instance to a datatype instance, and (iii) instantiated for RDF schema definitions in order to build up its ontology
properties from one class instance to another class instance. Class browser. It queries for instances, attributes and relationships in
instances have unique URIs. Instantiations may be attached to par- order to let its users explore the current state of the knowledge
ticular markups in the HTML documents, viz. URIs and attribute base, e.g. in order to directly relate HTTP :// WWW. AIFB . UNI -
values may appear as strings in the HTML text. KARLSRUHE . DE /WBS/ SHA /# HANDSCHUH with
For instance, one may decide, (i), to create an identi- HTTP :// WWW. AIFB . UNI - KARLSRUHE . DE /L EHRVERANSTALTUNGEN /
fier for a person by instantiating HTTP :// WWW. AIFB . UNI - W INTER / EBIZ + INTELLIGENTWEB /# COURSE .
KARLSRUHE . DE /WBS/ SHA /# HANDSCHUH from the class The KAON API hides the actual implementation of the reposi-
DC :C REATOR and for a course HTTP :// WWW. AIFB . UNI - tory and the query language used. For instance, it allows to connect
KARLSRUHE . DE /L EHRVERANSTALTUNGEN / 4
http://kaon.semanticweb.org/
3 5
http://www.ukoln.ac.uk/metadata/resources/dc/datamodel/WD-dc-rdf/. http://annotation.semanticweb.org/
to a KAON RDF repository via a simple JDBC connection or to a [2] IEEE Learning Technology Standards Committee. IEEE
RQL-based repository. The repository is used in two ways. First, it LOM Working Draft 6.1.
stores already available metadata and serves them to Ont-O-Mat via http://ltsc.ieee.org/wg12/index.html, April 2001.
KAON API in order to allow for coherent metadata. This way, the [3] Hadhami Dhraief, Wolfgang Nejdl, Boris Wolf, and Martin
chance is increased that there is only one identifier for the person Wolpers. Open learning repositories and metadata modeling.
named “Siegfried Handschuh” at Institute AIFB. Our experiences In International Semantic Web Working Symposium (SWWS),
have shown that without such service several identifiers for single Stanford, CA, July 2001.
persons are created. Second, it stores metadata created by Ont-O- [4] The Edutella Project. http://edutella.jxta.org/.
Mat. [5] Li Gong. Project JXTA: A technology overview. Technical
Furthermore, we provide an Edutella Wrapper for KAON (K- report, SUN Microsystems, April 2001.
Edutella Wrapper), which — like the corresponding Peer Configu- http://www.jxta.org/project/www/docs/TechOverview.pdf.
rator GUI — is a KAON plugin. The task of the K-Edutella Wrap- [6] Siegfried Handschuh and Steffen Staab. Authoring and
per is to wrap the KAON-API for QEL and vice versa. The K- annotating Web pages in CREAM. In Proceedings of
Edutella Wrapper calls JXTA lower levels for services like regis- WWW-2002. ACM Press, October 2002.
tration, pipes, etc. in order to connect to the outside world. Thus,
[7] M. Jarke, R. Gallersdörfer, M. Jeusfeld, M. Staudt, and
from the point of view of the Ont-O-Mat user, he has a tool that
S. Eherer. ConceptBase - a deductive object base for meta
may directly connect the Edutella network in order to query meta-
data management. Journal on Intelligent Information
data from other peers or provide metadata from his repository.
Systems, 4(2):167 – 192, 1995.
[8] J. W. Lloyd and R. W. Topor. Making prolog more
4. CONCLUSION expressive. Journal of Logic Programming, 3:225–240, 1984.
Our prototype scenario features a set of (already existing) peers, [9] Alexander Maedche, Steffen Staab, Rudi Studer, York Sure,
which we have extended with the appropriate Edutella wrappers, and Raphael Volz. Seal — Tying up information integration
and which connect to the Edutella framework with the functionali- and Web site management by ontologies. IEEE Data
ties local and distributed queries described in Section 2. The first Engineering Bulletin, March 2002.
prototype already contains the QEL query exchange mechanism, http://www.research.microsoft.com/research/db/debull/.
a simple mediatior and the wrapping of different repository peer [10] Sergey Melnik. RDF API Draft, January 2001.
types: http://www-db.stanford.edu/ melnik/rdf/api.html.
1. OLR (Open Learning Repository)[3] based peers using a [11] Wolfgang Nejdl, Boris Wolf, Changtao Qu, Stefan Decker,
subset of IMS/LOM metadata; Michael Sintek, Ambjörn Naeve, Mikael Nilsson, Matthias
Palmér, and Tore Risch. Edutella: A P2P networking
2. DbXML-based peers [14] as a prototype for an XML repos- infrastructure based on RDF. In Proceedings of WWW-2002.
itory using a simple mapping service to translate from RDF- ACM Press, 2002.
QEL-1 queries (conjunctive queries) to Xpath queries over [12] Mikael Nilsson and Matthias Palmér. Conzilla — towards a
the appropriate XML-LOM schema; concept browser. Technical Report CID-53,
3. AMOS-II-based peers [15] with local repositories; TRITA-NA-D9911, Department of Numeri-
cal Analysis and Computing Science, KTH, Stockholm, 1999.
4. KAON-based peers [9] allowing remote annotation [6] using http://kmr.nada.kth.se/papers/ConceptualBrowsing/cid 53.pdf.
an RDF-based ontology format; [13] Changtao Qu and Wolfgang Nejdl. Exploring JXTAsearch
5. Concept-Base, a repository with full datalog capabilities [7]. for P2P learning resource discovery. Technical report,
Learning Lab Lower Saxony, University of Hannover,
Moreover the resulting environment will allow the design and November 2001.
integration of other tools which make use of metadata. In addi- [14] Changtao Qu and Wolfgang Nejdl. Towards interoperability
tion to the Ont-O-Mat, other applications such as Conzilla [12], and reusability of learning resources: A SCORM-conformant
which uses graphs to input queries and visualize results, will benefit courseware for computer science education. Technical report,
from the Metadata enhanced Peer-to-Peer capabilities of Edutella. Learning Lab Lower Saxony, University of Hannover,
These first steps being done, a certain number of ameliorations are October 2001.
planned. In particular we will have to tackle mechanisms that pro- [15] T. Risch and V. Josifovski. Distributed data integration by
vide replication of data implementing a a modification exchange object-oriented mediator servers. Concurrency and
language (MEL) and that resolve scalability issues like the selec-
Computation: Practice and Experience, 13(11):933 – 953,
tion of appropriate hubs for given queries.
2001.
[16] Steve Waterhouse, David Doolin, Gene Kan, and Yaroslav
Acknowledgements Faybishenko. Distributed search in p2p networks. IEEE
The Edutella architecture, its query language and its various aspects Internet Computing, 6(1):68–72, January/February 2002.
have been defined in numerous discussions with many other partic- Special issue on Peer-to-Peer Networking.
ipants in the Edutella project, and we gratefully acknowledge their [17] Gio Wiederhold. Mediators in the architecture of future
support and important influence for this paper. information systems. IEEE Computer, 25(3):38 – 49, 1992.
5. REFERENCES
[1] Dan Brickley and R. V. Guha. W3C Resource Description
Framework (RDF) Schema Specification.
http://www.w3.org/TR/1998/WD-rdf-schema/, March 2000.
W3C Candidate Recommendation.