Re: [dotNetRDF-Develop] Integrating SPIN into dotnetrdf

[Tomasz P. <tom...@gm...>]

Hi Kevin, Rob

I have been thinking about SPIN for a very long time. And I have
actually very recently read somehere on answeres.semanticweb.com about
using SPIN to implement OWL reasoning.

Ever since I had started that fluent SPARQL I thought it could
actually be a good base to easily go from SPIN RDF representation to
actual queries.

I know that the implementation is far from complete. I have been busy
with a multitude of other tasks but if it could prove useful in
implementing SPIN it would be great. Actually one of my goals I did
have in mind was to use Fluent SPARQL for SPIN. Especially that
working with query strings or low-level SPARQL API will be far from
developer-friendly in te long run IMO.

Kevin, please have a look at my fork, where I have been documenting my
work on a wiki: http://bitbucket.org/romanticweb/dotnetrdf/wiki/Home

What do you guys think?

Thank,
Tom

On Fri, Mar 15, 2013 at 8:57 PM, Rob Vesse <rv...@do...> wrote:
> Hey Kevin
>
> Discussion inline:
>
> From: Kevin <ke...@th...>
> Date: Wednesday, March 13, 2013 7:40 PM
> To: Rob Vesse <rv...@do...>
> Subject: Integrating SPIN into dotnetrdf
>
> Rob,
>
>
>
> First thank you for your quality work you have done with the dotnetrdf
> project.  I have seen a few different posts about your initiative to
> integrate SPIN into dotnetrdf (ie.  SPIN Post).  After much reading on the
> subject it really seems that SPIN would really propel/complement dotnetrdf.
> I believe SPIN not only makes up for the missing OWL inference (Via SPIN
> OWL-RL implementation), it also can expand to suit the modelers imagination.
> The fact that the rules are in SPARQL makes for an unbeatable solution.
> Should it matter my current effort involves query a Virtuoso database (Some
> owl support) with dotnetrdf.  I would really appreciate you taking a look at
> the questions below:
>
>
>
> -Have you made any further progress on integrating SPIN into dotnetrdf?
> Would you allow me to have the source code in its current state?  Could I
> possibly be a contributor on this cause as I am not really equipped for the
> full task?  In any case I would appreciate any source code which I could use
> as a learning tool.
>
>
> No I haven't had time to do anything on SPIN for a long time now.  I've been
> primarily concentrating on getting core features stabilized such as the
> SPARQL engine which are obviously fairly key to building stuff like SPIN on
> top.
>
> However I still don't have time to work on SPIN directly so if you want to
> work on this please feel free, find the code in the mercurial repository at
> https://bitbucket.org/dotnetrdf/dotnetrdf
>
> The previous and very minimal SPIN stub is under Libraries\Query\Spin,
> create your own fork and then you can send pull requests as and when you
> have something to
>
> The key things that need to be done to get the core of SPIN implemented are
> as follows:
>
> Update the current spin-sparql-syntax.ttl to a current version, it likely
> doesn't represent the current version of the spec (this is primarily a
> convenience reference for developers)
> Finish the existing stubs for converting queries into their SPIN RDF
> representation (see SpinSyntax.cs)
> Write code to turn a RDF encoding of a SPIN query into a query
>
> The middle one would be the easiest to start with since there is already
> some partial stubs to get you started.
>
>
>
> -From the available TopQuadrant documentation I have tried to deduce how
> dotnetrdf might implement SPIN.  According to SPIN tutrial, TopBraid finds
> all SPIN inferecer rules and runs them when you hit play.  Would dotnetrdf
> SPIN inferencer only run the rules that are associated with the class
> structure being queried?  Basically I am confused how dotnetrdf decides
> when/how/which SPIN rules to run for a given query.
>
>
> That's an implementation detail, we would control how and when rules get
> run.  We need to get the basic implementation of SPIN done first before this
> aspect of things gets implemented anyway.
>
>
>
> -How much of SPIN could dotnetrdf possibly support.? It appears SPIN
> contains Inference Rules, Constraint Checking, and ability to Isolate rules
> for certain conditions.  Also the TopBraid tool seems to have  "User-Defined
> SPARQL functions" and "SPIN Query Templates".  I imagine dotnetrdf would
> have to keep up with any SPIN improvements.
>
>
> All of those are supportable in some shape of form, until we have the core
> of SPIN up and running we can't really implement those.  Most of those
> features run on top of the SPIN core and so will ultimately just be
> implementation details once we have a core to build upon.  User defined
> SPARQL functions are basically just SPARQL queries that return a single
> value and query templates are just parameterized queries both of which the
> existing SPARQL engine is capable of supporting in one way or another.  So
> it is just a case of exposing that functionality in the SPIN style.
>
> Hope this is enough to get you started, if not please let us know,
>
> Rob
>
>
>
> Regards,
>
> Kevin
>
>
> ------------------------------------------------------------------------------
> Everyone hates slow websites. So do we.
> Make your web apps faster with AppDynamics
> Download AppDynamics Lite for free today:
> http://p.sf.net/sfu/appdyn_d2d_mar
> _______________________________________________
> dotNetRDF-develop mailing list
> dot...@li...
> https://lists.sourceforge.net/lists/listinfo/dotnetrdf-develop
>