Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Giovanni Tummarello]

> When the recursive fetching is computer, we apply RDFS + some owl
>> reasoning (OWLIM being the final reasoner at the moment) and index it.
>>
>
> Just out of interest, if you detect an inconsistency do you still index it?
>

Not an expert at all but i believe the supported subset is not very prone to
allowing inconsistencies.
.. e.g. i can see to two tripels with the same functional property but
different values..  yes it would be indexed anyway in this case.

Renaud in cc can answer more authoritatively, as he designed the system [1]
also expect a clarifying blog post about how to better leverage Sindice
reasoning soon.

Now that we've ultimated the engineering and we know it works fine in large
numbers its time we actually document it well..
Giovanni

[1] Renaud Delbru , Axel
Polleres , Giovanni
Tummarello , Stefan
Decker 
*Context Dependent Reasoning for Semantic Documents in Sindice.*
In *Proceedings of the 4th International Workshop on Scalable Semantic Web
Knowledge Base Systems (SSWS 2008)*
Workshop at 7th International Semantic Web Conference (ISWC2008), Kalrsruhe,
Germany, 2008.

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Pierre-Antoine Champin]

Le 23/06/2009 23:06, Ian Davis a écrit :

On Tue, Jun 23, 2009 at 10:12 AM, Dan Brickley mailto:dan...@danbri.org>> wrote:

On 23/6/09 11:01, Martin Hepp (UniBW) wrote:

And Michael, please be frank - there is a tendency in the LOD
community
which goes along the lines of "OWL and DL-minded SW research has
proven
obsolete anyway, so we LOD guys and girls just pick and use the
bits and
pieces we like and don't care about the rest".


What made the Web so powerful is that its Architecture is extremely
well-thought underneath the first cover of simplicity.


One of those principles is partial understanding - the ability to do
something useful without understanding everything...


Absolutely.

We should also remember that multiple ontologies may exist that cover a
given term. I think this is often forgotten. There is no requirement
that the ontology statements retrieved by dereferencing the URI should
be used - they are only provided as _an_ additional source of
information. There may be many other ways to discover relevant
ontologies and a large class of those will be for private use. If I
choose to assert that dc:date and rev:createdOn are
owl:equivalentProperties then that is my prerogative. The beauty of the
semweb is that I can publish my assertions and potentially other people
could choose to adopt them.


Exactly.

So If I agree with you on this equivalence, and want to state that I 
*endorse* all inferences that can be made from my data using your axiom, 
I think owl:import'ing is, IMO, the thing to do.


Of course, I could still use rdfs:seeAlso, but it is not meant to imply 
this kind of formal endorsement.


  pa

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Danny Ayers]

While we could have countless arguments over the appropriateness of DL
(or OWL 2) in the Web environment, the bottom line is whether or not
owl:imports adds useful information - seems hard to see a problem with
that, whether agents can reason or not. The "follow your nose" thing.
What's the problem with more data?



-- 
http://danny.ayers.name

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Ian Davis]

On Tue, Jun 23, 2009 at 10:12 AM, Dan Brickley  wrote:

> On 23/6/09 11:01, Martin Hepp (UniBW) wrote:
>
>  And Michael, please be frank - there is a tendency in the LOD community
>> which goes along the lines of "OWL and DL-minded SW research has proven
>> obsolete anyway, so we LOD guys and girls just pick and use the bits and
>> pieces we like and don't care about the rest".
>>
>
>  What made the Web so powerful is that its Architecture is extremely
>> well-thought underneath the first cover of simplicity.
>>
>
> One of those principles is partial understanding - the ability to do
> something useful without understanding everything...
>

Absolutely.

We should also remember that multiple ontologies may exist that cover a
given term. I think this is often forgotten. There is no requirement that
the ontology statements retrieved by dereferencing the URI should be used -
they are only provided as _an_ additional source of information. There may
be many other ways to discover relevant ontologies and a large class of
those will be for private use. If I choose to assert that dc:date and
rev:createdOn are owl:equivalentProperties then that is my prerogative. The
beauty of the semweb is that I can publish my assertions and potentially
other people could choose to adopt them.

Ian

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Ian Davis]

On Tue, Jun 23, 2009 at 8:01 AM, Giovanni Tummarello  wrote:

> Just a remark about what we're doing in Sindice, for all who want to
> be indexed properly by us.
>
> we recursively dereference the properties that are used thus trying to
> obtain a closure over the description of the properties that are used.
> We also consider OWL imports.
>
> When the recursive fetching is computer, we apply RDFS + some owl
> reasoning (OWLIM being the final reasoner at the moment) and index it.
>

Just out of interest, if you detect an inconsistency do you still index it?

Ian

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Martin Hepp (UniBW)]

Hi Kingsley,
You are of course right - I assume that, despite the terminological mess 
I introduced, you agree with my line of argument;  I fully acknowledge 
it is heavily inspired by our San Jose sushi talk ;-)

Martin


Kingsley Idehen wrote:

Martin,

[SNIP]



As Kingsley said - deceptively simple solutions are cheap in the 
beginning but can be pretty costly in the long run.
I meant: "Deceptively Simple" is good. While  "Simply Simple" is bad 
due to inherent architectural myopia obscured by initial illusion of 
cheapness etc..


What made the Web so powerful is that its Architecture is extremely 
well-thought underneath the first cover of simplicity.
That's what I meant by: "Deceptively Simple", architectural apex is 
narrow (simple) while the base is broad (a pyramid) :-)
Exactly the opposite of "I will use this pragmatic pattern until it 
breaks" but instead 
That's what I meant by: "Simple Simple", architectural apex is broad 
while the base is narrow (think inverted pyramid).

"architectural beauty for eternity".

Yes! That what you get with: "Deceptively Simple" :-)


Kingsley


Just look at the http specs. The fact that you can do a nice 303 is 
because someone in the distant past very cleverly designed a protocol 
goes well beyond the pragmatic "I have a URL (sic!) and want to fetch 
the Web page in HTML (sic!)".


So when being proud of being the "pragmatic guys" keep in mind that 
nothing is as powerful in practice as something that is theoretically 
consistent.


Best
Martin


begin:vcard
fn:Martin Hepp
n:Hepp;Martin
org:Bundeswehr University Munich;E-Business and Web Science Research Group
adr:;;Werner-Heisenberg-Web 39;Neubiberg;;D-85577;Germany
email;internet:mh...@computer.org
tel;work:+49 89 6004 4217
tel;pager:skype: mfhepp
url:http://www.heppnetz.de
version:2.1
end:vcard

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Giovanni Tummarello]

Martin,

partially you could solve the problem yourself by putting the
owl:import triples in your ontology fragments e.g. the fragment, when
served, says "owl import" so that you're sure the ontology is used as
a whole..

would this do it? :-) fixing the problem in a "single" location might
be so much easier than expecting all to fix it at their side
(remember.. they see no advantage in it, just extra triples)

Giovanni

On Tue, Jun 23, 2009 at 10:01 AM, Martin Hepp
(UniBW) wrote:
> It was not my intend to insult anybody. But I still don't get why some of
> you want to recommend a pattern that breaks with a current W3C
> recommendation just on the basis that there are many documents out there
> that break with it. The Swoogle post from 2007 simply says that there are
> many documents out there that are not using it properly. But there are also
> many RDF resources out there that break with LOD principles and LOD
> recommendations and nobody would dare to question the principles solely on
> the basis of bad implementations.
>
> And Michael, please be frank - there is a tendency in the LOD community
> which goes along the lines of "OWL and DL-minded SW research has proven
> obsolete anyway, so we LOD guys and girls just pick and use the bits and
> pieces we like and don't care about the rest".
>
> As Kingsley said - deceptively simple solutions are cheap in the beginning
> but can be pretty costly in the long run.
>
> What made the Web so powerful is that its Architecture is extremely
> well-thought underneath the first cover of simplicity. Exactly the opposite
> of "I will use this pragmatic pattern until it breaks" but instead
> "architectural beauty for eternity".
>
> Just look at the http specs. The fact that you can do a nice 303 is because
> someone in the distant past very cleverly designed a protocol goes well
> beyond the pragmatic "I have a URL (sic!) and want to fetch the Web page in
> HTML (sic!)".
>
> So when being proud of being the "pragmatic guys" keep in mind that nothing
> is as powerful in practice as something that is theoretically consistent.
>
> Best
> Martin
>
>
> Michael Hausenblas wrote:
>
> Martin,
>
>
>
> (moving this to LOD public as suggested)
>
>
> Thanks.
>
>
>
> General note: I am quite unhappy with a general movement in parts of the
> LOD community to clash with the OWL world even when that is absolutely
> unnecessary. It is just a bad engineering practice to break with
> existing standards unless you can justify the side-effects. And this
> stubborn "i don't care what the OWL specs says" pattern is silly, in
> particular if the real motivation of many proponents of this approach is
> that they don't want or cannot read the OWL specs.
>
>
> I don't think it is particular helpful to insult people, to utter
> imputations and judge a book by its cover. If we can agree to stop using
> such terminology I'm more than happy to continue the discussion.
>
>
>
> On the other hand - what is your pain with  using RDFa in a way so that
> the extracted RDF model is equivalent to the model from an RDF/XML or N3
> serialization? Why this absolutely arbitrary "we LOD guys don't like
> owl:import ( we don't like OWL anyway, you know?), so we simply omit it"
> behavior?
>
> It is just silly to break with established standards just for saving 1 -
> 2 triples.
>
>
> Ok, so, again, for the chaps who didn't get the entire story. Martin
> champions the use of owl:import (and wants to see it written down as a good
> practice?) in linked data.
>
> My take on this is as follows: when one takes the linked data principles and
> applies them in practice (esp. referring to #2, here) there are naturally a
> dozens implementation choices as the principles simply leave room for
> interpretation.
>
> The people here know me from the RDFa TF, from the AWWSW TF and last but not
> least from the LOD community as a simple-minded, pragmatic guy, I hope ;)
>
> So, my hunch would be: the market will make the final decision, not a Martin
> Hepp and also not a Michael Hausenblas. If people think this is a clever
> idea, they will use it when publishing linked data. AFAIK, to date the usage
> of owl:import in linked data is close to non-existing (even in pre-LOD times
> it seemed to be not very common [1]).
>
> Concluding, I'd propose - respecting the nature of good *practice* - once we
> notice a serious usage of owl:import in LOD data, we may want to rehash this
> topic.
>
> Cheers,
>   Michael
>
> [1] http://ebiquity.umbc.edu/blogger/2007/06/15/how-owlimport-is-used/
>
>
>
> --
> --
> martin hepp
> e-business & web science research group
> universitaet der bundeswehr muenchen
>
> e-mail:  mh...@computer.org
> phone:   +49-(0)89-6004-4217
> fax: +49-(0)89-6004-4620
> www: http://www.unibw.de/ebusiness/ (group)
>  http://www.heppnetz.de/ (personal)
> skype:   mfhepp
> twitter: mfhepp
>
> Check out the GoodRelations vocabulary for E-Commerce

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Kingsley Idehen]

Martin,

[SNIP]



As Kingsley said - deceptively simple solutions are cheap in the 
beginning but can be pretty costly in the long run.
I meant: "Deceptively Simple" is good. While  "Simply Simple" is bad due 
to inherent architectural myopia obscured by initial illusion of 
cheapness etc..


What made the Web so powerful is that its Architecture is extremely 
well-thought underneath the first cover of simplicity.
That's what I meant by: "Deceptively Simple", architectural apex is 
narrow (simple) while the base is broad (a pyramid) :-)
Exactly the opposite of "I will use this pragmatic pattern until it 
breaks" but instead 
That's what I meant by: "Simple Simple", architectural apex is broad 
while the base is narrow (think inverted pyramid).

"architectural beauty for eternity".

Yes! That what you get with: "Deceptively Simple" :-)


Kingsley


Just look at the http specs. The fact that you can do a nice 303 is 
because someone in the distant past very cleverly designed a protocol 
goes well beyond the pragmatic "I have a URL (sic!) and want to fetch 
the Web page in HTML (sic!)".


So when being proud of being the "pragmatic guys" keep in mind that 
nothing is as powerful in practice as something that is theoretically 
consistent.


Best
Martin


Michael Hausenblas wrote:

Martin,

  

(moving this to LOD public as suggested)



Thanks.

  

General note: I am quite unhappy with a general movement in parts of the
LOD community to clash with the OWL world even when that is absolutely
unnecessary. It is just a bad engineering practice to break with
existing standards unless you can justify the side-effects. And this
stubborn "i don't care what the OWL specs says" pattern is silly, in
particular if the real motivation of many proponents of this approach is
that they don't want or cannot read the OWL specs.



I don't think it is particular helpful to insult people, to utter
imputations and judge a book by its cover. If we can agree to stop using
such terminology I'm more than happy to continue the discussion.

  

On the other hand - what is your pain with  using RDFa in a way so that
the extracted RDF model is equivalent to the model from an RDF/XML or N3
serialization? Why this absolutely arbitrary "we LOD guys don't like
owl:import ( we don't like OWL anyway, you know?), so we simply omit it"
behavior?

It is just silly to break with established standards just for saving 1 -
2 triples.



Ok, so, again, for the chaps who didn't get the entire story. Martin
champions the use of owl:import (and wants to see it written down as a good
practice?) in linked data.

My take on this is as follows: when one takes the linked data principles and
applies them in practice (esp. referring to #2, here) there are naturally a
dozens implementation choices as the principles simply leave room for
interpretation. 


The people here know me from the RDFa TF, from the AWWSW TF and last but not
least from the LOD community as a simple-minded, pragmatic guy, I hope ;)

So, my hunch would be: the market will make the final decision, not a Martin
Hepp and also not a Michael Hausenblas. If people think this is a clever
idea, they will use it when publishing linked data. AFAIK, to date the usage
of owl:import in linked data is close to non-existing (even in pre-LOD times
it seemed to be not very common [1]).

Concluding, I'd propose - respecting the nature of good *practice* - once we
notice a serious usage of owl:import in LOD data, we may want to rehash this
topic.

Cheers,
  Michael

[1] http://ebiquity.umbc.edu/blogger/2007/06/15/how-owlimport-is-used/

  


--
--
martin hepp
e-business & web science research group
universitaet der bundeswehr muenchen

e-mail:  mh...@computer.org
phone:   +49-(0)89-6004-4217
fax: +49-(0)89-6004-4620
www: http://www.unibw.de/ebusiness/ (group)
 http://www.heppnetz.de/ (personal)
skype:   mfhepp 
twitter: mfhepp


Check out the GoodRelations vocabulary for E-Commerce on the Web of Data!


Webcast:
http://www.heppnetz.de/projects/goodrelations/webcast/

Talk at the Semantic Technology Conference 2009: 
"Semantic Web-based E-Commerce: The GoodRelations Ontology"

http://tinyurl.com/semtech-hepp

Tool for registering your business:
http://www.ebusiness-unibw.org/tools/goodrelations-annotator/

Overview article on Semantic Universe:
http://tinyurl.com/goodrelations-universe

Project page and resources for developers:
http://purl.org/goodrelations/

Tutorial materials:
Tutorial at ESWC 2009: The Web of Data for E-Commerce in One Day: A Hands-on 
Introduction to the GoodRelations Ontology, RDFa, and Yahoo! SearchMonkey

http://www.ebusiness-unibw.org/wiki/GoodRelations_Tutorial_ESWC2009



  



--


Regards,

Kingsley Idehen   Weblog: http://www.openlinksw.com/blog/~kidehen
President & CEO 
OpenLink Software Web: http://www.openl

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Yves Raimond]

Hello!


>> Hmm, I am still not sure I get it. What do you mean by 100% reliable?
>> Can you be more sure that following an owl:imports link will lead you
>> to something more reliable?
>
> It means that the full semantics of an OWL ontology is defined by a file and
> all the imports. Axioms that are not on the class directly, or even not on a
> superclass, might have an effect on inference. For example, one can write,
> in OWL
> As a simple example, one can write, in any import, EquivalentClasses(:a :b).
> If you don't get that bit, then you will miss important inferences. For a
> more complicated example you could have
> FunctionalObjectProperty(p)
> InverseFunctionalObjectProperty(p)
> ObjectPropertyDomain(:a)
> ObjectPropertyRange(:b)
> That p is functional and inversefunctional property forces that there be a
> one to one relationship between subject and
> object. So if we say that :b is an enumerated class
> EquivalentClasses(:b ObjectOneOf(:i1 :i2 :i3))
> and that every instance of :a is :p related to some :b
> SubClassOf(:a ObjectSomeValuesFrom(:p :b))
> Then that forces the class :a to have at most 3 members, because we've
> stated that every instance of :a has a :p relation to some :b, that :p is
> one to one, and there are at most 3 distinct individuals in :b. Each of the
> axioms in this example could conceivably be in a different imported file.
> Tracking down, for a given class, what is a smaller set of axioms than is
> included in the full imports tree, but still yields the same set of
> inferences, is known as "modularization".
>>
>> > Serving fragments of likely relevant parts of an ontology for reducing
>> > the
>> > network overhead is not the same as proper modularization of the
>> > ontology.
>>
>> But if the concise description of the term is sent back when you
>> dereference a term, you should be able to explore the whole ontology
>> (class to its subclass to the ontology it is defined in etc.) and
>> therefore commit to all the axioms in it if indeed you need to? How
>> would such mechanism be different than following an owl:imports link?
>
> As you see from above, it isn't trivial to decide which axioms you need. If
> you want to be guaranteed that, put into a reasoner, you will get the
> inferences that the author of the ontology intended, then absent an
> algorithm for doing modularization correctly (nontrivial), the only way is
> to take the whole import.
>


Thanks a lot for that! I think I understand now :-)

But does that mean *all* LOD data currently available is "wrong" from
an OWL perspective (even the bits not using owl:sameAs ;-) )? In the
RDF representation of a resource, you typically find RDF statements
linking to other resources, and one statement linking the resource to
its type. Should these statements be part of an owl:Ontology which
would import the ontology you want to commit to? Indeed, axioms that
are in the ontology might have implications on the classification of
that particular resource?

Cheers, and thanks again!
y

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Michael Hausenblas]

Martin,

> It was not my intend to insult anybody.

Thank you.

> And Michael, please be frank - there is a tendency in the LOD community
> which goes along the lines of "OWL and DL-minded SW research has proven
> obsolete anyway, so we LOD guys and girls just pick and use the bits and
> pieces we like and don't care about the rest".

Your words, not mine ;)

> What made the Web so powerful is that its Architecture is extremely
> well-thought underneath the first cover of simplicity. Exactly the
> opposite of "I will use this pragmatic pattern until it breaks" but
> instead "architectural beauty for eternity".

"While simplicity makes it possible to deploy an initial implementation of a
distributed system, extensibility allows us to avoid getting stuck forever
with the limitations of what was deployed."

>From the seminal paper 'Principled Design of the Modern Web Architecture' by
Roy T. Fielding and Richard N. Taylor [1]. Agree.

Cheers,
  Michael

[1] http://www.ics.uci.edu/~fielding/pubs/webarch_icse2000.pdf

-- 
Dr. Michael Hausenblas
LiDRC - Linked Data Research Centre
DERI - Digital Enterprise Research Institute
NUIG - National University of Ireland, Galway
Ireland, Europe
Tel. +353 91 495730
http://linkeddata.deri.ie/
http://sw-app.org/about.html



> From: "Martin Hepp (UniBW)" 
> Organization: http://www.heppnetz.de
> Reply-To: 
> Date: Tue, 23 Jun 2009 11:01:19 +0200
> To: Michael Hausenblas 
> Cc: , David Booth , Linked
> Data community 
> Subject: Re: http://ld2sd.deri.org/lod-ng-tutorial/
> 
> It was not my intend to insult anybody. But I still don't get why some
> of you want to recommend a pattern that breaks with a current W3C
> recommendation just on the basis that there are many documents out there
> that break with it. The Swoogle post from 2007 simply says that there
> are many documents out there that are not using it properly. But there
> are also many RDF resources out there that break with LOD principles and
> LOD recommendations and nobody would dare to question the principles
> solely on the basis of bad implementations.
> 
> And Michael, please be frank - there is a tendency in the LOD community
> which goes along the lines of "OWL and DL-minded SW research has proven
> obsolete anyway, so we LOD guys and girls just pick and use the bits and
> pieces we like and don't care about the rest".
> 
> As Kingsley said - deceptively simple solutions are cheap in the
> beginning but can be pretty costly in the long run.
> 
> What made the Web so powerful is that its Architecture is extremely
> well-thought underneath the first cover of simplicity. Exactly the
> opposite of "I will use this pragmatic pattern until it breaks" but
> instead "architectural beauty for eternity".
> 
> Just look at the http specs. The fact that you can do a nice 303 is
> because someone in the distant past very cleverly designed a protocol
> goes well beyond the pragmatic "I have a URL (sic!) and want to fetch
> the Web page in HTML (sic!)".
> 
> So when being proud of being the "pragmatic guys" keep in mind that
> nothing is as powerful in practice as something that is theoretically
> consistent.
> 
> Best
> Martin
> 
> 
> Michael Hausenblas wrote:
>> Martin,
>> 
>>   
>>> (moving this to LOD public as suggested)
>>> 
>> 
>> Thanks.
>> 
>>   
>>> General note: I am quite unhappy with a general movement in parts of the
>>> LOD community to clash with the OWL world even when that is absolutely
>>> unnecessary. It is just a bad engineering practice to break with
>>> existing standards unless you can justify the side-effects. And this
>>> stubborn "i don't care what the OWL specs says" pattern is silly, in
>>> particular if the real motivation of many proponents of this approach is
>>> that they don't want or cannot read the OWL specs.
>>> 
>> 
>> I don't think it is particular helpful to insult people, to utter
>> imputations and judge a book by its cover. If we can agree to stop using
>> such terminology I'm more than happy to continue the discussion.
>> 
>>   
>>> On the other hand - what is your pain with  using RDFa in a way so that
>>> the extracted RDF model is equivalent to the model from an RDF/XML or N3
>>> serialization? Why this absolutely arbitrary "we LOD guys don't like
>>> owl:import ( we don't like OWL anyway, you know?), so we simply omit it"
>>> behavior?
>>> 
>>> It is just silly to break with established standards just f

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Dan Brickley]

On 23/6/09 11:01, Martin Hepp (UniBW) wrote:


And Michael, please be frank - there is a tendency in the LOD community
which goes along the lines of "OWL and DL-minded SW research has proven
obsolete anyway, so we LOD guys and girls just pick and use the bits and
pieces we like and don't care about the rest".



What made the Web so powerful is that its Architecture is extremely
well-thought underneath the first cover of simplicity.


One of those principles is partial understanding - the ability to do 
something useful without understanding everything...


http://www.w3.org/1999/04/WebData#epu

This attitude is deeply ingrained in the RDF scene, as well as (in a 
way) standardised in the Full flavour of OWL. It may explain why LOD 
folk might *seem* to be disrespectfully picking and choosing which bits 
of OWL to care about. It's part of the culture around here, and also 
part of the overall SW design. In FOAF for example, we used 
daml:UnambiguousProperty before OWL existed, and consuming application 
code made real practical use of it for data merging and identity 
reasoning without necessarily having a complete understanding of all of 
DAML+OIL (and later, OWL). This is because the semantics of that 
property class made certain guarantees that were concrete and 
immediately useful. The fact that the OWL specs can be used this way is, 
in my opinion, fantastic ... people find their way in, piece by piece, 
each step motivated by concrete needs. Taken as a whole they're rather 
large to swallow...


cheers,

Dan

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Martin Hepp (UniBW)]

It was not my intend to insult anybody. But I still don't get why some 
of you want to recommend a pattern that breaks with a current W3C 
recommendation just on the basis that there are many documents out there 
that break with it. The Swoogle post from 2007 simply says that there 
are many documents out there that are not using it properly. But there 
are also many RDF resources out there that break with LOD principles and 
LOD recommendations and nobody would dare to question the principles 
solely on the basis of bad implementations.


And Michael, please be frank - there is a tendency in the LOD community 
which goes along the lines of "OWL and DL-minded SW research has proven 
obsolete anyway, so we LOD guys and girls just pick and use the bits and 
pieces we like and don't care about the rest".


As Kingsley said - deceptively simple solutions are cheap in the 
beginning but can be pretty costly in the long run.


What made the Web so powerful is that its Architecture is extremely 
well-thought underneath the first cover of simplicity. Exactly the 
opposite of "I will use this pragmatic pattern until it breaks" but 
instead "architectural beauty for eternity".


Just look at the http specs. The fact that you can do a nice 303 is 
because someone in the distant past very cleverly designed a protocol 
goes well beyond the pragmatic "I have a URL (sic!) and want to fetch 
the Web page in HTML (sic!)".


So when being proud of being the "pragmatic guys" keep in mind that 
nothing is as powerful in practice as something that is theoretically 
consistent.


Best
Martin


Michael Hausenblas wrote:

Martin,

  

(moving this to LOD public as suggested)



Thanks.

  

General note: I am quite unhappy with a general movement in parts of the
LOD community to clash with the OWL world even when that is absolutely
unnecessary. It is just a bad engineering practice to break with
existing standards unless you can justify the side-effects. And this
stubborn "i don't care what the OWL specs says" pattern is silly, in
particular if the real motivation of many proponents of this approach is
that they don't want or cannot read the OWL specs.



I don't think it is particular helpful to insult people, to utter
imputations and judge a book by its cover. If we can agree to stop using
such terminology I'm more than happy to continue the discussion.

  

On the other hand - what is your pain with  using RDFa in a way so that
the extracted RDF model is equivalent to the model from an RDF/XML or N3
serialization? Why this absolutely arbitrary "we LOD guys don't like
owl:import ( we don't like OWL anyway, you know?), so we simply omit it"
behavior?

It is just silly to break with established standards just for saving 1 -
2 triples.



Ok, so, again, for the chaps who didn't get the entire story. Martin
champions the use of owl:import (and wants to see it written down as a good
practice?) in linked data.

My take on this is as follows: when one takes the linked data principles and
applies them in practice (esp. referring to #2, here) there are naturally a
dozens implementation choices as the principles simply leave room for
interpretation. 


The people here know me from the RDFa TF, from the AWWSW TF and last but not
least from the LOD community as a simple-minded, pragmatic guy, I hope ;)

So, my hunch would be: the market will make the final decision, not a Martin
Hepp and also not a Michael Hausenblas. If people think this is a clever
idea, they will use it when publishing linked data. AFAIK, to date the usage
of owl:import in linked data is close to non-existing (even in pre-LOD times
it seemed to be not very common [1]).

Concluding, I'd propose - respecting the nature of good *practice* - once we
notice a serious usage of owl:import in LOD data, we may want to rehash this
topic.

Cheers,
  Michael

[1] http://ebiquity.umbc.edu/blogger/2007/06/15/how-owlimport-is-used/

  


--
--
martin hepp
e-business & web science research group
universitaet der bundeswehr muenchen

e-mail:  mh...@computer.org
phone:   +49-(0)89-6004-4217
fax: +49-(0)89-6004-4620
www: http://www.unibw.de/ebusiness/ (group)
http://www.heppnetz.de/ (personal)
skype:   mfhepp 
twitter: mfhepp


Check out the GoodRelations vocabulary for E-Commerce on the Web of Data!


Webcast:
http://www.heppnetz.de/projects/goodrelations/webcast/

Talk at the Semantic Technology Conference 2009: 
"Semantic Web-based E-Commerce: The GoodRelations Ontology"

http://tinyurl.com/semtech-hepp

Tool for registering your business:
http://www.ebusiness-unibw.org/tools/goodrelations-annotator/

Overview article on Semantic Universe:
http://tinyurl.com/goodrelations-universe

Project page and resources for developers:
http://purl.org/goodrelations/

Tutorial materials:
Tutorial at ESWC 2009: The Web of Data for E-Comme

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Dan Brickley]

On 23/6/09 09:33, Martin Hepp (UniBW) wrote:

Hi Dan:
I think Alan already gave examples this morning. An ontology can contain
statements about the relationship between conceptual elements - classes,
properties, individuals - that (1) influence the result to queries but
(2) are not likely retrieved when you just dereference an element from
that ontology. The more complex an ontology is, the more difficult is it
to properly modularize it.


Indeed, I missed his mail until after I'd sent mine. And the examples 
are helpful. However they are - for the non-SemWeb enthusiast - 
incredibly abstract:


FunctionalObjectProperty(p)
InverseFunctionalObjectProperty(p)
ObjectPropertyDomain(:a)
ObjectPropertyRange(:b)
etc.

What I'd love to see is some flesh on these bones: a wiki page that 
works through these cases in terms of a recognisable example. Products, 
people, documents, employees, access control, diseases, music, whatever. 
I want something I can point to that says "this is why it is important 
to take care of the formalisms...", "this is what we can do so that 
simple-minded but predictable machines do the hard work instead of us...".



But basically my main point is that the use of owl:imports is defined
pretty well in

http://www.w3.org/TR/owl-ref/#imports-def

and there is no need to deviate from the spec just for the matter of gut
feeling and annoyance about the past dominance of DL research in the
field. And as the spec says - with a proper owl:imports statement, any
application can decide if and what part of the imported ontologies are
being included to the local model for the task at hand.


+1 on respecting the specs, but also all know that not every piece of 
specification finds itself useful in practice. Having a worked-through 
to the instance level account of why owl:imports is useful would help. 
There is no compulsion re standards here: if someone is happy publishing 
RDFS, we can't make them use OWL. If they're happy using OWL we can't 
make them use RIF. If they're happy with RIF 1, we can't make them use 
RIF 2 etc. Or any particular chapter or verse of those specs.


What we can do is ground our evangelism in practical examples. And for 
those to be compelling, they can't solely be at the level of properties 
of properties; we need an account in terms of instance level use cases too.


cheers,

Dan

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Michael Hausenblas]

Martin,

> (moving this to LOD public as suggested)

Thanks.

> General note: I am quite unhappy with a general movement in parts of the
> LOD community to clash with the OWL world even when that is absolutely
> unnecessary. It is just a bad engineering practice to break with
> existing standards unless you can justify the side-effects. And this
> stubborn "i don't care what the OWL specs says" pattern is silly, in
> particular if the real motivation of many proponents of this approach is
> that they don't want or cannot read the OWL specs.

I don't think it is particular helpful to insult people, to utter
imputations and judge a book by its cover. If we can agree to stop using
such terminology I'm more than happy to continue the discussion.

> On the other hand - what is your pain with  using RDFa in a way so that
> the extracted RDF model is equivalent to the model from an RDF/XML or N3
> serialization? Why this absolutely arbitrary "we LOD guys don't like
> owl:import ( we don't like OWL anyway, you know?), so we simply omit it"
> behavior?
> 
> It is just silly to break with established standards just for saving 1 -
> 2 triples.

Ok, so, again, for the chaps who didn't get the entire story. Martin
champions the use of owl:import (and wants to see it written down as a good
practice?) in linked data.

My take on this is as follows: when one takes the linked data principles and
applies them in practice (esp. referring to #2, here) there are naturally a
dozens implementation choices as the principles simply leave room for
interpretation. 

The people here know me from the RDFa TF, from the AWWSW TF and last but not
least from the LOD community as a simple-minded, pragmatic guy, I hope ;)

So, my hunch would be: the market will make the final decision, not a Martin
Hepp and also not a Michael Hausenblas. If people think this is a clever
idea, they will use it when publishing linked data. AFAIK, to date the usage
of owl:import in linked data is close to non-existing (even in pre-LOD times
it seemed to be not very common [1]).

Concluding, I'd propose - respecting the nature of good *practice* - once we
notice a serious usage of owl:import in LOD data, we may want to rehash this
topic.

Cheers,
  Michael

[1] http://ebiquity.umbc.edu/blogger/2007/06/15/how-owlimport-is-used/

-- 
Dr. Michael Hausenblas
LiDRC - Linked Data Research Centre
DERI - Digital Enterprise Research Institute
NUIG - National University of Ireland, Galway
Ireland, Europe
Tel. +353 91 495730
http://linkeddata.deri.ie/
http://sw-app.org/about.html



> From: "Martin Hepp (UniBW)" 
> Organization: http://www.heppnetz.de
> Reply-To: 
> Date: Mon, 22 Jun 2009 20:42:23 +0200
> To: Michael Hausenblas 
> Cc: , Richard Cyganiak , "Hepp,
> Martin" , Hugh Glaser ,
> , "Booth, David (HP Software - Boston)"
> , Linked Data community 
> Subject: Re: http://ld2sd.deri.org/lod-ng-tutorial/
> 
> Hi Michael:
> 
> (moving this to LOD public as suggested)
> 
> General note: I am quite unhappy with a general movement in parts of the
> LOD community to clash with the OWL world even when that is absolutely
> unnecessary. It is just a bad engineering practice to break with
> existing standards unless you can justify the side-effects. And this
> stubborn "i don't care what the OWL specs says" pattern is silly, in
> particular if the real motivation of many proponents of this approach is
> that they don't want or cannot read the OWL specs.
> 
> As for owl:imports:
> 
> When importing an ontology by owl:imports, you commit to the whole
> formal account of that ontology. If you just include an element from
> that ontology by using it and hope that dereferencing will get the
> relevant formal account in your model, you expose your model to
> randomness - you don't know what subset of the formal account you will
> get served. Ontology modularization is a pretty difficult task, and
> people use various heuristics for deciding what to put in the subset
> being served for an element. There is no guarantee that the fragment you
> get contains everything that you need.
> 
> On the other hand - what is your pain with  using RDFa in a way so that
> the extracted RDF model is equivalent to the model from an RDF/XML or N3
> serialization? Why this absolutely arbitrary "we LOD guys don't like
> owl:import ( we don't like OWL anyway, you know?), so we simply omit it"
> behavior?
> 
> It is just silly to break with established standards just for saving 1 -
> 2 triples.
> 
> Best
> Martin
> 
> Michael Hausenblas wrote:
>> Martin, 
>> 
>> As an aside: I think I proposed already once to not have this discussion in
>> a private circ

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Martin Hepp (UniBW)]

Hi Dan:
I think Alan already gave examples this morning. An ontology can contain 
statements about the relationship between conceptual elements - classes, 
properties, individuals - that (1) influence the result to queries but 
(2) are not likely retrieved when you just dereference an element from 
that ontology. The more complex an ontology is, the more difficult is it 
to properly modularize it.


But basically my main point is that the use of owl:imports is defined 
pretty well in


http://www.w3.org/TR/owl-ref/#imports-def

and there is no need to deviate from the spec just for the matter of gut 
feeling and annoyance about the past dominance of DL research in the 
field. And as the spec says - with a proper owl:imports statement, any 
application can decide if and what part of the imported ontologies are 
being included to the local model for the task at hand.


Martin


Dan Brickley wrote:

On 22/6/09 23:16, Martin Hepp (UniBW) wrote:



Yves Raimond wrote:

Ontology modularization is
a pretty difficult task, and people use various heuristics for 
deciding what
to put in the subset being served for an element. There is no 
guarantee that

the fragment you get contains everything that you need.



There is no safe way of importing only parts of an ontology, unless you
know that its modularization is 100% reliable.
Serving fragments of likely relevant parts of an ontology for reducing
the network overhead is not the same as proper modularization of the
ontology.


Can you give a concrete example of the danger described here? ie. the 
pair of a complete ("safe") ontology file and a non-safe subset, and 
an explanation of the problems caused.


I can understand "there is no guarantee that the fragment you get 
contains everything you need", and I also remind everyone that 
dereferencing is a privilege not a right: sometimes the network won't 
give you what you want, when you want it. But I've yet to hear of 
anyone who has suffered due to term-oriented ontology fragment 
downloads. I guess medical ontologies would be the natural place for 
horror stories?


cheers,

Dan




--
--
martin hepp
e-business & web science research group
universitaet der bundeswehr muenchen

e-mail:  mh...@computer.org
phone:   +49-(0)89-6004-4217
fax: +49-(0)89-6004-4620
www: http://www.unibw.de/ebusiness/ (group)
http://www.heppnetz.de/ (personal)
skype:   mfhepp 
twitter: mfhepp


Check out the GoodRelations vocabulary for E-Commerce on the Web of Data!


Webcast:
http://www.heppnetz.de/projects/goodrelations/webcast/

Talk at the Semantic Technology Conference 2009: 
"Semantic Web-based E-Commerce: The GoodRelations Ontology"

http://tinyurl.com/semtech-hepp

Tool for registering your business:
http://www.ebusiness-unibw.org/tools/goodrelations-annotator/

Overview article on Semantic Universe:
http://tinyurl.com/goodrelations-universe

Project page and resources for developers:
http://purl.org/goodrelations/

Tutorial materials:
Tutorial at ESWC 2009: The Web of Data for E-Commerce in One Day: A Hands-on 
Introduction to the GoodRelations Ontology, RDFa, and Yahoo! SearchMonkey

http://www.ebusiness-unibw.org/wiki/GoodRelations_Tutorial_ESWC2009




begin:vcard
fn:Martin Hepp
n:Hepp;Martin
org:Bundeswehr University Munich;E-Business and Web Science Research Group
adr:;;Werner-Heisenberg-Web 39;Neubiberg;;D-85577;Germany
email;internet:mh...@computer.org
tel;work:+49 89 6004 4217
tel;pager:skype: mfhepp
url:http://www.heppnetz.de
version:2.1
end:vcard

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Dan Brickley]

On 22/6/09 23:16, Martin Hepp (UniBW) wrote:



Yves Raimond wrote:

Ontology modularization is
a pretty difficult task, and people use various heuristics for deciding what
to put in the subset being served for an element. There is no guarantee that
the fragment you get contains everything that you need.



There is no safe way of importing only parts of an ontology, unless you
know that its modularization is 100% reliable.
Serving fragments of likely relevant parts of an ontology for reducing
the network overhead is not the same as proper modularization of the
ontology.


Can you give a concrete example of the danger described here? ie. the 
pair of a complete ("safe") ontology file and a non-safe subset, and an 
explanation of the problems caused.


I can understand "there is no guarantee that the fragment you get 
contains everything you need", and I also remind everyone that 
dereferencing is a privilege not a right: sometimes the network won't 
give you what you want, when you want it. But I've yet to hear of anyone 
who has suffered due to term-oriented ontology fragment downloads. I 
guess medical ontologies would be the natural place for horror stories?


cheers,

Dan

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Giovanni Tummarello]

Just a remark about what we're doing in Sindice, for all who want to
be indexed properly by us.

we recursively dereference the properties that are used thus trying to
obtain a closure over the description of the properties that are used.
We also consider OWL imports.

When the recursive fetching is computer, we apply RDFS + some owl
reasoning (OWLIM being the final reasoner at the moment) and index it.

We are currently working on a public validator where people can try
their files and see the full chain of fetching/inference.

Giovanni

On Mon, Jun 22, 2009 at 7:42 PM, Martin Hepp
(UniBW) wrote:
> Hi Michael:
>
> (moving this to LOD public as suggested)
>
> General note: I am quite unhappy with a general movement in parts of the LOD
> community to clash with the OWL world even when that is absolutely
> unnecessary. It is just a bad engineering practice to break with existing
> standards unless you can justify the side-effects. And this stubborn "i
> don't care what the OWL specs says" pattern is silly, in particular if the
> real motivation of many proponents of this approach is that they don't want
> or cannot read the OWL specs.
>
> As for owl:imports:
>
> When importing an ontology by owl:imports, you commit to the whole formal
> account of that ontology. If you just include an element from that ontology
> by using it and hope that dereferencing will get the relevant formal account
> in your model, you expose your model to randomness - you don't know what
> subset of the formal account you will get served. Ontology modularization is
> a pretty difficult task, and people use various heuristics for deciding what
> to put in the subset being served for an element. There is no guarantee that
> the fragment you get contains everything that you need.
>
> On the other hand - what is your pain with  using RDFa in a way so that the
> extracted RDF model is equivalent to the model from an RDF/XML or N3
> serialization? Why this absolutely arbitrary "we LOD guys don't like
> owl:import ( we don't like OWL anyway, you know?), so we simply omit it"
> behavior?
>
> It is just silly to break with established standards just for saving 1 - 2
> triples.
>
> Best
> Martin
>
> Michael Hausenblas wrote:
>
> Martin,
>
> As an aside: I think I proposed already once to not have this discussion in
> a private circle of 'randomly' selected people but rather in the appropriate
> lists (rdfa public or public-lod). However, if you prefer to continue here,
> we continue here, FWIW.
>
>
>
> In my opinion the owl:imports
> stems from a time where people confused publishing on the Semantic Web with
> firing up Protege and clicking around like wild. So, concluding, for me it
> is not obvious to use owl:imports and I don't see *any* benefit from using
> it. Not in RDF/XML and also not in RDFa ;)
>
>
> you know that i sometimes appreciate your opinion ;-),
>
>
> Yeah, same here :D
>
>
>
> ... but i think it is
> pretty questionable to break with well-defined standards specifications
> for just a matter of gut feeling and personal preference.
>
>
> Ok, let me rephrase this. You, or whoever publishes RDFa can of course do
> whatever she likes. Wanna use owl:imports? Fine. Don't wanna use it. Ok!
>
> The point I was trying to make (not very successfully, though): from a
> linked data perspective (and basically this is what Richard and I try to
> achieve here; offering good practices for linked data *in* RDFa) the usage
> of owl:imports is, how to put it, not encouraged.
>
> So far I have not heard any convincing argument from you why one should use
> it, but I'm happy and open to learn.
>
> Cheers,
>   Michael
>
>
>
> --
> --
> martin hepp
> e-business & web science research group
> universitaet der bundeswehr muenchen
>
> e-mail:  mh...@computer.org
> phone:   +49-(0)89-6004-4217
> fax: +49-(0)89-6004-4620
> www: http://www.unibw.de/ebusiness/ (group)
>  http://www.heppnetz.de/ (personal)
> skype:   mfhepp
> twitter: mfhepp
>
> Check out the GoodRelations vocabulary for E-Commerce on the Web of Data!
> 
>
> Webcast:
> http://www.heppnetz.de/projects/goodrelations/webcast/
>
> Talk at the Semantic Technology Conference 2009:
> "Semantic Web-based E-Commerce: The GoodRelations Ontology"
> http://tinyurl.com/semtech-hepp
>
> Tool for registering your business:
> http://www.ebusiness-unibw.org/tools/goodrelations-annotator/
>
> Overview article on Semantic Universe:
> http://tinyurl.com/goodrelations-universe
>
> Project page and resources for developers:
> http://purl.org/goodrelations/
>
> Tutorial materials:
> Tutorial at ESWC 2009: The Web of Data for E-Commerce in One Day: A Hands-on
> Introduction to the GoodRelations Ontology, RDFa, and Yahoo! SearchMonkey
>
> http://www.ebusiness-unibw.org/wiki/GoodRelations_Tutorial_ESWC2009
>
>
>
>

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Alan Ruttenberg]

On Mon, Jun 22, 2009 at 6:25 PM, Yves Raimond wrote:

> On Mon, Jun 22, 2009 at 10:16 PM, Martin Hepp
> (UniBW) wrote:
> >
> >
> > Yves Raimond wrote:
> >
> > Ontology modularization is
> > a pretty difficult task, and people use various heuristics for deciding
> what
> > to put in the subset being served for an element. There is no guarantee
> that
> > the fragment you get contains everything that you need.
> >
> >
> >
> > Sorry, just jumping on that, as this is something I am having quite a
> > lot of troubles to understand (and since quite a long time). Maybe I
> > am missing something obvious, but how does using owl:imports avoid
> > this randomness? When using it, you're still hoping that dereferencing
> > the object of owl:imports will get you the relevant information? I
> > agree that owl:imports allows you to commit to a whole ontology
> > instead of committing to single terms within an ontology, but I would
> > argue that in most cases, you just want to pick a few terms in an
> > ontology.
> >
> > There is no safe way of importing only parts of an ontology, unless you
> know
> > that its modularization is 100% reliable.
>
> Hmm, I am still not sure I get it. What do you mean by 100% reliable?
> Can you be more sure that following an owl:imports link will lead you
> to something more reliable?


It means that the full semantics of an OWL ontology is defined by a file and
all the imports. Axioms that are not on the class directly, or even not on a
superclass, might have an effect on inference. For example, one can write,
in OWL

As a simple example, one can write, in any import, EquivalentClasses(:a :b).
If you don't get that bit, then you will miss important inferences. For a
more complicated example you could have

FunctionalObjectProperty(p)
InverseFunctionalObjectProperty(p)
ObjectPropertyDomain(:a)
ObjectPropertyRange(:b)

That p is functional and inversefunctional property forces that there be a
one to one relationship between subject and
object. So if we say that :b is an enumerated class

EquivalentClasses(:b ObjectOneOf(:i1 :i2 :i3))

and that every instance of :a is :p related to some :b

SubClassOf(:a ObjectSomeValuesFrom(:p :b))

Then that forces the class :a to have at most 3 members, because we've
stated that every instance of :a has a :p relation to some :b, that :p is
one to one, and there are at most 3 distinct individuals in :b. Each of the
axioms in this example could conceivably be in a different imported file.

Tracking down, for a given class, what is a smaller set of axioms than is
included in the full imports tree, but still yields the same set of
inferences, is known as "modularization".


> > Serving fragments of likely relevant parts of an ontology for reducing
> the
> > network overhead is not the same as proper modularization of the
> ontology.
>
> But if the concise description of the term is sent back when you
> dereference a term, you should be able to explore the whole ontology
> (class to its subclass to the ontology it is defined in etc.) and
> therefore commit to all the axioms in it if indeed you need to? How
> would such mechanism be different than following an owl:imports link?


As you see from above, it isn't trivial to decide which axioms you need. If
you want to be guaranteed that, put into a reasoner, you will get the
inferences that the author of the ontology intended, then absent an
algorithm for doing modularization correctly (nontrivial), the only way is
to take the whole import.


> Sorry for all the questions, but this is really something I'm having a
> hard time understand.
>
> (Btw, all the ontologies I wrote or contributed to hold owl:imports
> links, so I am really not against this practice, but I have to admit I
> don't understand it)


Hope this helps.

To the general discussion, I would point out that getting all the same
inference is *not* always what the job needs. For
some sorts of tasks, for instance informal browsing, or indexing of terms to
comments and labels (and others), or providing content that will be
integrated by someone else who *does* import all the ontologies needed,  it
may suffice to simply mention a term. In a case I work on, some ontologies
are simply too large to be reasoned with or used in tools, so importing a
complete ontology to reference a term is impractical, even if it means that
we don't get complete inference. For a description of what we do in those
cases, and the justification for it, see these documents in which we've
written it up.

http://www.webont.org/owled/2008/papers/owled2008eu_submission_38.pdf
http://docs.google.com/Doc?docid=dzprnmw_24cp3693dd&hl=en

Regards,
Alan



>
>
> Cheers,
> y
>
>

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Yves Raimond]

On Mon, Jun 22, 2009 at 10:16 PM, Martin Hepp
(UniBW) wrote:
>
>
> Yves Raimond wrote:
>
> Ontology modularization is
> a pretty difficult task, and people use various heuristics for deciding what
> to put in the subset being served for an element. There is no guarantee that
> the fragment you get contains everything that you need.
>
>
>
> Sorry, just jumping on that, as this is something I am having quite a
> lot of troubles to understand (and since quite a long time). Maybe I
> am missing something obvious, but how does using owl:imports avoid
> this randomness? When using it, you're still hoping that dereferencing
> the object of owl:imports will get you the relevant information? I
> agree that owl:imports allows you to commit to a whole ontology
> instead of committing to single terms within an ontology, but I would
> argue that in most cases, you just want to pick a few terms in an
> ontology.
>
> There is no safe way of importing only parts of an ontology, unless you know
> that its modularization is 100% reliable.

Hmm, I am still not sure I get it. What do you mean by 100% reliable?
Can you be more sure that following an owl:imports link will lead you
to something more reliable?

> Serving fragments of likely relevant parts of an ontology for reducing the
> network overhead is not the same as proper modularization of the ontology.

But if the concise description of the term is sent back when you
dereference a term, you should be able to explore the whole ontology
(class to its subclass to the ontology it is defined in etc.) and
therefore commit to all the axioms in it if indeed you need to? How
would such mechanism be different than following an owl:imports link?

Sorry for all the questions, but this is really something I'm having a
hard time understand.

(Btw, all the ontologies I wrote or contributed to hold owl:imports
links, so I am really not against this practice, but I have to admit I
don't understand it)

Cheers,
y

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Martin Hepp (UniBW)]

Yves Raimond wrote:

Ontology modularization is
a pretty difficult task, and people use various heuristics for deciding what
to put in the subset being served for an element. There is no guarantee that
the fragment you get contains everything that you need.




Sorry, just jumping on that, as this is something I am having quite a
lot of troubles to understand (and since quite a long time). Maybe I
am missing something obvious, but how does using owl:imports avoid
this randomness? When using it, you're still hoping that dereferencing
the object of owl:imports will get you the relevant information? I
agree that owl:imports allows you to commit to a whole ontology
instead of committing to single terms within an ontology, but I would
argue that in most cases, you just want to pick a few terms in an
ontology.
There is no safe way of importing only parts of an ontology, unless you 
know that its modularization is 100% reliable.
Serving fragments of likely relevant parts of an ontology for reducing 
the network overhead is not the same as proper modularization of the 
ontology.


Thus, you should import the ontology only, and not the fragments served 
via the dereferencable IDs of selected ontology elements. Partial 
commitment would require that there is a proper definition of the part.

For example, I may agree with the way OWL-Time models
time-zones etc., but I don't agree with the way it models time
intervals vs. events.

  
If that ontology has two explicit parts, e.g. time-core and time-full, 
then you can commit to each one individually. If not, I would strongly 
discourage committing to a random fragment only.


Cheers
Martin


--
--
martin hepp
e-business & web science research group
universitaet der bundeswehr muenchen

e-mail:  mh...@computer.org
phone:   +49-(0)89-6004-4217
fax: +49-(0)89-6004-4620
www: http://www.unibw.de/ebusiness/ (group)
http://www.heppnetz.de/ (personal)
skype:   mfhepp 
twitter: mfhepp


Check out the GoodRelations vocabulary for E-Commerce on the Web of Data!


Webcast:
http://www.heppnetz.de/projects/goodrelations/webcast/

Talk at the Semantic Technology Conference 2009: 
"Semantic Web-based E-Commerce: The GoodRelations Ontology"

http://tinyurl.com/semtech-hepp

Tool for registering your business:
http://www.ebusiness-unibw.org/tools/goodrelations-annotator/

Overview article on Semantic Universe:
http://tinyurl.com/goodrelations-universe

Project page and resources for developers:
http://purl.org/goodrelations/

Tutorial materials:
Tutorial at ESWC 2009: The Web of Data for E-Commerce in One Day: A Hands-on 
Introduction to the GoodRelations Ontology, RDFa, and Yahoo! SearchMonkey

http://www.ebusiness-unibw.org/wiki/GoodRelations_Tutorial_ESWC2009




begin:vcard
fn:Martin Hepp
n:Hepp;Martin
org:Bundeswehr University Munich;E-Business and Web Science Research Group
adr:;;Werner-Heisenberg-Weg 39;Neubiberg;;D-85577;Germany
email;internet:mh...@computer.org
tel;work:+49 89 6004 4217
tel;pager:skype: mfhepp
url:http://www.heppnetz.de
version:2.1
end:vcard

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Mark Birbeck]

Hi Dan,

I'm afraid I don't completely follow the history of the discussion
that Martin is raising, but the reason he has included me on the CC
list is because during a chat at SemTech last week, he asked me what I
thought about owl:imports. I said that I was actually using it in my
RDFa processor; after parsing a document, the processor queries the
triple store to see if any of the triples have an owl:imports
predicate, and if they do, the referenced document is loaded.

I have no particular opinion on whether owl:imports is a good solution
or not. The reason I adopted it was because I wanted some way to
modularise the ontologies I was creating on argot-hub; for example, I
have some documents that contain nothing but a single SKOS collection,
and I thought it would be a good idea to allow those to be used in
other ontologies.

So, if owl:imports is wrong that's fine, but what then is best
practice for importing small parts of a document into a larger whole?
If you're not using owl:imports in FOAF, then what do you use?

Or is the general approach to put the whole ontology into one document
(which is not how I'd like to proceed)?

(Actually...I'm getting a horrible feeling that I'm going to be told
that people do owl:sameAs to reference one ontology within another --
i.e., one term at a time. I really hope not. :))

Regards,

Mark

On Mon, Jun 22, 2009 at 8:58 PM, Dan Brickley wrote:
> [snip]
>
> Yup, re owl:imports, I enthusiastically added it to the FOAF spec when some
> OWL WG insider suggested it was the right thing to use, and dutifully
> removed it when someone (I forget who in both cases - quite possibly same
> person!) a few years later told me it had fallen from fashion within the OWL
> scene.
>
> Re attitudes to OWL ... I do agree there have in the distant past (ie. last
> year!) been a few casually dismissive remarks around here regarding OWL.
> It's all too easy for a healthy enthusiasm for practical tools to trick us
> into seeing tools that we're not so familiar with as impractical. I'm happy
> to have read plenty of useful discussion here and nearby about how best to
> use or augment owl:sameAs. FOAF is a described using OWL. I expect some day
> in the not too distant future, Dublin Core Terms will be described in OWL
> too. And the community on public-lod@w3.org have been excellent champions of
> both. Things aren't too polarised, despite the occasional lapses into "them
> and us"-ism...
>
> Optimistically,
>
> Dan
>
>



-- 
Mark Birbeck, webBackplane

mark.birb...@webbackplane.com

http://webBackplane.com/mark-birbeck

webBackplane is a trading name of Backplane Ltd. (company number
05972288, registered office: 2nd Floor, 69/85 Tabernacle Street,
London, EC2A 4RR)

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Dan Brickley]

[snip]

Yup, re owl:imports, I enthusiastically added it to the FOAF spec when 
some OWL WG insider suggested it was the right thing to use, and 
dutifully removed it when someone (I forget who in both cases - quite 
possibly same person!) a few years later told me it had fallen from 
fashion within the OWL scene.


Re attitudes to OWL ... I do agree there have in the distant past (ie. 
last year!) been a few casually dismissive remarks around here regarding 
OWL. It's all too easy for a healthy enthusiasm for practical tools to 
trick us into seeing tools that we're not so familiar with as 
impractical. I'm happy to have read plenty of useful discussion here and 
nearby about how best to use or augment owl:sameAs. FOAF is a described 
using OWL. I expect some day in the not too distant future, Dublin Core 
Terms will be described in OWL too. And the community on 
public-lod@w3.org have been excellent champions of both. Things aren't 
too polarised, despite the occasional lapses into "them and us"-ism...


Optimistically,

Dan

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Yves Raimond]

Hello!

>
> (moving this to LOD public as suggested)
>
> General note: I am quite unhappy with a general movement in parts of the LOD
> community to clash with the OWL world even when that is absolutely
> unnecessary. It is just a bad engineering practice to break with existing
> standards unless you can justify the side-effects. And this stubborn "i
> don't care what the OWL specs says" pattern is silly, in particular if the
> real motivation of many proponents of this approach is that they don't want
> or cannot read the OWL specs.
>
> As for owl:imports:
>
> When importing an ontology by owl:imports, you commit to the whole formal
> account of that ontology. If you just include an element from that ontology
> by using it and hope that dereferencing will get the relevant formal account
> in your model, you expose your model to randomness - you don't know what
> subset of the formal account you will get served. Ontology modularization is
> a pretty difficult task, and people use various heuristics for deciding what
> to put in the subset being served for an element. There is no guarantee that
> the fragment you get contains everything that you need.
>

Sorry, just jumping on that, as this is something I am having quite a
lot of troubles to understand (and since quite a long time). Maybe I
am missing something obvious, but how does using owl:imports avoid
this randomness? When using it, you're still hoping that dereferencing
the object of owl:imports will get you the relevant information? I
agree that owl:imports allows you to commit to a whole ontology
instead of committing to single terms within an ontology, but I would
argue that in most cases, you just want to pick a few terms in an
ontology. For example, I may agree with the way OWL-Time models
time-zones etc., but I don't agree with the way it models time
intervals vs. events.

Also, I don't agree that questioning owl:imports is equivalent to
dismissing OWL all-together. I think most of the people on this list
are OWL-heads (having contributed or created quite a lot of
ontologies, some of them even being OWL-DL! :-) ), and I don't
remember seeing an anti-OWL statement on this list?

Cheers!
y

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Kingsley Idehen]

Martin Hepp (UniBW) wrote:

Hi Michael:

(moving this to LOD public as suggested)

General note: I am quite unhappy with a general movement in parts of 
the LOD community to clash with the OWL world even when that is 
absolutely unnecessary. It is just a bad engineering practice to break 
with existing standards unless you can justify the side-effects. And 
this stubborn "i don't care what the OWL specs says" pattern is silly, 
in particular if the real motivation of many proponents of this 
approach is that they don't want or cannot read the OWL specs.


As for owl:imports:

When importing an ontology by owl:imports, you commit to the whole 
formal account of that ontology. If you just include an element from 
that ontology by using it and hope that dereferencing will get the 
relevant formal account in your model, you expose your model to 
randomness - you don't know what subset of the formal account you will 
get served. Ontology modularization is a pretty difficult task, and 
people use various heuristics for deciding what to put in the subset 
being served for an element. There is no guarantee that the fragment 
you get contains everything that you need.


On the other hand - what is your pain with  using RDFa in a way so 
that the extracted RDF model is equivalent to the model from an 
RDF/XML or N3 serialization? Why this absolutely arbitrary "we LOD 
guys don't like owl:import ( we don't like OWL anyway, you know?), so 
we simply omit it" behavior?


It is just silly to break with established standards just for saving 1 
- 2 triples.

All,

There is a simple rule of thumb re. technology that ultimately works 
long term (i.e. scales when edge cases surface) and its called: 
Deceptively Simple. We have to understand that real tech. that makes any 
significant difference over the long term always has a strong 
"deceptively simple" component to it e.g., HTTP as a prime example.


"Simply Simple" does not work, it doesn't scale due inherent autism re. 
edge cases. Popularity != work if you end up down a technology 
cul-de-sac, ultimately!


Note: Web 2.0 is the land of "Simply Simple" and in due cause we will 
all see that its sole purpose has been evolving the Web to a point where 
the case for Linked Data and the essential vision of the Semantic Web 
Project are much easier to comprehend and appreciate.


Personally, I will never understand the anti OWL sentiment that appears 
to exist in some LOD quarters; especially as OWL based reasoning 
combined with Linked instance Data is where the real magic resides.



Courtesy of the GoodRelations Ontology, we're now able to sharpen the 
Linked Data value prop. down to a slogan that reads:
Describe your wants/needs or products/services clearly, then simply 
leave the Web to do the REST.


The most significant takeaway from Semtech2009 was the fact that Yahoo! 
and Google already grok the implications of the statement above, via the 
lenses of RDFa as a mechanism for expressing and exposing GoodRelations 
based Linked instance Data.


OWL is important, and lets collectively work to improve its 
appreciation. What's good for the ABox is also good for the TBox re. our 
collective efforts :-)


Kingsley


Best
Martin

Michael Hausenblas wrote:
Martin, 


As an aside: I think I proposed already once to not have this discussion in
a private circle of 'randomly' selected people but rather in the appropriate
lists (rdfa public or public-lod). However, if you prefer to continue here,
we continue here, FWIW.

  

In my opinion the owl:imports
stems from a time where people confused publishing on the Semantic Web with
firing up Protege and clicking around like wild. So, concluding, for me it
is not obvious to use owl:imports and I don't see *any* benefit from using
it. Not in RDF/XML and also not in RDFa ;)
  

you know that i sometimes appreciate your opinion ;-),



Yeah, same here :D

  

... but i think it is
pretty questionable to break with well-defined standards specifications
for just a matter of gut feeling and personal preference.



Ok, let me rephrase this. You, or whoever publishes RDFa can of course do
whatever she likes. Wanna use owl:imports? Fine. Don't wanna use it. Ok!

The point I was trying to make (not very successfully, though): from a
linked data perspective (and basically this is what Richard and I try to
achieve here; offering good practices for linked data *in* RDFa) the usage
of owl:imports is, how to put it, not encouraged.

So far I have not heard any convincing argument from you why one should use
it, but I'm happy and open to learn.

Cheers,
  Michael

  


--
--
martin hepp
e-business & web science research group
universitaet der bundeswehr muenchen

e-mail:  mh...@computer.org
phone:   +49-(0)89-6004-4217
fax: +49-(0)89-6004-4620
www: http://www.unibw.de/ebusiness/ (group)
 http://www.heppnetz.de/ (personal)
skype:   mfhepp 
twitter: mfhepp


C

Re: http://ld2sd.deri.org/lod-ng-tutorial/

[Martin Hepp (UniBW)]

Hi Michael:

(moving this to LOD public as suggested)

General note: I am quite unhappy with a general movement in parts of the 
LOD community to clash with the OWL world even when that is absolutely 
unnecessary. It is just a bad engineering practice to break with 
existing standards unless you can justify the side-effects. And this 
stubborn "i don't care what the OWL specs says" pattern is silly, in 
particular if the real motivation of many proponents of this approach is 
that they don't want or cannot read the OWL specs.


As for owl:imports:

When importing an ontology by owl:imports, you commit to the whole 
formal account of that ontology. If you just include an element from 
that ontology by using it and hope that dereferencing will get the 
relevant formal account in your model, you expose your model to 
randomness - you don't know what subset of the formal account you will 
get served. Ontology modularization is a pretty difficult task, and 
people use various heuristics for deciding what to put in the subset 
being served for an element. There is no guarantee that the fragment you 
get contains everything that you need.


On the other hand - what is your pain with  using RDFa in a way so that 
the extracted RDF model is equivalent to the model from an RDF/XML or N3 
serialization? Why this absolutely arbitrary "we LOD guys don't like 
owl:import ( we don't like OWL anyway, you know?), so we simply omit it" 
behavior?


It is just silly to break with established standards just for saving 1 - 
2 triples.


Best
Martin

Michael Hausenblas wrote:
Martin, 


As an aside: I think I proposed already once to not have this discussion in
a private circle of 'randomly' selected people but rather in the appropriate
lists (rdfa public or public-lod). However, if you prefer to continue here,
we continue here, FWIW.

  

In my opinion the owl:imports
stems from a time where people confused publishing on the Semantic Web with
firing up Protege and clicking around like wild. So, concluding, for me it
is not obvious to use owl:imports and I don't see *any* benefit from using
it. Not in RDF/XML and also not in RDFa ;)
  

you know that i sometimes appreciate your opinion ;-),



Yeah, same here :D

  

... but i think it is
pretty questionable to break with well-defined standards specifications
for just a matter of gut feeling and personal preference.



Ok, let me rephrase this. You, or whoever publishes RDFa can of course do
whatever she likes. Wanna use owl:imports? Fine. Don't wanna use it. Ok!

The point I was trying to make (not very successfully, though): from a
linked data perspective (and basically this is what Richard and I try to
achieve here; offering good practices for linked data *in* RDFa) the usage
of owl:imports is, how to put it, not encouraged.

So far I have not heard any convincing argument from you why one should use
it, but I'm happy and open to learn.

Cheers,
  Michael

  


--
--
martin hepp
e-business & web science research group
universitaet der bundeswehr muenchen

e-mail:  mh...@computer.org
phone:   +49-(0)89-6004-4217
fax: +49-(0)89-6004-4620
www: http://www.unibw.de/ebusiness/ (group)
http://www.heppnetz.de/ (personal)
skype:   mfhepp 
twitter: mfhepp


Check out the GoodRelations vocabulary for E-Commerce on the Web of Data!


Webcast:
http://www.heppnetz.de/projects/goodrelations/webcast/

Talk at the Semantic Technology Conference 2009: 
"Semantic Web-based E-Commerce: The GoodRelations Ontology"

http://tinyurl.com/semtech-hepp

Tool for registering your business:
http://www.ebusiness-unibw.org/tools/goodrelations-annotator/

Overview article on Semantic Universe:
http://tinyurl.com/goodrelations-universe

Project page and resources for developers:
http://purl.org/goodrelations/

Tutorial materials:
Tutorial at ESWC 2009: The Web of Data for E-Commerce in One Day: A Hands-on 
Introduction to the GoodRelations Ontology, RDFa, and Yahoo! SearchMonkey

http://www.ebusiness-unibw.org/wiki/GoodRelations_Tutorial_ESWC2009




begin:vcard
fn:Martin Hepp
n:Hepp;Martin
org:Bundeswehr University Munich;E-Business and Web Science Research Group
adr:;;Werner-Heisenberg-Web 39;Neubiberg;;D-85577;Germany
email;internet:mh...@computer.org
tel;work:+49 89 6004 4217
tel;pager:skype: mfhepp
url:http://www.heppnetz.de
version:2.1
end:vcard