Web of Data as a Solution for Interoperability. Case
Studies
Sabin C. Buraga
Faculty of Computer Science, “Alexandru Ioan Cuza” University of Iaşi
16, Berthelot Street – 700483 Iaşi, Romania
busaco@info.uaic.ro – http://www.purl.org/net/busaco
The paper draws several considerations regarding the use of Web of Data
(Semantic Web) technologies – such as metadata vocabularies and ontological
constructs – to increase the degree of interoperability within distributed
systems. A number of case studies are presenting to express the knowledge in a
platform- and programming language-independent manner.
1. Introduction
The paper describes several case studies of using the actual semantic Web
technologies to model the knowledge within distributed systems in order to give
support for assuring the interoperability.
To express the resources and services stored and/or provided by a distributed
system, the existing semantic Web means are considered. The semantic Web – also
called the Web of data – represents a transition from “opaque” documents to machine
understandable data (resources themselves and the links between them).
In this study, we intend to describe several approaches based on the existing means
of the semantic Web that can be used in the context of distributed computing for
resource modeling and accessing. After a brief survey of the actual semantic Web
concerns and directions of interests, we will present five original case studies:
1. defining a RDF-based metadata vocabulary in order to describe the entities of a
distributed file system;
2. expressing temporal relations, with practical applications in the context of resource
discovery;
3. developing a semantic Web-based Grid system that uses our defined Linda
extensions and the Alchemi Grid as a foundation for a knowledge Grid;
4. specifying ontological descriptions for the Grid services, with applications in the
context of e-learning;
5. creating the bridges between the social aspects of the current Web and the semantic
Web, on the basis of linked data repositories.
At the end, we propose further directions of research.

2 Sabin C. Buraga
2. Web of Data – a Brief Presentation
2.1 Preamble
The World Wide Web space is primarily compounded by pages (documents that
contain mark-ups) with information in the form of natural language text and
multimedia intended for humans to read and to understand. Computers are principally
used to render this hypermedia information, not to reason about it.
The current stage of the Web is the social Web (Gruber, 2006), where the users are
the peers in the communication graph, creating and exchanging information freely,
with the machines acting as only the storage and transportation means for this content,
with little involvement in data creation and consume.
However in the next stages of the Web development, information needs no longer
to be intended for human readers only, but also to be processed by the machines,
enabling – among others – intelligent information services, personalized Web
applications, and semantically empowered search engines. This is the seminal idea of
the semantic Web (Shadbolt, Hall & Berners-Lee, 2006). The Semantic Web is
viewed as “an extension of the current Web in which information is given well-
defined meaning, better enabling computers and people to work in cooperation”
(Berners-Lee, Hendler & Lassila, 2001).
When advancing towards the semantic Web, the main obstacle is the effort of
organizing the knowledge – content, metadata, ontological constructs – made by the
existing content providers. In the current systems, the users must work with certain
vocabularies, tagging entities and relations. The purpose of these processes is to make
the data comprehensible not only for humans, but also for computers (Allemang &
Hendler, 2008).
2.2 Main Building Blocks
Each resource available on Web is uniquely addressed by using the Uniform Resource
Identifiers (URI).
To express and process metadata, the Resource Description Framework – RDF
(Manola & Miller, 2004) model can be used. RDF is a current standard of the World
Wide Web Consortium (W3C) and an important brick of the semantic Web. RDF is a
language for representing information about resources in the World Wide Web space.
The RDF format is intended to be used to capture and state the conceptual structure of
existing information.
The core concept is that of making statements about (Web) resources – the so-
called RDF triples – of the form: “Subject has a property whose value is an object” in
which the key components are the following:
1. The subject is the resource being described (for example, a Web site or a person).
2. The property, or predicate, which is the actual characteristic of the subject on
which the statement focuses (for example, creator).

Web of Data as a Solution for Interoperability. Case Studies 3
3. The object which denotes the actual value of the property for the described subject
(for example, Sabin Buraga).
Thus, the RDF assertions – triples of URIs having the structure: {subject, property,
object} – can be viewed as a data model for describing semantics of data that can be
processed by the computers.
Via the RDF assertions, we can attach metadata to the Web resources, by
eventually using common vocabularies describing “things” of interest: properties,
domains, persons, etc. For example, relations between certain types of resources can
be expressed via DCMI (Dublin Core Metadata Initiative), FOAF (Friend Of A
Friend) and others vocabularies 1 . Also, metadata can be embedded into the Web
pages themselves – this is the case of RDFa 2 and microformats 3 initiatives.
Using these simple assertions, for which RDF defines diverse means of
serialization (in XML, N3, etc.), complex representations of things can be built by
composing them and interlinking resource descriptions. In the context of describing
data, RDF and the Semantic Web promote the idea of an “open world” where
descriptions are not meant to be interpreted as exhaustive, but only as statements
about the knowledge from a particular point of view: the fact that some things are not
contained in a description does not mean they do not exist, only that the description
author does not know them, or cannot state anything about them, another source could
provide those descriptions.
To enhance knowledge sharing and interconnectivity, the Semantic Web proposes
linking these descriptions in a web of linked data, achievable by following the next
guidelines (Bizer, Heath & Berners-Lee, 2009):
1. URIs are to be used to name things on the Web, such as every thing (practical or
abstract) on the Web is uniquely identifiable – for instance, multimedia resources,
groups of persons, or published articles.
2. The URIs should be accessed by computers via standard protocols, such as HTTP,
allowing to look-up those names on the Web. This is also known as the
“dereferenceable URIs” rule: besides having an unique identifier for anything on
the Web, the URI that identifies the thing should direct to the place where more
information about that thing is found.
3. When such a URI is looked-up, useful information must be provided. In other
words, useful descriptions (complete, correctly described to be machine
understandable) should be found at the resources’ locations.
4. The descriptions should include links to other URIs to allow discovery of more
things: when something on the Web relates to something else on the Web, the links
to the specific resource identifiers should be used to create, overall, a graph of
knowledge.
To gain benefit of the full potential of Semantic Web, the main idea is to start
publishing data as RDF. Existing data can be interconnected for further uses, in order
to assure – among others – the interoperability.
1 Please, consult following addresses: http://www.dublincore.org/, http://xmlns.com/foaf/0.1/
and http://www.data-vocabulary.org/.
2 http://www.w3.org/TR/xhtml-rdfaprimer/.
3 http://microformats.org/.

4 Sabin C. Buraga
The above presented ideas are applied and supported by the Linked Data initiative
which tries to provide a platform for interlinking the existing semantic resources on
the Web, centralizing the information and tools to help create the Web of (linked)
data.
In the present, there are plentiful approaches focused solely on creating the
descriptions needed, on “triplifying the Web” 4 , to transform as much content on the
Web into described resources as possible.
Additionally, a query language for RDF data is already a W3C standard: SPARQL
(SPARQL Protocol and RDF Query Language) 5 . This language is allowing access to
resources in the triple statement data model, and defining the access guidelines to
expose such data through services – so-called SPARQL end-points.
The ontologies are the next step of knowledge description, evolved from the need
to represent concepts and relations between concepts, to enable formal definitions of
domains knowledge and reasoning about the knowledge, in a rigorous (potentially
machine understandable) form. An ontology offers an abstract, simplified version of
the world (conceptualization) in a formal and declarative representation, implicitly
processable by a computer (Gasevic, Djuric & Devedzic, 2009). According to
(Horrocks, 2008), an ontology could be viewed as “an engineering artifact, usually a
model of (some aspect of) the world; it introduces vocabulary describing various
aspects of the domain being modeled, and provides an explicit specification of the
intended meaning of the vocabulary”.
To represent these formalizations on the Web, RDFS (the RDF Schema) was
defined as an extension of the RDF to include basic features to describe simple
ontologies (vocabularies, taxonomies). For a higher expressivity, Web ontology
languages were specified to allow the description of more complex relations, such as
the cardinality of a property, characteristics of properties, class relations, or the
equivalence of concepts. One important standard is the Web Ontology Language –
OWL (Dean & Schereiber, 2004) that can be used to structure and characterize
resources and/or relations between them. Knowledge about the resources can be
shared within a given community of practice. By using OWL and related languages,
we can model ontologies – documents describing abstract, inference and logic
information representation: knowledge about resources (Allemang & Hendler, 2008).
3. Case Studies
3.1 Using RDF to Attach Metadata to the Entities of a Distributed File System
We need to adopt first a model for describing the resources situated at the storage
level of a distributed system. Thus, we must supply a metadata-based high-level
model for an abstract file system.
4 See, for instance, http://triplify.org/.
5 http://www.w3.org/TR/rdf-sparql-query/.

Web of Data as a Solution for Interoperability. Case Studies 5
To represent RDF statements about various file characteristics, we have to define
first a vocabulary expressed by an XML-based language used to specify the file
properties, called XFiles (Buraga, 2002). The purpose of this language is to provide
constructs for expressing metadata concerning a resource, such as type – e.g.,
ordinary, directory, device and others –, location, owner, permissions, size, etc.
For example, to specify an ownership property and a password-based authorization
method to access a set of files stored on the local machine, we can provide the
following RDF assertions – in this case, we use the XML syntax. The xf construct
denotes the prefix of the XFiles namespace.
<rdf:RDF>
<rdf:Bag rdf:ID="myfiles">
<!-- a collection of dispersed files -->
<rdf:li resource="file:///tmp/book.tex" />
<rdf:li
resource="file:///home/busaco/articles/ieee09.pdf" />
<rdf:li
resource="file:///mount/ext/laptop/documents/pics/" />
</rdf:Bag>
<rdf:Description rdf:about="#myfiles">
<!-- metadata attached to the file collection -->
<xf:Properties>
<xf:Auth>Basic</xf:Auth>
<xf:Owner rdf:ID="busaco">
<rdf:Description
rdf:about="http://www.purl.org/net/busaco">
<xf:Login xf:uid="714">busaco</xf:Login>
</rdf:Description>
</xf:Owner>
<xf:Permissions>
<xf:Permission>User-Read</xf:Permission>
<xf:Permission>User-Write</xf:Permission>
</xf:Permissions>
</xf:Properties>
</rdf:Description>
</rdf:RDF>
The fact following fact is stated: “For the given collection of files, the owner of
these files is the user busaco. The files will be accessed by providing a password and
only the owner will be able to read and write them.”
The Owner element includes the information about the owner of a file: login name,
password, group, real identity, etc. Of course, it is possible to have multiple owners
for a single given file. The Auth element specifies the authentication method to access
a given file – for example, basic or digest user authentication. The Permissions
element reflects the set of file permissions, e.g., “read”, “write”, “execute” – on Unix
– or “Full Control”, “Change Permissions”, “Read”, or “Take Ownership” – on
Windows; also, this parameter can be used to store Network File System (NFS) file
modes. The entire specification is available in (Buraga, 2002).

6 Sabin C. Buraga
The proposed model was used to express the involved resources of the multi-agent
systems (Buraga, 2006; Buraga, Alboaie & Alboaie, 2005) and the Intranet
applications (Buraga & Rusu, 2006).
Using these assertions, we can assure interoperability at the level of the file system,
because this model – being abstract – has a higher level of generality.
3.2 Modeling Temporal Relations in RDF
In this section, we’ll provide a general model to express the temporal relations
established between resources. A vocabulary, called TRSL (Temporal Relation
Specification Language) is defined to specify the time model according to the Interval
Temporal Logic (ITL) – a simple linear model of time (Allen, 1991).
Given any two temporal intervals, there are thirteen mutually exclusive
relationships that can be established. To model these relations, one primitive relation
Meets is introduced. Time periods can compose to produce a larger period. For any
two periods that meet, there is another period that is the “concatenation” of them.
Also, periods of time define an equivalence class of periods that meet them. These
equivalence classes uniquely define the periods.
An ordering axiom could be introduced. Intuitively, this axiom asserts that for any
two pairs of periods, such that i meets j and k meets l, then either they both meet at the
same “place”, or the place where i meets j precedes the place where k meets l, or vice
versa.
It can be proved that no period can meet itself, and that if one period i meets
another j, then j can not also meet i (finite circular models of time are not possible).
With this system, the complete range of the thirteen intuitive relationships that
could hold between time periods could be specified. For example, one period is before
another if there exists another period that spans the time between them, for instance:
Before (i, j) ≡ ∃ m : Meets (i, m) ∧ Meets (m, j).
Fig. 1. The possible relations between time periods (equality not shown) – see (Allen, 1991).
In a similar manner, other relationships – After, MetBy, Overlaps, OverlappedBy,
Starts, StartedBy, During, Contains, Finishes, FinishedBy – are defined (Figure 1).
A period can be classified by the relationships that it can have with other periods of
time. A period that has no sub-periods can be called a moment and a period that has
sub-periods, an interval. Also, we can define a notion of time point by a construction

Web of Data as a Solution for Interoperability. Case Studies 7
that specifies the beginning and ending of periods (moments and points are distinct).
A discrete time model can be given, where periods map to pairs of integers <I, J>,
where I < J. Moments correspond to pairs of the form <I, I + 1>, and points
correspond to the integers themselves. A similar model build out of pairs of real
numbers does not allow moments.
Our defined TRSL vocabulary could express the relations Before, Meets, Overlaps,
Starts, During, and Finishes that can be established between Web resources. These
temporal relationships can help to determine the dynamics of that Web sites’ content
and can be used, among others, by the Web agents in mirroring/discovering activities.
The updating or querying actions can depend on the temporal relations that can be
expressed by TRSL and RDF constructs. The TRSL language allows intervals of time
(beginning and ending of periods) and, of course, moments.
For each time relation, TRSL offers an element that corresponds to a specific
relation (e.g., <Meets> element for Meets relation). The beginning and ending of time
periods are denoted by begin and, respectively, end attributes. Also, TRSL defines the
dur attribute for specifying a known or predictive time period – this will allow Web
agents to reason about different actions that may need to be performed. The source
and destination (viewed as operands) of a temporal relation can be expressed by RDF
constructs, too.
The syntax and the semantics of the TRSL language are detailed in (Buraga &
Ciobanu, 2002). We use TRSL constructs to specify temporal relations between the
documents stored within our ITW system (Buraga & Găbureanu, 2003), a multi-
platform and multi-language architecture used to discover (multimedia) resources.
The ITW platform is based on Web services and software agents, exploiting the
relations between Web sites’ resources – consult also (Buraga & Rusu, 2006).
An example of a metadata XML-based file associated to a video resource (e.g., a
film trailer or a conference speech excerpt) follows:
<rdf:Description
rdf:about="http://www.location.info/Video.mpeg">
<!-- temporal information -->
<temporal:link begin="2009-05-09T07:33:00"
end="2010-05-09T07:33:00" linkType="temporal">
<temporal:Before dur="7D">
<rdf:Description
rdf:about="http://mirror.org/video/1.mpeg">
...</rdf:Description>
</temporal:Before>
</temporal:link>
<!-- metadata -->
<dc:title xml:lang="en">A video</dc:title>
<xf:Properties>
<xf:Location ip="193.231.30.225" port="80">
www.infoiasi.ro</xf:Location>
<xf:Owner>...</xf:Owner>
<!-- other useful information -->
</xf:Properties>
</rdf:Description>

8 Sabin C. Buraga
The document defines a Before relation between two resources. The video resource
denoted by http://www.location.org/Video.mpeg is considered the original one, but a
copy is located at http://mirror.org/video/1.mpeg. Each update of the original video
implies another update of the copy after 7 days. The original resource will be
available between the dates specified by begin and end attributes. Metadata
information – expressed by the XFiles vocabulary – includes the address of the
storage machine and the owner of the resource. Also, any other useful information –
such as DCMI elements denoted by the dc namespace – can be specified.
3.3 Specifying Grid Resources and Services
This second case study regards the Grid systems. Grid computing – a promising
paradigm for the advanced distributed computing – makes possible the sharing,
selection, and aggregation of world-wide distributed heterogeneous (hardware,
software, logical) resources for solving large-scale problems in different areas of
interest – e.g., science, engineering, learning, commerce, etc. – or for granting access
to substantial repositories of data, information, or knowledge (Abbas, 2004; Berman,
Fox & Hey, 2003; Buyya, 2002).
Grid applications are distinguished from traditional Internet applications – mostly
based on client/server model – by their simultaneous use of large number of
(hardware and software) resources. That involves dynamic resource requirements,
multiple administrative domains, complex and reliable communication structures,
stringent performance requirements, etc.
Resource management and scheduling in existing environments is a complex task.
The geographic distribution of the resources owned by diverse organization with
different usage policies, cost models, and varying load and availability patterns is
problematic. The producers – the owners of resources – and consumers – the users of
resources – have different goals, objectives, strategies, and requirements (Buyya,
2002; Joseph & Fellenstein, 2003).
3.3.1 Extending the Linda Coordination Model to Design a Semantic Grid
The concept of semantic Grid has evolved along with the development of the
semantic Web and, in parallel, with the Grid computing. It represents a natural
evolution toward a knowledge-centric and metadata-driven computing paradigm.
The semantic Grid is different from the classic Grid models due of use of metadata
and ontological constructs for describing the stored information. The transformation
of data into something more than a collection of elements implies the understanding
of the context, format and meaning of the data. The semantic Web already has years
of experience in serving supplementary information to help describe data in the Web
pages, therefore allowing the Web browsers, applications, and users to make
decisions about how to process that data. The semantic Grid uses similar principles to
represent information in the virtualized memory space, by dealing with two major
issues: data discovery and data integration.
By using the Linda coordination model, the peer-to-peer communication paradigm,
and current semantic Web technologies, we propose a semantic Web-based system –

Web of Data as a Solution for Interoperability. Case Studies 9
called DisMy (Iacob & Buraga, 2009) – that uses the Alchemi Grid (Ranjan et al.,
2003) as a foundation for a knowledge-based Grid.
The Linda (Gelender, 1989) language provides a communication model based on a
bulletin board rather than direct messaging, using a shared memory called a tuple
space. This approach is very useful in the context of Grid computing. As a
coordination language, its sole responsibility is the communication and coordination
applications developed in the host languages. A Linda system is composed from a set
of objects that can basically be of two kinds: tuples and tuple spaces.
For the tuple spaces, the DisMy system uses a view-based approach, regarding the
information in the shared memory space: the “data view” and the “fact view”. The
data are represented as all the tuples along with the classic Linda primitives. The facts
are the RDF tuples along with the extended Linda primitives – details in (Iacob &
Buraga, 2009). In this approach, the fact view – using the RDF tuples – maintains
information regarding the tuple space itself. The RDF defines semantic connections
between documents, types of data or even other RDF tuples. Based on our prior
experience (Buraga & Alboaie, 2004), the RDF triples can be easily adapted to model
a Linda tuple. All the RDF tuples contain fields to represent the basic RDF triple-
based model: subject, predicate, and object. In the DisMy tuple space, the tuples can
have XML documents as fields (including RDF/XML), primitive data types or custom
classes. The classic matching problem from the Linda model is extended in this
implementation to accept these kinds of tuples.
Also, we define an URI-based address space to identify each resource within the
DisMy system. The URI has the form: dismy://[host]/[tuple]/.../[tuple]/identification.
The name solver implemented by DisMy helps the user with human friendly name
support. For example, if the tuple is named at creation time “reviews”, and the field
with “andreibsc”, the address is: dismy://station33/reviews/andreibsc.
Keeping in mind the fact that Linda supports duplicate tuples, two elements with
the same name are uniquely denoted by extending the address with another level in
nesting: dismy://station33/reviews/andreibsc/1. This model can easily be adapted to
support the development of a document version control system.
DisMy implements a decentralized P2P topology, using the Alchemi managers to
manage the peer connections between executors. In the future, DisMy will support a
dynamic connection mechanism in which peers will be linked based on parameters
like network performance and peer load.
3.3.2 Semantic Descriptions of Grid Services
Using at a storage level a semantic model, different statements regarding the
resources/services provided by a Grid system could be asserted. A Grid platform can
be improved to support semantic Web technologies, in order to create, manage and
present knowledge concerning any categories of users. Also, by using semantic Web-
based descriptions for Grid services, the applications could automatically discover,
invoke and compose the desired services. With the support of the ontologies, the
inter-operability and execution monitoring are also possible.
To semantically enrich the Grid services several models can be used, in this case
the Web Service Modeling Ontology – WSMO (Fensel et al., 2007). To manage the
Grid resources, a general ontology is specified. The concepts (classes), the relations –
eventually organized in hierarchies –, the instances, and the axioms are defined.

10 Sabin C. Buraga
Using this ontology, the Grid services can be semantically modeled by describing
their capabilities. At the syntactic level, the Web Service Modeling Language –
WSML (Fensel et al., 2007) is used.
In our example, a Grid service that offer the access to the metadata attached to a
given resource is specified. First, several fundamental operations are defined. These
operations regard the storage of the resources, considered as files, following the
model detailed in the section 3.1 of this paper. We can easily classify the resources by
grouping them on directories – an uncomplicated taxonomy.
We identified three important concepts: file, owner, and directory. Furthermore,
the ownership relation and an axiom which restricts an owner to be a member of the
owner class are specified in the following manner:
ontology _”http://www.infoiasi.ro/gridOntology”
nonFunctionalProperties
dc#title hasValue ”An ontology regarding
the resources stored within a Grid”
endNonFunctionalProperties
concept file
name ofType _string
hasOwner ofType owner
concept owner subConceptOf user
ownerOf inverseOf(hasOwner) ofType file
concept directory
nonFunctionalProperties
dc#description hasValue ”A directory includes
0 or more items (files)”
endNonFunctionalProperties
inode ofType _string
items ofType file
relation ownership (impliesType owner,
impliesType file)
nonFunctionalProperties
dc#relation hasValue ownershipFromOwner
endNonFunctionalProperties
axiom ownershipFromOwner
definedBy
ownership (?x, ?y) :− ?x[ownerOf hasValue ?y]
memberOf owner.
A possible instance is expressed by:
instance bootstrapGlobusFile memberOf file
name hasValue ”bootstrap.jar”
hasOwner hasValue root
To give a semantic model for the Grid service, its capabilities must be described. In
our case, to point out the insertion of a new file into a directory, the following can be
asserted:
webService ”http://www.infoiasi.ro/AddFileService”
nonFunctionalProperties
dc#title hasValue ”Adding a file to a directory”

Web of Data as a Solution for Interoperability. Case Studies 11
endNonFunctionalProperties
importsOntology
_”http://www.infoiasi.ro/gridOntology”
capability
sharedVariables {?inode , ?filename}
precondition
definedBy
?i memberOf string and ?filename memberOf file.
postcondition
definedBy
forall ?dir ( ?dir [ inode hasValue ?inode ]
memberOf directory implies
?dir [ items hasValue ?filename])
The insertion of a file into a given directory can also be considered as specifying a
category for a given resource.
This model was proposed in the context of a Grid system concerning e-learning
(Brut & Buraga, 2008) and e-health – within the TELEMON project (Alboaie, Buraga
& Felea, 2008).
3.4 Connecting the Web of Users to the Web of Data. An Experiment
The problem we want to resolve in this case study is how can use already existing
linked data – modeled in RDF – in a practical and transparent way, directly for the
human consumption and reuse. On the basis of a prior experience (Luca & Buraga,
2008; Luca & Buraga, 2009), we are investigating the concerns of creating a system
to enable users as peers in the data web communication, with particular concern to not
require technical background from the user and, in the same time, preserving the
rigorousness and denotative characteristics of the data web, materializing these in a
semantic data retrieval and re-usage tool.
The following flow could be defined (Luca, 2009) in order to give access users to
be linked data expressed by the current semantic Web techniques, with strong
implications on data interoperability – see Figure 2:
1. while editing content on the social Web (i.e, in a blog or wiki application), a user
issues a search, to retrieve an answer from the semantic Web, to use the value in
the content she is editing;
2. to resolve this query, the system first identifies the subject as a structured object
(RDF description) using a semantic search backend;
3. to determine the user property, a user ontology is inferred from the query and the
context of the page or the user history;
4. the data retrieved regarding the search subject and the inferred user ontology are
then aligned and correspondences are identified for the searched property, allowing
to associate a value to that user searched property;
5. the values such obtained are presented to the user, who chooses a result to reuse in
the context of her editing activity;
6. in order to produce semantic markup on re-usage in the social Web context – as
microformats, for example – an ontology inferred from the microformats
descriptions is used;

12 Sabin C. Buraga
7. the result ontology along with the user property description is aligned with the
microformats ontology, and the values for the microformats properties are
identified from the resulting correspondences;
8. the microformat thus created is serialized and inserted in the user edited page as the
result of her initial inquiry, to enrich the content created by the user in the social
Web application.
Also, additional steps are made. Upon the user choice of a value to use, feedback is
collected to be used in further alignments. When the markup is created in the edited
document, if a microformat alignment is not satisfactory, the RDFa constructs could
be generated.
Fig. 2. Overview of the proposed system (Luca, 2009).
As a prototype, a command of a Ubiquity 6 extension for the Firefox browser was
developed. SPARQL queries are issued for the semantic data repositories available –
the current implementation uses DBpedia, DBLP Berlin database, and the Linked
Movie Database – through their SPARQL endpoints, for subjects and properties
6 http://labs.mozilla.com/projects/ubiquity/

Web of Data as a Solution for Interoperability. Case Studies 13
resolved through conventions and flexible mapping rules. This proof of concept is
based on the PSW (Practical Semantic Works) 7 script.
4. Conclusions and Further Work
The paper presents several case studies regarding the use of actual semantic Web
models, languages, and technologies as proper solutions for the management of
knowledge within large-scale distributed systems in the context of assuring the data
interoperability. We described original approaches in expressing the metadata and
relations between the Web resources, including practical examples of deployment.
As further directions of research, we intend to investigate the methods of providing
access to, filtering, aggregating, and reusing the resources – data and services –
provided by the existing social Web applications.
We consider that a more deep and systematic investigation of the relations between
the semantic Web and the social Web is needed in order to increase interoperability.
More powerful models of user interaction – including those sensitive to context and
driven by semantic Web technologies – must be provided by the next generation of
applications.
References
A. Abbas (Editor), Grid Computing: A Practical Guide to Technology and Applications,
Charles River Media, 2004.
L. Alboaie, S. Buraga, V. Felea, “TELEMON – a SOA-based e-Health System. Designing the
Main Architectural Components”, Proceedings of the 9th International Conference on
Development and Application Systems – DAS 2008, Suceava, 2008.
J. Allen, “Time and Time Again: The Many Ways to Represent Time”, International Journal of
Intelligent Systems, 6 (4), 1991.
D. Allemang, J. Hendler, Semantic Web for the Working Ontologist, Morgan Kaufmann, 2008.
F. Berman, G. Fox, T. Hey (Editors), Grid Computing. Making the Global Infrastructure a
Reality, Wiley, 2003.
T. Berners-Lee, J. Hendler, O. Lassila, “The Semantic Web”, Scientific American, 5, 2001.
C. Bizer, T. Heath, T. Berners-Lee, “Linked Data – The Story So Far”, International Journal
on Semantic Web and Information Systems (IJSWIS) – Special Issue on Linked Data, 2009 –
to appear.
M. Brut, S. Buraga, “An Ontology-based Approach for Modeling Grid Services in the Context
of E-Learning”, International Journal of Web and Grid Services (IJWGS) – Special Issue on
Web/Grid Information and Services Discovery and Management, Volume 4, Issue 4, 2008.
S. Buraga, “A Model for Accessing Resources of the Distributed File Systems”, Advanced
Environments, Tools and Applications for Cluster Computing, Lecture Notes in Computer
Science – LNCS 2326, Springer-Verlag, 2002.
7 The script participated in the Scripting Challenge during the 5th Workshop on Scripting and
Development for the Semantic Web, collocated with the European Semantic Web
Conference, 2009. Also, visit http://students.info.uaic.ro/~lucaa/psw.

14 Sabin C. Buraga
S. Buraga, “Semantic Web Technologies in the Context of Agent Applications. From Design to
Practical Deployment”, Advances in Electrical and Computer Engineering, Academy of
Technical Sciences of Romania, Volume 6 (13), Number 1 (25), 2006.
S. Buraga, L. Alboaie, “A Metadata Level for the tuBiG Grid-aware Infrastructure”,
Proceedings of the 6th International Symposium on Symbolic and Numeric Algorithms for
Scientific Computing – SYNASC 2004, Mirton Publishing House, Timişoara, 2004.
S. Buraga, S. Alboaie, L. Alboaie, “An XML/RDF-based Proposal to Exchange Information
within a Multi-Agent System”, Concurrent Information Processing and Computing, IOS
Press, 2005.
S. Buraga, G. Ciobanu, “A RDF-based Model for Expressing Spatio-Temporal Relations
between Web Sites”, Proceedings of the 3rd International Conference on Web Information
Systems Engineering (WISE 2002), IEEE Computer Society Press, 2002.
S. Buraga, P. Găbureanu, “A Distributed Platform based on Web Services for Multimedia
Resource Discovery”, Proceedings of the 2nd International Symposium on Parallel and
Distributed Computing, IEEE Computer Society Press, 2003.
S. Buraga, T. Rusu, “Using Semantic Web Technologies to Discover Resources within the
Intranet of an Organization”, D.T. Pham, E.E. Eldukhri, A.J. Soroka (Eds.), Intelligent
Production Machines and Systems (IPROMS), Elsevier, 2006.
R. Buyya, “Economic-based Distributed Resource Management and Scheduling for Grid
Computing”, PhD Thesis, Monash University, Melbourne, Australia, 2002.
M. Dean, G. Schereiber (Editors.), OWL Web Ontology Language Reference, W3C
Recommendation, Boston, 2004: http://www.w3.org/TR/owl-ref/.
D. Fensel et al., Enabling Semantic Web Services. The Web Service Modeling Ontology,
Springer, 2007.
D. Gasevic, D. Djuric, V. Devedzic, Model Driven Engineering and Ontology Development,
Second Edition, Springer, 2009.
D. Gelernter, “Multiple Tuple Spaces in Linda”, J. G. Goos (Editor), Lecture Notes in
Computer Science – LNCS 365, Springer-Verlag, 1989.
T. Gruber, “Where the Social Web Meets the Semantic Web”, 5th International Semantic Web
Conference, Keynote Presentation, 2006: http://videolectures.net/iswc06_gruber_wswms/.
I. Horrocks, “Ontologies and the Semantic Web”, Communications of the ACM, Volume 51,
Number 12, December 2008.
A. Iacob, S. Buraga, “DisMy – a Semantic Grid System based on the Linda Coordination
Model”, Proceedings of the International Conference on Knowledge Engineering,
Principles and Techniques (KEPT 2009), Cluj-Napoca, 2009 – to appear.
J. Joseph, C. Fellenstein, Grid Computing, Prentice Hall PTR, 2003.
A. P. Luca, “Practical Semantic Works. Bridging the Web of Users and the Web of Data”,
Master Thesis, “A. I. Cuza” University of Iaşi, 2009.
A. P. Luca, S. Buraga, “Microformats based Navigation Assistant. A Non-intrusive
Recommender Agent: Design and Implementation”, Proceedings of the 10th International
Conference on Enterprise Information Systems (ICEIS), INSTICC, 2008.
A. P. Luca, S. Buraga, “Enhancing User Experience on the Web via Microformats-Based
Recommendations”, Enterprise Information Systems. Revised Selected Papers, Lecture
Notes in Business Information Processing, Volume 19, Springer, 2009.
F. Manola, E. Miller (Editors), RDF (Resource Description Framework) Primer, W3C
Recommendation, Boston, 2004: http://www.w3.org/TR/rdf-primer/.
R. Ranjan, A. Luther, R. Buyya, S. Venugopal, “Alchemi: A .NET-based Grid Computing
Framework and its Integration into Global Grids”, Technical Report, Department of
Computer Science and Software Engineering, University of Melbourne, Australia, 2003.
N. Shadbolt, W. Hall, T. Berners-Lee, “The Semantic Web Revisited”, IEEE Intelligent
Systems, Volume 3, Number 21, 2006.