Ontology-Driven Software Development

snufflevoicelessInternet and Web Development

Oct 22, 2013 (3 years and 8 months ago)

76 views

Ontology
-
Driven Software Development


with Prot
é
g
é

and OWL

Holger Knublauch

Stanford Medical Informatics

holger@smi.stanford.edu


Model
-
Driven Semantic Web Workshop

21.09.2004

Prot
é
g
é

Core System (since 1990s)




Generic metamodel (OKBC)



Configurable



Open platform with “Plugins”

OWL Plugin (since 2003)




OWL Full metamodel



Optimized user interface



Built
-
in reasoning access



Several thousand users

Prot
é
g
é

/ OWL Plugin

Prot
é
g
é

/ OWL Plugin

Overview


How to develop Semantic Web
applications?


Example


Architecture and OWL
-
Java mapping


Tool support


Can we apply this to general purpose MDA?


OWL is often more suitable than UML


Major benefit: Semantics at edit
-
time & run
-
time

Example Scenario

Traditional Web Architecture

Semantic Web Architecture

Ontologies

Travel Ontology

ActivityProvider

ContactAddress

Activity

AdventureActivity

providesActivity

hasContact

BungeeJumping

Caving

HeliBungeeJumping

Geography Ontology

GeographicArea

Country

City

hasLocation

Travel Extension Ontologies

Software Architecture (1)

Travel.owl

Customer.owl

HeliBungee.owl

...

Semantic Web Layer

Internal Layer

Ontology representation

as Java objects

ActivityX.owl

Reasoners (OWL DL, SWRL, ...)

End
-
User

Interface

(JSP)

Web Service

Interface

(WSDL)

Web Service, Control Logic

(Java Code)

Core Ontologies

Ontology Code in Java

OntModel model = ...;

OntProperty nameProperty = model.getOntProperty(baseURI + “name”);

Individual myActivity = model.getIndividual(baseURI + “test”);

String name = myActivity.getPropertyValue(nameProperty);

Bookings.book(myActivity);

...

XYModel model = ...;

Activity myActivity = model.getActivity(baseURI + “test”);

String name = myActivity.getName();

myActivity.book();

...

Typical approach with a generic API (Jena):

Nicer approach with a customized API:

UML to Java (conventional)

Activity

-

name : String

ActivityProvider

providedBy

0..*

0..*

public class Activity {



private String name;



private Collection providers;



public String getName()



public void setName(String name)



public Iterator listProviders()



public void addProvider(ActivityProvider p)



public void removeProvider(ActivityProvider p)

}

OWL to Java (Jena)

Activity

-

name : String

ActivityProvider

providedBy

0..*

0..*

public class Activity
extends OntClassImpl

{




public String getName()



public void setName(String name)



public Iterator listProviders()



public void addProvider(ActivityProvider p)



public void removeProvider(ActivityProvider p)

}

Working with Jena Classes

Resource

OntProperty

OntClass

RDF

Triple Store

Customer

Activity

Bungee

Generic Level

Application Level

Software Architecture (2)

Travel.owl

Customer.owl

HeliBungee.owl

...

Semantic Web Layer

Internal Layer

Activity.java

...

Customer.java

...

Dynamic Object Model (Jena)

ActivityX.owl

Reasoners (OWL DL, SWRL, ...)

End
-
User

Interface

(JSP)

Web Service

Interface

(WSDL)

Web Service, Control Logic

(Java Code)

Core Ontologies

Dynamic Object Model


Model is accessible at run
-
time:


Generic algorithms/reasoners can be executed


Generic test cases available at run
-
time


Generic serialization, database storage etc.


Generic user interfaces can be generated


Classes can be handled as individuals
(Metaclasses are supported)


Instances can have multiple types

(dynamic polymorphism using Jena API)


Instances can be classified & change types

Other OWL to Java Benefits

Traditional Code:





Code based on generated Jena classes:

Collection patients = model.getPatients();

for(Iterator it = patients.iterator(); it.hasNext(); ) {


Patient patient = (Patient) it.next();


if(patient.isMale()) {


patient.doSomething();


}

}

for(Iterator it = model.listIndividuals(MALE, true); it.hasNext(); ) {


Patient patient = (Patient) it.next();


patient.doSomething();

}

Generalizing This Approach


Every program has a “domain model”


Customers, Accounts, Products


Patients, Diseases, Treatments


Domain model is potentially most reusable


No real need for UML


Paradigm shift to a

new dialect of OO


Model

View

Control

Dynamic Object Models and MDA


MDA taken to extremes


Design not only to generate code


Design is part of the deployed system


Open ontologies to share between applications


Machine
-
accessible semantics at run
-
time


Built
-
in reflection across metalevels


However: Limited expressivity of OWL;
Coding needed (procedural attachment).

Advantages of OWL over UML


Explicit, sharable modeling artifacts


Open architecture of Semantic Web


OWL has rich semantics


closer to domain than UML


built
-
in reasoning support (DL, SWRL)


A single language across metalevels

Strengths of tools like Prot
é
g
é


Can be used by domain experts


Better scalable than visual UML modeling


Reasoning support at edit
-
time


Rapid prototyping of models


Individuals can be acquired using forms


Open architecture / adaptability


Start your application as a plugin

Ontology
-
Driven Development

Model

View

Control

Incremental Code

Generation

Agile Modeling

Agile Programming

Future Work with Prot
é
g
é (1)


Embrace UML, encourage use of OWL


Incremental OWL
-
Java code generation

1.
Determine optimal mapping OWL to Java,

(using an example application)

2.
Define rules for updating code in response to
changes in the ontology (create, rename, etc).

3.
Write Eclipse plugin to perform the updating
(either directly or in batch mode)

Future Work with Prot
é
g
é (2)


Use Prot
é
g
é

as an ODM editor


Map core Prot
é
g
é metamodel to RDF(S)










Collaborations?

ODM Bridge