Programming with OWL is error-prone due to the lack of type-safe integration into programming languages. While generic types such as Resource can represent anything the data can model, they make it impossible to errorcheck programs. Mapping ontological concepts into types of the programming language on the other hand often cannot capture the ontology completely and duplicates knowledge that a semantic reasoner already has. Semantics4J, an extended Java compiler, allows for type-safe programming with OWL by integrating DL expressions as types and values into the programming language. This paper presents a prototype that supports our theoretical concept [4] by relying on an extended type-checking process building upon a reasoner as well as class expression queries that are being used as types themselves.
While OWL allows for capturing knowledge in a natural manner, programming with
such a data source is error-prone. There are two common approaches to program with
OWL. Using generic types (1) such as Resource as exemplified by [
In the ontological part (Listing 1), everyone who has recorded a song is defined to be a Musician (line 1). ActingMusicians are entities who are both Actor and Musician (lines 2–3). A RockMusician is a special form of a Musician (lines 4).
In the data part (Listing 2), hendrix has recorded the song machineGun (lines 1–2). 1 2 3 4 5 6 7 8 9 10 11 12
The entity elvis, who is both Actor and RockMusician is said to have influenced hendrix (lines 3–5). A mapping that converts such data into types of a programming language faces difficulties because of implicit knowledge, e.g. the fact that hendrix is a Musican or the lack of multiple inheritance in common programming languages. With regard to the latter, consider ActingMusician, which is subsumed by both Actor and Musican. But it must also handle the intricacies of the influencedBy role, which is used very broadly. As a result, many mappings cannot fully capture the ontology for the purpose of type checking the program.
Our system relies on a type system extension. It uses DL expressions as types and
extends the type-checking process to benefit from a semantic reasoner. This has been
explored from a theoretical point of view in [
As an example, consider an application written for the data as defined in Listings 1 and 2. Such an application could query for all Musicians and then print their influences. Listing 3 depicts the outline of such a program while leaving out the specifics of a getInfluences method for mapping from a Musician to his influences. p u b l i c c l a s s I n f l u e n c e s from " m u s i c . r d f " { p u b l i c s t a t i c S e t <9« : i n f l u e n c e d B y » >>
g e t I n f l u e n c e s ( . . . a r t i s t ) { . . . } p u b l i c s t a t i c v o i d main ( S t r i n g a r g s [ ] ) { f o r ( « : M u s i c i a n » a r t i s t : query f o r ( " : M u s i c i a n " ) S y s t e m . o u t . f o r m a t ( "%s was i n f l u e n c e d by %s " , a r t i s t . getName ( ) ,
S t r i n g . j o i n ( " , " , names ( g e t I n f l u e n c e s ( a r t i s t ) ) ) } } ) ;
Listing 3. Program querying for musicians and listing their influences.
Line 1 of the program specifies the class name and data source ”music.rdf“ the program is written for. Lines 2–3 contain the signature of the getInfluences method. This method returns a set of values where each value is an instance of the DL expression 9influencedBy :>. In the main method of the program, Line 7 contains a query for all Musicians over which the for-loop iterates. For each Musician, the getInfluences method is called and its results are joined into a single string via the getName method which returns the fragment identifier part of the entities IRI. An important feature of Semantics4J is that DL expressions are both types and values. DL expressions as types are used during the type-checking of the program. DL expressions as values, e.g., 6 as a parameter to the query-for operator, are treated as strings and are implicitly converted to roles and concepts. This allows them to be dynamic, enabling the construction of a query on the fly. Assuming that a concept name, e.g., Actor, is being passed to the program via command line, the query in line 6 could also query for the intersection of the two concepts (see Listing 4).
f o r ( « : M u s i c i a n » a r t i s t : query f o r ( " : M u s i c i a n " u a r g s [ 0 ] )
Listing 4. Example for a dynamically constructed query.
Typing of query-for is dependent on the given input values. However, only the static parts of such queries can be used for typing as the dynamic part may change during runtime. Therefore, the query displayed in Listing 4 is only typed with the concept Musician. This is also true if the dynamic part is not given as a program parameter, but rather as another variable holding a reference to some string.
A simple approach to the getInfluences method may be to assume that all Musicians have an influence. The method could therefore take an instance of the DL expression 9influencedBy:> and query for influences directly (see Listing 5). p u b l i c s t a t i c S e t <9« : i n f l u e n c e d B y »
g e t I n f l u e n c e s ( 9« : i n f l u e n c e d B y » > r e t u r n a r t i s t . ( " : i n f l u e n c e d B y " ) ; >> a r t i s t ) { }
Listing 5. Example for problematic code.
However, this code contains a type error—since it unknown whether Musician is a subconcept of 9influencedBy.>, it is problematic to assume that this relation holds. To enforce type safety, Semantics4J requires the programmer to do a type case instead (see Listing 6). This also requires the presence of a default case which applies if it is either unknown whether the Musician has an influence or if it is known that the Musician has no influence.
p u b l i c s t a t i c S e t <9« : i n f l u e n c e d B y » >> g e t I n f l u e n c e s ( « : M u s i c i a n » a r t i s t ) { s w i t c h t y p e ( a r t i s t ) { 9« : i n f l u e n c e d B y » > i n f l u e n c a b l e {
r e t u r n i n f l u e n c a b l e . ( " : i n f l u e n c e d B y " ) ; } d e f a u l t { r e t u r n
C o l l e c t i o n s . e m p t y S e t ( ) ; } } }
Listing 6. Type-safe example code.
Semantics4J builds upon ExtendJ, a JastAdd Extensible Java compiler [
In this paper, we present Semantics4J, an extended Java compiler for type-checking programs working with OWL. It allows for using ontological concepts as types by integrating the reasoner into type-checking. Furthermore, it provides typed queries. Typing information allows the system to reject potentially problematic programs that may produce runtime-errors. However, some restrictions have been put onto the system. A pure extension that does not modify existing rules of a compiler requires a strict and unambiguous syntactic separation between existing rules and newly integrated rules. The distinction between types and values also creates some restrictions as values can be created and modified during runtime. Typing of e.g., query-for can only consider values given directly to the operator while variable parts are ignored. A deeper knowledge about the dynamics of such variables would be desirable to allow for a more precise typing, but requires an analysis of the flow of the program that is currently not implemented.