Feed on
Posts
Comments

How realistic is using OWL for semweb data integration?

Apr 11th, 2008 by Phil Dawes

I like listening to the talis podcasts because they motivate me to think about semantic-web issues. Unfortunately I usually spend the entire session muttering to myself because I disagree with so much that is said.

The issue for me is that speakers often paint a rosy view of a merged data world where ‘if only’ people would adopt RDF and share their ontologies, systems would be able to communicate and share data. OWL is commonly painted in a broad-brushed way as the mechanism that would then enable semantic web interoperability. I have my doubts - deterministic ontologies get complicated and brittle very quickly.

Here’s a test:

If atom were an RDF format (i.e. same data structure, just in RDF), could OWL realistically be used to allow an RSS1.0 app to interpret atom data?

Posted in Semantic Web | Comments

Viewing 5 Comments

    • ^
    • v
    If ATOM were an RDF format, nobody would use it :) and if RDF is the answer, then we're asking the wrong questions...
    • ^
    • v
    Sure. You could use OWL to identify the correspondences between the various pieces of the Atom structure with the pieces of the RSS 1.0 structure, and then you could perform queries against a mixed collection of RSS 1.0 documents and Atom/RDF documents, e.g.


    <owl:Class rdf:about="http://purl.org/rss/1.0/item">
    <equivalentClass rdf:resource="http://purl.org/atom/ns#draft-ietf-atompub-format-08/entry"/>
    </owl:Class>

    I learned from a recent Talis podcast that Dave Beckett has something that I believe will let you treat Atom documents as RDF, which would be a significant step toward implementing this.

    Bob DuCharme
    • ^
    • v
    Hi Bob,

    Thanks for the reply.
    I suspect the devil is in the detail. For example how would you map RSS1.0's item 'description' and Atom's entry 'content'?. The former is a literal property but the latter is structured object.
    • ^
    • v
    Sorry I didn't make that very clear. I meant the rdf for rss1description is:
    <pre>
    #item1 rss1:description "foobah"
    </pre>
    whereas the atom RDF for content would be something like :
    <pre>
    #entry1 atom:content #content1
    #content1 atom:type "xhtml"
    #content1 atom:value "foobah"
    </pre>
    Does that make sense?
    • ^
    • v
    Hi Phil,
    Just say "Atom *is* an RDF format" :-)

    Pretty much any data format can be treated as a (domain-specific) RDF serialization by specifying a mapping between the format and the RDF model ("micromodels" or "Custom RDF Dialects"). A bunch of folks have been working on such a mapping for Atom for a while now, albeit very intermittently.

    The mapping is harder than one might first think because of Atom's relatively complex structure (compared to say RSS). While stuff like the expression of content can be done in RDF in a more or less direct mapping as you demonstrate, the really tricky bit is around IDs (Henry Story's done a lot of work on this, though he now reckons he might have been overengineering a little).

    But all being well we'll have some agreement on a preferred mapping pretty soon, and there's the possibility that Atom might then become GRDDL-enabled (technicially this part's straightforward, all it needs is a tweak to the namespace doc plus the mapping in XSLT). As and when that happens, to any GRDDL-aware agent, every existing Atom doc will be an RDF doc, without any effort from the doc publisher.

    So, "...could OWL realistically be used to allow an RSS1.0 app to interpret atom data?".

    Hmm, as Bob suggests it may be possible to express equivalences that an OWL reasoner could make sense of, but I think there's an easier route through a word he uses: queries.

    If you wanted to create RSS 1.0 from Atom expressed in RDF, you could do it using SPARQL with something like:

    CONSTRUCT {
    ?item1 rss1:description ?desc
    } WHERE {
    ?entry1 atom:content ?content1 .
    ?content1 atom:type "xhtml" .
    ?content1 atom:value ?desc .
    }

    The tool Dave Beckett's set up is triplr, which can transform between lots of different serializations - but I've just noticed it chokes on Atom's namespace, presumably because it doesn't have a # or / at the end. I'd better ping him...

    http://triplr.org/rdf/planet.intertwingly.net/m...
    etc.
close Reblog this comment
Powered by Disqus · Learn more
blog comments powered by Disqus