On Synergies between Model Transformations and Semantic Web Technologies

Abstract

The integration of heterogeneous data is a reoccurring problem in different technical spaces. With the rise of model-driven engineering (MDE), much effort has been spent in developing dedicated transformation languages and accompanying engines to transform, compare, and synchronize heterogeneous models. At the same time, ontologies have been proposed in the Semantic Web area as the main mean to describe the intension as well as the extension of a domain. While dedicated languages for querying and reasoning with ontologies have been intensively studied, specific support for integration concerns leading to executable transformations is rare compared to MDE. Based on previous studies which relate metamodels and models to ontologies, we discuss in this paper synergies between transformation languages of MDE, in particular Triple Graph Grammars (TGGs), and Semantic Web technologies (SWTs), namely OWL/SPARQL. First, we show how TGGs are employed to define correspondences between ontologies and how these correspondences are expressed in SPARQL. Second, we show how reasoning support of SWTs is applied to allow for underspecified model transformation specifications as well as how the different assumptions on existing knowledge effect transformations. We demonstrate these aspects by a common case study.

Keywords

• Model Transformation
• Model Integration
• Triple Graph Grammars
• OWL
• SPARQL

-

The integration of heterogeneous data has first emerged in the database area [ 26 ]. However, data integration is a reoccurring problem, not only in the database area, but in different technical spaces [ 8, 11 ]. With the raise of model-driven engineering (MDE), much effort has been spent in developing dedicated transformation languages and accompanying engines to transform, compare, and synchronize heterogeneous models.

At the same time, ontologies have been proposed in Semantic Web to describe the

intension as well as the extension of a domain. While dedicated languages for querying and reasoning with ontologies have been intensively studied (e.g., classification of individuals and consistency checking are provided by standard reasoner), specific support for integration concerns leading to executable transformations is rare.

In order to understand the differences and commonalities between MDE and Semantic Web technologies (SWTs), several studies have investigated about the languages used in both fields to describe the domain of discourse [ 28 ]. Thus, bridges are already available between these two worlds for transforming metamodels and corresponding models to ontologies and vice versa. Some studies go also beyond purely structural information [ 12 ], but bridges concerning dynamic information are still mostly unexplored. Moreover, for specific domains, such as configuration management [ 4 ], both technologies are applied, but mostly in an isolated manner as we currently explore in a recent project3.

Based on previous studies which relate metamodels and models to ontologies [5,10],

we discuss in this paper synergies between transformation languages of MDE, in particular Triple Graph Grammars (TGGs) [ 24 ], and SWTs, namely a combination of OWL/SPARQL. First, we show how TGGs are employed to define correspondences between ontologies visualized as metamodels and how these correspondences are operationalized by a compilation of TGGs to OWL/SPARQL. Second, we show how reasoning support of SWTs is applicable to allow for underspecified model transformation specifications, i.e., the concrete types of instances are assigned in a post-processing step using OWL reasoner. Third, we discuss how switching between the closed world assumption (CWA) to an open world assumption (OWA) is beneficial for particular integration scenarios where only partial knowledge of existing models is present. We demonstrate these aspects by a common case study.

The rest of this paper is structured as follows. In the next section, we introduce the

running example for this paper as well as the technological prerequisites. In Section 3, we discuss the mapping between TGGs and OWL/SPARQL in a general form, whereas in Section 4 we demonstrate the compilation of TGGs to OWL/SPARQL by-example and discuss how features of ontologies may be exploited for model transformations. In

Section 5 we discuss related work before we conclude in Section 6.

2 2.1

Preliminaries

Motivating Example

As an example we will illustrate how heterogeneous views on computer networks can be joined (cf. Fig. 1). The first view comprises the physical network structure including cables of various types and speed as well as computers. The second view contains the application structure of the network, i.e., various computers are running different services which might require each other. In that case, a connection to a matching service is required. Connections can be modeled by their physical structure, as well as their logical network structure. By using TGGs we are able to define correspondences between both structures, which can be used to either ( ) express graph transformation rules to transform individuals from one schema to another or ( ) check whether or not such alignments hold for given models. Extending those correspondence definitions with SWTs, allows even more sophisticated reasoning, inferencing, and querying tasks. 3 http://cosimo.big.tuwien.ac.at

Device name:FString networkCables

Computer * utilization:FDouble

Router slots:FInteger maxBandWidth:FDouble curBandWidth:FDouble (a) TGGs have first been introduced by Andy Schürr [ 24 ]. A TGG rule combines elements from a left model (LM), a right model (RM) and a correspondence model (CM). Each TGG rule contains a left hand side graph (LG) conforming to LM, a right hand side graph (RG) conforming to RM and a correspondence graph (CG) conforming to CM which connects elements from LG and RG. Vertices and edges may not be deleted by any rule, they can only be preserved or created. In contrast to usual graph transformation rules, TGG rules are inherently bidirectional. A TGG engine searches for rule applications creating the required input graphs and creates elements of all other graphs during that process. For example, in a transformation scenario an input graph for LM would result in a graph for CM and RM. TGG rules might also have additional constraints, e.g., negative application conditions or attribute constraints, also restricting the value of an attribute depending on attribute values of other objects in the TGG rule.

The left-hand side of Fig. 5 shows a simple example of a TGG rule of a computer

network that relates connections of the same speed without declaring them equal. Black elements denote elements which have been matched already, green elements are elements which are matched or created then. In this case, the difference between both models is only a syntactical one. 2.3

Semantic Web Technologies (SWTs) RDF & OWL. The Resource Description Framework (RDF)4 is a framework to describe and represent information about resources and is both human-readable and machine-processable, which enables the possibility to easily exchange information among different applications using RDF triples.

In RDF everything is a resource, uniquely identified by its URI and all data is repre

sented as (, , ) triples, where subjects and predicates are URIs and objects can either be literals (strings, integers, . . . ) or URIs.

Since RDF itself does not contain sophisticated semantics to express characteristics of concepts or to define more expressive relationships among them, the Web Ontology

4 http://www.w3.org/TR/rdf-mt/ Language (OWL)5 was developed. Introducing OWL allows the usage of reasoning systems such as Pellet [ 27 ], FaCT++ [ 29 ] or HermiT [ 25 ] to ( ) infer new knowledge and ( ) detect inconsistencies based on the modeled semantics.

SPARQL. The Protocol And RDF Query Language (SPARQL) is basically the standard query language for RDF6. Its syntax (cf. Figs. 2-4) is highly influenced by an RDF serialization format called Turtle [ 1 ] and SQL. In its current version, SPARQL allows besides basic query operations such as union of queries, filtering, sorting and ordering of results as well as optional query parts, the use of aggregate functions (SUM, AVG, MIN, MAX, COUNT,...), the possibility to use subqueries, perform update actions via SPARQL Update and several other requested features as indicated in [ 18 ].7

Another important feature of SPARQL are CONSTRUCT queries, which allow the construction of new RDF graphs based on a previously matched (against one ore more input graphs) SPARQL graph pattern (cf. Fig. 3). Their main purpose lies in data integration scenarios, where data from one ore more data sources have to be normalized to fit a common schema [ 19, 23 ]. } 3 SELECT ?a ?name WHERE { ?a a :Device . ?a :name ?name .

Aligning TGGs and SWTs

CONSTRUCT {

?a :hasName true . } WHERE { ?a a :Device .

?a :name ?name . } In the following, we map basic TGG rules to SPARQL queries. The TGG rule definition is based on [ 2 ] and extended by labels. Advanced features of graph transformations like multi–nodes are not supported. Subsequently, we discuss two benefits of using SWTs: ( ) automatic type inference and ( ) reasoning under CWA and OWA. Definition 1 (E–Graph). A labeled E–Graph = ( , , , NA, EA, (src , trg ) ∈{ , EA,EA} , ) consists of graph vertices , data vertices , graph edges, node attribute edges and edge attribute edges , NA, EA, source and target edge functions src and trg mapping edges to corresponding vertices and a labeling function defining a label for each vertex and edge. As shorthand we use src( ) and trg( ) to denote source and target edge functions operating on edges of any kind. Definition 2 (Typegraph). A typegraph TG is an E-Graph specifying the relation between types. A type morphism maps nodes and edges of a graph to the corresponding nodes and edges in the type graph. 5 http://www.w3.org/TR/owl2-overview/ 6 http://www.w3.org/TR/sparql11-overview/ 7 For a comprehensive overview on the semantics of SPARQL queries see [ 17, 22 ].

DSIG algebra.

. . . , {} LG ), = Definition 3 (Triple graph). A triple graph TRG = (L G−− ← of three E–Graphs LG, CG and TG and morphisms and mapping corresponding RG) consists C G→− − nodes from the correspondence graph to other graphs.

Definition 4 (TGG rule). A parametrized TGG rule TGG = (SG, ZG, ac) consists of a source triple graph SG, a target triple graph ZG ⊃ For the sake of simplicity, we consider application conditions as boolean formulas using ∧ and ∨ , over atomic positive application conditions (PACs) and negative application conditions (NACs) defined as triple graphs which might share vertices with each other SG, and application conditions ac. and SG and TG.

Example 1. The TGG rule r2n = (tr , tr , true) represented in Fig. 5 could be specified as follows: The type graph of both models is derived from the metamodel. For example, a subset of the typegraph for network1 could be specified as n1 = ({ n1 , n1 } , { double} , { sn1 , n1 } , { bn1 } , }{ , { ( n1 , n1 ), ( n1 , n1 )} , { ( n1 , n1 ), ( n1 , n1 )} ), { ( 1, n1 )} , { ( n1 , double)} , {} , }{ ) combined with a standard double The source graph of TGG rule tr = (LG − − ← LG = ({ 1, 2} , ∅ , . . . , ∅ ), CG = ({ g2c1, g2c2} , ∅ , . . . , ∅ ), TG = ({ cb1, cb2} , ∅ , = ∅ ,

= ∅ . The target graph tr = (LG − − ← LG ∪

({ 1} , { } , { 1, 1} , { 1} , ∅ , { ( 1, 1), ( 1, 1)} , { ( 1, 1), ( 1, 2)} , { (, 1)} , { (, )} , ∅ , ∅ ), CG = CG ∪ ( }{ , ∅ , . . . , ∅ ), RG = RG ∪ ({ 1} , { } ,

P. Type TGG

W c,m W c,m 1 ̸

Vertex

Vertex 1, 2, tive matching

SPARQL

? ( ) a ( ( )).

= 2, injec- FILTER (? ( 1) != ? ( 2)). C cr W c,m C cr m,cr m,cr m m W c W c C C W W C C W W W

Vertex

Edge

Edge

Vertex

Edge

Vertex

Edge

Vertex

Edge

→↦ →↦

Mapping 1

tt or ts

Mapping 1

tt or ts

Atomic PAC ac

Atomic NAC ac ac1(∧|∨ )ac2 ? ( ) a ( ( )). ? ( ( )) dom( ): ( ) ? ( ( )). ? ( ( )) dom( ): ( ) ? ( ( )). ? ( ) tgg:hasMatch true.

? ( ( )) tgg:hasMatch_dom( )_ ( ) ? ( ( )).

FILTER NOT EXISTS {? ( ) tgg:hasMatch true.} FILTER NOT EXISTS {? ( ( )) tgg:hasMatch_dom( )_ ( ) ? ( ( ))} FILTER EXISTS {? ( ) tgg:hasMatch true.} FILTER EXISTS {? ( ( )) tgg:hasMatch_dom( )_ ( ) ? ( ( ))} m,cr 2 from ss, st, ? ( 1) owl:sameAs ? ( 2) m,cr 2 from ss, st, ? ( 1) owl:sameAs ? ( 2)

BIND (EXISTS {<expand ac acc. to Tab. 1>}) AS ?gn(ac) BIND (NOT EXISTS Tab. 1>}) AS ?gn(ac)

{<expand ac acc. to applied recursively until the atomic operations.

Full AC ac = FILTER (?gn(ac1) (&&/||) ?gn(ac2)) or rather In this case, the specific match of vertices in a TGG rule has to be stored to be able to subsequently apply the constraint. Thus, attributes :hasSwrlRule_name_index might be set true to specify that an element is used as element nr. index in the SWRL rule name. In such a way, not only conditions in the TGG can be formulated, but also invariants of each individual model or the merged model. Simple invariants may also be modeled directly in OWL. In the following, we will show an example to illustrate how this may help reducing the complexity of TGG rules significantly. Automatic Type Inference. Considering the two views on an imaginary network, one might distinguish the creation of Coppercables and Glassfibrecables based on the speed of a correlating Connection between two previously aligned Devices and Connectables (e.g. creating a Glassfibrecable if the speed exceeds a certain threshold or a Coppercable otherwise). Although such distinctions can be modeled with TGGs, at least two TGG rules (in our case; one matching

Coppercable and one matching Glassfibrecable) would be necessary.

A more convenient way to model such a behavior can be achieved by out-sourcing the type inference to OWL reasoners and only define one TGG rule, which describes the more general Cable and Connection correspondence as depicted in Figure 5 (with its corresponding SPARQL CONSTRUCT query). The constraints itself (i.e., defining the concept Glassfibrecable to be equivalent to an anonymous concept which is defined as Cable having a speed with a value over 17) can be directly modeled within the ontology using OWL axioms8 and were generated during the initial model to ontology transformation .

TGG rule example physical (namespace o1) correspong1:Device + source dence + k1:Cable (ns. c) bandWidth<=<n gc1:D2C g2:Device + target logical (namespace o2) g3:Connectable + source + c1:Connection speed<=<n g4:Connectable + target Metamodel excerpt (namespace o1)

Cable bandWidth:<Double

gc:2G:D2c2C inv:<bandWidth<<<17 inv:<bandWidth<>=<17

CopperCable

GlassFibreCable

CONSTRUCT { ?k1 a o1:Cable . ?k1 o1:source ?g1 . ?k1 o1:target ?g2 . ?k1 o1:bandWidth ?n . ?k1 tgg:hasMatch true .

?c1 tgg:hasMatch true . } WHERE { ?gc1 a c:D2C. ?gc2 a c:D2C. ?g1 owl:sameAs ?gc1 . ?g2 owl:sameAs ?gc2 . ?g3 owl:sameAs ?gc1 . ?g4 owl:sameAs ?gc2 . ?c1 o2:source ?g3 . ?c1 o2:target ?g4 . ?c1 o2:speed ?n .

FILTER (?gc1 != ?gc2) .

FILTER (?g1 != ?g2) .

FILTER (?g3 != ?g4) .

FILTER EXISTS

{?gc1 tgg:hasMatch true} .

FILTER EXISTS

{?gc2 tgg:hasMatch true} .

FILTER NOT EXISTS

{?c1 tgg:hasMatch true} .

} Reasoning under Open and Closed World Assumption. One of the major benefits of SWTs for integration scenarios are their well defined semantics and the extensive reasoner support as already discussed previously. With OWL and OWL reasoners it is 8 cf. [ 6 ] for a comprehensive list of OWL axioms e.g., possible to describe cardinality constraints, perform automatic type inferencing as discussed above and to check for inconsistency in the given models.

While Semantic Web languages are based on OWA (i.e., if a statement is not ex

plicitly stated, it does not mean that it does not exist), software engineering languages are mostly based on CWA (i.e., if a statement is not present, it does not exist) [ 20 ]. To deal with this issue, we translate parts9 of the constraints expressed as OWL axioms into SPARQL queries and query for the presence of individuals which violate those constraints. E.g., consider the cardinality constraint computers exactly 2 Computer for concept System expressed in OWL Manchester Syntax10. The answer to the question whether or not a particular System has the right amount of Computers, would not be directly decidable for the OWA but for the CWA with the support of SPARQL as depicted in Listing 1.

ASK WHERE { { SELECT (count(?b) AS ?number) ?a WHERE { ?a a :System .

?a :computers ?b . } GROUP BY ?a } FILTER(?number != 2)}

Listing 1. ASK Query which returns true if a System has not exactly 2 Computers

4

Related Work

We discuss three lines of related work: ( ) approaches for bridging models and ontologies, ( ) approaches for transforming transformations to SWTs, and ( ), approaches directly using SWTs to encode model transformations.

Bridging models and ontologies. Combining modeling approaches steaming from

MDE with ontologies has been studied in the last decade [ 5 ]. There are several approaches to transform Ecore-based models to OWL and back, e.g., cf. [ 9, 31 ]. In addition, there exist approaches that allow for the definition of ontologies in software modeling languages such as UML by using dedicated profiles [ 13 ]. Moreover, there are also approaches which combine the benefits of models and ontologies such as done in [ 14, 16 ]. Not only the purely structural part of UML is considered, but some works also target the translations of constraints between these two technical spaces by using an intermediate format [ 3 ]. We build on these mentioned approaches, but we focus on correspondence definitions and their execution as transformations.

Transforming transformations to SWTs. Concerning the definition and execution of

model transformations based on SWTs, we are aware of two approaches. First, [ 15 ] propose the usage of an ATL-inspired language for defining mappings between ontologies. Thus, uni-directional transformations are implementable for ontologies as it is known from model transformations. Another approach is presented in [ 30 ] which translates parts of ATL transformations to ontologies for checking the consistency of transformation rules, e.g., overlaps between rules in terms of overlapping matches. In our work, we follow this line of research, but we consider bi-directional transformations specified in TGGs. Thus, in our translations to ontologies we have to consider not only source to 9 The decision, which constraints have to be translated, highly depends on the respective integration scenario. 10 http://www.w3.org/TR/owl2-manchester-syntax/ target transformations, but we have to encode comparison and synchronization transformations as well in SPARQL.

Specifying transformations with SWTs. Finally, there are approaches which shift the

definition of the model transformations to the SWTs. For instance, in [ 21 ] it is proposed to use SWRL to define the correspondences between models to allow for model synchronization. In [ 10 ], ontology matching tools are applied to search for correspondences between metamodels and to derive from these correspondences model transformations. In the context of this work, we have the assumption that correspondences are defined based on models using TGGs, but at the same time we explored which benefits from ontology reasoning may be transferred to model transformation approaches. 5

Conclusion and Further Work

In this paper we have outlined an initial mapping between TGGs and OWL/SPARQL. Especially, new features of the latest SPARQL version helped in defining a comprehensive mapping between these languages. Moreover, we also explored how reasoning capabilities can be leveraged for underspecified model transformations.

While the initial results of applying our approach seem promising, both from a

mapping point of view and usage of reasoning capabilities for model transformations, further investigation are planned such as considering a mapping between TGGs and SWRL. Empirical studies are planned as well in the area of configuration management together with our industry partner Siemens AG Österreich. In particular, for performing distributed configuration management [ 4 ] where several different models and reasoners have to be connected, we plan to apply our approach to provide the necessary integration means.

Acknowledgment: This work has been funded by the Vienna Business Agency (Austria), in the programme ZIT13 plus, within the project COSIMO (Collaborative Configuration Systems Integration and Modeling) under grant number 967327.

References

1. David Beckett and Tim Berners-Lee . Turtle-terse RDF triple language . W3C Team Submission , 14 , 2008 .

2. Juan de Lara, Roswitha Bardohl, Hartmut Ehrig, Karsten Ehrig, Ulrike Prange, and Gabriele Taentzer . Attributed graph transformation with node type inheritance . Theoretical Computer Science , 376 ( 3 ): 139 - 163 , 2007 .

3. Dragan Djuric , Dragan Gasevic, Vladan Devedzic, and Violeta Damjanovic . A UML Profile for OWL Ontologies . In Proc. of MDAFA , pages 204 - 219 , 2004 .

4. Andreas A. Falkner , Alois Haselböck, Gottfried Schenner, and Herwig Schreiner . Modeling and solving technical product configuration problems . AI EDAM , 25 ( 2 ): 115 - 129 , 2011 .

5. Dragan Gasevic , Dragan Djuric, and Vladan Devedzic . Model Driven Engineering and Ontology Development (2 . ed.). Springer, 2009 .

6. OWL Working Group. OWL 2 Web Ontology Language . W3C recommendation , 2012 .

7. Frank Hermann, Hartmut Ehrig, Fernando Orejas, Krzysztof Czarnecki, Zinovy Diskin, Yingfei Xiong, Susann Gottmann, and Thomas Engel. Model synchronization based on triple graph grammars: correctness, completeness and invertibility . SoSyM , pages 1 - 29 , 2013 .

8. Zhenjiang Hu , Andy Schürr, Perdita Stevens, and James F. Terwilliger . Dagstuhl seminar on bidirectional transformations (bx) . SIGMOD Record , 40 ( 1 ): 35 - 39 , 2011 .

9. Gerti Kappel , Elisabeth Kapsammer, Horst Kargl, Gerhard Kramler, Thomas Reiter, Werner Retschitzegger, Wieland Schwinger, and Manuel Wimmer . Lifting Metamodels to Ontologies: A Step to the Semantic Integration of Modeling Languages . In Proc. of MODELS , pages 528 - 542 , 2006 .

10. Gerti Kappel , Horst Kargl, Gerhard Kramler, Andrea Schauerhuber, Martina Seidl, Michael Strommer , and Manuel Wimmer . Matching metamodels with semantic systems - an experience report . In Proc. of BTW Workshops , pages 38 - 52 , 2007 .

11. Ivan Kurtev , Mehmet Aksit, and Jean Bézivin . Technical Spaces: An Initial Appraisal . In Proc. of CoopIS , 2002 .

12. Sergey Lukichev . Defining a subset of OCL for expressing SWRL rules . InRuleApps , pages 1 - 3 , 2008 .

13. Milan Milanovic , Dragan Gasevic, Adrian Giurca, Gerd Wagner, and Vladan Devedzic . Towards Sharing Rules Between OWL/SWRL and UML/OCL . ECEASST, 5 , 2006 .

14. Fernando Silva Parreiras and Steffen Staab . Using ontologies with UML class-based modeling: The TwoUse approach . Data Knowl. Eng., 69 ( 11 ): 1194 - 1207 , 2010 .

15. Fernando Silva Parreiras , Steffen Staab, Simon Schenk, and Andreas Winter . Model driven specification of ontology translations . InProc. of ER , pages 484 - 497 , 2008 .

16. Fernando Silva Parreiras , Steffen Staab , and Andreas Winter . On marrying ontological and metamodeling technical spaces . In Proc. of FSE , pages 439 - 448 , 2007 .

17. Jorge Pérez , Marcelo Arenas, and Claudio Gutierrez . Semantics and Complexity of SPARQL . In Proc. of ISWC , pages 30 - 43 , 2006 .

18. Axel Polleres . SPARQL1 . 1: New features and friends (OWL2, RIF) . In Web Reasoning and Rule Systems , pages 23 - 26 . Springer, 2010 .

19. Axel Polleres , François Scharffe, and Roman Schindlauer . SPARQL+ + for mapping between RDF vocabularies . In Proc. of OTM , pages 878 - 896 , 2007 .

20. Tirdad Rahmani , Daniel Oberle, and Marco Dahms . An adjustable transformation from OWL to Ecore . In Proc. of MODELS , pages 243 - 257 , 2010 .

21. Federico Rieckhof , Mirko Seifert, and Uwe Aßmann . Ontology-based model synchronisation . In Proc. of TWOMDE Workshop , 2010 .

22. Simon Schenk . A sparql semantics based on datalog . In Proc. of KI , pages 160 - 174 , 2007 .

23. Simon Schenk and Steffen Staab . Networked graphs: a declarative mechanism for SPARQL rules, SPARQL views and RDF data integration on the web . In Proc. of WWW , pages 585 - 594 , 2008 .

24. Andy Schürr . Specification of Graph Translators with Triple Graph Grammars . InProc. of WG Workshop , pages 151 - 163 , 1994 .

25. Rob Shearer , Boris Motik, and Ian Horrocks. HermiT: A Highly-Efficient OWL Reasoner . In Proc. of OWLED Workshop , 2008 .

26. Nan C. Shu , Barron C. Housel, Robert W. Taylor, Sakti P. Ghosh, and Vincent Y. Lum. EXPRESS : A Data EXtraction, Processing, amd REStructuring System . ACM Trans. Database Syst ., 2 ( 2 ): 134 - 174 , 1977 .

27. Evren Sirin , Bijan Parsia, Bernardo Cuenca Grau, Aditya Kalyanpur, and Yarden Katz . Pellet: A practical OWL-DL reasoner . J. Web Sem., 5 ( 2 ): 51 - 53 , 2007 .

28. Steffen Staab , Tobias Walter, Gerd Gröner, and Fernando Silva Parreiras. Model driven engineering with ontology technologies . In Proc. of Reasoning Web , pages 62 - 98 , 2010 .

29. Dmitry Tsarkov and Ian Horrocks . FaCT++ description logic reasoner: System description . In Automated reasoning , pages 292 - 297 , 2006 .

30. Dennis Wagelaar . Towards using OWL DL as a metamodelling framework for ATL . In Proc. of MtATL Workshop , pages 79 - 85 , 2010 .

31. Tobias Walter , Fernando Silva Parreiras, Gerd Gröner, and Christian Wende . OWLizing: Transforming Software Models to Ontologies . In Proc. of ODiSE , pages 7 : 1 - 7 : 6 , 2010 .