Tag Archives: semanticweb

Tales from the SIOC-o-sphere #7

20080403a.png It’s been three months since my last round-up of all things SIOC-ed, so here is entry number seven in the series:

Previous SIOC-o-sphere articles:

#6 http://sioc-project.org/node/310
#5 http://sioc-project.org/node/294
#4 http://sioc-project.org/node/272
#3 http://sioc-project.org/node/271
#2 http://sioc-project.org/node/138
#1 http://sioc-project.org/node/79

Kingsley remixes my DataPortability slides as "Data Accessibility and Me: Introducing SIOC, FOAF and the Linked Data Web"

Kingsley Idehen told me on IRC that he remixed my presentation on DataPortability and SIOC from yesterday as Data Accessibility and Me: Introducing SIOC, FOAF and the Linked Data Web.

I’ve never had my slides remixed before, I’m honoured! Here’s the new version:

DataPortability, Microsoft's Contacts API and OpenSocial.org

20080326a.png (No, the picture I created on the right ISN’T the new DataPortability logo; I totally missed out on the closing date, but it will serve as an image for this blog post. There have been some very cool submissions for the competition however.)

There were two interesting announcements yesterday in the portability space. The first was from Microsoft, announcing that they would be “working with Facebook, Bebo, Hi5, Tagged and LinkedIn to exchange functionally-similar Contacts APIs, allowing us to create a safe, secure two-way street for users to move their relationships between our respective services” (Contacts APIs provide contact data portability). The second was from Google, Yahoo! and MySpace, jointly announcing that an OpenSocial Foundation is to be formed as a non-profit entity (OpenSocial provides social application portability). Unfortunately, there is still some confusion regarding exactly what data portability functionality OpenSocial will offer (if any), and at the moment the consensus seems to be that DataPortability and OpenSocial aren’t as related as previously thought.

DataPortability (including Microsoft’s move in this area) is mainly about users being able to have portable data (profiles, identities, content like photos, videos, discussion posts) that they can move between the services and sites that they trust and choose to use. (See Uno de Waal’s interesting post on how the Microsoft Invite2Messenger service allows you to get your Facebook friends’ e-mail addresses in plain text.)

OpenSocial on the other hand is more about “gadget” portability, where social applications can be deployed across a variety of social networking sites. As summarised by Julian Bond, OpenSocial consists of a gadget API (for gadget programmers) and a standard for site owners to implement these gadgets on their own sites. The part of OpenSocial related to DataPortability is a REST API, details of which are a bit vague right now. Not to be confused with OpenSocial (although the similar names make this difficult), the Social Graph API from Google is more related to DataPortability as it indexes semantic data from many social networking sites like Hi5, MySpace, LiveJournal, Twitter, etc. and allows users to bring their social graph with them when they sign up for a new site that supports the API.

Apart from the lack of intersection between Microsoft (plus affiliate Facebook) and Google, a good few companies are in multiple “camps” (DataPortability, Contacts APIs, OpenSocial), as shown by the Venn diagram I drew below:

20080326b.png

Marc Canter and others have pointed out that although the Contact APIs from Microsoft are not open in themselves, at least the APIs seem to export as much data as they can import. Marc also says that Microsoft (and other big companies) may not be explicitly following the actions (e.g. the technical recommendations) of the DataPortability initiative, but rather claims that it would hurt them if they didn’t open up and go along with some portable data efforts given the current climate and the tide of users in favour of this.

For users to have true data portability, there needs to be some consensus on both the APIs and the formats needed to transfer / represent this portable data. It may be that a number of APIs and formats are required for different scenarios. The Semantic Web is an ideal means for representing the data to be ported from social websites, in that is well suited (using vocabularies like SIOC and FOAF) to represent how people and all kinds of objects on these sites are connected together (documents, discussions, meetups, places, interests, media files – whatever). Of course other data formats may be used, but most importantly, it would be a waste of time to come up with a bunch of new formats for representing the data that needs to be portable, because a lot of work has been done on how to best provide interoperable, reusable and linked data through efforts like the Semantic Web, AtomPub and the microformats community.

I’ll be attending the DataPortability Lunch Meetup in London on the 6th April 2008 if anyone there feels like a chat about some of these topics…

Related posts:

Semantic Web for Dummies

20080220a.jpg I referenced this on the SIOC-Dev mailing list recently, and when I pasted it on the DataPortability.org steering group chat this morning (in parallel with our first phone conference), Drummond Reed suggested I blog it. It’s originally from MIT’s Stefan Marti:

XML customised tags, like:
<dog>Nena</dog>
+ RDF relations, in triples, like:
(Nena) (is_dog_of) (Kimiko/Stefan)
+ Ontologies / hierarchies of concepts, like:
mammal -> canine -> Cotton de Tulear -> Nena
+ Inference rules like:
If (person) (owns) (dog), then (person) (cares_for) (dog)
= Semantic Web!

(Picture by Duncan Hull.)

int.ere.st – create and share tags across your online communities

As mentioned in a previous blog post, int.ere.st has just launched. The main objective of int.ere.st is to demonstrate how Semantic Web and Web 2.0 technologies can be combined to provide better metadata creation and sharing support across various online communities.

With int.ere.st, you can save, tag and bookmark your own as well as other people’s tag clouds, as represented using the SCOT ontology. The tag meta search also allows you to look for similar patterns of tagging from other people based on their interests (as expressed using tags).

Some functionalities of int.ere.st include:

  • Various options for tag searching, such as and (&), or (space), co-occurrence (+), broader (>), and narrower (< )
  • User searching
  • Resource searching
  • Integrating tagged data across communities
  • Meta tagging
  • Ontology bookmarking
  • Sharing metadata produced using the FOAF, SIOC, and SCOT ontologies

You can try it at out at http://int.ere.st/. Here are some video demos of int.ere.st in action, and some more videos are forthcoming:


Short


Long

State of the SIOC-o-sphere (#5)

It’s that random time of the year again where I summarise what’s been going on in the world of SIOC

Testing Yahoo! Pipes

Yes, it’s very cool! RSS fans, prepare to be blown away. Via this Slashdot article and CaptSolo’s post on sioc-dev:

“Yahoo has introduced a new product called Pipes. It seems to be a GUI-based interface for building applications that aggregate RSS feeds and other services, creating Web-based apps from various sources, and publishing those apps. Sounds very cool. TechCrunch has a decent write-up, and Tim O’Reilly is all over it. The site was down for a few hours and is just back up. Has anybody tried this?”

and from the Pipes page:

Pipes is an interactive feed aggregator and manipulator. Using Pipes, you can create feeds that are more powerful, useful and relevant.

So I created a basic pipe to take three feeds from Planet Journals, IrishBlogs.ie and awards.ie about the forthcoming Irish Blog Awards using the “Fetch” module. I then used their “For Each: Annotate” module to add a sioc:topic annotation, using the first matching result from a Yahoo! search for the phrase “Irish Blog Awards”. The graphical interface is very easy to use, and a screenshot of the pipe construction is shown on the left. You can see the pipe output on the right below; unfortunately the RSS 2.0 dump loses the sioc:topic annotation I added, but the JSON dump still retains it so with a bit of manipulation this could provide the appropriate RDF.

20070213a.png20070213b.png

Buxon visor for sioc:Forum browsing

I’ve been testing out the Buxon visor for browsing SIOC forums, created by the SWAML developers and written in PyGTK.

So far, it works great (with SWAML-generated data). I used an example script packaged with python-libgmail (archive.py) to download an inbox from a GMail account (subscribed to the sioc-dev mailing list) to mbox format, and then ran swaml.py on that mbox to convert it to SIOC RDF. The resulting RDF is here, and I successfully browsed this with Buxon (as shown in the screenshot below). Great job, SWAML guys!

This is a nice demonstrator, and it just remains to do the same for a few more SW-related mailing lists…

20061108a.png

Microformats and SIOC

(Got a chance to finish this idea during BlogTalk Reloaded today! I just needed some more inspiration…)

It’s been a year since I last took a look at the overlap between the SIOC Project and Microformats (mf). I’ve been trying to catch up with recent developments, especially the cite-rel draft by Ryan King and Eran Globen.

I admire the Microformats resolve to “solve problems”, rather than provide generic things that may in the future be used for X or Y (even though I believe that too is important, or else I wouldn’t be a Semantic Web researcher!). I also think that there is no good reason that both the Semantic Web and Microformats communities can’t work together (despite arguments like this). There are people on both sides who strongly feel that the other is going in the wrong direction, but it would be a mistake to let any such voices dominate. Both communities are trying to add semantics in the Web, and using things like GRDDL and Micromodels / mf RDF representations, the existing work from both sides can be reused.

So, with this in mind and in terms of SIOC, I hope that we can use Microformats to help create closer interlinks between the objects that make up online communities – I’m talking mainly about posts, forums / blogs, communities and user profiles. I’m going to start with three or four things I want SIOC to do for Microformats and vice versa, and then we can go from there. These correspond to some of the links shown in my “connecting discussion clouds” picture.

One User, Many User Accounts

At the moment, it is quite difficult to identify all the posts made by a particular person through their various user personas or profiles on different sites – e.g. find all the blog posts and comments and forum threads I’ve created in the past year. In the SIOC and FOAF vocabularies, there are two properties linking people to user profiles: a Person is linked to a User using a “hasOnlineAccount” link, and a User is linked to a Person using an “account_of” relationship. Using a mf for sioc:account_of / foaf:hasOnlineAccount would help with the “One Person, Many User Accounts” issue – e.g. these links could be created from a user signature or other public profile field. For example, I have an account on boards.ie, and I want to say that I am the same person described by a FOAF profile on my own site, or that I hold another account on boards.jp. Maybe links are required in both directions to confirm that I am really am who I claim I am, but this can be done at least (even if it is tedious). This may also require some BBCodes for forums that translate to the appropriate HTML.

Example


<div class="User">
I am <a rel="account_of" href="http://johnbreslin.com/">John Breslin</a>, and I also have another account, <a rel="hasOnlineAccount" href="http://microformats.org/wiki/User:Cloud">Cloud on microformats.org</a>.
</div>

Virtual Forums

Wouldn’t it be nice if you could have a virtual forum of all your posts on blogs, forums, mailing lists, whatever? Apart from going around to all of your favourite sites and linking to your posts from a page, another option would be to do it in reverse – when you create your post, link back to your own post aggregation resource. From the user side, this could be achieved by creating a mf for sioc:has_container that allows linking to “Virtual Forums” from the post creator side, e.g. from the post content. Also, virtual forums could be created that list all the posts by people in a restricted social network, or constructed for posts / threads that refer to a certain resource or topic.

Example


<div class="Post">
Another post that is related to my love of <a rel="has_container" href="http://www.johnbreslin.com/forums/electronicmusic/">electronic music</a>, Tangerine Dream are releasing five previously unreleased albums next week...
</div>

Unified Communities

This kind of corresponds to Eran’s idea of “distributed social anything“. In SIOC, we use has_part and part_of to link any object to a particular community. The concept of Community in SIOC is very generic – but the idea is that you should have a structured way to link different things (forums, people, etc.) to a community object. Let’s say that there’s a community talking about the TV series Lost, and they have a blog, a mailing list, an aggregation of Lost-related blogs, or just a news website – these could be linked to an identified central community resource through part_of / has_part relation. Similarly, I could identify myself or my user profile on a particular site as being part of that Lost community. From forums, a mf for has_part / part_of would allow one to link a forum or blog or any discussion channel to a larger community, e.g. this could be done from a forum description. Also, a mf for has_part / part_of would help to link a user to a community, e.g. by creating a typed link from a user signature.

Example


<div class="Forum">
Welcome to the <a href="http://sioc-project.org/forum/">SIOC forums</a>, where we talk about the <a rel="part_of" href="http://www.semanticweb.org/">Semantic Web</a> and internet discussions.
</div>

Distributed Conversations

Ryan and Eran have already done a lot towards this idea with the cite-rel draft. In terms of SIOC, we already have the has_reply and reply_of relationships, which match up to their proposals: rel-reply corresponds to sioc:has_reply, and rev-reply corresponds to sioc:reply_of. Using the mf cite-rel versions of has_reply / reply_of would allow these distributed threads to form, e.g. if used from the post content. cite-rel brings the reply idea a step further by introducing rel-forward and rev-forward (basically, has_reply and reply_of with quoted content). Ultimately, we need ways to say that a post is in agreement or disagreement with a previous post or even with specific parts of a previous post (see picture below). Also, we may need to describe other reply types that are needed, as with IBIS. (Note: rev-update and rel-update may correspond to sioc: previous_version and sioc:next_version respectively, and via may be compared with sioc:related_to.)

Example


<div class="Post">
As a follow up to my previous post about <a rel="reply_of" href="http://www.johnbreslin.com/blog/2006/09/07/creating-connections-between-discussion-clouds-with-sioc/">connecting discussion clouds</a>, I have realised that I need to say more about people and topics, especially as discussed <a rel="related_to" href="http://www.johnbreslin.com/blog/2005/11/11/iswc-2005-over-won-an-ipod-aligning-sioc-with-foaf-and-skos/">here</a>. Edit: I've since posted about how <a rel="has_reply" href="http://www.johnbreslin.com/blog/2006/09/27/sioc-foaf-skos/">FOAF and SKOS can be used to describe people and topics</a>.
</div>

Even in just a single thread there can be many challenges in terms of identifying agreement and disagreement. My picture below illustrates some of the complexity relating to implementing such reply types, especially when user revisions of content are brought into play. There are two types of agreement / disagreement shown in this example: the orange lines show those between responses to the discussion topic, and the purple lines show those between revised versions of a content item.

20061001c.png

Future

I’d like to hear from both communities (Microformats and Semantic Web) on this, so please comment if you have time. Maybe eventually we can come up with a proper SIOC-roformat (hSIOC?) based on some of the ideas in this brief draft.

20061001e.png