1. I need to review who got an account on MY site

2. I need to have the spam filtered out, which eats up CPU cycles

3. Most of us have their own blog, use the interlinking nature of the web!

My suggestion is: please post an article on your own blog and trackback the article on my blog you wanted to comment on. If you don’t have a blog: use identi.ca and url’shorten the URL of my article in your dent

Thanks!

. Plazes has removed the “places” Atom feed and just puts a “activities” feed online. This is not what I expect to get provided by a location service. Thanks for all, need to have a look at fireeagle…

A moat server is a piece of software accessible via HTTP and delivery HTML, RDF/XML or JSON representations of the meaning of a tag. moat server by Alexandre Passant drives my installation. It leverages PHP, MySQL and ARC2 do to its job. One feature I do miss is something like a scutter to gather data I may have published earlier.

Update xmlgrddl could be a good thing to extract tags from every post… need to have a look

The weapon of choice for near real time information delivery is obviously XMPP. I will use publish-subscribe to provide information, by doing so any of my peers may or may not subscribe to a node onto which I publish information. And I will set up a hierarchy of nodes onto which I will publish different kinds of information. So here we go with the root node: home/b4mad.net/goern, this is mainly due to the fact that I use ejabberd2 to run my XMPP Server. There are a few subnodes:

• bookmark – for bookmarks that I send out, I need to figure out the format of published information
• micropublish – for twitter like things, that is basically Atom over XMPP
• media/stillimage – for a photostream…

As a good semantic web citizen I will note down what nodes exist at which URI and what they are used for. The first rough scratch is available.

For the moment there is a shell like Java application which accepts two commands: exit and purge, to exit the shell and purge off all items from the micropublish node. Any other words typed in the shell will be treated a an micropublish update and published as a Atom entry to my micropublish node.  The second application is a gateway to twitter.com: it is subscribed to my pubsub micropublish node and will pick up any atom entry and post it as a twitter update.

The next thing it write up is a process and format to publish my bookmarks and to have some nice GUI clients that can handle my updates… Or should it be integrated into WorkPress?!

• Flickr.com – is good for sharing photos, but their time has come. Most important the censorship issues mark the point to flag flickr as “need to migrate away from it”. By now it is still in my accounts file
• del.icio.us – good and thats it… keep it
• jaiku.com – is aggregating other services and trying to give a timeline of my online footsteps. This is a good services from the point of “declarative living”, but: delete account, because:
• noserub has been implemented at #B4mad.Net this is good, as I take back control of my data back from jaiku
• mugshut.org is kind of the same thing, never really used it…
• I will use twitter for this microblogging thingy…
• all this SIP and VoIP accounts need to be deleted: mobile phones are not replacable
• plazes.com is kind of good as a location/presence services. I need to figure out how to do that with geonames.org and noserub by myself!
• openbc.com or xing… what is the value add of this service?
• upcoming.com and calendar.google.com – upcoming supports venues and is more like “calendar sharing” google calendar is … do I really need this?

I will try to consolidate even more and provide one web view of all that and one xmpp infrastructure to deliver updates to interessted agents/persons.

Using their maps I tried to locate myself which is pretty easy. Why I have to do that by myself? This information is actually available online as a SPARQL result, Google could be aware of that…

Ok, next step: I need a Frisör (barber) nearby, just look for barber shops at Google Maps nearby the location I just found. Now I need to have a look at the screen just because Google is not aware of what “near by” means, for me it means “within walking distance” (approx. 1km).

3rd step: have a walk… will report back when I returned

Subscribe to my brain was brought up by Leigh Dodds in June 2005. His goal was to consolidate different (subscribable) source of information a user published. The key he used to join this sources was the user’ mailbox IRI sha1 checksum. So he sent on and did it the semantic web way and provided a webservice to fulfill the task and provide a OPML file that may be imported directly into a aggregator.

Red Hat”s solution is to provide a single web pages to replace the aggregator and no webservice but user configurable source to aggregate from. This is nice, from a web design point of view. But it is basically redundant. For a semantic web guy, most of the information mugshot requests (by forcing me to fill in my user profile) is available on the web and maintained anyways:

• Accounts at flickr, del.icio.us et al – I have this written down in a RDF/XML FOAF file, as may others do on the web. Advantage: that foaf file is gnupg signed by me, it is verifiable if that account do really belong to me. Any user may open up a account at mugshot or flickr and predent his is me. The only authorative source for that information is my FOAF file.
• Personal Information – like my blog url, my picture and the user name and passowrd I”d like to use is requested by mugshot. Again, most of this information is stored in my FOAF files. Username and authentication may be provided by OpenID and friends.

Next interessting architectural decission of mugshot was to poll data by retrieving it from the sources I manually configured in my user profile. Feels like stone age now we have Ping the Semantic Web.com (PTSW). mugshot aggregates feed, so doing it the right way(tm) would be to monitor PTSW for updates of this feeds. If they are not pinging PTSW make them ping, that would help a bigger community than just the mughot guys and girls.

And finaly, it’s just a me too project, I did it in 2006: haha :) There is no need to let others consolidate a single page about myself.

PS: and why the hack is my email address spammer readable on mugshot??

… the other day Henry send a Mail to sioc-dev mailinglist raising the question of simularities between SIOC and AtomOWL [0].

AtomOWL introduces a Content Class which represents the encoded content of a entry of a atom feed. SIOC uses a RSS 1.0 Module to keep a sioc:Post‘s content. The SIOC Vocabulary Specification [1] does not instruct to use RSS 1.0 Module or AtomOWL.

What I would like to propose is, that the SIOC community adapts usage of the AtomOWL:Content class as it’s primary container for content as a SIOC best practice.

Using AtomOWL:Content instead of content:encoded gives two advantages:

1. Content is typed

content:encoded used CDATA[] to store its content, from a RDF/XML consumer perspective there is no way to figure out what the type of content is. AtomOWL:Content uses MIME media types to indicate the type of content. Some valuable information!

2. Reuse of Vocabularies

SIOC in general tries to reuse existing vocabularies. The use of content:encoded shows this. SIOC is a very progressive and fast developing eco system. Using the latest standards in content description on the semantic web is a stringent step forward.

In addition to that,

3. Cost of implementation is small

as an exporter of sioc data only needs to add a little more information to its output stream. Any information provided in a AtomOWL:Content object is provided by the underlying content management system or may be concluded. Integration of AtomOWL:Content enriched sioc data with the AtomOWL feed of the content management system is easy.

An Example

As an example how we could link AtomOWL:Content into a sioc:Post I have added a code snippet:

<sioc:Post rdf:about="http://B4ma...cribe-content/">
  <sioc:link rdf:resource="http://B4ma...cribe-content/"/>
  <sioc:has_container rdf:resource="http://b4ma...hp?sioc_type=site#weblog"/>
  <sioc:title>SIOC and AtomOWL: a new way to describe content…</sioc:title>
  <sioc:has_creator rdfs:label="gnu" rdf:resource="http://B4ma...uthor/gnu/"/>
  <sioc:created_at>2006-08-21T17:49:06Z</sioc:created_at>
  <content rdf:parseType="Resource">
    <rdf:type rdf:resource="http://bblfish.net/work/atom-owl/2006-06-06/#Content"/>
      <body rdf:parseType="Literal">
        <xhtml><div xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" 
           xml:base="http:/b4mad.net/">
       <p><i>[content of the post itself here]</i></p>
     </div></xhtml>
      </body>
    <type>text/xhtml</type>
  </content>
  <sioc:topic rdfs:label="sioc" rdf:resource="http://B4ma...tic-web/sioc/"/>
  <sioc:has_reply>
    <sioc:Post rdf:about="http://B4ma...cribe-content/#comment-20558">
      <rdfs:seeAlso rdf:resource="http://b4ma...ment&sioc_id=20558"/>
    </sioc:Post>
  </sioc:has_reply>
</sioc:Post>

So, the interssting part is the red one… the content is simply inserted using a rdf:parseType="Resource" and a RDF type of AtomOWL:Content and a content type of XHTML (thats the white part). The rest (red parts) is to describe the sioc:Post content itself.

References:

• [0] AtomOWL Vocabulary Specification
• [1] SIOC Vocabulary Specification

[he] believe this [SIOC] started as a vocabulary for managing information associated with online forums, but it now has considerable overlap into the generic content management side of things.

My comment on the SIOC-dev mailinglist somehow has the same direction.

Beside the huge area of SIOC browser development and Uldis’ Ontology maintainance there needs to be a task to reduce redundancy with other Ontologies and add some usage recommendations to the SIOC Spec. Although the use of SKOS in combination with SIOC needs some more elaboration.

See Also: SIOC TODO list

I dont think that the RSS Aggregator on the list of desktop killer-applications. It is one nice channel that delivers data to the use. It is polled, most of the time data ist older than 30min if it appears in the RSS Aggregator.

Next question: why enrich a simple mail and put some meta data arround it that are already present in the mail itself?

And what about the back channel? If mail drops into my RSS Aggregator, how to answer? Via mail? Open up another program on the desktop and copy/paste text that I want to quote and…. Having a mailer functionality as integrated part of the RSS Aggregator doesnt seem right too, as many people have a preference for the mail application.

But wait… what is good about the idea of representing mail meta data a RDF/XML (or n3 or…) and aggregate them? It is possible to store them in a database for later use, maybe for a context sensitive search or regrouping.
To have them available for mixing and integration with other data provided by other sources.
To form a homogenous view of the communication a user had in the past, regardless of the media/channel/application he used.

After a few discussions with CaptSolo and with some help from EliasT I have tweaked my WordPress to include the needed RDFa. Looking at the source of this page you will see something like:

<div class="primary" about="http://B4mad.Net/datenbrei/archives/2006/06/05/sioc-live-query/" role="sioc:Post">
 <span style="display:none">
  <link rel="rdfs:seeAlso" href="http://b4mad.net/datenbrei/index.php?sioc_type=post&sioc_id=308" about="http://B4mad.Net/datenbrei/archives/2006/06/05/sioc-live-query/">
  <meta property="dc:format">application/rdf+xml</meta>
 </link>
</span>
</div>

To enabled correct parsing and XML Namespace assignment by a RDFa parser the <html> element must contain namespace declarations for rdf, rdfs, dc and sioc.

Using some RDFa extractor service on any page on B:\datenbrei will give you a RDF file containing a rdfs:seeAlso (of type application/rdf+xml) which points to the RDF generated by the WordPress SIOC plugin for the corresponding page.

Next step: write a short XSLT to enable GRDDLing the same rdfs:seeAlso out of the post’s page.

Planet RDF provides a foafroll, a RDF/XML representation of the feeds which get aggregated and their authors. This is a good starting point and actually a pretty complete description of the RDF community (at least of the blogging RDF community).

Taking a look at foafroll we find foaf:Agents and there blogs. This provided data will be convertet into SIOC Users in the first step.

<foaf:Agent rdf:nodeID="id2245901"> 
 <foaf:name>FOAF Project</foaf:name> 
 <foaf:weblog> 
  <foaf:Document rdf:about="http://rdfweb.org/"> 
   <dc:title>FOAF Project</dc:title> 
   <rdfs:seeAlso> 
    <rss:channel rdf:about="http://rdfweb.org/index.rdf"> 
     <foaf:maker rdf:nodeID="id2245901"/> 
     <foaf:topic rdf:resource="http://www.w3.org/2001/sw/"/> 
     <foaf:topic rdf:resource="http://www.w3.org/RDF/"/> 
    </rss:channel> 
   </rdfs:seeAlso> 
  </foaf:Document> 
 </foaf:weblog> 
 <foaf:interest rdf:resource="http://www.w3.org/2001/sw/"/> 
 <foaf:interest rdf:resource="http://www.w3.org/RDF/"/> 
</foaf:Agent>

I would like to propose a mapping like this:

 <sioc:User rdf:nodeID="sioc-id2245901">
  <sioc:name>FOAF Project</sioc:name>
  <sioc:link rdf:resource="http://rdfweb.org/" />
 </sioc:User>
 <foaf:Agent rdf:nodeID="id2245901"> 
  <foaf:holdsAccount rdf:nodeID="sioc-id2245901" />
 </foaf:Agent>

Next step is to set up a sioc:Usergroup containing all members (foaf:Agents) of the foafroll:

 <sioc:Usergroup rdf:ID="authors">
  <sioc:name>Authors at PlanetRDF.com</sioc:name>
  <sioc:has_member rdf:nodeID="sioc-id2245901" />
 </sioc:Usergroup>

Interpreting sioc:Site as “This is a Community” and not as “This is one Site of others of a Community” one must interpret Planet RDF as a Forum of the community/Site:

<sioc:Forum rdf:nodeID="f-1">
 <sioc:name>PlanetRDF.com, part of the RDF Community</sioc:name>
 <sioc:link rdf:resource="http://planetrdf.com/"/>
 <rdfs:seeAlso rdf:resource="http://planetrdf.com/index.rdf" />
</sioc:Forum>

<sioc:Site rdf:about="http://planetrdf.com/">
 <sioc:name>The RDF Community</sioc:name>
 <sioc:description>Planet of the RDF Community</sioc:description>
 <sioc:link rdf:resource="http://planetrdf.com/"/>
 <sioc:host_of rdf:nodeID="f-1"/>
 <sioc:has_group rdf:resource="#authors"/>
</sioc:Site>

Note: Maybe it would make some sense to rename sioc:Site to sioc:Community? See also a SIOC-dev posting (or was it a chat with CaptSolo??).

I have not done some Jena-based code up until now. Before releasing it I would like to have some comments on the idea, maybe some improvements need to be incorporated…

A complete example of a SIOC-from-foafroll (handcrafted) and some coffee is available too.

Some interessting stuff is happening:

• Leigh Dodds has release a new version of his Jena-based scutter I need to check out…
• Danny Ayers is peeking on Scuttering Microformats

So, lots to check out in the next days…

Time to get to work for money, have a nice day.

PS: I am really unsure where the information that the keys need to be updated is announced. Maybe there is a feed or mailing list out there??

References:

• debian-user-german mailing list
• The GNU Privacy Handbook
• del.icio.us cloud

What about an application that shows hiking or biking tracks on a map, with media annotation like photos/videos or sound per waypoint or per a region. The trancks themself may be edited online using a web application or a standalone client which reads in GPS data from some device. After the user finished editing the track a publish subscribe mechanism (xmpp?) is used to notify the aggregator that a new track is available for a user, maybe only available for the user’s client application or in a server centric storage – depends on user’s decision. If the user uses the standalone (local) client he may configure a access control system based on some web of trust or some friend of friend of friend relation.

If some foreign web user selects a track of a user to be shown it is either stored on the server or only available via the user’s local client (which may be offline hmm.) Note: I want to put in SPARQL/XMPP here!! Maybe only the access control system resists on the user’s local client and is queried by the server based web application, with a default of “access” or “no access”.

This needs work, just blogged to get it writen down…

This is a Web 2.0 Website! “Web 2.0 is an attitude not a technology. It’s about enabling and encouraging participation through open applications and services. By open I [Ian Davis] mean technically open with appropriate APIs but also, more importantly, socially open, with rights granted to use the content in new and exciting contexts.” — Ian Davis, 2005

But from my point of view there is no such thing like Web 2.0, we got all the technology, all the tools, what I encorage is the attitude described above.

Within the FOAF Vocabulary there is no way to give the contacting Person a list of methods that I (as the FOAF providing Person) would like him to use to contact me. To answer the question “What is the best way to contact goern?” we need some extensions to FOAF that are able to document what recommendation I give on how to contact me: preferred online accounts.

The first extension I would like to suggest is to extend foaf:OnlineAccount to represent Email Online Accounts. The new OnlineEmailAccount is a subclass of foaf:OnlineAccount and has a mbox and mbox_sha1sum property in addition to the inherited properties. This extension will introduce redundant data becuase mbox and mbox_sha1sum is defined for a foaf:Person. TODO: link this four properties to be semantically the same.

The second extension is a subclass of foaf:OnlineAccount and is called PreferredOnlineAccount. It has no additional properties and is only used to denote an online account of any kind (Chat or Email) as a preferred online account. Example usage may be found in an earlier posting on this topic.

As a first draf I have put together something I called FOAFX – FOAF Extensions this can also be found on schemaweb

I’ll be very happy to receive any feedback on the idea, extensions and draft.

PS: or should I just attach a Nokia 770 to the lower right of my bath’s mirror?!

The basic idea behind the new Me is that most (or even all) applications will be understood as “services”, that means that the application:

1. provides the data it uses via some RESTful interface
2. emits messages if data is processed/received/…

and that the information provided by services are consumed and visualized by “clients”, which:

1. pick up messages emitted by the applications/services
2. know how to visualize the messages
3. fetch data via REST and “work” with the data

Services and clients may be plugged together using a visual editor so that the user may choose which and how messages are visualized by the functions provided by a client.

To archive this pluggability both (service and client) need to describe their interfaces, data structures and operations they provide, hence a central registry or method to negotiate between services and clients is needed.

A very high level Architectur Overview Diagram looks like this:

Nice, but what’s so new about it?

The essence is: this idea gives back power to the user by enabling him to do with the data held by some application what the user wants to do. Applications of today are extensible, this means that one may write plugins for some application to extend the functionality of that application. Having an application emitting messages about what is going on inside the application enables the user to write clients that react on an application. Communication between different services and clients can be established in a more flexible way.

Ja, ok… what for? all this slow and complex stuff?

All this to get rid of unintegrated applications, unintegrated business processes and the fun of having different views onto your living environment: the place you work, the place you life.

Whats next?

The next step will be the definition of some use cases to explain the idea a little more touchy.

–
supported by loud music: Karma Sutra (Slinky Mix) from the album “Aftershock” by Aphrodite

• Geo 1.0α plugin is WORKING
• FOAF Output 1.16RC is WORKING
• FOAF Output seeAlso’s 1.1 is WORKING
• FOAF Output Semantic Visits 1.2 is WORKING
• Kitten’s Spaminator 1.0rc7 seems to be WORKING but not tested with real world spammers

The third step was a test upgrade of the database, all went ok with the wp-admin/upgrade.php, even the enclosures have been preserved. Afterwards I replaced wp-rdf.php with my own enhanced version.

It looks like everything is prepared to move to WordPress 1.5, some little design work to do on the new templates left…

First of all I got rss2ical installed. To make it work I also modified wp-rdf.php to generate dc:date values as needed by rss2ical.

Next step was to establish a new category and modify wp-blog-header.php to output postings that have postdate in the future. I got that trick from the WordPress Support.

So, that’s it… here is the ical stream of upcomming #B4mad.Net events.

In general, podcasting is a very convenient way to consume information. aggregation technology for RSS feeds is good and downloading applications such as iPodder help getting all podcasts together.

From my point of view the most time consuming task ist listening… you need to invest 45min if your podcast is 45min (maybe 35min…). So called shownotes help finding stuff that is most interessting, thus having good show notes is a good tool to deliver a high service level to the consumers of podcasts. From my point of view this is a good example: . Topics are very easy to identify and have a time index so it’s easy to jump directly to the topic of my personal interesst.

more to come…

Listening to Adam Curry‘s lates Daily Source Code (rss) I found a audio comment by Koan Bremner talking about the interlinkage of OPML and MP3 (via id3 tags). Maybe the thing I tried to outline early on the blog is exactly one of this applications the podcasters are looking for. Podcasting is very much like having a (partly) offline multi media (mp3, mail, html, opml) conversation or discussing an idea and making annotations to that idea as MP3 file. So, it’s not just about linkage from a MP3 to a OPML and vice versa but also about timely correct linkage. What is also needed is a fancy GUI editor to attach the audio comment to the right position of the MP3 one is annotating. After that, there needs to be a publishing mechanism including a trackback/pingback to the URL of the initial MP3 file.

So there needs to be some evaluation on the technologies like OPML, RSS 1.0, MP3 ID3 tags and trackbacks and the opportunities to link them together. In addition to that I will try to pin down a concept for that editor the annotating user could use and the publishing mechanism. And I will have a close look at Adam’s blog, maybe there are some interessting things going on too.

unter’m Strich: MP3 file containing ID3 tags with html:a to a URL of an OPML file which also contains RDF stuff (RSS 1.0) with enclosures pointing to some URL of other MP3 files

As I go along with julian’s paradigm of “implement something and if it works publish it” I’ve done my pubsub experiments. The hardest part for me as a non-programmer was to get the application talk to the pub/sub service. I use python, so there is no library that contains JEP-0060 support at all.

Publication/subscription service
In addition to the server PubSub Components we need some projects focusing on implementing the client side library, for Python or C# or both. I’ve done parts of this, but I think they are to crappy to make it into public. ralphm told me that maybe he is going to make a Python library for JEP-0060. We must support him!

Encryption
On another frontier I have tried to get client to client GPG encryption working; macosx to macosx and macosx to linux. I used Fire.app and Psi on macosx and Gabber and Psi on Linux. All of the clients are not very interoperable, only Psi/macosx to Psi/Linux works which encryption and signing. Why is that? I understand that there is JEP-0027 and JEP-0116, both are kind of outdated, because there is RFC3923, which is not implemented by and client.

Move things forward
I guess there is some kind of “moving things forward masterplan”… but where is it? May I read it?

As Beagle is Mono based, I need to try it out on MACOSX, maybe I finally find a way to run dashboard on MACOSX…

So… have fun…

Ah, and by the way, what about auto-abbr’eviation??

So I browsed thru jabber.org and found the following Jabber Enhancment Proposals:

• JEP-0071 – XHTML Instant Messaging
• JEP-0060 – Publish Subscribe

This two JEPs lead me to the idea, that Dashboard could be restructured two be:

• A XHTML Instant Messaging (Jabber) client
• and the user receives messages from a jabber bot, because he is subscribed to a special node
• which itself queries the backends
• after the node received a query from the client

Actually, this lifts the idea of Dasbboard somehow away from the desktop, but on the other hand enables us to communicate with data sources off site, which is also possible with Dashboard backends using http… So, what is the advantage of having this jabber based implementation of “implicite queries”?

It may deliver information from foreign sources, service providers could provide backends. The information may be more up to date, because changes of freign information are pushed to all subscribers (the backend).

The concept needs investigation at all!