Semantic Web technologies are available and gain popularity both on the Web and on the desktop. However, in spite of common representation formats, personal and online data is still di cult to interlink, notably because of the di erent vocabularies used to describe it, as well as the lack of common identi ers between desktop and Web-based applications. In this paper, we describe a process for easily publishing and sharing of personal notes as Linked Data. Our approach can be used to publish any kind of information from the desktop to the Web, enabling integration of small chunks of personal knowledge into the Web of Data and focusing on a user-driven approach of knowledge management.
Semantic Web technologies are now deployed in various domains and applications. Among the di erent sub-domains of the broader Semantic Web vision, two relevant elds are the Linked Data initiative, focusing on global interlinking on the Web, and the Semantic Desktop, focusing on personal information integration. While these two domains share compatible representation models (RDF(S)/OWL), there is still a gap between data from the Web and the desktop. Among others, vocabularies that they use are generally not well integrated and identi ers (URIs) are generally distinct. Such gap can be explained as the Semantic Desktop focused on using local identi ers and desktop-related ontologies, while the Linking Open Data (LOD) initiative focused on the global reuse of identi ers and ontologies.
In this paper, we tackle a particular issue regarding the integration of data from these two environments, o ering an approach for publishing personal notes from the desktop (using Semantic Desktop technologies) to the Web (using the Linked Data principles). Especially, our need is to publish this data online without losing the personal context established on the desktop. Our approach consists of two main steps: (i) preparing the desktop data for sharing, and (ii) publishing it online. In addition, it requires two prerequisite steps, which are not the focus of this paper: (i) the note-taking process and annotation of the note (adding the context), and (ii) the identi cation of Web URIs which represent the same real-world thing as the desktop resources that belong to the context of a note. We will however describe (in less detail) these two initial steps to give the entire view of the work ow.
Transferring personal desktop data online requires some issues to be properly addressed. To achieve this goal, our contributions include: (i) mappings between the relatively small number of desktop vocabularies and the most popular Web vocabularies. The mappings are used in the transformation of the desktop data, represented with the desktop ontologies, to data represented with the Web vocabularies, ready to be published online; (ii) a process for publishing of desktop information on the Web using the Linked Data principles, while protecting the sensitive private data from being shared unwillingly, and (iii) a system implementation that allows sharing of semantic personal notes as semantic blog posts, interlinked with existing information within the LOD cloud.
The remainder of the paper is structured as follows. We rst describe a motivating use case, from which we identi ed the main requirements of our system (Section 2). In Section 3, we continue with the background work on which our approach is built. Section 4 details the process and its realisation, focusing on the ontology mappings and the software architecture, and Section 5 evaluates the conformance of the system with the initial requirements. We then discuss related work and some challenges and lesson learnt we have found when implementing the system, before concluding the paper. 2
Two relevant characteristics of blog posts are: (i) their topics are of interest to the author and thus are very likely to have references to things present on the desktop (e.g. people, events); (ii) they belong to a context consisting of the references made in their content, such as places, projects, or other blog posts However, not all blog posts start by being a blog post. Some are just ideas or impressions jotted down for later, in one's preferred desktop note-taking application. Nevertheless, some of these notes do become posts after polishing and re ning.
Tools from the Semantic Desktop [
Currently, personal notes, even the ones semantically enriched using Semantic Desktop applications, must be published as blog posts by being manually copied into a blogging tool. In this way, any additional semantic information available on the desktop becomes lost or, if copied, leads to broken references as they point to the local resources which are not accessible outside of the desktop. The note-taking to publishing process is sometimes shortcut by using the drafting functionality that some systems like WordPress or Blogger o er, so that users can directly take the notes in the blogging tool, usually online, thus replacing the desktop note-taking application. Using online tools deprives the user from having the personal context automatically added to the blog post, since desktop information cannot be easily integrated in Web-based interfaces.
In order to enable a better translation from personal notes to blog posts, or simply to Web-based information available to others (for example, meeting notes published in a company intranet or lecture notes shared between students of a same class), we de ned a list of requirements that a system for publishing semantic personal data online should ful l: R1 Publish the complete desktop data on the Web without losing any relevant information, including metadata and context (e.g. tags, relations, identi ers); R2 Protect any machine readable and private data that might be unwillingly be included in the context being transferred; R3 Publish the note according to the Linked Data principles and describe it use popular ontologies; R4 Enable object-centred sociality by establishing connections between data published by di erent users. 3 3.1
In order to enable our approach for publishing notes from the desktop to the Web, we reused previous work and software components already available. In this section, we present them brie y and explain why we chose them and how they contribute to the global picture that our architecture provides.
Semantic Desktop. Extensive research has been done in the area of the
Semantic Desktop. Systems like Haystack [
Our solution builds on the NEPOMUK realisation of the Semantic Desktop, more precisely Nepomuk-KDE2. It extracts metadata from the desktop (i.e. from les, address book, calendar, task manager, etc.) and integrates it into a central repository, making it available to all applications. The data is described using
a common representation { Nepomuk Representation Language (NRL)3, and a set of ontologies4, known as \desktop ontologies". They describe the desktop data, at di erent levels of abstraction, and can be complemented by additional ontologies, like Xesam5.
SemNotes. SemNotes is a note-taking application for the NEPOMUK Semantic Desktop, which uses semantics to save the context of each note by linking it to the relevant desktop resources mentioned, such as people, events, projects, etc. It uses the \desktop ontologies" to describe its data structure and the relations between the notes and other resources from the desktop. We decided to add our Linked Data publishing functionalities to an existing note-taking application as SemNotes for two reasons: (i) usually blog posts or online articles start as personal notes that are re ned until ready to be published, as we discussed earlier, and (ii) a familiar application such as SemNotes is more likely to be used than a new one, notably as users will not have to learn a new systems but keep to their existing note-taking habits.
Linked Data. The term Linked Data was rst introduced by Berners-Lee
in 2006 to de ne a set of best practices for publishing data on the Web [
We propose an approach that enables the publishing and sharing of personal notes by extending the functionality provided by SemNotes. The process consists of two steps: (i) transformation and (ii) publication. In the rst step, the note is transformed locally for publication, and private local data is replaced with public server references. In the second step, the transformed note is published online on a dedicated server, where the resources referenced and the tags assigned, are shared between the notes of all users. As we mentioned above, there are also two prerequisite steps: (i) the note-taking process and semi-automatic annotation of the note, which is the usual note-taking approach, and (ii) the identi cation of Web aliases for the desktop resources related to a note, where URIs are mined from the Web for locally de ned resources, such as people, events or projects. These steps are required in the work ow, but will not be detailed in this paper.
The rst prerequisite step | note-taking and annotation of the note with the relevant desktop resources | must be performed before any actual sharing of 3 NRL is an extension of RDF which provides named graphs and a closed world assumption more suitable to the desktop environment. 4 http://www.semanticdesktop.org/ontologies/ 5 http://xesam.org/main/XesamOntology
notes can be done. The annotation is done semi-automatically and is an existing feature in SemNotes. For each note, the user is o ered a list of possible related desktop resources from which he can choose the relevant ones. When a resource is chosen, a link (i.e. an RDF triple) is created in the local repository between it and the note.
The second prerequisite step consists in nding Web resource for each of
the desktop entity linked to the note that is about to be published. This step
is currently executed by a desktop service that relies several Semantic Web
indices (i.e. Sindice7) and public SPARQL endpoints (i.e. DBpedia, Semantic
Web Dog Food Server) to retrieve results. The matching process is based on the
one described in [
Based on the process described in the previous section, we engineered a system for publishing personal notes on the Web. The system is divided between its local part and its remote part, as shown Figure 1. The local part handles local private data, while the remote one handles online public data. The separation between them extends over 3 layers: ontology, data and application. On the ontology level, the NEPOMUK desktop ontologies are used locally while popular Web vocabularies are used on the server-side. These ontologies are used to describe the data exchanged between the applications. Desktop data is stored in the local NEPOMUK repository, which is provided with any NEPOMUK installation, while Web data is distributed in the Linked Data cloud. Finally, on the application level, the local component is an extension to SemNotes that provides publishing functionality for notes, and the remote component is a server that hosts and publishes online the notes received.
The rst step of the process is executed on the local side, by an extension of the SemNotes application. Then, the publication step is done by the server, which receives information from the desktop and publishes the note, as we will describe next. These two application components, the communication between them, and the data translation process are described in detail below. 4.1
Although both the Semantic Desktop and the Semantic Web use the same representation languages, i.e. RDF(S)/OWL, they use di erent vocabularies to describe their data. This vocabulary gap makes data integration di cult. The NEPOMUK project uses \desktop ontologies" to describe its data. The central ontology here is the Personal Information Model8 (PIMO). SemNotes represents
personal notes as instances of pimo:Note and are linked to the pimo:Things they mention by the relation pimo:isRelated. When a desktop resource is found to represent the same real world entity as a Web resource, the relation is stored on the desktop as pimo:hasOtherRepresentation. This property is recommended by the PIMO speci cation as desktop equivalent to the owl:sameAs relation, although without the formal semantics that the latter provides. We also use the property pimo:hasOtherRepresentation to store the remote URL of a note when it is published. The property is replaced with pimo:hasDeprecatedRepresentation if the note changes on the desktop after publication.
While well-suited to represent desktop information, these ontologies are not
used, so far, on the Web. However, numerous vocabularies have emerged for
describing semantic data published online. Among them, a limited number have
gained wide-spread adoption, including: (i) FOAF for describing people and
their social relations; (ii) SIOC for describing communities and their
interactions; (iii) DOAP9 for software projects; (iv) GeoNames10 for geographic
information; (v) the Music Ontology for music-related information; and (vi) models
such as Dublin Core for general metadata or SKOS to represent lightweight
controlled vocabularies. Such ontologies have now been widely adopted and are
recommended as best practices when publishing data on the Web [
Consequently, while representing similar objects, the two sets of vocabularies must be aligned so that on the one hand, desktop information can be moved to the Web and understood by usual SW applications (that rely on the aforementioned vocabularies) and on the other hand, Web information could be understood and imported by SD applications. In order to enable interoperability between the desktop and the Web, we de ned mappings between the sets of
Class Subclass of Property Subproperty of pimo:Note sioc:Post nao:prefLabel rdfs:label nao:Tag sioct:Tag nao:created dcterms:created pimo:Person foaf:Person nao:lastModified dcterms:modified pimo:Project doap:Project nao:hasTag sioc:topic pimo:Event ical:Vevent pimo:isRelated sioc:related_to
Table 1. Sample of the mapping between (i) classes, and (ii) properties. ontologies. The mappings create appropriate subclasses or subproperties of the relevant concepts from the chosen vocabularies.
SIOC is probably the most widely used vocabulary for interlinking social
media within the Linked Data cloud. There are already many tools for creating
and using SIOC data [
In order to publish the resources with a consistent URI scheme, we de ned
patterns for naming of the various objects published from the desktop on the
Web. In the schema de nition, we apply several Linked Data patterns described
in [
For each note the server generates a new unique identi er id which is used to create the note's URI in the form: http://semnotes.deri.ie/notes/note/id.
According to the proxy URIs identi er creation pattern, we generate new URIs for the resources related to the notes. This ensures that the publishing process is consistent and avoids having to choose among several Web aliases a resource could have. Like the notes, each resource has a unique identi er on the server, which is used to create the resource URI according to the following format: http://semnotes.deri.ie/notes/resource/id. Each resource is shared by all the notes that link to it, which increases the interlinking and the consistency of the data. For each resource, the server keeps internally a list of Web aliases (i.e. Web URIs that were found to represent the exact same real world thing) using owl:sameAs links. 11 Although nao:lastModified and dcterms:modified do not have the same semantics, de ning subproperty relations between them is acceptable.
Tags are considered a particular type of resources, and are also shared on the server. The speci c format for the URI di erentiates them from regular resources: http://semnotes.deri.ie/notes/tag/label. The label of the tag acts as a unique identi er, and is case sensitive. They are created on the y, and are persisted when they are used for the rst time.
Non-information resources12 also got their own URI, and we distinguish URI of the resources and URIs of the pages describing them. 4.3
The rst step of the process consists in the preparation of the note for publishing. This phase consists of including all the relevant information about the note in the content, speci cally the title, creation and last modi cation time, the tags and the referenced resources. This transformation is necessary, so that less only the HTML content of the note is sent to the server, and not the entire RDF graph describing the note. The content is already stored as HTML, but to include in it all the metadata about the note, it has to be enriched with RDFa before it is posted to the server.
The preparation step is done on the desktop side, by the extension to the note-taking tool, but still requires to communicate with the publishing server to retrieve Web URIs for the note and the linked resources. In case the note has already been published, the user can overwrite the old post (on the Web) or create a new one. Depending on this choice, the server is requested a new URI or the existing one is used (that was saved in the local repository when the note was published the previous time). The referenced resources are shared by all the published notes, therefore the server must create the URI for a resource only if it has not been created before. To decide if a local resource already has a server URI created, the list of Web aliases found for it | in the second prerequisite step of the process | is sent to the server (see Fig. 2). If a resource with the same type and a similar list of aliases exists, the server reuses it, otherwise it creates a new one and saves the information about it in its own RDF repository. On the server, the URI aliases are saved as owl:sameAs as it is customary for Linked Data. The server URIs for the note and the resources are also stored on the desktop for reuse, as pimo:hasOtherRepresentation.
The communication between SemNotes and the server is done with a single REST call, in order to minimise network delays. The reply contains the newly created URI for the note, if one was required, as well as a list of server URIs for the resources (see Figure 3).
Using the information received from the server, the note content is enriched with RDFa. The metadata about the note, like type, creation and last modi cation times and the tags, is added in meta tags in the head of the HTML page. RDFa is added to the title tag and in the body, to the links. Figure 4 shows the content of a note prepared for publishing. 12 For a discussion about information resources and non-information resources, we refer the reader to http://www.w3.org/TR/webarch#id-resources { } "id" : "", "resources": [ { After preparation step, which takes place on the desktop side, the RDFa enriched content is sent to the server via another REST call. The publication step of the process only handles public data. When the content is received it is parsed and the server extracts the contained RDF triples and stores them in its repository. The content (as it is received) is also stored.
The server implementation uses ARC213, as it provides out of the box RDFa parsing and an RDF repository. It is easily deployable due its minimal setup requirements (a PHP enabled Web server and a MySQL database), thus making our system easily deployable as well. 13 http://arc.semsol.org <!DOCTYPE html PUBLIC '-//W3C//DTD XHTML RDFa 1.0//EN'
'http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd'> <html about="http://semnotes.deri.ie/notes/note/4baccab834e20"> <head> <meta content="sioc:Post" property="rdf:type"/> <meta rel="sioc:topic" href="http://semnotes.deri.ie/notes/tag/concert"/> <title property="dc:title">concert sunday</title> </head> <body> ...
<a rel="sioc:is_related"
href="http://semnotes.deri.ie/notes/resource/4bacca84ca8bb">Scorpions</a> ... </body> </html>
Fig. 4. RDFa-annotated XHTML content of note.
All server URIs are dereferenceable, as required by the Linked Data principles. For notes, the URI redirects to the RDFa annotated HTML page containing the note itself (as shown in Figure 5 (i)), the URI of the note being the URL of this page. For the linked resources, the URI is also dereferenceable and provides RDFa information about itself, linking to the known existing Web aliases of the same resource. The description also includes a list of backlinks to all the notes that reference the resource (see Figure 5 (ii)). The page for a tag will contain backlinks to all the notes tagged with it.
The RDFa annotated page for the note is generated on the user's desktop by the SemNotes plugin, as we have seen in the previous step, while the one describing each resource and tag is generated on the y, by the server, when the URI is requested. 5
When establishing the speci cations of the framework, we identi ed four main requirements (Section 2). Our proposal conforms with them as follows.
R1: Publish the complete desktop data on the Web without losing any relevant information, including metadata and context (e.g. tags, relations, identi ers). By translating existing desktop data in RDF an putting it online, available as RDFa, the whole information available on the desktop side is made available on the Web for further reuse. In addition, all information from the original notetaking tool, including title, tags, etc. is publicly made available on the Web.
R2: Protect any machine readable and private data that might be unwillingly be included in the context being transferred;.
By replacing the private desktop data with equivalent public Web data, we protect the former. On the desktop there is much private personal information stored about the resources, like the email address or telephone number for people, or the list of attendees of an event. When the person or event linked to by a note that is afterwards published online, such private information is not exported, because the reference to the local resource is replaced by a reference to already public Web data representing the same thing. In this manner, the context of the note being published is preserved, but the private details are not exposed.
R3: Publish the note according to the Linked Data principles and describe it use popular ontologies.
Our system publishes notes on the Web using the Linked Data principles. Each note has its own URI, as well as resources, and these URIs are made dereferenceable, while distinguishing information resources and non-information resources. In addition, while original desktop data is provided using \desktop ontologies", the published information is made available using FOAF, SIOC, Dublin Core, etc. and the mappings have been validated through Vapour14.
R4: Enable object-centred sociality by establishing connections between data published by di erent users.
Since resources and tags are shared between users, notes can be browsed
serendipitously through shared topics, or tags. This enables \object-centred sociality"
[
Semantic blogging has received much interest since it was introduced by Cayzer
and Shabajee in [
The main bene t of the rst category, represented by tools like SemiBlog [
Online services like BlogAccord [
In this paper we presented an approach for publishing personal notes as Linked Data on the Web. The aim of our work was to provide a way for publishing and sharing complete information by preserving the personal context of the notes without compromising privacy. Our solution makes a step towards bridging the gap between Semantic Desktop data and Linked Data.
We de ned a publishing process that comprises two steps: (i) preparation {
the note is transformed into a SIOC-based Web representation; and (ii)
publication / sharing { the note is published online following the Linked Data principles.
In addition, we provided a related implementation and tested it against a set
of requirements regarding publishing personal content from the desktop to the
Web as Linked Data. While we do not address security issues in this current
release, we consider SW-compliant authentication systems such as FOAF+SSL
[