Representing BORM Process Models using OWL and RDF

Marek Such

anek

1,2 a

and Robert Pergl

1 b

Faculty of Information Technology, Czech Technical University in Prague,

akurova 9, Prague, Czech Republic

Faculty of Business and Economics, University of Antwerp,

Prinsstraat 13, Antwerp, Belgium

Keywords:

Ontology, BORM, Business Process Modelling, RDF, OWL, Transformation.

Abstract:

Business Object Relationship Modeling (BORM) is a business process analysis method based on communi-

cating ﬁnite-state machines and Petri nets. However, because of its tooling support and non-interoperability

of formats, it is rather niche. This work proposes a way of representing the knowledge from BORM process

models in RDF by creating a BORM ontology. It beneﬁts from previous work done on different conceptual

and process modelling languages and their transformations to OWL. The resulting RDF representation brings

increased interoperability and enhanced analysis possibilities, e.g., using SPARQL or RDF visualization tools.

A part of this work is also a BORM-to-RDF export feature for the OpenPonk modelling platform. The result-

ing BORM ontology is ready for use in practice and further work.

1 INTRODUCTION

Business process modelling is an activity of describ-

ing processes for documentation, optimization, or au-

tomation purposes (Scholz-Reiter and Stickel, 2012).

In terms of process engineering as part of concep-

tual modelling, there are various languages and meth-

ods to build a process model, e.g. BPMN, UML,

LML, or BORM. Business Objects Relation Mod-

elling (BORM) (Merunka et al., 2009) uses an object-

oriented approach through simplistic notation, focus-

ing on connecting business and software engineering.

It is built on formal foundations of communicating

ﬁnite-state machine. However, it turned not to be

enough for this method to be successful.

The usability of a modelling language or method

is directly related to the tooling support and inter-

operability to help users use it (Scholz-Reiter and

Stickel, 2012). Despite several substantial advan-

tages, BORM is becoming unknown as an artefact of

the past. Several tools allow BORM modelling; how-

ever, the used formats do not allow interoperability

and are blockers in further use (e.g. orchestration, se-

mantic integration, or normalization). Various tools

for modelling or simulation of BORM models use

speciﬁc formats that do not interchange knowledge.

https://orcid.org/0000-0001-7525-9218

https://orcid.org/0000-0003-2980-4400

Technologies of semantic web and linked data are

well-known for their interoperability, versatility, and

machine-actionability. RDF can be used to capture

practically any knowledge with the possibility to use

multiple formats to store and exchange it (for in-

stance, Turtle or RDF/XML). RDF schema or OWL

ontology can be used to give the data in RDF mean-

ing. Last but not least, SPARQL can serve to query

and manipulate RDF data in a standard and universal

way. (Powers, 2007; Breitman et al., 2010)

In this work, we aim to allow capturing BORM

models with the use of RDF and OWL. Giving a

new interoperable way of knowledge representation

and way of modelling has the potential to revive the

method. By using RDF and OWL, the formal foun-

dations and critical features of BORM must stay orig-

inal. It must support the transformation from and to

representations used by the existing modelling tools.

In the Section 2, we brieﬂy explain the BORM,

related tools, and necessary background in terms of

RDF. Section 3 describes the ﬁrst step, building an

ontology-based on BORM metamodel. Then, Sec-

tion 4 shows how the ontology is used for represent-

ing BORM models in RDF. Section 5 demonstrates

the advantages of RDF representation in several use

cases. Section 6 provides a discussion and evaluation

of the results together with an outline of possible fu-

ture steps.

170

Suchánek, M. and Pergl, R.

Representing BORM Process Models using OWL and RDF.

DOI: 10.5220/0010653900003064

In Proceedings of the 13th International Joint Conference on Knowledge Discovery, Knowledge Engineering and Knowledge Management (IC3K 2021) - Volume 2: KEOD, pages 170-177

ISBN: 978-989-758-533-3; ISSN: 2184-3228

2 RELATED WORK

This section serves as a brief overview of the BORM

modelling and important terminology needed for

work with RDF and OWL. It provides references to

relevant previous work and details.

2.1 BORM Method

Business Objects Relation Modelling (BORM) (as

summarized in (Merunka et al., 2009) and (Molhanec

et al., 2011)) is a process modelling method for cap-

turing knowledge of typical business systems. Its de-

velopment started in 1993 and turned to be an effec-

tive due to its understandability and formal founda-

tions. It is possible to apply formalism for validation

and simulation (Podlouck

y and Pergl, 2014). The re-

lation between BORM and other process modelling

languages (BPMN and UML Activity Diagram) is de-

scribed (Such

anek and Pergl, 2019).

We focus on Object Relations (OR) and Business

Architecture (BA) diagrams. OR captures the process

using communicating ﬁnite-state machines. Each ma-

chine represents a role of particular subject, i.e., the

ﬂow in process for a given participant. Through com-

munication it composes a process with multiple roles.

BA diagram provides an overview of the whole busi-

ness and shows how processes are used in scenar-

ios and related to business functions.(Merunka et al.,

2009; Knott et al., 2000)

2.2 Craft.CASE

Craft.CASE (CRAFT.CASE Ltd., 2015) is an enter-

prise tool for modelling with BORM. As also de-

scribed in (Merunka et al., 2009) and (Podlouck

y and

Pergl, 2014), it supports the entire BORM method

and not just the modelling part. It guides the analyst

through the various stages of business analysis. The

export and import are done through custom XML se-

rialization of a whole project using .crx ﬁle exten-

sion. However, it also offers partial exports to CSV

and JSON that allows simpler processing. As it is an

enterprise and proprietary tool, the feature set is lim-

ited in free version. The development of the tool does

not seem to be active (last update in 2015).

2.3 OpenCASE

OpenCABE (formerly OpenCASE) (Pergl and Tuma,

2012) is a BORM modelling tool based on the Eclipse

Modeling Framework (EMF). It focuses primarily on

the Object Relations and Business Architecture dia-

grams and their relations. Still, it also offers print-

able HTML reports that can be used in process oper-

ations as a scenario or decision helper. Furthermore,

a project can be exported and imported through XMI

format that uses a custom proﬁle. Unfortunately, the

development of this tool is discontinued, and Open-

Ponk can be seen as its successor.

2.4 OpenPonk

OpenPonk modelling platform (Uhn

ak and Pergl,

2016) is a metamodelling platform and a modelling

tool implemented in Pharo (Smalltalk). The core fea-

ture of OpenPonk is to support various metamodels

and use them for modelling purposes. There are vari-

ants of OpenPonk with different metamodels: UML

Class Diagram, OntoUML, Petri Nets, Finite State

Machines, and BORM ORD. The open-source project

is published on GitHub

and actively developed (last

release for BORM in March 2021). It has also proven

its usefulness in terms of modularity in live visual

modelling (Bliznicenko et al., 2017).

The serialization of models for import and ex-

port in OpenPonk is done as a ZIP archive contain-

ing several JSON ﬁles and Smalltalk Object Notation

(STON) ﬁle(s). It directly serializes objects represent-

ing the model in Smalltalk. Another option is to ex-

port the diagram as a PNG picture. However, Open-

Ponk is designed to be extended including custom ex-

port and import functionality.

2.5 RDF and OWL

The ontologies and knowledge representation in in-

formation technologies are tightly related to RDF

(Resource Description Framework) and OWL (The

Web Ontology Language). Its use is widespread

across various domains (conceptual modelling, Se-

mantic Web, bioinformatics, FAIR data, artiﬁcial in-

telligence, and others). In many places, it replaces

XML and JSON representations. Although some as-

pects in linking can be seen similar in XML (and

XPath, XSD, XSLT, or XMLNS), the simplicity and

versatility of RDF prevails. (Breitman et al., 2010)

The core ideas of keeping the information in

triples composed of subject, predicate, and object,

where each can be uniquely identiﬁed resource

enable simple knowledge modelling and referencing.

Then, to give meaning to the triples (describe classes

and their properties including constraints), ontology

can be used, e.g. RDF Schema (RDFS) or OWL

with higher expressiveness. Finally, SPARQL can be

used in a standard way to query knowledge from RDF

https://github.com/OpenPonk

Representing BORM Process Models using OWL and RDF

171

knowledge representation as well as manipulate

it, including transformation. (Powers, 2007)

2.6 Conceptual Modelling with RDF

The versatility of ontologies, including OWL and

RDF, is also manifested in several process-oriented

ontologies. Our work can beneﬁt from some that de-

scribe novel approaches or contain important lessons

learned. For example, (Garanina et al., 2019) de-

sign a process ontology with a focus on veriﬁca-

tion. (Natschl

ager, 2011) proposes an ontology for

BPMN2 standard. (Kchaou et al., 2021) describes a

transformation from BPMN to OWL, which is similar

to our goal. Another interesting approach in terms of

business process modelling is presented in (von Ros-

ing et al., 2015). It aims to create a vocabulary of the

terminology used in business process models. It is a

potential source for linking (in linked data way) with

RDF representing BORM models. To support reason-

ing and queries over UML models, UML to OWL

transformation (Wei et al., 2018) is showing to be a

promising way which further allows to utilize com-

plex SPARQL queries (Wei and Sun, 2021).

3 BORM ONTOLOGY

This section described the OWL ontology based on

BORM for capturing the same knowledge represented

by OR and BA diagrams. OWL is used instead of

RDF Schema for required features in terms of con-

straints and meta-modelling. The examples and rela-

tion to diagrams from Craft.CASE is provided in Sec-

tion 4 based on the ontology.

The BORM Ontology

is designed based on

BORM metamodel for OR and BA diagrams. The

ontology was developed using Prot

e tool (Musen,

2015) and then structurally improved in its Turtle tex-

tual format. It is a single ontology describing both

metamodels for OR and BA diagrams as those are

highly interlinked. It cannot use only RDFS as OWL

is used for metamodelling support. The suggested

preﬁx for BORM ontology is borm:. The naming is

taken directly from BORM metamodel; changes and

additional elements are explicitly mentioned further.

3.1 Business Architecture

The business architecture part of the ontology con-

tains four core classes:

http://purl.org/ontoborm

• borm:Business is not directly deﬁned in the

BORM method. However, we need a single top-

level entity that bounds others. It represents a

modelled business organisation.

• borm:Function represents a business function.

It has two subclasses borm:InternalFunction

and borm:ExternalFunction (disjoint, union).

• borm:Scenario supports a certain function a

business and serves as a container for related pro-

cesses.

• borm:Process represents a single object-relation

diagram, i.e., description of a business process

that is part of a certain scenario.

All of these classes require standard rdfs:label

for human-readable name. Use of rdfs:comment

is recommended for brief explanation. There

are three object properties for relating entities

borm:hasFunction, borm:hasScenario, and

borm:hasProcess (in the ontology with corre-

sponding domain and range). As inverse rela-

tions, borm:ofBusiness, borm:ofFunction, and

borm:ofScenario are deﬁned. The semantics of

the properties of BORM are different from generic

part-of taxonomies which is the reason for not using

existing like it is done for labels.

For expressing relations between scenarios,

the corresponding object properties are included:

borm:usesScenario, borm:extendsScenario, and

borm:followsScenario. Again, with its inverted

variants. The properties follows are used to express

transitions between scenarios.

The following properties are deﬁned for the

class borm:Scenario to provide additional de-

tails based on BORM: borm:hasIntitiation,

borm:hasAction, and borm:hasResult. Initially,

those were datatype properties using a string lit-

eral. However, to allow linking triggers, actions,

and results in linked-data sense, those are designed

as object properties and additional classes were

created: borm:Intitiation, borm:Action, and

borm:Result. With that, one can specify just a de-

scription for (anonymous) individual as well as create

own subclass that has additional properties and links.

For example, a result may be a completed order that

requires total price computed.

3.2 Object Relations

The object relations part of the ontology is more com-

plex than the business architecture. First, there are

ﬁve classes to express participants in processes and

their roles (ﬂows):

KEOD 2021 - 13th International Conference on Knowledge Engineering and Ontology Development

172

• borm:Participant represents a type of stake-

holders that may participate in processes. There

are three subclasses (disjoint, non-union) inspired

by OpenPonk and OpenCABE: borm:Person,

borm:System, borm:Organization.

• borm:Role is used to relate a participant with a

process, i.e., a participant has a role in a process.

This could be seen as an object property; however,

we need to specify additional details and have a

reference to distinguish the different roles of the

same participant in multiple processes.

• borm:State represents a state within a role.

There are two special subclasses for start and end

state.

• borm:Activity represents an activity within a

role that serves for transition between two differ-

ent states (that are within the same role).

• borm:Transition is used to express the transi-

tion between two states via activity. It is not done

through object relation for the same reasons as

role – there is additional information required for

its instances.

Again, well-known rdfs:label is required

and rdfs:comment are recommended for human-

readability. The union of classes borm:State and

borm:Activity forms borm:RoleElement which

has property borm:ofRole. A role uses object prop-

erties borm:startsWith and borm:endsWith with

an corresponding state subclass instances. A transi-

tion can be related to states using borm:sourceState

and borm:targetState, and with an activity by

borm:transitsThrough. Then, a participant is re-

lated to its role by borm:hasRole, and role to pro-

cess by borm:ofProcess. The last part is to capture

relations between roles, and related constraints:

• borm:Communication represents a links between

activities of different roles within the same pro-

cess. It has two subclasses (union, disjoint) for

synchronous and asynchronous communication.

• borm:DataFlow can be attached to a communica-

tion. It is intended to by used by domain-speciﬁc

class, e.g., Order can be borm:DataFlow.

• borm:Constraint can be used for both commu-

nication and transition and speciﬁes a condition as

in BORM which result into two subclasses (dis-

joint, union). It should be described by text, but

can be related to domain-speciﬁc entity similarly

to data ﬂow.

A communication is related to activities by

borm:sourceActivity and borm:targetActivity

object properties. To distinguish the directional-

ity of data ﬂows, there are two sub-properties of

borm:hasDataFlow, namely borm:hasInputFlow

and borm:hasOutputFlow. The object property

borm:ofCommunication forms link between a com-

munication constraint and a communication, and cor-

respondingly for transitions (borm:ofTransition).

Then, to support sub-process (more speciﬁcally a

process ﬂow within a state), a borm:State is a sub-

class of that abstracts the common properties, i.e., the

ability to contain a process ﬂow (have role elements,

starting and ending states).

3.3 Constraints

There are identiﬁed ﬁve rules that must hold and are

implemented using SHACL:

• A transition relates two non-equal states within

the same role.

• A communication relates two activities of two dif-

ferent roles within the same process.

• If a role has a state, it must have at least one start

state and at least one end state.

• All ﬂows must start in a start state.

• All ﬂows must ultimately end in an end state.

3.4 Levels of Abstractions

As mentioned, some of the classes are designed to

be instantiated by domain-speciﬁc entities. For ex-

ample, it allows org:SalesPerson to be of type

borm:Person. Then, an instance of a salesperson can

be a particular human being, e.g., John to be of type

org:SalesPerson (which is also owl:Class). The

same principles may be applied to all of our classes.

There are three abstraction levels:

1. Metamodel level = BORM ontology in OWL that

deﬁnes how to deﬁne processes.

2. Model level = BORM model in RDF+OWL that

deﬁnes the processes in an organisation in com-

pliance with BORM ontology.

3. Instance level = BORM model in RDF that cap-

tures instances of processes (e.g. who and when

participated in the process).

Our target in this work is the ﬁrst two levels. How-

ever, the third level is fully supported and can help or-

ganisations track processes, simulate and verify them.

3.5 Hierarchies in BORM

The last missing part of the BORM metamodel re-

lated to BA and OR diagrams is the option to spec-

ify hierarchies of participants and products (used

Representing BORM Process Models using OWL and RDF

173

as data ﬂows). Such hierarchies fall into level 2,

i.e., are part of the model, where it can be ex-

pressed through standard rdfs:subClassOf prop-

erty. For example, org:SalesPerson may have sub-

class org:SalesChiefPerson. Such hierarchies of-

ten exist in domain ontologies, and including a special

one in the ontology would add an additional burden.

4 BORM MODEL IN RDF

This section demonstrates how the ontology can be

used to represent a BORM model in RDF. It uses

one of the default examples of Craft.CASE tool with

E-Shop model. In the following examples, we omit

preﬁxes and other details for the sake of clarity and

brevity. Similarly, the example identiﬁers also do not

use long UUIDs but short names (e.g. fun1).

4.1 Business Architecture

In the BA diagram in Figure 1, four business func-

tions are captured, two external (light grey) and two

internal (dark grey). One internal function has a sin-

gle scenario. In external functions, there are ﬁve sce-

narios linked with various relations. Three of them

have processes (linked OR diagrams). There is the

single top-level individual of borm:Business with

those four functions. The scenarios are linked to the

functions and between themselves. The processes are

linked to scenarios as shown in Source Code 1.

Figure 1: Business Architecture Diagram of E-Shop.

4.2 Participants

Before capturing the knowledge from OR diagrams,

the next step is to describe the participants that are

used across these diagrams. The hierarchy of partic-

ipants may also be included. For the E-Shop case,

Source Code 1: Example of BORM BA in RDF.

:myEShop a borm:Business ;

rdfs:label "My E-Shop Example" ;

borm:hasFunction :f1, :f2, :f3, :f4 ;

:f1 a borm:InternalFunction ;

rdfs:label "Sell Food" ;

rdfs:comment "..." .

:sce2 a borm:Scenario ;

borm:usesScenario :sce1 ;

borm:followedByScenario :sce3 ;

borm:ofFunction :fun1 ;

borm:hasIntitiation :init21 ;

rdfs:label "schedule delivery" ;

rdfs:comment "..." .

there are eight participants with a hierarchy for sup-

pliers as shown in Source Code 2.

Source Code 2: Example of participants in RDF.

:par1 a borm:Participant, owl:Class ;

rdfs:label "Supplier" .

:par2 a borm:Participant ;

rdfs:label "Supermarker Supplier" ;

rdfs:subClassOf :par1 .

4.3 Object Relations

Then for each OR diagram, i.e., a process in terms of

the ontology, roles and their parts with links can be

captured. From the E-Shop example, the update de-

livery (Figure 2) process has been selected. Part of its

RDF representation is shown in Source Code 3. No-

tice that states :st1 and :st4 (start and end states)

do not have to deﬁne label due to the use of the sub-

classes. For the data ﬂow :df1, it would also be pos-

sible to specify the data structure used for the ﬂow.

Figure 2: Object Relations Diagram of E-Shop.

KEOD 2021 - 13th International Conference on Knowledge Engineering and Ontology Development

174

Source Code 3: Example of BORM OR in RDF.

:ro1 a borm:Role ;

borm:startsWith :st1 ;

borm:endsWith :st4 .

:st1 a borm:StartState ;

borm:ofRole :ro1 .

:act1 a borm:Activity ;

borm:ofRole :ro1 ;

rdfs:label "opens website" .

:tr1 a borm:Transition ;

borm:sourceState :st1 ;

borm:targetState :st2 ;

borm:transitsThrough :act1 .

:df1 a borm:DataFlow ;

rdfs:label "Login data" .

:co1 a borm:SynchronousCommunication ;

borm:sourceActivity :act1 ;

borm:targetActivity :act4 ;

borm:hasInputFlow :df1 .

5 EXAMPLE USE CASES

SPARQL as part of the Semantic Web stack (Breit-

man et al., 2010) can be used to efﬁciently query in-

formation from a BORM model in RDF. A business

analyst can have several queries prepared and execute

them with different models. Helpful might be queries

that count certain elements or patterns in the model,

for example, number of activities for each participant

across all processes as shown in Source Code 4. Also

interesting are ASK queries that yield true or false,

for instance, number of communications between two

participants as shown in Source Code 5. It can be even

used to validate the model, a more complex query can

ask if it is valid (does not violate any of the ﬁve con-

straints stated in this paper). DESCRIBE can help to

ﬁnd out more information about a particular entity in

a model, especially if it is linked with other RDF data.

Finally, it can be used to CONSTRUCT new statements

from a model.

As already shown in shorter examples in previ-

ous sections, knowledge from different sources can

be linked to create a more precise domain descrip-

tion. We tried to transform a UML Class Diagram to

OWL according to (Zedlitz et al., 2011) and link it

with an overlapping BORM model in RDF/OWL. An

example for this approach is shown in Source Code 6.

Then, we also experimented with additional ontolo-

gies. In the integration, some of the classes from

UML were identical to participants and data ﬂow en-

Source Code 4: Example of SPARQL query to count activ-

ities for each participant.

SELECT

?p, ?p_label, (count(distinct ?a) as ?cnt)

WHERE {

# PREFIXes

?a rdf:type borm:Activity .

?a borm:ofRole ?r .

?r borm:ofParticipant ?p .

?p rdfs:label ?p_label .

} ORDER BY DESC(?cnt)

Source Code 5: Example of SPARQL query to check if

there is communication from p1 towards p2 in any process.

ASK {

# PREFIXes

:p1 borm:hasRole ?r1 .

?r1 borm:hasElement ?e1 .

:p2 borm:hasRole ?r2 .

?r2 borm:hasElement ?e2 .

?c a borm:Communication .

?c borm:sourceActivity ?e1 .

?c borm:targetActivity ?e2 .

}

tities in BORM. Such a mapping could be done even

semi-automatically with use of natural language pro-

cessing (NLP) methods.

Source Code 6: Example of Linked BORM Model.

# ... common imports

@import borm: http://purl.org/ontoborm

@import m2: https://example.com/my-uml

@import : https://example.com/my-borm

:SalesPerson a borm:Person, owl:Class .

<https://orcid.org/0000-0001-7525-9218>

a borm:Person, m2:Human, foaf:Person ;

rdf:label "John Walker" ;

foaf:name "John Walker" ;

m2:firstName "John" ;

m2:lastName "John" ;

borm:hasRole :role01 .

We managed to implement an export feature in

the OpenPonk modelling platform for BORM models

with the proposed RDF representation. It plainly cre-

ates XML as a serialisation of the model. However,

there were two limitations encountered with Open-

Ponk. First, there is a lack of support of RDF in Pharo,

limiting the use of RDF/XML format. Second, the

current implementation of BORM in OpenPonk sup-

ports only OR; therefore, on import, the BA part is ig-

nored. Nevertheless, it enables the use of OpenPonk

to visualise OR diagrams from BORM in RDF.

Representing BORM Process Models using OWL and RDF

175

6 DISCUSSION

The BORM ontology is published with standard

metadata and is ready to be used and enhanced in

the future. A community of adopters can manage

such contributions. Eventually, a new version may

be released with suggested ways of transforming the

underlying models. The resulting ontology is classi-

ﬁed to be valid by Prot

e (Musen, 2015) as well as

the reasoners HermiT (1.3.8) and Apache Jena (4.1.0)

used during the development. The ontology does not

have any signiﬁcant issues in terms of quality assess-

ment (Mc Gurk et al., 2017) of completeness, accu-

racy, understandability, compliance, availability and

consistency. It has been achieved by applying the best

practices during the development; however, the on-

tology must retain its quality when changed by vari-

ous contributors. That is supported by set contribution

rules and reviewing process.

The ultimate goal of promoting interoperability

for BORM models has been achieved and demon-

strated in the previous section. All entities in the RDF

representation of a BORM model may have identiﬁers

through which can be referenced. These references

are internal, e.g., a participant in multiple processes

can be identiﬁed as one entity. However, it can also

be external; one may add more statements about an

entity as shown for participants and particular people.

Finally, having BORM in RDF allows various tooling

designs for RDF and OWL.

Although interoperability was the primary objec-

tive of this work, the use of RDF and OWL to repre-

sent BORM models also improved model (and busi-

ness process) analysis possibilities. As shown in the

example use cases, SPARQL can be used to extract

speciﬁc knowledge. For example, how many pro-

cesses the participant has a role if there is any commu-

nication between two participants in the whole busi-

ness, or the most complex process by counting states

and transitions. With RDF, it is also possible to look

for similarities across processes in order to eliminate

duplicity and, as part of optimization, add a com-

mon sub-process. The BORM models in RDF can

be validated in the same manner as is described by

Natschl

ager (Natschl

ager, 2011) for BPMN 2.0 or

queried as Wei and Sun (Wei and Sun, 2021) pro-

poses for UML. The validation can also be done us-

ing a more modern approach with SHACL and ShEx

shape expressions. Finally, semantic reasoners can be

used to infer new statements of a model, for instance,

concerning class hierarchies.

Future work can focus both on managing BORM

models in RDF in terms of linking, querying, or eval-

uating its quality. In terms of development, other

import and export feature for Craft.CASE and Open-

CABE formats would be helpful for historical models

in addition to our support in OpenPonk (as an open-

source and actively developed tool). The RDF rep-

resentation and use of the OpenPonk modelling plat-

form should streamline prototyping of such improve-

ments and their subsequent reﬁning.

7 CONCLUSIONS

In this paper, the BORM ontology has been pro-

posed to promote the interoperability of BORM pro-

cess models. The ontology is designed according to

the metamodel of BORM; more speciﬁcally, its part

related to business process modelling. Standard on-

tology metadata and documentation has been used to

improve its practical usability. It has been also de-

scribed how business processes can be represented in

RDF by using the ontology—representing the knowl-

edge from Object Relation and Business Architecture

diagrams using RDF proven to open multiple pos-

sibilities for business analysis. The primary advan-

tage lies in the ability to link to other domain knowl-

edge in a linked data way. Moreover, other conse-

quential advantages are discussed in the paper, e.g.,

using SPARQL to extract speciﬁc information from

BORM models or visualization. Finally, possible fu-

ture steps are outlined, mainly providing BORM-like

visualization of the diagrams and transformation for

Craft.CASE project format in addition to our RDF ex-

port from OpenPonk modelling tool.

ACKNOWLEDGEMENTS

The research was supported by the grant

of Czech Technical University in Prague

No. SGS20/209/OHK3/3T/18.

REFERENCES

Bliznicenko, J., Papoulias, N., Pergl, R., and Stinckwich, S.

(2017). Towards modularity in live visual modeling:

A case study with openponk and kendrick. In Laval, J.

and Etien, A., editors, Proceedings of the 12th edition

of the International Workshop on Smalltalk Technolo-

gies, IWST 2017, Maribor, Slovenia, September 4-8,

2017, pages 3:1–3:10. ACM.

Breitman, K., Casanova, M., and Truszkowski, W. (2010).

Semantic Web: Concepts, Technologies and Applica-

tions. NASA Monographs in Systems and Software

Engineering. Springer London.

KEOD 2021 - 13th International Conference on Knowledge Engineering and Ontology Development

176

CRAFT.CASE Ltd. (2015). Craft.CASE: Business Process

Analysis, version 2.4.18.1. [online][visited 2021-06-

05].

Garanina, N. O., Anureev, I. S., and Borovikova, O. (2019).

Veriﬁcation-oriented process ontology. Autom. Con-

trol. Comput. Sci., 53(7):584–594.

Kchaou, M., Khlif, W., Gargouri, F., and Mahfoudh, M.

(2021). Transformation of BPMN model into an

OWL2 ontology. In Ali, R., Kaindl, H., and Ma-

ciaszek, L. A., editors, Proceedings of the 16th In-

ternational Conference on Evaluation of Novel Ap-

proaches to Software Engineering, ENASE 2021, On-

line Streaming, April 26-27, 2021, pages 380–388.

SCITEPRESS.

Knott, R. P., Merunka, V., and Pol

ak, J. (2000). Process

modeling for object oriented analysis using BORM

object behavioral analysis. In Proceedings of the 4th

International Conference on Requirements Engineer-

ing, ICRE ’00, Schaumburg, Illinois, USA, June 19-

23, 2000, pages 7–16. IEEE Computer Society.

Mc Gurk, S., Abela, C., and Debattista, J. (2017). Towards

ontology quality assessment. In MEPDaW/LDQ@

ESWC, pages 94–106.

Merunka, V., Brozek, J., Sebek, M., and Pol

ak, J. (2009).

BORM - business object relation modeling. In Nicker-

son, R. C. and Sharda, R., editors, Proceedings of the

15th Americas Conference on Information Systems,

AMCIS 2009, San Francisco, California, USA, August

6-9, 2009, page 788. Association for Information Sys-

tems.

Molhanec, M., Merunka, V., and Merunkov

a, I. (2011).

Business knowledge modelling using the BORM

method. In Salampasis, M. and Matopoulos, A., ed-

itors, Proceedings of the 5th International Confer-

ence on Information and Communication Technolo-

gies for Sustainable Agri-production and Environment

(HAICTA 2011), Skiathos, Greece, September 8-11,

2011, volume 1152 of CEUR Workshop Proceedings,

pages 385–396. CEUR-WS.org.

Musen, M. A. (2015). The Prot

e Project: A Look Back

and a Look Forward. AI Matters, 1(4):4–12.

Natschl

ager, C. (2011). Towards a BPMN 2.0 ontology. In

Dijkman, R. M., Hofstetter, J., and Koehler, J., edi-

tors, Business Process Model and Notation - Third In-

ternational Workshop, BPMN 2011, Lucerne, Switzer-

land, November 21-22, 2011. Proceedings, volume 95

of Lecture Notes in Business Information Processing,

pages 1–15. Springer.

Pergl, R. and Tuma, J. (2012). Opencase - A tool for

ontology-centred conceptual modelling. In Bajec, M.

and Eder, J., editors, Advanced Information Systems

Engineering Workshops - CAiSE 2012 International

Workshops, Gda

nsk, Poland, June 25-26, 2012. Pro-

ceedings, volume 112 of Lecture Notes in Business

Information Processing, pages 511–518. Springer.

Podlouck

y, M. and Pergl, R. (2014). Towards formal foun-

dations for BORM ORD validation and simulation. In

Hammoudi, S., Maciaszek, L. A., and Cordeiro, J.,

editors, ICEIS 2014 - Proceedings of the 16th Interna-

tional Conference on Enterprise Information Systems,

Volume 2, Lisbon, Portugal, 27-30 April, 2014, pages

315–322. SciTePress.

Powers, S. (2007). Practical RDF. O’Reilly Media.

Scholz-Reiter, B. and Stickel, E. (2012). Business Process

Modelling. Springer Berlin Heidelberg.

Such

anek, M. and Pergl, R. (2019). Mapping UFO-B to

bpmn, borm, and UML activity diagram. In Pergl, R.,

Babkin, E., Lock, R., Malyzhenkov, P., and Merunka,

V., editors, Enterprise and Organizational Modeling

and Simulation - 15th International Workshop, EO-

MAS 2019, Held at CAiSE 2019, Rome, Italy, June

3-4, 2019, Selected Papers, volume 366 of Lecture

Notes in Business Information Processing, pages 82–

98. Springer.

Uhn

ak, P. and Pergl, R. (2016). The openponk modeling

platform. In Laval, J. and Etien, A., editors, Proceed-

ings of the 11th edition of the International Workshop

on Smalltalk Technologies, IWST 2016, Prague, Czech

Republic, August 23-24, 2016, page 14. ACM.

von Rosing, M., Laurier, W., and Polovina, S. M. (2015).

The BPM ontology. In von Rosing, M., von Scheel,

H., and Scheer, A., editors, The Complete Business

Process Handbook: Body of Knowledge from Process

Modeling to BPM, Volume I, pages 101–121. Morgan

Kaufmann/Elsevier.

Wei, B. and Sun, J. (2021). Leveraging SPARQL queries for

UML consistency checking. Int. J. Softw. Eng. Knowl.

Eng., 31(4):635–654.

Wei, B., Sun, J., and Wang, Y. (2018). A knowledge en-

gineering approach to UML modeling. In Pereira,

O. M., editor, The 30th International Conference

on Software Engineering and Knowledge Engineer-

ing, Hotel Pullman, Redwood City, California, USA,

July 1-3, 2018, pages 60–63. KSI Research Inc. and

Knowledge Systems Institute Graduate School.

Zedlitz, J., J

orke, J., and Luttenberger, N. (2011). From

UML to OWL 2. In Lukose, D., Ahmad, A. R.,

and Suliman, A., editors, Knowledge Technology -

Third Knowledge Technology Week, KTW 2011, Ka-

jang, Malaysia, July 18-22, 2011. Revised Selected

Papers, volume 295 of Communications in Computer

and Information Science, pages 154–163. Springer.

Representing BORM Process Models using OWL and RDF

177