{"id":1930,"date":"2006-12-18T09:20:00","date_gmt":"2006-12-18T09:20:00","guid":{"rendered":"http:\/\/www.leobard.net\/blog\/?p=1930"},"modified":"2017-11-04T15:47:48","modified_gmt":"2017-11-04T15:47:48","slug":"two-user-interfaces-for-the-semantic-web-a-generic-semantic-web-editor-and-masses-of-mashups","status":"publish","type":"post","link":"https:\/\/www.leobard.net\/blog\/2006\/12\/18\/two-user-interfaces-for-the-semantic-web-a-generic-semantic-web-editor-and-masses-of-mashups\/","title":{"rendered":"Two user interfaces for the semantic web: a generic semantic web editor and masses of mashups"},"content":{"rendered":"

In this article I will show in what direction for editing RDF I will head in the next year, proposing two approaches: first one Java based integrated RDF browser and editor for the desktop, and second masses of small data mashup editor applications on the web.<\/b><\/p>\n

So, you want to publish data about that upcoming event, the date, time, and place of that appointment, and the expected participants? And you want to do it in a way that it integrates with social websites and everybody can add the data into their individual information management system, be it on google calendar or in their personal timetable? The semantic web would offer that, allowing you to publish any data on the web using an open and free standard. The only problem is: you don’t get an “one editor does it all” and you don’t get decent integration into your everyday applications – yet.<\/p>\n

Once you published the data in RDF format, there are some firefox plugins that let others use it, and search engines such as swoogle <\/a>or swse <\/a>will pick the data up. I tried in 2004 to find a generic RDF browser<\/a> and editor and again later<\/a> but could not be satisfied. Many people feel the same and some reacted in their blogs<\/a>, coming to the conclusion that we do not need something as generic as raw RDF, but user friendly applications to edit it.<\/p>\n

For 2007, I plan to be part of two streams of work that will happen. <\/p>\n

Plan A: The Semantic Desktop Rich Client<\/a> based on Eclipse RCP<\/b><\/p>\n

This is going to be a desktop application that lets you download, edit and publish Semantic Web data. It will look something like the many applications already built on RCP<\/a>:
\n\"ibmWorkplaceClient\"<\/a><\/p>\n

If you don’t know Eclipse RCP: its a framework that lets you plug together bigger applications using Java. Ok, not as cross-language as the .NET platform or as used as ActiveX controls, but at least Java is now open source and exists on most platforms. And accidentially, I am familiar programming it. <\/p>\n

So, the plan is<\/a> to first define a few background components for RDF data handling, using the RDF2Go abstraction layer to allow you to plugin any RDF store you want. Then we need a few screws and hinges and a registry of plugins, and hopefully you will be able to browse and edit most common RDF data using a nice plugin. For example, a plugin to edit FOAF files and publish them somewhere would be part.<\/p>\n

This project is coined Semantic Desktop Rich Client and is hosted on the semanticdesktop.org wiki<\/a>, some people from Nepomuk will start coding a small core and then we discuss with others how to standardize a little.<\/p>\n

Plan B: masses of small data mashup editor applications on the web<\/b><\/p>\n

The problem of editing and publishing RDF can also be solved on the web itself. Some of you may know the foaf-a-matic editor<\/a> that allows you to create RDF statements. For example, I could go there, create some RDF and put it here. Lets do that. Here is the result:<\/p>\n

<rdf:RDF
\nxmlns:rdf=”http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns#”
\nxmlns:rdfs=”http:\/\/www.w3.org\/2000\/01\/rdf-schema#”
\nxmlns:foaf=”http:\/\/xmlns.com\/foaf\/0.1\/”
\nxmlns:admin=”http:\/\/webns.net\/mvcb\/”>
\n<foaf:Person rdf:ID=”me”>
\n<foaf:name>Leo Sauermann<\/foaf:name>
\n<foaf:givenname>Leo<\/foaf:givenname>
\n<foaf:family_name>Sauermann<\/foaf:family_name>
\n<foaf:mbox_sha1sum>
\nbda8b719cf44de6997b69bc9cc5fca622b2645b3
\n<\/foaf:mbox_sha1sum><\/foaf:Person>
\n<\/rdf:RDF><\/cite><\/p>\n

Doesnt look that pretty. No wonder, its got to be embedded in the HTML code of this webpage. Then it would look something like this (my blog cuts out RDF code, so I cannot really post it here, tried it, doesnt work, don’t want to fuzz with rRDF now, be patient, someone will make a mashup that lets you allow to embed rdf in a blog):<\/p>\n

Leo Sauermann
\nLeo
\nSauermann
\nbda8b719cf44de6997b69bc9cc5fca622b2645b3<\/cite><\/p>\n

Thats the advantage of RDF, its compatible with HTML and if you want more featurs, checkout eRDF<\/a> and RDF-A<\/a>.<\/p>\n

The problem we need to solve now is:<\/b> editors such as the foaf-a-matic need to be able to suck data in, edit it, and put it at the place where they got them from. Think of it like using more than one text editor on the same file, vi, emacs, kwrite, MS-Word, openoffice they are all nice ways to edit text. The same with the Semantic Web, and the advantage is that the Semantic Web data is designed to be on the web anyway. <\/p>\n

So, we need to write small editors that can suck data from RDF repositories, edit the RDF a little, and store it back. You have your store at A, got all your data there, and your friend Alistair tells you about that great photo annotator on flunker.com, which happens to be a RDF editor like the one the XSLT semi-god Masahide Kanzaki<\/a> offers. We only need more of them, and we need an automatic way to BLOG the data that was created by editors like Kanzaki.<\/p>\n

So, at the end, I would like to be able to copy\/paste the RDF generated by Masahides web-application into this blog and have the great annotations shown here.<\/p>\n

ok, lets do that, here is the RDF of a photo annotation, here again the code:<\/p>\n


\n<rdf:RDF
\nxmlns:rdf=”http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns#”
\nxmlns:rdfs=”http:\/\/www.w3.org\/2000\/01\/rdf-schema#”
\nxmlns:dc=”http:\/\/purl.org\/dc\/elements\/1.1\/”
\nxmlns:foaf=”http:\/\/xmlns.com\/foaf\/0.1\/”
\nxmlns:image=”http:\/\/jibbering.com\/vocabs\/image\/#”
\nxmlns:an=”http:\/\/www.w3.org\/2000\/10\/annotation-ns#”
\n>
\n<rdf:Description rdf:about=””>
\n<an:annotates
\nrdf:resource=”http:\/\/static.flickr.com\/31\/39230921_71f02f0f10.jpg”\/>
\n<an:author>leobard<\/an:author>
\n<an:created>2006-12-18T09:02:37Z<\/an:created>
\n<\/rdf:Description>
\n<foaf:Image
\nrdf:about=”http:\/\/static.flickr.com\/31\/39230921_71f02f0f10.jpg”>
\n<dc:title>Leo and Inkel<\/dc:title>
\n<dc:description>Leo and inkel at Buenos Aires<\/dc:description>
\n<dc:creator>Leobard<\/dc:creator>
\n<image:width>375<\/image:width>
\n<image:height>500<\/image:height>
\n<image:hasPart>
\n<image:Rectangle rdf:ID=”p1″>
\n<image:points>261,62 339,198<\/image:points>
\n<dc:title>Inkel<\/dc:title>
\n<image:depicts rdf:parseType=”Resource”>
\n<dc:description>Inkel<\/dc:description>
\n<\/image:depicts>
\n<\/image:Rectangle>
\n<\/image:hasPart>
\n<image:hasPart>
\n<image:Rectangle rdf:ID=”p2″>
\n<image:points>100,65 201,202<\/image:points>
\n<dc:title>Leo<\/dc:title>
\n<image:depicts rdf:parseType=”Resource”>
\n<dc:description>Leobard<\/dc:description>
\n<\/image:depicts>
\n<\/image:Rectangle>
\n<\/image:hasPart>
\n<\/foaf:Image>
\n<\/rdf:RDF>
\n<\/cite> <\/p>\n

\nand here is the result you get when rendering it nicely, this time using Kanzakis magic:<\/p>\n