Search Mailing List Archives


Limit search to: Subject & Body Subject Author
Sort by: Reverse Sort
Limit to: All This Week Last Week This Month Last Month
Select Date Range     through    

[protege-owl] Best of Breed OWL API

Nick Khamis symack at gmail.com
Wed Mar 25 05:45:14 PDT 2009


Forwarded conversation
Subject: Best of Breed OWL API
------------------------

From: *Nick Khamis* <symack at gmail.com>
Date: Fri, Mar 20, 2009 at 11:13 PM
To: topbraid-composer-users at googlegroups.com, GATE ML <
gate-users at lists.sourceforge.net>


Hello Everyone,

We are currently considering one of the following (jena.jar, gate.jar,
protege.jar) libraries to assist in CRUD (Create, Read, Update, Delete)
operations of ontologies. We will be using triple stores such as (jenadb,
sdb, rdfcrm). I am trying to learn from your experiences regarding this
issue and what  your advice (pros and cons) is in terms of using the listed
libraries. We are also open to recommendations of other APIs that I have not
listed.

Regards,
Ninus.

----------
From: *Jeremy Carroll* <jeremy at topquadrant.com>
Date: Fri, Mar 20, 2009 at 11:35 PM
To: topbraid-composer-users at googlegroups.com, GATE ML <
gate-users at lists.sourceforge.net>




Please clarify: CRUD operations for

-          ontologies

-          triples in ontologies expressed in RDF

-          or something else? (e.g. axioms in ontologies, or individuals in
say an OWL Ontology)





Concerning Jena, when I worked on that project, the belief was that the
typical life cycle had

   Create + Update operations, followed by Read operations

and we tended to design with that in mind, while supporting CRUD in any
order. i.e. we believed Jena was being used more for analysis type
applications than OLTP type applications.



Of course, I don’t know any better than anyone else (not in the Jena team)
what the current design goals are.



Jeremy







*From:* topbraid-composer-users at googlegroups.com [mailto:
topbraid-composer-users at googlegroups.com] *On Behalf Of *Nick Khamis
*Sent:* Friday, March 20, 2009 8:14 PM
*To:* topbraid-composer-users at googlegroups.com; GATE ML
*Subject:* [tbc-users] Best of Breed OWL API

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"TopBraid Composer Users" group.
To post to this group, send email to
topbraid-composer-users at googlegroups.com
To unsubscribe from this group, send email to
topbraid-composer-users+unsubscribe at googlegroups.com<topbraid-composer-users%2Bunsubscribe at googlegroups.com>
For more options, visit this group at
http://groups.google.com/group/topbraid-composer-users?hl=en
-~----------~----~----~----~------~----~------~--~---


----------
From: *Atanas Kiryakov* <naso at sirma.bg>
Date: Sat, Mar 21, 2009 at 7:10 AM
To: topbraid-composer-users at googlegroups.com, GATE ML <
gate-users at lists.sourceforge.net>, Hamish Cunningham <hamish at dcs.shef.ac.uk>,
Arjohn Kampman <arjohn.kampman at aduna-software.com>


 Dear Nick,

what you refer as "GATE OWL API" is probably the API of Sesame 1.2. Actually
GATE integrates SwiftOWLIM 2.9.1 as part of its standard distribution (the
same holds for TBC, as far as I know). OWLIM in general provides storage and
reasoning backend through the Sesame APIs

Speaking of APIs, Sesame's main APIs allow manipulation of RDF store. One
can CRD RDF triples (updating RDF triple is a non-sense). Thus you can
assert:

    C1 rdfs:subClassOf C2

or delete this statement or ask for any statements paterns (e.g. C1
rdfs:subClassOf ?x). And evaluate queries, of course. This is obviously a
low-level RDF API, that is designed for maximum efficiency when it comes to
moving around large volumes of data in RDF (plenty of public benchmark
results prove it is the best for this).

If you want to use OO-style API, where you deal with classes and objects
(instead of triples), you can look at the Graph API of Sesame (
www.openrdf.org) and Elmo. There is also a simple OO-style API as part of
GATE

Finally, there are APIs which allow one to deal with OWL definitions and
primitives (e.g. having specific programmatic support for
owl:minCardinality), e.g. http://owlapi.sourceforge.net/. It's my personal
opinoin that most of the users and applications (other than ontology
enditors) usually do not need such APIs - people edit ontologies in editors
as TBC, then only load them programatically (as RDF files) into repositories
such as Sesame. Of course, there are plenty of different ways to get the
same job done, depending on your application and environment.

Regards,
Naso

----------------------------------------------------------
Atanas Kiryakov
CEO of Ontotext AD, http://www.ontotext.com
Sirma Group Corp, http://www.sirma.bg
Phone: (+359 2) 8091 555; Fax: 8090 404
----------------------------------------------------------


----------
From: *Nick Khamis* <symack at gmail.com>
Date: Sat, Mar 21, 2009 at 8:34 AM
To: topbraid-composer-users at googlegroups.com


Hey Jeremy,

Thanks you so much for you response... We are going to be working with OWL
Ontologies with axioms, individuals, and reasoning using OWL-DL Tableau
Reasoners. I have been using TBC for over a year now and I love it... I
never looked into whether or not TBC has an API that we can use for the said
operations? If so how complete is it.

Regards,
Ninus

----------
From: *Nick Khamis* <symack at gmail.com>
Date: Sat, Mar 21, 2009 at 9:11 AM
To: topbraid-composer-users at googlegroups.com


Hey Atanas,

Thank you so much for your response. Basically we are looking to implement
an application that automatedly generates OWL-DL Ontologies that have
axioms, individuals and also make use a tableau reasoner, as well as store
them in a repository. That being said I understand that SwiftOWLIM is one of
the fastest reasoners out there, however; as you know it is not a full
OWL-DL tableau reasoner and cannot deduce things such as disjointness. That
being said we are looking for an OWL API (OO Style would be nice) that is
complete in the sense that it will allow for the CRD of "complete" OWL-DL
KBs. I think "The OWL API at http://owlapi.sourceforge.net/" is just what
the doctor ordered, has anyone here used the API is it any good (easy to
use, somewhat complete, well documented, supported)?

Best Regards,
Ninus.

----------
From: *Nick Khamis* <symack at gmail.com>
Date: Sat, Mar 21, 2009 at 9:17 AM
To: topbraid-composer-users at googlegroups.com


Hey Jeremy,

We are also looking to generate in an automated manner the complete DL
Ontology (Concepts, Individuals, Properties etc..), and also make use of a
tableau reasoner.

----------
From: *Atanas Kiryakov* <naso at sirma.bg>
Date: Sat, Mar 21, 2009 at 12:54 PM
To: topbraid-composer-users at googlegroups.com


 Hi Nick

if you *really* need DL reasoning SwiftOWLIM and Sesame's APIs are not for
you. I am emphasizing *really* because there are plenty of people who chose
DL being influenced by something and afterwards get surprised by the
specific constraints that it requires

As a general comment, the completeness of the reasoning is not determined by
the API (i.e. the interface definitions), but rather from the implementation
that you will choose. For instance, one can provide results of a sound and
complete inference through Sesame's interfaces (OWLIM could have been doing
this, if it was a tableau reasoner) and another one could provide shallow or
incomplete inference through DIG (yo u have to look at this, if you are into
DL reasoning)


----------
From: *Peter Crowther* <Peter.Crowther at melandra.com>
Date: Mon, Mar 23, 2009 at 6:34 AM
To: GATE ML <gate-users at lists.sourceforge.net>


> From: Atanas Kiryakov [naso at sirma.bg]
Others of us have different opinions, and regard RDF-level APIs as
shockingly low-level and OWL APIs as "about right" :-).  But then, I'm from
the description logic side of the world and would have preferred OWL to be a
set of XML extensions to RDF rather than an interpretation of particular RDF
triples.

As Antanas says, there are plenty of different ways to get the same job
done!

- Peter

------------------------------------------------------------------------------
Apps built with the Adobe(R) Flex(R) framework and Flex Builder(TM) are
powering Web 2.0 with engaging, cross-platform capabilities. Quickly and
easily build your RIAs with Flex Builder, the Eclipse(TM)based development
software that enables intelligent coding and step-through debugging.
Download the free 60 day trial. http://p.sf.net/sfu/www-adobe-com
_______________________________________________
GATE-users mailing list
GATE-users at lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/gate-users

----------
From: *Scott Henninger* <shenninger at topquadrant.com>
Date: Tue, Mar 24, 2009 at 2:03 PM
To: TopBraid Composer Users <topbraid-composer-users at googlegroups.com>



Nick;  In terms of access to TBC functionality, TopBraid supports a
couple of way to get to Composer/Live functionality.  Probably the
most relevant in your case is SPARQLMotion (http://www.topquadrant.com/
sparqlmotion/ <http://www.topquadrant.com/%0Asparqlmotion/>).  This has
modules for reasoners, SPARQL queries,
import/export formats, etc.  The scripts can be exposed as REST Web
Services.

The implication is that SPARQLMotion has access to a large set of
Composer features and you can access this from the outside world by
creating a script, exposing the script as a Web service, and storing
it on TopBraid Live.  This is quite powerful, as you can design a
series of ontology manipulations using a graphical language and access
this via a simple Web service call.  In many ways, the API is yours to
design.

Ensemble also provides access to Composer features via a configurable
Web application.

-- Scott
> On Fri, Mar 20, 2009 at 11:35 PM, Jeremy Carroll <jer... at topquadrant.com
>wrote:

----------
From: *Nick Khamis* <symack at gmail.com>
Date: Wed, Mar 25, 2009 at 8:36 AM
To: topbraid-composer-users at googlegroups.com


Hello Everyone,

So just to wrap up this thread, and this information may be useful for
others...

When talking about creating an OWL-DL ontology editing application using
java code and an Ontology API to help do so we have:

Name
Link                                                           Desc
The OWL API                        http://owlapi.sourceforge.net/.
OO Style OWL-DL API
Jena                                     http://jena.sourceforge.net/

Jeremy you brought up the comment that Jena was designed more for analysis
type applications as opposed to ontology editing applications. From the
little that I have experimented (jena java code examples) I saw that Jena
could be a good candidate for use as an API for an ontology editing
application? I put a question mark because I would like your expert
elaboration on this please.

We also have a different option as brought up by Scott. Using TBC's API to
edit ontologies using SPARQLMotion and web services (interesting take).

We talked a little about how to integrate the reasoning services, into an
ontology editing application... Atanas mentioned DIG and also pointed out
how we could have "shallow" inferencing when using DIG. I did experiment and
read up on DIG and also agree that is not a good idea, furthermore; the
ontology editing application will reside on the same server as the reasoner
making less need for using DIG.... That being said what are your takes on
how to integrate reasoning services using java code and (new topic :) a
"Reasoning Services API".
If I remember correctly TBC uses DIG for pellet and other reasoners that we
may want to add, the new version of Protege stopped using DIG for reasoning
services the last time I looked.

I would like to thank everyone in advanced for your expertise and input,

Regards,
Ninus
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.stanford.edu/pipermail/protege-owl/attachments/20090325/e332508c/attachment.html>


More information about the protege-owl mailing list