An Ontology-based Approach for Enabling Linked Data Capabilities to
MOF Compliant Models
Fernando Silva Parreiras
1
, Gerd Gr
¨
oner
2
and Tobias Walter
2
1
Faculty of Business Sciences, FUMEC University, Av Afonso Pena 3880, 30130009 Belo Horizonte, Brazil
2
Institute for Web Science and Technologies – WeST, University of Koblenz-Landau, 56072 Koblenz, Germany
Keywords:
OWL, Linked Data, Software Engineering, UML, MOF, Model Driven Engineering.
Abstract:
In the software development process, there are standards for general-purpose modeling languages and domain-
specific languages, capable of capturing information about multiple views of systems, e.g., static structure and
dynamic behavior. In a networked and federated development environment, modeling artifacts need to be
linked, adapted and analyzed to meet the information requirements of multiple stakeholders. In this paper,
we present an approach for linking, transforming and querying MOF-compliant modeling languages on the
web of data. We define structural mappings between MOF and OWL and propose the usage of semantic web
technologies for linking and querying software models.
1 INTRODUCTION
In a model-driven architecture, software engineers
rely on a variety of languages for designing soft-
ware systems. As different stakeholders need differ-
ent views of the information, the software develop-
ment environment needs to encompass a myriad of
general-purpose and domain-specific languages with
complementary and overlapping applications.
Since it is hard to capture all aspects of software
into one single model, contemporary model-driven ar-
chitectures include numerous notations to be used ac-
cording to the software development task. The in-
evitable usage of multiple languages leads to unman-
ageable redundancy in developing and managing the
same information across multiple artifacts and, even-
tually, information inconsistency. With the growing
demand for networked and federated environments,
the question arises about what and how existing web
standards can help existing modeling standards in ful-
filling the requirements of a web of models.
Semantic web technologies (Antoniou and van-
Harmelen, 2004) and linked open data (LOD) prin-
ciples (Bizer et al., 2008) allow any kind of data to
be represented, identified, linked and formalized on
the web. The same data can be adapted for use with
another purpose, according to the software engineer’s
perspective.
The interest on this topic has motivated the Ob-
ject Management Group (OMG) to issue a request
for proposal aiming at defining a structural mapping
between Meta Object Facility (MOF) models and
Resource Description Framework (RDF) representa-
tions (OMG, 2009b). This mapping should make
possible to apply LOD principles into MOF compli-
ant models and to publish MOF compliant models as
LOD resources.
In a collaborative environment, developers cre-
ate architectures with information expressed in mul-
tiple modeling languages. These languages should be
grounded with stronger semantics than MOF can pro-
vide today.
The Web Ontology Language (OWL) (W3C OWL
Working Group, 2009) provides a powerful solu-
tion for formally describing domain concepts in net-
worked environments. OWL is part of the semantic
web stack, is compatible with RDF and with LOD
principles. OWLs objective is to provide evolution,
interoperability, and inconsistency detection of shared
conceptualizations.
Although transformations from the MOF-like
metamodels to OWL have been proposed before (Ga-
sevic et al., 2004), addressing the aforementioned
problems requires a coherent framework comprising
techniques not only for transforming but for extend-
ing, linking and queries MOF compliant models.
In this paper, we describe such a framework for
supporting the interaction and interrelationships of
modeling languages in distributed software modeling
environments. We present our contribution as fol-
126
Silva Parreiras F., Gröner G. and Walter T..
An Ontology-based Approach for Enabling Linked Data Capabilities to MOF Compliant Models.
DOI: 10.5220/0004006201260131
In Proceedings of the 14th International Conference on Enterprise Information Systems (ICEIS-2012), pages 126-131
ISBN: 978-989-8565-11-2
Copyright
c
2012 SCITEPRESS (Science and Technology Publications, Lda.)
lows: Section analyzes the requirements to be ad-
dressed. Section 3 describes the building blocks of
our approach. We analyze the related work in Section
4. Section 5 finishes the paper.
2 REQUIREMENTS
Based on demand identified in OMG’s request for
proposal (OMG, 2009b), we identify three funda-
mental requirements for realizing a linked-open data
environment in model-driven software development:
RQ1: Extend Modeling Languages. Metamodeling
languages based on EMOF do not provide ca-
pabilities for integrating conforming modeling
languages, or for defining constraints for these
languages. Here, an additional (constraint-
and expression-) language that provides more
expressiveness than usual modeling languages is
required. It should provide constructs to integrate
languages (e.g. by asserting that concepts are
equivalent).
RQ2: Identification of Equivalences. For semi-
automatically integrating modeling languages, a
mechanism is required that allows for identifying
concepts that are equal over languages and that
are then candidate for merging. The result is a
combined metamodel.
RQ3: Integration Management. To achieve an in-
tegrated representation of several modeling lan-
guages, we need more that one technique. Firstly,
languages and conforming models must be trans-
formed into the same representation. Further they
must be linked for reasoning and querying over
languages and models.
Addressing these requirements allows for achiev-
ing the following features:
Consistent View over Multiple MOF Models.
Based on an integration of multiple (MOF-based)
languages and constraints describing depen-
dencies between languages, we get a consistent
view over multiple models conforming to those
languages.
Integrated Well-formedness Constraints. Based on
the extended modeling language, we are able to
define integrated well-formedness constraints in
an embedded manner. This means that language
designers should be able to use the metamodeling
language (e.g. EMOF) of choice and still anno-
tate elements of language metamodels to define
constraints.
Dependency Checking. Once languages are inte-
grated, apart from consistency checking (check-
ing if models conform to the language meta-
model), it is possible to check dependencies
across language models.
Query Answering. Based on underlying formal se-
mantics and constraints, it is possible to query
models and inferences. It is possible to ask and
answer the following question: What is the effect
of updating the plug-in pellet? How much do I
have to test? Furthermore we are able to query
for impacts of model elements to others (Impact
Analysis) and thus can identify e.g. cyclic depen-
dencies or other unexpected consequences.
3 INTEGRATING MOF AND OWL
In this section, we describe how we exploit ontology
technologies to represent the semantics of modeling
languages with OWL. We present how we link mod-
eling languages with OWL, how we transform MOF-
based models in OWL and how we query and manage
links between modeling languages.
Our approach consists of (1) optionally extending
MOF metamodels with OWL annotations, (2) trans-
lating MOF metamodels and models into OWL con-
cepts, properties, individuals and property assertions,
(3) using ontology matching to link same classes and
individuals across metamodels and (4) write and exe-
cute queries over multiple MOF models.
3.1 OWL for Conceptual Modeling
Despite features of OWL like shared conceptualiza-
tions, support to evolution, interoperability and con-
sistency detection, OWL provides multiple means for
describing classes. It relies on class and property ex-
pressions to construct class descriptions. These de-
scriptions represent sets of individuals by specifying
conditions on the individuals’ properties.
In the following list, we present examples us-
ing OWL2 syntax of constructs used to link MOF
metamodels with OWL. In Line 1, we describe the
equivalence of a UML Activity and BpmnDiagram.
The equivalence of the set of individuals of the class
OpaqueAction and the set of individuals of the class
Activity where the property activityType is set to Task
in the BPMN metamodel is defined in Line 2. Lines 3
and 4 characterize the property general of the UML
metamodel as irreflexive and transitive. In Line 5,
we derive a new property in the BPMN metamodel
based on a property chain, i.e., a composition of the
properties outgoingEdges and target are properties of
AnOntology-basedApproachforEnablingLinkedDataCapabilitiestoMOFCompliantModels
127
sucessorActivities. For instance, if individual x out-
goingEdges y and y target z than x sucessorActivities
z. Similarly, a property chain ancestorNodes for the
UML metamodel is defined in Line 6. The equiva-
lence of the defined property chains is expressed in
Line 7.
Listing 1: Linking MOF metamodels with OWL.
1 Eq u i v a l e n t C l a s s e s ( uml : A c t i v i t y
bpmn : BpmnDiagram )
E q u i v a l e n t C l a s s e s ( uml : O p a q u e A c t i o n
ObjectSomeValuesFrom
( bpmn : a c t i v i t y T y p e bpmn : Task ) )
I r r e f l e x i v e O b j e c t P r o p e r t y
( uml : g e n e r a l )
T r a n s i t i v e O b j e c t P r o p e r t y ( uml : g e n e r a l )
5 SubO bjec tPro pertyOf (
ObjectP r o p e r t yChain
( bpmn : o u t g o i n g E d g e s bpmn : t a r g e t )
bpmn : s u c e s s o r A c t i v i t i e s )
Sub Obje ctPr oper tyOf (
ObjectP r o p e r t yChain ( uml : o u t g o i n g
uml : t a r g e t ) uml : s u c e s s o r N o d e s )
Sub Obje ctPr oper tyOf (
ObjectP r o p e r t yChain ( uml : i n c l u d e
uml : a d d i t i o n ) uml : i n c l u d e U s e C a s e s )
Sub Obje ctPr oper tyOf (
ObjectP r o p e r t yChain
( O b j e c t I n v e r s e O f ( uml : a d d i t i o n )
uml : i n c l u d i n g C a s e )
uml : i n c l u d i n g U s e C a s e s )
E q u i v a l e n t O b j e c t P r o p e r t i e s
( uml : s u c e s s o r N o d e s
bpmn : s u c e s s o r A c t i v i t i e s )
At the model level, developers can link mod-
els (metamodel instances) with OWL constructs.
The SameIndividual axioms allow to define the
equality of individuals in order to assert that in-
stances of different metamodels are the same.
For example, if we have a UML package called
west.twouse.backend, we can assert that this package
is the same as the Java package with the same
name SameIndividual(uml:west.twouse.backend
java:west.twouse.backend).
Additionally, OWL2 provides other standard con-
structs that can help to enrich MOF metamodels and
to extend its expressiveness (RQ1). Object property
axioms aim at characterizing object properties like the
definition of subproperty relations and the expression
of reflexive, irreflexive, symmetric, asymmetric and
transitive properties. Moreover, equivalent and dis-
joint axioms allow explicit statements on the equiva-
lence and disjointness of classes and properties.
Another benefit of using OWL for metamodel an-
notations is the monotonicity of OWL, i.e., adding
further axioms to a model does not falsify existing ex-
tailments. Thus, OWL provides a non-invasive way to
integrate same or similar concepts over modeling lan-
guages (RQ3).
3.2 Extending MOF Models
In order to extend the expressiveness of Ecore meta-
models, we use a annotation profile. In this paper,
we consider Ecore as an implementation of EMOF
for the Eclipse Modeling Framework (EMF) (Budin-
sky et al., 2003). In an Ecore-based metamodel, every
element is an EObject and therefore can adopt EAnno-
tations (Budinsky et al., 2003). The process of build-
ing and extending ECore-based metamodels consists
of three steps:
1. To build the metamodel by using the Ecore
metametamodel.
2. To annotate the metamodel in order to make it
more understandable for OWL annotations, which
are created in step 3. This means that each ele-
ment in a metamodel gets an annotation, so that
it represents an ontology element. For example:
EClasses are annotated by #Class to represent an
OWL Class; EReferences are annotated by #Ob-
jectProperty to represent an OWL Object Prop-
erty, or EAttributes are annotated by #DataProp-
erty to represent an OWL Data Property. This step
can be accomplished automatically, since we have
to iterate over all elements in the metamodel.
3. To create annotations to define additional con-
structs that usually are not expressable in Ecore-
based metamodels. In general, we can create
additional OWL annotations for Class Axioms,
Object Property Axioms, Data Property Axioms,
Class Expressions, Object Property Expressions
and Data Property Expressions.
For example, we can define the concepts of two
classes as equivalent by creating a new annotation
#EquivalentWith, which refers (by references) to
those annotations of Ecore classes. Alternatively,
we can define references as transitive, creating a
#Transitive annotation which refers to the anno-
tation of the reference that should be declared as
transitive.
3.3 Mapping MOF and OWL
Ecore and OWL have a lot of similar constructs,e.g.,
classes, attributes and references. To extend the ex-
pressiveness of Ecore with OWL constructs, we need
to establish mappings between the Ecore constructs
and OWL constructs.
Based on these mapping, we develop a generic
transformation script to transform any Ecore Meta-
model/Model into OWL TBox/ABox OWLizer.
ICEIS2012-14thInternationalConferenceonEnterpriseInformationSystems
128
M1 Model
M2 Metamodel
Metamodel to TBox
Ontology
M3 Ecore
Metametamodel
conformsTo
conformsTo
OWL Metamodel
conformsTo
Transformation
conformsTo
Model to ABox
Language User
Language
Designer
OWLizing
Annotations
Figure 1: OWLizer.
Fig. 1 depicts the conceptual schema of transforming
Ecore into OWL.
The four lanes, Actor, Ecore, Model Transforma-
tion and OWL show three modeling levels according
to the OMGs Four layered metamodel architecture:
the metametamodel level (M3), the metamodel level
(M2) and the model level (M1). Vertical arrows de-
note instantiation whereas the horizontal arrows are
transformations from the Ecore modeling space to the
OWL modeling space. The ontology consists of the
TBox that represents the metamodel and the ABox
which expresses the model.
The language designer annotates the existing
metamodel with Ecore annotations for OWL. These
annotations work in the same way as the UML profile
for OWL. Thus, the language designer can create new
attributes and references and define axioms for them
in OWL by using reference properties. It is possible
to add further modeling axioms in OWL for the model
elements, e.g., expressing two artifacts as identical.
A model transformation takes the metamodel and
the annotations as input and generates an OWL on-
tology where the concepts, enumerations, properties
and data types (TBox) correspond to classes, enu-
merations, attributes/references and data types in the
metamodel. Another transformation takes the model
created by the language user and generates individ-
uals in the ABOX of the same OWL ontology. The
whole process is transparent for language users.
The structural mapping from Ecore-based meta-
models and models to OWL makes MOF models
available as federated, accessible and query-ready
LOD resources. Models can be transformed into a
common representation in OWL ontologies accord-
ing to this structural mapping. Having models repre-
sented in OWL ontologies, one might connect these
ontologies and process these ontologies in a federated
way. Thus, the resulting OWL representations ad-
dress the requirement RQ3 (Integration Management:
transform, link and query models) defined in Sect. 2.
3.4 Ontology Matching
In a model driven paradigm, resources expressed us-
ing distinct modeling languages must be reconciled
before usage. In this paper, we illustrate some of the
multiple ontology matching techniques. For a deeper
understanding of this topic, please refer to (Euzenat
and Shvaiko, 2007).
Ontology matching is the discipline responsible
for studying techniques for reconciling multiple re-
sources on the web. It comprises two steps: match and
determine alignments and the generation of a proces-
sor for merging and transforming. Matching identifies
the correspondences. A correspondence for two on-
tologies A and B is a quintuple including an id, an en-
tity of ontology A, an entity of ontology B, a relation
(equivalence, more general, disjointness) and a confi-
dence measure. A set of correspondences is an align-
ment. Correspondences can take place at the schema-
level (metamodel) and at the instance-level (model).
Matchings use multiple criteria: name of enti-
ties, structure (relations between entities, cardinal-
ity), background knowledge, e.g., existing ontolo-
gies or wordnet. Techniques can be string-based or
rely on linguistic resources. Furthermore, matchings
are established according to the structures that are
compared: (i) Internal structure comparison: this in-
cludes property, key, datatype, domain and multiplic-
ities comparison. (ii) Relational structure compari-
son: the taxonomic structure between the ontologies
is compared. (iii) Extensional techniques: extensional
information is used in this method, e.g., formal con-
cept analysis
The correspondences depend on the applied cri-
teria and technique. For example, if we apply string
matching, it generates a false positive correspondence
between the UML Activity and the BPMN Activity.
However, if we apply structure-based techniques and
analyze the structure of the UML class Action and the
BPMN class Activity, we see that both have similar
structures (both have one superclass with two associa-
tions with the same cardinalities). However, the UML
class Action is abstract and the BPMN class Activity
is concrete. So, we could assert that the class Activity
is a subclass of class Action.
Automatic matching techniques should be assisted
by domain experts because of existence of false pos-
itive matches. For example, the correspondence be-
tween BpmnDiagram and UML Activity is hard to
catch automatically. With the ontology matching ca-
pabilities, we address the requirements RQ2 (Identi-
fication) and RQ3 (Integration Management: trans-
form, link and query models) by identifying corre-
spondences for creating links between (meta) models.
AnOntology-basedApproachforEnablingLinkedDataCapabilitiestoMOFCompliantModels
129
3.5 Querying MOF-models
SPARQL is the W3C standard query language
for RDF graphs, which is a triple-based lan-
guage (Prud’hommeaux and Seaborne, 2007). Writ-
ing SPARQL queries for OWL can be time-
consuming for those who work with OWL ontologies,
since OWL is not triple-based and requires reification
of axioms when using a triple-based language. There-
fore, we proposed SPARQLAS, a language that al-
lows for specifying expressions that rely on inferences
over OWL class descriptions (Schneider, 2010). It is
a seamless extension of the OWL syntax for query-
ing OWL ontologies. SPARQLAS enables using vari-
ables wherever an entity (Class, Datatype, Object-
Property, DataProperty, NamedIndividual) or a literal
is allowed.
SPARQLAS queries are translated into SPARQL
queries and executed by any SPARQL engine that
supports graph pattern matching for OWL2 entail-
ment regime (Glimm and Parsia, 2010). SPARQLAS
queries operate on both the schema level (M2 meta-
modeling level) and on the instance level (M1 model-
ing level). For example, Listing 2 show a SPARQLAS
query about use cases that include other use cases. In
this example, we ask about the individuals ?x whose
type is an anonym class where the transitive property
includeUseCase has as value some use case.
Listing 2: Use Cases that includes some other use case.
1 Namespace : uml = < . . . uml2 / 3 . 0 . 0 /UML#>
S e l e c t ? x
Where :
? x t y p e ( UseCase and
i n c l u d e U s e C a s e some Use Case )
With SPARQLAS, we cover requirement RQ3
(Integration Management: transform, link and query
models) by providing distributed query facilities for
models and metamodels represented in OWL.
3.6 Proof of Concept
We have realized our approach in the TwoUse Toolkit
and it is available for download on the project web
site
1
. The TwoUse toolkit uses the Eclipse Modeling
Framework (Steinberg et al., 2009) and comprises (a)
a set of model transformations, (b) a set of textual and
graphical editors, and (c) a set of reasoning services,
e.g., classification, realization, query answering and
explanation.
1
http://twouse.googlecode.com/.
3.7 Limitations
Depending on the strategy for matching and align-
ing ontologies there is the possibility of false positive
matches. For example, if we use a string based match-
ing technique, we match OWL classes with the same
name as equivalent, although the two concepts might
not be semantically the same. Thus, domain experts
must be involved to proof the results of matching and
alignments.
A further limitation of our approach regards the
quality of metamodels. There are metamodels that are
designed for generating code. We have seen that, in
order to ease the implementation, references in ECore
can be declared as containment (instead of imple-
menting reference resolvers). This leads to the situa-
tion where multiple objects represent the same model
elements. Here ontology matching techniques are
powerless, since models and the ontology extracted
from these models consist of elements having same
names or properties.
A further issue in evaluating our approach is the
missing implementations of technical spaces. In our
case, all implementations are under the roof of Ecore,
an implementation of EMOF. In the future we would
like to do similar tests under (C)MOF.
Moreover, linking and aligning metamodels and
models means firstly transforming (owlizing) ev-
erything into one ontological representation and
secondly processing ontology matching algorithms,
which can cause performance issues.
4 RELATED WORK
The integration of software artifacts has been the topic
of works including (Antoniol et al., 2005; Mockus
and Herbsleb, 2002). However, these approaches pre-
sented dedicated extractors for specific systems,e.g.,
bug tracking and version control but not for soft-
ware models. Moreover, neither of these approaches
presents formats for publishing data suitable to the
linked-data approach, i.e. they do not share the princi-
ples of interoperability for connecting federated soft-
ware models across the Web.
Kiefer et al. (Kiefer et al., 2007) and Iqbal et
al. (Iqbal et al., 2009) explored semantic web ap-
proaches for transforming software artifacts such as
data from version control systems, bug tracking tools
and source code into linked data. Both approaches
use artifact-specific extractors and thus work only for
a fixed number of software artifacts. We propose a
generic approach for transforming and managing any
MOF metamodel in a web format.
ICEIS2012-14thInternationalConferenceonEnterpriseInformationSystems
130
The OMG ontology definition metamodel (OMG,
2009a) specifies mappings between OWL and UML.
In this paper, we present a general approach for map-
ping arbitrary MOF models into OWL. We provide
the means to express any MOF metamodel in its
equivalent OWL.
The OMG Request For Proposal for MOF to
RDF Structural Mapping in support of Linked Open
Data (OMG, 2009b) aims at defining a structural
mapping between OMG-MOF models and RDF. This
work is a response to this request. We propose an
approach to be used as a benchmark for future pro-
posals.
5 CONCLUSIONS
In this paper, we propose an approach to enable anal-
ysis, federation, querying and rationalization of mod-
els expressed in MOF compliant languages, including
OMG standards and domain-specific languages. We
demonstrate how our approach addresses the require-
ments of an architecture ecosystem (OMG, 2009b).
The contribution in this paper shows that the usage
of the Ontology Web Language for specifying meta-
models is a viable solution to achieve interoperabil-
ity and shared conceptualizations. The role of OWL
is not to replace MOF or the Object Constraint Lan-
guage because OWL addresses distinct requirements,
specially concerning networked environments. OWL
should compose the spectrum of software modeling
languages in a unified architecture.
REFERENCES
Antoniol, G., Penta, M. D., Gall, H., and Pinzger, M.
(2005). Towards the integration of versioning systems,
bug reports and source code meta-models. Electr.
Notes Theor. Comput. Sci., 127(3):87–99.
Antoniou, G. and vanHarmelen, F. (2004). A Semantic Web
Primer. MIT Press, Cambridge, MA, USA.
Bizer, C., Heath, T., Idehen, K., and Berners-Lee, T. (2008).
Linked data on the web (ldow2008). In WWW ’08:
Proceeding of the 17th international conference on
World Wide Web, pages 1265–1266, New York, NY,
USA. ACM.
Budinsky, F., Brodsky, S. A., and Merks, E. (2003). Eclipse
Modeling Framework. Pearson Education.
Euzenat, J. and Shvaiko, P. (2007). Ontology matching.
Springer.
Gasevic, D., Djuric, D., Devedzic, V., and Damjanovi, V.
(2004). Converting uml to owl ontologies. In Pro-
ceedings of the 13th international World Wide Web
conference on Alternate track papers & posters, pages
488–489. ACM.
Glimm, B. and Parsia, B. (2010). SPARQL 1.1 En-
tailment Regimes. Working draft 26 january 2010,
W3C. Available on http://www.w3.org/TR/sparql11-
entailment/.
Iqbal, A., Ureche, O., Hausenblas, M., and Tummarello, G.
(2009). Ld2sd: Linked data driven software devel-
opment. In Proceedings of the SEKE’2009, Boston,
Massachusetts, USA, July 1-3, 2009, pages 240–245.
Knowledge Systems Institute Graduate School.
Kiefer, C., Bernstein, A., and Tappolet, J. (2007). Mining
software repositories with isparql and a software evo-
lution ontology. In ICSEW ’07: Proceedings of the
29th International Conference on Software Engineer-
ing Workshops, Washington, DC, USA.
Mockus, A. and Herbsleb, J. D. (2002). Expertise browser:
a quantitative approach to identifying expertise. In
ICSE ’02: Proceedings of the 24th International Con-
ference on Software Engineering, pages 503–512,
New York, NY, USA. ACM.
OMG (2009a). Ontology Definition Metamodel. Object
Modeling Group.
OMG (2009b). Request For Proposal MOF to RDF
Structural Mapping in support of Linked Open
Data. Object Modeling Group. Available at
http://www.omg.org/cgi-bin/doc?ad/2009-12-09.
Prud’hommeaux, E. and Seaborne, A. (2007). SPARQL
query language for RDF (working draft). Technical
report, W3C.
Schneider, M. (2010). Sparqlas: Writing sparql queries in
owl syntax. Bachelor thesis, University of Koblenz-
Landau. German.
Steinberg, D., Budinsky, F., Paternostro, M., and Merks,
E. (2009). EMF: Eclipse Modeling Framework 2.0.
Addison-Wesley Professional.
W3C OWL Working Group (2009). OWL 2 Web Ontol-
ogy Language Document Overview. Technical re-
port. Available at http://www.w3.org/TR/2009/WD-
owl2-overview/.
AnOntology-basedApproachforEnablingLinkedDataCapabilitiestoMOFCompliantModels
131