Re: Enhancing object-oriented programming with OWL

Hi,

Well, if there would be some way to do multiple inheritance in Java, 
that could be very useful.  I was thinking it would probably be possible 
to do some of the class reasoning in Java with its limited support for 
multiple inheritance with interfaces, just we would be partially limited 
in what we can do with classes in Java.  There shouldn't be a problem 
with the property reasoning, SPARQL, or rules in Java though (well I 
have methods to compute all the triplestore indexes).  Semantic Web 
Services written as Java annotations on methods should work if 
annotations are extended to support arbitrary datatypes.

I could have written the code in a language that has multiple 
inheritance, but we can do a lot in Java, and Java is just my best 
language.  It might be straightforward to copy the code to any other 
object-oriented language.  I just looked at Python decorators this 
morning, since Python has multiple-inheritance. It doesn't look 
straightforward to use them just for metadata on code elements like Java 
annotations, but maybe it can be done.  If it can, it looks like they 
would support arbitrary datatypes.  And then maybe we could add all of 
OWL, SPARQL, rules, and Semantic Web Services to Python without 
modifying Python...  Well, there would need to be something like AspectJ 
for Python as I'm doing it.

Truthfully, I haven't spent much thought about how best to do the class 
reasoning.  I focused on the property reasoning and indexes and was 
waiting to talk to people about the class reasoning.  I'll have to look 
into the technologies you mention.

Tim


On 08/18/2012 04:55 PM, adasal wrote:
>
>     We would need to modify a compiler to determine to which classes
>     an object belongs so we would know what methods can be used with
>     it.  There could be methods in defined classes.
>
>
> You must be thinking about a multiple class inheritance hierarchy.
>
> There is this project 
> http://insightfullogic.com/blog/2011/sep/16/multiple-inheritance/
> but I think there must be other implementations.
> Further containers for IoC such as Tapestry have a mature mixin 
> implementation for class transformation, or Scala (and Java 8 to be) 
> supports traits.
> Wouldn't this cover it instead of messing around with the compiler?
>
> I would have thought the real problem is how to define precedence in 
> the multiple hierarchy. How does OWL deal with contradictory 
> definitions in the hierarchy?
>
> Adam
>
> On 18 August 2012 16:10, Timothy Armstrong <tim.armstrong@gmx.com 
> <mailto:tim.armstrong@gmx.com>> wrote:
>
>     Hi Adam,
>
>     What I have in mind is fitting my software together with Sesame or
>     Jena and just having the back-end store sets of objects instead of
>     whole triples and see how that works. For benchmarks, I think it
>     won't be very difficult to get SPARQL running on my software,
>     since I have methods to compute all the triplestore indexes
>     (permutations of subject-predicate-object) from all of main
>     memory, but SPARQL isn't running yet.
>
>     I just meant that my understanding was that OWL can express
>     anything about data OOP can express, and more, but I'm sure Alan
>     is right that there is more than abstract classes. By "disparity"
>     I meant that even if there are differences between OOP and OWL of
>     which I'm not aware, I still don't see a problem with adding OWL
>     to OOP.
>
>     We would need to modify a compiler to determine to which classes
>     an object belongs so we would know what methods can be used with
>     it.  There could be methods in defined classes.
>
>     Tim
>
>
>
>     On 08/18/2012 07:35 AM, adasal wrote:
>>
>>
>>     On 17 August 2012 23:08, Timothy Armstrong <tim.armstrong@gmx.com
>>     <mailto:tim.armstrong@gmx.com>> wrote:
>>
>>         Certainly, object-oriented classes and OWL classes are
>>         different, but my understanding is that the main difference
>>         is just that OWL is strictly better.
>>
>>
>>     What do you mean by 'strictly', 'better' and 'strictly better'?
>>
>>          I'm not aware of anything OOP can do that OWL cannot do, but
>>         OWL can do a lot more.
>>
>>
>>     What do you mean by 'do'? Do you mean it is more expressive such
>>     that it is possible to define in OWL what cannot be defined in
>>     OOP? Isn't that axiomatic in that they are different languages
>>     with different semantics?
>>     What you are really saying is that you want to extend the syntax
>>     of OOP in a form you think is convenient to use such that it will
>>     be able to express OWL semantics.
>>
>>         Well, abstract classes, but that's all I can think of.
>>
>>     So is this relevant?
>>
>>         Or if there is still going to be a disparity,
>>
>>     What does this mean?
>>
>>         we should still just be able to add all the OWL class
>>         constructs and everything else about OWL and let people use
>>         them in OOP.
>>
>>     You mean with your annotations - but the issue really is whether
>>     this is more convenient than existing approaches.
>>
>>         We'd need to get into a compiler to do some of it, but I
>>         think it would be worth it.
>>
>>     Why would it be necessary to get into the compiler, what are you
>>     talking about?
>>     Do you mean to pick up annotations - that is not necessary as new
>>     annotations can be defined as things stand - or to optimise such
>>     as in the way you mention where reasoning is selective. I can't
>>     see that this needs access to the compiler so much as an
>>     understanding of the logic of whether and when selective
>>     reasoning is a proper optimisation.
>>
>>     You would have to show that your approach is better than the
>>     existing approaches to optimisation that sit on top of triple and
>>     quad stores.
>>     Can you do this?
>>
>>     Adam
>>
>
>