solutions for semantic web (OWL ontologies, SPARQL, reasoning) and model driven development (metamodel, model design, model transformation, code generation)

Extend Ecore with OWL by Ecore Annotations of OWL Axioms

| Friday, August 27, 2010
Do you want more expressiveness than Ecore can offer?

In this video we show how to use an ecore textual language for annotating ecore metamodels with OWL axioms. Afterwards, you can use the OWLizer to transform metamodel and model into OWL.

OWL Annotations for textual Ecore Metamodels

| Tuesday, August 17, 2010
Using the TwoUse Toolkit, it is possible to easily annotate text-based Ecore metamodels by (Ecore-based) textual annotations. The editor provides syntax highlighting for annotations which are based on OWL 2 Web Ontology Language in Manchester Syntax. The Ecore metamodels together with its annotations are transformed by the OWLizer into a pure OWL 2 Ontology (representing the input for reasoning tools). Figure 1 gives a screenshot of the editor which is implemented as an Eclipse plugin based on EMF Text.

In general we have extended a metamodeling language (Ecore) by constructs provided by OWL. Thus we have a much more expressiveness language to develop Ecore-based metamodels which continuously can be used in the MDD process (e.g. to define the abstract syntax of a modeling language or for code generation) and in addition are "ready" for ontology technologies.

The extended grammar for Ecore metamodels and the extended annotations is given in the following:
EPackage =
{EAnnotation} "package" name
["\"" name "\""] "{" {EClass} {EPackage} "}" ;

EClass =
["abstract"] ("interface" | "class")
["" EClass {"," EClass} ">"] name
["\"" name "\""]
["extends" EClass {"," EClass}]
{classAnnotation} "{" {EClass | EOperation} "}";

EParameter =
{("ordered" | "unique")} EClass name
["(" integer ".." integer ")"] ;

EReference =
{ ("containment" | "derived" | "transient" | "volatile" | "unique" |
"ordered" | "unsettable" | "changeable" | "resolveProxies") }
"reference" (EClass | EGenericType) name
["=" "\"" name "\""]
["(" integer ".." integer ")"]
["opposite" EReference] {endReferenceAnnotation} ";" ;

EOperation =
{("ordered" | "unique")} "operation" ("void" | EClass)
["(" integer ".." integer ")"]
["" ETypeParameter {"," ETypeParameter} ">"] name "(" [EParameter {"," EParameter}] ")"
["throws" EClass {"," EClass}] ";" ;

EEnumLiteral = {EAnnotation} EDataType ":" name "=" "\"" EEnumLiteral "\"" ";" ;
EAnnotation = "[" {
"eAnnotations" ":" EAnnotation |
"source" ":" "\"" name "\"" |
"details" ":" "\"" name "\"" "=" "\"" name "\"" |
"contents" ":" EObject |
"references" ":" EReference |
"eModelElement" ":" EObject } "]";
EObject = "EObject";
EDataType = {EAnnotation} ["serializable"] "datatype" name "\"" name "\"";
ETypeParameter = {EAnnotation} name ;
EGenericType =
"typed" ["" (ETypeParameter | "?" "extends" EGenericType | "?" "super" EGenericType) ">"]
EClass ["" (EGenericType | "?" ) {"," (EGenericType | "?")} ">"] ;

frontReferenceAnnotation = "(" (
"functional" |
"inversefunctional" |
"symmetric" |
"asymmetric" |
"reflexive" |
"irreflexive" |
) ")";

endReferenceAnnotation = "(" (
"equivalentTo" OPE |
"subPropertyOf" OPE |
"domain" CE |
"range" CE |
"disjointWith" OPE |
"inverseOf" name |
"subPropertyChain" OPE "o" OPE {"o" OPE}
) ")";

classAnnotation = "(" (
("equivalentTo" | "disjointWith") CE {CE} |
"subClassOf" CE |
"disjointUnionOf" CE CE {CE}
) ")";

CE = "(" (
["not"] name |
"not" CE |
CE "and" CE { "and" CE } |
CE "or" CE {"or" CE} |
OPE ("some" | "only") CE |
OPE "Self" |
OPE ("min" | "max" | "exactly") "cardinality" nonnegativeinteger CE
) ")" ;

OPE = name | "(" "inverse" name ")" ;

digit = "0"|"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9";
nonnulldigit = "1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9";
integer = ["-"] nonnulldigit {digit} | "0";
nonnegativeinteger = "0" | nonnulldigit {digit};
name = ( letter | "_" ) { letter | digit | "_" } ;
letter = "a".."z" | "A".."Z" ;

OWL, UML, SPARQL, templates: TwoUse examples

| Friday, August 6, 2010
This video shows how to start using the twouse toolkit by examples:
  • SPARQL Querying
  • OWL Ontology Template
  • OWL Graphical Notation
  • OWL Functional Syntax
  • SWRL Rule Graphical Notation
  • SWRL Rule with UML Profile for SWRL
  • SPARQLAS Query
  • OWL Ontology with UML Profile for OWL

OWL + Metamodel: Model Bridge

| Wednesday, August 4, 2010
Model bridges connect software models and ontologies on the modeling layer M1. They are de fined in the metamodeling layer M2 between diff erent metamodels. The figure below exemplifies a model bridge.

Model Bridge

Integration bridges merge information of the models from the software modeling and from the ontology space. This allows the building of integrated models (on modeling layer M1) using constructs of both modeling languages in a combined way, e.g. to integrate UML class diagrams and OWL.

A transformation bridge describes a (physical) transformation between models in layer M1. The models are kept separately in both modeling spaces. The information is moved from one model to the model in the other modeling space according to the transformation bridge.

OWL + Ecore: Language Bridges

The figure below depicts the general architecture of a language bridge, combining software languages and ontology technologies. The bridge itself is de fined at the M3 layer, where a metametamodel like Ecore is considered and bridged with the OWL metamodel. Here we diff er between two kinds of bridges: M3 Integration Bridge and M3 Transformation Bridge.

Language Bridge
The design of an M3 integration bridge consists mainly of identifying concepts in the Ecore metametamodel and the OWL metamodel which are combined.

The M3 Transformation Bridge allows language designers and language users to achieve representations of software languages (Metamodel/Model) in OWL. It provides the transformation of software language constructs like classes and properties into corresponding OWL constructs.

Using Templates in OWL Ontologies

Integrating model-driven development and semantic web resulted in metamodels
and model-driven tools for the semantic web. However, these metamodels or tools
do not provide dedicated support for dealing with templates in ontology

Using Templates with OWL and UML Notation
Templates are useful for encapsulating knowledge and modeling
recurrent sets of axioms like ontology design patterns. We propose an extension
of existing metamodels and tools to support ontology engineers in modeling
OWL ontology templates. Our approach allows ontology engineers to keep template
specifications as first-class citizens, reducing complexity and increasing
reusability in ontology engineering.

Bridging Software Languages and Ontology Technologies: Tutorial at SPLASH 2010

Current model-driven development approaches allow for a more productive way of developing software systems. However, building tools and languages for software development still suffer a neglect of semantics in modeling and metamodeling.

An interest to strengthen semantics in modeling and metamodeling that gained scientific and commercial attention is the integration of ontology technology and software development. Ontology formalisms for consistency validation and dynamic classification as well as semantic web technologies for enabling shared terminologies and automated reasoning provide means for leveraging metamodeling and language engineering.

This tutorial on Bridging Software Languages and Ontology Technologies  at SPLASH 2010 enlightens the potential of ontology and semantic web technology for modeling and metamodeling in software development, positioning it among modeling standards like UML, and MOF; and (2) illustrates ontology-enabled software development with real application scenarios in areas like software design patterns, domain-specific languages and variability management.

Model Driven Engineering with Ontology Technologies

Ontologies constitute formal models of some aspect of the world that may be used for drawing interesting logical conclusions even for large models. Software models capture relevant characteristics of a software artifact to be developed, yet, most often these software models have no formal semantics, or the underlying (often graphical) software language varies from case to case in a way that makes it hard if not impossible to fix its semantics.

At the Reasoning Web Summer School 2010: Semantic Technologies for Software Engineering we present a lecture on the use of ontology technologies for software modeling in order to carry over advantages from ontology technologies to the software modeling domain. It will turn out that ontology-based metamodels constitute a core means for exploiting expressive ontology reasoning in the software modeling domain while remaining flexible enough to accommodate varying needs of software modelers.