Model driven software development and semantic web technologies are spreading increasingly. But today semantic web technologies are rarely used in the software development, even though the additional use of these technologies could improve the software development process. One reason for the rare use of these technologies in the software development is that semantic web technologies are barely integrated with the established software development tools. This paper proposes an approach for integrating semantic web technologies with model driven software development.
In today's software development models have an important role. The developers
create several models, which they write down in modeling languages like UML
[
In model driven software development a further step is taken. In addition
the developers use the models as input for a code generator. The generator
implements a skeletal structure for the software on the basis of the models. The
generated code can be modi ed and extended by the developer. The Eclipse
Modeling Framework (EMF) [
During the last years semantic web technologies, which are based on
ontologies, have spread increasingly. With the spread of these technologies the desire
for using these technologies also for the software development arised. It was
begun to deal with ontology driven software development. In the ontology driven
software development ontologies are used as basis for the code generation. An
ontology is a formal representation of knowledge. The knowledge is described by
concepts and the relations between these concepts. The Web Ontology Language
(OWL) [
Both models and ontologies have di erent advantages and disadvantages. Ontologies de ne classes with logical expressions. The classes, which are de ned by an ontology, have a very exible, dynamic class membership. But ontologies do not provide an opportunity to specify the dynamic behaviour. In contrast models enable the developer to specify the dynamic behaviour. But models use a static class membership.
For future development it is desirable to combine model driven software
development and ontology driven software development with each other to use the
advantages of both and to avoid their restrictions. Such a combination must
take the di erences of models and ontologies into account. These di erences and
approaches how they can be bridged are handled by [
This paper proposes an approach for such a combination. This approach extends the functionality of the Eclipse Modeling Framework by the possibility to use semantic web technologies. It provides additional features to developers of the model driven community like de ning OWL property restrictions for attributes and references or attaching queries to operations. The generated code prohibits the violation of the property restrictions and executes the attached query during an execution of the operation. Developers of the ontology driven community get a framework, which provides them the opportunity to develop software ontology driven, to model the dynamic behaviour and to attach queries to operations. The framework could also be used to create an ontology and to populate the created ontology with instances. 2
This section introduces a simple purchase order example as running example. Figure 1 shows an Ecore diagram for the example. The example includes three classes: Store, Customer and Order. There are containment references from Store to Customer, from Store to Order and from Customer to Store. In addition there is an reference previousOrders from Order to Order. An order has one operation called getOrders. We want that a SPARQL query is executed during a call of getOrders and we want that previousOrders is transitive. The challenge is to generate the whole code of this example. With model driven development frameworks we had to implement both the code for the transitivity of previousOrders and the code for the query execution by hand. With ontology driven development frameworks we could generate the code for previousOrders, but we had to write the whole code of getOrders by hand. With the approach of this paper it would be possible to generate the code for both getOrders and previousOrders. 2.2
The proposed approach has several advantages for developers. Developers of the ontology driven community get the opportunity to model the behaviour. This makes it possible to generate more code and reduces the programming e ort. By describing the behaviour of an operation with a SPARQL query the opportunity to query a generated ontology is provided. This could simplify the implementation of operations for developers of the ontology driven community and the model driven community.
Developers of model driven software get the opportunity to use property restrictions for attributes and references. For instance this allows the de nition of transitive references. The maintenance of the EMF functionalities improves the acceptance in the EMF community and the use of UML-like models simpli es the entry in the approach for software developers.
The approach provides the opportunity to create ontologies based on a class diagram to developers, who are not from the semantic web area. Editors for the creation of ontologies and the population of these ontologies are provided. These editors could simplify the creation of ontologies and support the avoidance of inconsistencies. 3.1
The proposed work should be an approach for combining model driven software development and ontology driven software development. A tool should be implemented that ful lls the following requirements:
It generates Java code based on models and semantic web technologies. It uses an Ecore model with annotations of the semantic web area as input for the code generator.
It should be possible to annotate property restrictions to attributes and references and to annotate queries to operations.
The generated code extensively implements the semantics of the Ecore model and its annotations.
Its code generator extends the EMF Generator and supports code regeneration like the EMF Generator does.
It is integrated into the TwoUse Toolkit [
The tool uses an Ecore model with annotations of the semantic web area as basis for the code generation. For instance it should be possible to annotate a SPARQL query to an operation of an Ecore class to describe the behaviour of this operation. The generated code of this operation contains code that executes this SPARQL query. The Ecore annotation connects the SPARQL query le with the operation. The path of the SPARQL query is derived from the source property of the annotation and inserted into the generated code during the code generation.
In addition references and attributes of an Ecore class can be annotated by OWL property restrictions. For instance it should be possible to de ne that a reference or an attribute should be transitive. Therefore Ecore annotations are attached to the reference respectively the attribute. The value of the source properties of these annotations de ne the types of the restrictions. The references properties of the annotations can be used to de ne other elements of the Ecore models as parameters for the restrictions.
For the purchase order example we would create the SPARQL query for getOrders and add an EAnnotation to getOrders in the Ecore model, whose source property we set to the path of the SPARQL query. In addition we would add an EAnnotation with source #ObjectProperty to previousOrders and an EAnnotation with source #TransitiveObjectProperty to this Annotation. 3.3
The tool extends the EMF generator with the facility of generating code
corresponding to the annotations of the semantic web area. In addition the tool
should provide the possibility to use the original functionality of the EMF
Generator. For the implementation of the code generator the JET templates [
The generated code extensively implements the semantics of the Ecore model and its annotations of the semantic web area. The generated code is based on the code, which the EMF generator would generate for the Ecore model. An ontology that models the semantics of the Ecore model and its annotations is generated. The Ecore model is transformed into the TBox of the ontology. The ABox of the ontology includes the instances of the Ecore model. For the purchase order example the TBox would include the Store, Customer and Order classes and their properties and the ABox would include the Store, Customer and Order instances and their properties.
The generated code uses the generated ontology for implementing the semantics of the annotated Ecore model. The generated code for an operation, that is associated with a SPARQL query, includes code that executes the annotated query on the generated ontology. The path of the query is derived from the source property of the annotation and stored into a variable of the generated code.
The generated ontology is also used to ensure that the property restrictions, which are associated with a reference or an attribute are not violated. According to the EMF code generation the generated code for multiplicity-many attributes and references includes only a get method, which retrieves an EList, and no set method. For multiplicity-many attributes and references, which are associated with property restrictions, the retrieved list is a special list, whose methods prohibit the violation of these restrictions. For the purchase order example the get method for previousOrders would retrieve a TransEList, whose methods use the generated ontology to ensure, that the transitivity is maintained.
The tool will be implemented as an Eclipse plugin. Therefore it can be integrated into the TwoUse Toolkit without much e ort. The TwoUse Toolkit is a toolkit that already provides many features that support the model driven development and the ontology engineering. Because of the integration into the TwoUse Toolkit the tool can use these features. For instance the OWLizer of the TwoUse Toolkit can be used for the generation of an ontology from an annotated Ecore model. By the integration of the tool into the TwoUse Toolkit a software development environment is provided that supports model driven software development as well as a combination of model driven and ontology driven software development.
There are several works that deal with the use of semantic web technologies in the software development. In this section some of these works are presented and brie y summarized.
The work of Andreas Eberhart [
In the work of Kalyanpur et al. [
Holger Knublauch [
Puleston et al. [
Hillairet et al. [
The work Ontology De nition Metamodel of the OMG [
This paper proposes an approach for combining model driven and ontology driven development. The approach is based on the Eclipse Modeling Framework and its metamodel Ecore. It is intended to extend the EMF generator by adding the possibility to use semantic web technologies for the code generation and within the generated code. Therefore the extended code generator gets Ecore models with annotations of the semantic web area as input.
The integration of the extended generator into the TwoUse Toolkit achieves that a rich software development environment is provided, which could improve the software development process. In addition it could be used to create an ontology and to ll the created ontology with instances. The proposed approach provides additional features to developers of the model driven community and of the ontology driven community. Because developers of the model driven community can use the semantic web technologies in a familiar environment, it could support a broader adoption of these technologies in this community.