Reuse of Semantic Business Process Patterns

Lobna Makni

, Nahla Zaaboub

and Hanene Ben-Abdallah

Mir@cl Laboratory, Faculty of Economic Sciences and Management, Sfax University, Sfax, Tunisia

Faculty of Computing and Information Technology, King Abdullaziz University, Jeddah, K.S.A.

Keywords:

Reuse, SB2P Repository, Search Method, Business Object, Instantiation Operator.

Abstract:

Reusing business process artefacts, in business process modelling, can accelerate the design activity and im-

prove the quality of the resulting products. Among the variety of reusable artefact types proposed during the

last decade, Semantic Business Process Pattern (SB2P) offers business patterns that encapsulate knowledge

and expertise in a particular domain. The reuse of a SB2P provides for the adoption of commonly used prac-

tices while offering guidance on possible variations. This paper proposes a reuse method that assists a business

process designer, ﬁrst, in retrieving an appropriate SB2P from a repository, and then adapting it through a set

of instantiation operators to meet its speciﬁc requirements. The retrieval method relies on both semantic and

behavioural information encapsulated in the SB2P. In addition, the instantiation operators ensure the deriva-

tion of a business process design that respects a set of quality metrics. The reuse method is illustrated through

an example.

1 INTRODUCTION

The advent of reuse oriented modelling in BPM led

to the proposition of several reusable artefact types.

The various reusable artefacts (Haddar et al., 2012)

rely on proven practices and solutions to provide for

assistance in designing high quality business process

models while reducing the designer costs.

The beneﬁts of reuse in PAISs (Process Aware In-

formation Systems) are widely accepted in theory and

practice (Fettke and Loos, 2003). In fact, designing

high quality process models from scratch is often time

consuming, error-prone and costly (Indulska et al.,

2009). In the last decade, a variety of reusable arte-

facts are proposed in the literature. Recently, (Makni

et al., 2011) propose a new pattern concept called Se-

mantic Business Process Pattern (SB2P). A SB2P is a

pattern synthesized from a set of process models be-

longing to the same business domain. It is composed

of process fragments that are semantically common

among this set of process models. A SB2P is intended

to accelerate the design process by providing the de-

signer with a business process model skeleton con-

taining all mandatory activities and some conﬁgurable

ones (Haddar et al., 2012). It is automatically gener-

ated from a reduced set of business process models

belonging to the same domain. SB2Ps are stored in

a pattern repository organized according to business

domains. The size of the SB2P repository can be im-

portant since many SB2Ps may be generated for the

same domain.

Given a repository of SB2Ps, a designer would

need a means, ﬁrst, to retrieve the SB2P that cov-

ers his/her business requirements and, secondly, to in-

stantiate a retrieved pattern to model his/her business

needs in order to accelerate the design process and

ameliorate the quality of the resulting process mod-

els. Existing business process retrieval methods use

query languages (Awad, 2007), (Choi et al., 2007),

(Jin et al., 2010) based on the control-ﬂow perspec-

tive; the remaining aspects of a business process like

data is, however, ignored. In addition, querying re-

quires a good knowledge of the querying language.

Furthermore, the so-far proposed instantiation opera-

tors (La Rosa et al., 2013), like add/remove a node,

are generic operators intended for model evolution,

and they do not explicitly analyse their effects on the

model quality.

In this work, we contribute to business process

modelling by assisting in the reuse of SB2Ps. More

speciﬁcally, we propose a retrieval method for query-

ing SB2Ps based on the data of business processes.

In addition, we propose a set of instantiation opera-

tors applicable under constraints that accounts for the

quality of the derived business process model.

The rest of the paper is organized as follows: Section

Makni L., Zaaboub N. and Ben-Abdallah H..

Reuse of Semantic Business Process Patterns.

DOI: 10.5220/0005003500360047

In Proceedings of the 9th International Conference on Software Engineering and Applications (ICSOFT-EA-2014), pages 36-47

ISBN: 978-989-758-036-9

 2014 SCITEPRESS (Science and Technology Publications, Lda.)

2 positions our research in the light of related works.

Section 3 reviews the SB2P concept through an ex-

ample. Section 4 presents a SB2P retrieval method

based on the data aspect. Section 5 presents a set of

instantiation operators to adapt a SB2P to meet a de-

signer’s requirements. Section 6 summarizes the pre-

sented work and highlights its extensions.

2 RELATED WORK

Several solutions have been investigated to support

the reuse of business process models. We classify

these solutions into two categories: (i) reusable busi-

ness process artefact retrieval and (ii) adaptation of

reusable artefacts.

2.1 Reusable Business Process Artefact

Retrieval

Mindful of the importance of query languages for

business process models, the Business Process Man-

agement Initiative (BPMI) proposed to deﬁne a stan-

dard business process model query language in 2004.

However, no standard has been published so far. Sev-

eral approaches were proposed to express and execute

queries over a collection of business process models

(Beeri et al., 2008), (Awad and Sakr, 2012), (Jin et al.,

2011), (ter Hofstede et al., 2013). They are classi-

ﬁed into two main categories. The ﬁrst category en-

ables the formulation of a query as a business process

model fragment (Jin et al., 2010), (Choi et al., 2007),

(Jin et al., 2011), (ter Hofstede et al., 2013). Its aim is

to identify all models in a repository, that contain the

query fragment by detecting similar activity labels us-

ing only the equivalence semantic relation.

On the other hand, the second category pro-

vides speciﬁc constructs for expressing process model

queries like existence or absence of paths between

activities (Beeri et al., 2008), (Awad and Sakr,

2012). We cite, for example, the graphical query lan-

guage called BPMN-Q (Business Process Modelling

Notation-Query) proposed by (Awad and Sakr, 2012).

It is a visual and graphical query language which can

be used for querying a repository of process models

modelled with BPMN standard. It extends BPMN

notation with seven additional constructs e.g., generic

join to present the query purpose. It allows represent-

ing a structural BPMN queries and speciﬁes whether

a given process model is syntactically similar to a

query (Awad, 2007), (Awad et al., 2008). In addition,

queries can be formulated using control-ﬂow aspect

of process model in (Awad and Sakr, 2012), (Choi

et al., 2007) (Jin et al., 2010), (Jin et al., 2011). Other

aspects are treated, only in (Choi et al., 2007), like re-

sources, process goal.

The execution of a query on a collection of pro-

cess models can be handled in one of two ways: 1) by

translating the query to SQL (Awad, 2007) or XML

standard (Choi et al., 2007), (Beeri et al., 2008) or 2)

by using the sub-graph isomorphism algorithms (Jin

et al., 2010). In this second case, indexes can also

be used to speed up the query execution (Jin et al.,

2013).

Note that there are other techniques available, in

the literature, which can be useful for querying pro-

cess model repositories like VisTrails and WISE sys-

tems. The VisTrails system (Scheidegger et al., 2008)

allows users to query workﬂow by example and to re-

ﬁne workﬂows by analogies. The workﬂow engine

WISE (Shao et al., 2009) returns the most speciﬁc

workﬂow hierarchies containing matching keywords.

Overall, the proposed query languages proposed

in the literature focus only on control-ﬂow aspect of

business process and ignores other process aspect like

data. In this paper, we propose a new method to

retrieve a SB2P like BPMN process model from a

repository of patterns using the semantic (business

object), behavioural (causality and concurrency rela-

tions) and hybrid (combination of semantic and be-

havioural) criteria on the basis of textual query.

2.2 Adaptation of Reusable Artefacts

When creating business process models, one of the

fundamental challenges the process designer faces is

to cope with the adaptation of reusable artefacts which

are complex and of coarse granularity such as refer-

ence models. Indeed, a reference model has a recom-

mending character, covers a family of process mod-

els, and can be customized in different ways accord-

ing to the designer requirements. Several approaches

have been proposed in the literature to adapt reference

models through conﬁguration (Rosa, 2009), (Rose-

mann and van der Aalst, 2007), (Gottschalk et al.,

2008). They are classiﬁed into two main categories.

The ﬁrst category is based on behaviour by extending

the existing process modelling language. In this con-

text, conﬁgurable process models have been devel-

oped to make reuse of reference process models with

managing business process variability (Rosa et al.,

2009), (Rosa, 2009). For example, Conﬁgurable-

Event Process Chain (C-EPC) provides a support to

customize reference models where EPC functions can

be annotated. The annotation provides the informa-

tion that these functions are mandatory or optional

(Rosemann and van der Aalst, 2007), (Rosa et al.,

2007).

ReuseofSemanticBusinessProcessPatterns

In addition, (Gottschalk et al., 2008) propose an

approach for conﬁguring workﬂow models by en-

abling, hiding or blocking some conﬁgurable work-

ﬂow elements. These approaches allow to deﬁne re-

quirements over the conﬁguration alternative that may

be chosen. They neither are allowed to move or

add model elements nor to adapt element attributes

when conﬁguring a variant. So, requirements do not

prescribe mandatory constraints, but serve as recom-

mendations (i.e., two activities either may have to be

deleted together from the reference process or none

of them). The second category of approaches is based

on structure through adaptation patterns. The adap-

tation depends on concrete designer requirements by

applying a set of change operations. Weber et al. (We-

ber et al., 2008) provide a comprehensive overview

of possible adaptation patterns that can occur when

process models are modiﬁed. An adaptation pattern

represent generic operations which can be applied on

any process model. It enables structural changes of

process schemes. For example, AP1 (AP2) allows

inserting (deleting) a process fragment in a process

model. The Provop proposal follows this approach

(Hallerbach et al., 2010). It provides advanced tool

support for adapting a base process and for ensuring

syntactical and semantical correctness of derived pro-

cess variants (Hallerbach et al., 2010).

3 OVERVIEW OF THE SB2P

CONCEPT

A SB2P is a pattern synthesized from a set of business

process models belonging to the same business do-

main (Makni et al., 2010). Informally, it is composed

of process fragments semantically common among

the source models.

These fragments may have different structural

and/or behavioural representations in the original

models; the SB2P factorizes these constructs into

a form that preserves the semantics of these frag-

ments. It is intended to accelerate the design pro-

cess by providing the designer with a business pro-

cess model skeleton containing all mandatory activi-

ties and some conﬁgurable ones. Mandatory activities

are recurrent and equivalent activities shared between

the source models (e.g., ”revaluation at actual price”,

”WIP calculation”). Together with their associated

control-ﬂow, they constitute the backbone of the pat-

tern and have to be present in any business process

model derived from this SB2P. For this reason, they

are coloured pink to highlight their importance to the

designer in the sense when removing one of these ac-

tivities from the pattern it may change its semantics

and corrupt the process behaviour. Also, they play

the role of milestones, between which there are vari-

ation points. We illustrate the SB2P concept by the

example of ﬁgure 1-a which shows a pattern automat-

ically constructed from two business process models

choosen among the SAP reference models (Keller and

Teufel, 1998). These models are from the domain of

cost accounting which computes the costs incurred

in the production of company activities (e.g., inter-

nally manufactured materials) in order to make com-

plex cost analysis.

In a SB2P, there are also variation points. A varia-

tion point is a precise position within a SB2P that ad-

mits different structural representations in the source

models. For example, we can found a unit of work

represented in one process model by a single activ-

ity (e.g., ”manufacturing order overhead calculation”)

but the same unit of work is represented by a pro-

cess fragment composed of a collection of activities

(e.g., ”cost object overhead calculation” and ”product

cost collector overhead calculation”) in the other pro-

cess model. These structural differences are extracted

from the source models during the SB2P construction

process. They are stored in a database and are linked

to their corresponding variation point. So, a variation

point have multiple variants and a decision needs to be

taken on which variant to use when instantiating the

SB2P. For example, in ﬁgure 1-a the variation point

C can be instantiated with one of the two fragments

PF1 and PF2 of ﬁgure 1-b. PF1 and PF2 were ex-

tracted from the source models during the SB2P con-

struction process. Once all the variation points have

been treated, the SB2P becomes a derived business

process model.

In a SB2P, a variation point can be a:

• Reﬁned Activity: It stands for a unit of work

which may be represented by a process fragment

which subsumes and reﬁnes it. In the pattern, the

reﬁned activity is represented as an annotated and

empty sub-process. The annotation contains a list

of reﬁning fragments. When instantiating the pat-

tern, the designer can either keep the activity as a

single unit, or reﬁne it into one of its annotating

process fragments.

• Decomposable Activity: It stands for a unit of

work which may be represented by a process frag-

ment which partly-corresponds and decomposes

the decomposable activity. In a SB2P, the decom-

posable activity is represented as an annotated and

empty sub-process. The annotation contains a list

of component fragments. When instantiating the

pattern, the designer can either keep the activity

as a single unit, or decompose it into one of its

annotating process fragments.

ICSOFT-EA2014-9thInternationalConferenceonSoftwareEngineeringandApplications

Figure 1: An example of SB2P for the cost accounting process.

• Skipped Activity: It is a silent activity without

added value. In the pattern, it is an optional ac-

tivity and is represented as an annotated empty

activity. When instantiating the pattern, the de-

signer can insert into or delete a skipped activity,

or insert in it one of its annotating process frag-

ments.

• Conﬁgurable Connector: It is a generic connec-

tor. It subsumes possible build time connectors

that are less or equally expressive. It is anno-

tated (e.g. conﬁgurable OR, AND or XOR) and

coloured black to differentiate it from other con-

nectors in the pattern. It can have several variants

(AND, XOR, OR) depending on its type.

As a SB2P resembles a business process model,

its formal deﬁnition is also close to that of business

process models. However , to consider variation

points, we add a fourth one, the conﬁgurable con-

nector. Also, we deﬁne the function F

re f

which

assigns process fragments to reﬁnable activities.

decomp

is a function that assigns process fragments

to decomposable activities. F

skip

is a function that

assigns process fragments to skipped activities.

To give a formal deﬁnition of a SB2P, we start

with deﬁning a process fragment.

Deﬁnition 1 (Process-fragment): A process frag-

ment is a tuple (O, A, G, F) where:

• O is a set of objects partitioned into a disjoint sets

A of non-empty activities (task or sub-process)

and gateways G.

• F ⊆ O × O is the control-ﬂow relation between

objects.

Deﬁnition 2 (SB2P): A SB2P is a tuple

(O, A, E, G, F, F

re f

, F

decomp

, F

skip

) where:

• O = A ∪ E ∪ G is a set of objects partitioned into

disjoint sets of activities A, events E, and gate-

ways G; A = A

∪ A

∪ S is the set of activities

partitioned into a non-empty set of mandatory ac-

tivities A

, A

a set of skipped activities and a set

of sub-processes S; G = G

∪ G

is a set of gateways partitioned into disjoint sets of

parallel fork gateways G

, parallel join gateways

, XOR decision gateways G

, XOR merge

gateways G

and conﬁgurable gateways G

• F ⊆ O × O is the control-ﬂow relation used to

deﬁne process fragments, i.e., a set of sequence

ﬂows connecting objects.

• F

re f

: S → P (T ∪ Fg) where S is the set of sub-

processes and P (T ∪ Fg) denotes the power-set

of tasks T and process fragments F. For sp ∈ S

and t ∈ P (T ∪ Fg), F

re f

(sp) = t means that each

element of t reﬁnes sp.

• F

decomp

: S → P (T ∪ Fg). For sp ∈ S and t ∈

P (T ∪ Fg), F

decomp

(sp) = t means that each el-

ement of t is a component of sp.

• F

skip

: A

→ P (T ∪ Fg). For each sk ∈ A

and t ∈

P (T ∪ Fg), F

skip

(sk) = t means that each element

of t can replace sk.

ReuseofSemanticBusinessProcessPatterns

4 SB2P RETRIEVAL METHOD

As mentioned in Section 2, the various query lan-

guages to search for reusable business process arte-

facts (Awad and Sakr, 2012), (Beeri et al., 2008), (Jin

et al., 2011), (ter Hofstede et al., 2013) do not ac-

count for the data aspect. To overcome this shortage,

we propose a search method that exploits the business

objects which model the data aspect. Before introduc-

ing our method, we ﬁrst deﬁne the SB2P repository

structure.

4.1 SB2P Repository

Figure 2 shows the conceptual model of a SB2P

repository which is an extension of the UML meta-

model of BPMN (OMG, 2013). Note that SB2Ps

(class Pattern) and BPMN business processes (class

Process) are quite similar because both are composed

of activities, events and gateways which are related by

sequence ﬂows. So, the extending elements concern

the domain and the variation points. In fact, SB2Ps

are organized by domain. Each SB2P is composed of

a set of nodes. A node can be an event, a gateway

or an activity. A gateway may be ”OR”, ”AND” or

”XOR”. An activity is characterized by a label and

acts on an data object. We also characterise an activ-

ity by its type. Indeed, an activity, in a SB2P, is either

mandatory or conﬁgurable. A conﬁgurable activity

is a variation point in a SB2P on which the designer

can introduce some modiﬁcations (i.e. by applying

instantiation operators (see section 5) to imitate the

pattern according to his/her requirements. It can be

reﬁned, extended (have additional dependency) or de-

composed. An activity, in a SB2P, is related to one

or more activities. The type of behavioural relation-

ship is either causal (means that an activity follows

the other) or parallel.

To improve the efﬁciency of SB2Ps retrieval

within the repository, we deﬁne two inverted indexes,

namely, the activity index ActIndex and the busi-

ness object index BOIndex. The business object in-

dex implements the association between the classes

Pattern Acitivity and DataObject in the UML meta-

model of ﬁgure 2. The business object index takes

the form of set of pairs (business object; activity list)

where business object denotes the object appearing in

some activity labels and activity list denotes the set

of these activities. When a new pattern is added to

the SB2P repository, all the activity labels can be ex-

tracted, and then the business object index can be up-

dated.

On the other hand, the activity index implements

the association between the classes Pattern Acitivity

and Activity in the UML meta-model of ﬁgure 2. The

activity index takes the form of set of pairs (activity;

pattern list) where activity denotes an activity occur-

ring in some patterns and pattern list denotes the set

of these patterns. Given a pattern, we ﬁrst extract all

its activities. The extraction algorithm takes linear

time in terms of the number of activities of the pat-

tern. Then, the mapping between the activities and

the patterns is updated in the activity index.

4.2 Search Methods

Our search method is based on three criteria which are

the semantic, the behavioural and the hybrid (combi-

nation of the two cited criteria) one.

4.2.1 Semantic Search

The SB2P semantics is coded in its activities’ labels.

The label of an activity deﬁnes the role of the activity

in the process pattern and the type of business objects

on which they act. Thus, we propose to exploit ac-

tivity labels and especially business objects to make

semantic search. Indeed, a business object refers to

a concept from the enterprise business domain. It

describes an entity manipulated by the activities and

therefore by the business actors. Therefore, a search

method based on business objects allows an accurate

query of the SB2Ps repository according to semantic

criteria.

Our method extracts patterns which contain ac-

tivities acting on business objects whose names are

introduced by the designer in the query. A query is

a predicate composed of business objects and semi-

colons which replace the logical operator ’and’.

Semantic criteria based on business objects can

improve research results. In fact, they allow the de-

tection of all activities acting on the business object

without the need to make neither calculi of similar-

ity between activity labels nor thresholds to compare

results. Moreover, we can detect not only equivalent

business objects but also other semantic relationships

like hyponymy and hypernymy in order to enlarge our

research results. In addition, using business objects

as search criteria accelerates the search process be-

cause the number of business objects is smaller than

the number of activities in the organization. In addi-

tion, the use of indexes on business objects accelerates

and make the search ore efﬁcient.

To compare business objects, we need a business

domain speciﬁc ontology. In our study, we construct

a Business Object ONtology (BOON) which offers

a reference terminology that deﬁnes semantic corre-

spondences between business objects. The BOON

has a WordNet like conceptual schema an a logical

ICSOFT-EA2014-9thInternationalConferenceonSoftwareEngineeringandApplications

Figure 2: Conceptual model of SB2P repository.

reasoning. But, it is domain speciﬁc and it takes

into consideration synonymy, hyponymy, hypernymy,

meronymy and holonymy relations. Further, unlike

WordNet, it accepts composed nouns like ”manufac-

turing order”. For example, using the BOON, we

can detect that in the manufacturing domain the busi-

ness object ”manufacturing order” is equivalent to the

business object ”Order”.

The query is answered via a set of resolution

phases. The ﬁrst phase consists in scanning the busi-

ness object index to check whether the in-putted BO

name is associated with any SB2P. If the search leads

to one or more SB2P(s) in the result, we show the de-

tected patterns to the designer. Otherwise, we carry

on with the search within the business objects derived

from the in-putted one using synonymy, subsumption

and part-of semantic relationships. If all phases fail,

the query processing is terminated with no match.

Procedure SemanticSearch (Pattern[] SB2Ps,

DataObject BO, Pattern[] ResultP)

i, j, k: integer

SynBO, SubBO, PartBO: DataObject[]

Begin

if (BO in BOIndex) then

ResultP = list of patterns associated to BO

else

SynBO <- getSynonym(BO)

For i=1 to |SynBO|

{

if (SynBO(i) in BOIndex) then

ResultP=list of patterns associated to BO

}

SubBO <- getSubsumption(BO)

For j=1 to |SubBO|

{

if (SubBO(j) in BOIndex) then

ResultP=list of patterns associated to BO

}

PartBO <- getMeronym(BO)

For k=1 to |PartBO|

{

if (PartBO(k) in BOIndex) then

ResultP=list of patterns associated to BO

}

EndIf

End.

We have developed a tool, called ’SB2P Reuse

Tool’, which automates our SB2P search method.

’SB2P Reuse Tool’ is a plug-in integrated in the Oryx

platform (Oryx-Editor, 2010). To search for a pattern,

the user starts with entering the domain of the pat-

tern. Then, he gives a key word like query by spec-

ifying a list of business objects separated by semi-

colons. Figure 3 represents the result of the execu-

tion of the query ”manufacturing order” in the man-

ufacturing domain. In this ﬁgure, we see that there

are four patterns (oryx-canvas 120, oryx-canvas 103,

etc.) in the repository which use the ”manufacturing

order” business object. The designer clicks on the but-

ton ’Show’ in front of each pattern to show it.

Semantic search using business objects is efﬁcient

and not complex, because the number of business ob-

jects of a given domain is not high. Moreover, it is of

great help for the designer since he/she can put a syn-

onym, a subsuming or a component business object in

the query. Using business objects as search criterion

can be also adopted for searching for speciﬁc models

within repositories of business process models.

However, a query restricted to expressing business

objects is not always sufﬁcient. In fact, one may need

to express behavioural relationships between activi-

ties in a query like causality or concurrency to de-

ﬁne the context within which some activities should

be performed in the desired pattern. For this reason,

we add in the next section behavioural criteria to our

search method.

4.2.2 Behavioural Search

The SB2P notation presents a behavioural description

of business processes through control-ﬂow represen-

tation. A SB2P can be regarded as a graph. So, it

represents the order in which activities are performed

during the execution of the process. When we search

ReuseofSemanticBusinessProcessPatterns

Figure 3: Semantic search.

for a SB2P in the repository, we sometimes want to

express a behavioural relationship between activities

like causality or concurrency. In this paper, we con-

centrate on these two relationships because these are

the most important behavioural operators. So, we

start with deﬁning them:

• Causality: Two activities A and B in a SB2P are in

causal relation, if the graph of the SB2P contains

a path with at least one arc leading from A to B

(A precedes B).

• Concurrency: Two activities A and B are in con-

currency relation, if they are not causally related

and they have a common ancestor which must be

a parallel connector (A is in parallel with B).

These basic behavioural operators are sufﬁcient to

express behavioural search criteria. In fact, the SB2P

subsumes the behaviour of a great number of mod-

els. So, we don’t need to express sharp behavioural

queries. To answer a behavioural query, we deﬁne the

function behavSearch() which takes as input two ac-

tivity labels and a behavioural criterion (0 for Causal-

ity and 1 for Concurrency). It returns an array of

all patterns of the repository satisfying the in-putted

query.

On the other hand, we adopt the approach pro-

posed by (Jin et al., 2011) to detect behavioural re-

lations between activities. This approach is based on

two phases: extraction of behavioural relations and

building indexes on behavioural relationships. We

can check whether a task can be executed (parallel

or causal) by traversing all the transitions in the pat-

tern. We develop the following algorithm ExtC to

detect causal relations between pairs of activities in

the SB2P. This algorithm consists in a procedure that

takes as input the SB2P pattern and its activities. The

purpose of this procedure is to extract behavioural

causal relationships between each pair of activities in

a SB2P.

Procedure ExtC (Pattern p, Pattern_Activity[]a)

i: integer

NodeSucc: Pattern_Activity

Begin

For{i = 1 to |a|}{

NodeSucc <- getSucc(a[i])

Causality(p,a[i] ,NodeSucc)

}

End.

Then, we can update the inverted index ActIndex.

Every entry of the index is composed of a pair of

activities, a character that indicates the type of be-

havioural relation between them and the list of pattern

where the activities appear and satisfy the indicated

relationship. We choose the character ’S’ for causal-

ity and ’C’ for concurrency. The following algorithm

of the procedure Causality stores the causality (’S’)

behavioural relationship.

Procedure Causality(Pattern p,Pattern_Activity

node, Pattern_Activity

succNode)

i, j: integer

NodeSucc: Pattern_Activity[]

Begin

If(node ofType Activity)

{

If(succNode ofType Activity)

{

updateActIndex((node, succNode,’S’),p)

}

else

{

NodeSucc <- getSucc(succNode)

For(j = 1 to |NodeSucc|){

Causality(p,node,NodeSucc[j])

}

End.

The complexity of the algorithm ExtC is calcu-

lated in the worst case on the basis of the loop and

the nested recursive call of the procedure causality().

Thus, the complexity of the algorithm is O(n

To detect concurrency relationships between ac-

tivities in the SB2P, we deﬁne the procedure

ExtConcurrency. This latter detects all pairs of ac-

tivities in the pattern which have a parallel connector

(AND) as a common ancestor.

Procedure ExtConcurrency (Pattern p,

Pattern_Activity[] a)

i, j: integer

Begin

For(i = 1 to |a|-1)

ICSOFT-EA2014-9thInternationalConferenceonSoftwareEngineeringandApplications

{

For{j = i+1 to |a|)

{

If(a[i]!=a[j])

{

If(commonAncestor(a[i], a[j],p)

{

updateActIndex((a[i], a[j],’C’),p)

}

End.

When a new pattern is added to the repository, all

behavioural relations are extracted and inserted into

the index. It is easy to see that the index can be up-

dated incrementally. When a pattern is deleted from

the repository, we delete it from all inverted index en-

tries.

4.2.3 Hybrid Search

The hybrid search combines the semantic and be-

havioural search methods. It is conducted according

to the following algorithm:

Function Hybrid (String label1, String label2,

integer behavRel):Pattern[]

p: Pattern[]

DLabel1, DLabel2: String[]

Begin

p <- behavSearch (label1,

label2, behavRel)

If ( p is not null)

Then return p

Else {

DLabel1 <- getSyn(label1)+

getSub(label1)+getPart(label1)

D2Label2 <- getSyn(label2)+

getSub(label2)+getPart(label2)

For i = 1 to |DLabel1| {

For j = 1 to |DLabel2|{

p <- behavSearch(DLabel1[i],

DLabel2[j], behavRel)

If ( p is not null)

Then return p

}

return p

End.

The idea behind this algorithm is to enlarge our

search by deriving behavioural queries from the in-

troduced one. The function Hybrid takes as input a

pair of activity labels label1 and label2 and the be-

havioural relation behaveRel between them and re-

turns the list of patterns containing these activities

related by the in-putted behavioural relationship or

other derived relationships. First, it checks if the be-

havioural search BehavSearch leads to one or more

Figure 4: Hybrid search.

results. If not, it calls the functions getSyn() to get

synonyms, getsub() to derive hypernyms, hyponyms

and getPart() to have holonyms and meronyms from

label1 and label2. The derived labels are obtained by

applying the Semantic rules proposed in (Makni et al.,

2012). They are based on the comparison of actions

and business objects of the activity labels.

Figure 4 shows the result of the query deﬁned in

the text box devoted to the query speciﬁcation. This

query is composed of causally (causal behavioural

operator) related activities (”WIP calculation” and

”product cost analysis”). As shown in this ﬁgure, we

obtain one pattern (oryx-canvas 123) which contains

these two causally related activities. This corresponds

to the pattern of ﬁgure 1-a.

The complexity of the hybrid search algorithm is

calculated in the worst case on the basis of the func-

tions getSyn(), getSub() and getPart(). The complex-

ity of each one is O(n

). Therefore, the complexity of

the overall algorithm is O(n

4.3 Empirical Validation

We have conducted an experiment to evaluate our

search algorithms and to highlight the importance of

the semantic search. To do this, we have automat-

ically constructed a test collection of SB2Ps from

the SAP reference models (Keller and Teufel, 1998).

Then, we measured the precision and recall of our

search algorithms using only the behavioural and hy-

brid criteria (without the semantic one). The preci-

sion is the number of correctly retrieved patterns di-

vided by the number of retrieved patterns. Recall is

the number of correctly retrieved patterns by the total

ReuseofSemanticBusinessProcessPatterns

Figure 5: Precision and recall of our search algorithms.

number of patterns. Then, we compare the values of

precisions and recalls.

The histogram of ﬁgure 5 show the results of our

experiment. We see that all search algorithms give

precise results. But the recall becomes high when we

add semantics.

5 INSTANTIATION OPERATORS

An instantiation operator acts on a variation point of a

SB2P to adapt it according to the designer’s require-

ments. When all the variation points are treated by in-

stantiation operators, a SB2P becomes a regular busi-

ness process represented in BPMN. Depending on the

variation point, a set of instantiation operators may be

applicable. Each instantiation operator is subject to

pre and post conditions that ensure that the ﬁnal busi-

ness process is syntactically well-formed and remains

within the semantic scope of the original SB2P. In ad-

dition, none of the instantiation operators changes the

behaviour of the SB2P’s mandatory activities: being

consensus activities among the process models of the

domain, mandatory activities must be preserved. Fur-

thermore, besides the syntactic well-formedness, se-

mantic and behavioural preservation, the instantiation

operators should guarantee the derivation of a process

model with a quality not less than the SB2P’s original

one. In the remainder of this section, we present the

ﬁve instantiation operators which are applicable to the

various types of variation points in SB2Ps:

• insert: to add a process fragment in a variation

point.

• abstract: to keep the variation point as it is with-

out making any modiﬁcation.

• delete: to remove an activity from the pattern.

• rename: to alter the name of an activity.

• conﬁgure: to specify the type of conﬁgurable con-

nectors.

We will present the above operators classiﬁed ac-

cording to the variation point types. For each instanti-

ation operator, we present its pre and post conditions,

its steps and results in the SB2P elements, and its im-

pact on the mostly used business process model com-

plexity metrics calculated by the quality evaluation

tool proposed in (Makni et al., 2010). The considered

metrics are the size, the density and the Control-Flow

Complexity (CFC) metric.

The size metric counts the number of activities

in a business process model (Cardoso et al., 2006).

In addition, the CFC metric concerns the analysis of

XOR-splits, OR-splits, and AND-splits control-ﬂow

elements. The main idea behind the metric is to eval-

uate the number of mental states that have to be con-

sidered when a designer is developing a process (Car-

doso et al., 2006). The density metric relates the num-

ber of available connections to the number of maxi-

mum connections for the given number of nodes (Car-

doso et al., 2006).

5.1 Instantiation of Decomposable or

Reﬁned Activities

A decomposable or reﬁned activity can be subject to

an insert or abstract instantiation operator.

5.1.1 Operator insert

- Pre-condition: The process fragment to be in-

serted is well-formed (i.e., structured block

(Nicola et al., 2010)).

- Post-condition: The SB2P is well-formed.

- Steps: Select one of the process fragments anno-

tating the decomposable or reﬁned activity, insert

it into the variation point and eliminate the anno-

tation from this activity.

- Results: The decomposable or reﬁned activity be-

comes a regular sub-process object encapsulating

the detailed activities selected by the designer.

- Effects on quality metrics: The size metric in-

creases. Also, the density and the CFC met-

rics increase. Consequently, the overall architec-

tural complexity of the resulting process model in-

creases.

Figure 6 shows an example of instantiating the de-

composable activity ”Manufacturing order overhead

calculation” which corresponds to the variation point

’B’ in ﬁgure 1-a. The designer chooses the process

fragment (PF1) from the set of process fragments ’B’

ICSOFT-EA2014-9thInternationalConferenceonSoftwareEngineeringandApplications

Figure 6: Instantiation of decomposable activity.

(see ﬁgure 1-b) and applies the ’insert’ instantiation

operator. As a result, the sub-process ”Manufacturing

order overhead calculation” contains the process frag-

ment composed of ”cost object overhead calculation”

and ”product cost collector overhead calculation”.

5.1.2 Operator abstract

- Pre-condition: None

- Post-condition: None

- Steps: The annotation of the decomposable activ-

ity is eliminated.

- Results: Neither semantic nor structural modiﬁca-

tions are introduced in the pattern.

- Effects on quality metrics: No changes.

5.2 Instantiation of Skipped Activities

A skipped activity can be subject to a Delete, Rename

or Insert instantiation operator.

5.2.1 Operator delete

- Pre-condition: None.

- Post-condition: The SB2P is well-formed.

- Steps: Redirect each of the incoming edges of

the skipped activity to all the targets of its outgo-

ing edges; delete all of its outgoing edges; ﬁnally

delete the skipped activity.

- Results: No semantic modiﬁcation is introduced

on the model.

- Effects on quality metrics: The size metric of

the instantiated pattern decreases and also its den-

sity declines. Consequently, the overall structural

complexity is reduced, hence, the instantiated pat-

tern will be easier to understand.

5.2.2 Operator rename

- Pre-condition: The name to be inserted respects

the syntactic pattern: action + business object

(Makni et al., 2012).

- Post-condition: None.

- Steps: Select one activity from the list annotating

the skipped activity to rename it or enter a new

label. Then, eliminate the annotation from this

activity.

- Results: No structural modiﬁcation is introduced

into the model.

- Effects on quality metrics: None of the structural

metrics is affected. However, names which re-

veal the intention of the designers more clearly

improve understandability of the model and con-

sequently result in decreased costs of change and

reduced errors (Becker et al., 2000).

5.2.3 Operator insert

- Pre-condition: The process fragment to be in-

serted is well-formed (i.e., structured block)

(Nicola et al., 2010).

- Post-condition: The SB2P is well-formed.

- Steps: Select one of the process fragments an-

notating the skipped activity, insert it into the

skipped activity and eliminate its annotation, then

rename the skipped activity.

- Results: The skipped activity becomes a regular

sub-process containing the inserted process frag-

ment.

- Effects on quality metrics: The size metric in-

creases. Also, the density and the CFC met-

rics increase. Consequently, the overall architec-

tural complexity of the resulting process model in-

creases.

Figure 7: Instantiation of skipped activity.

ReuseofSemanticBusinessProcessPatterns

Figure 8: An example of instantiated SB2P for the cost accounting process.

Figure 7 shows the instantiation of the variation

point ”C” (see ﬁgure 1-a) which is a skipped activity.

in by applying the insert instantiation operator. As

a result, the empty sub-process contains the process

fragment (PF1) in the ﬁgure 1-b composed of ”pre-

liminary settlement” and ”variance calculation cumu-

lated”.

5.3 Instantiation of Conﬁgurable

Connectors

5.3.1 Operator Conﬁgure

- Pre-condition: None.

- Post-condition: None.

- Steps: A conﬁgurable OR-connector may be

mapped to a regular OR-, XOR- or AND-

connector. The conﬁgurable AND-connector may

only be mapped to a regular AND-connector with

a decision to be made by the designer as to how

many of n available process paths are to be exe-

cuted in synchronization. The conﬁgurable XOR-

connector may only be mapped to a regular XOR-

connector or to a single process sequence.

- Results: Each conﬁgurable connector will be-

comes a regular one.

- Effects on quality metrics: Evidently, gateways

affect the Control Flow Complexity (CFC) of the

pattern. The CFC is calculated by adding the CFC

of all split constructs presented in the pattern. The

greater the value of the CFC, the greater the over-

all architectural complexity of the pattern is.

Figure 8 is an example of an instantiated SB2P. We

obtained it after applying the ’insert’ instantiation

operator on the variation point ’B’ which is decom-

posable activity (see ﬁgure 1-a) and on the variation

point ’C’ which is a skipped activity (see ﬁgure 1-a).

In addition, we applied the ’delete’ instantiation

operator on the skipped activities marked by ’C’

and ’E’ in ﬁgure 1-a and the ’abstract’ instantiation

operator on the variation point decomposable activity

marked by ’A’. Finally, we applied the ’conﬁgure’

instantiation operator on the conﬁgurable connectors.

In summary, we used 6 instantiation operators

(’insert’, ’delete’, ’abstract’ and ’conﬁgure’) to adapt

the pattern.

6 CONCLUSION

In this paper, we presented a reuse method for SB2P,

which assists a designer in retrieving a SB2P from a

repository and applying a set of instantiation opera-

tors. The novelty of the proposed retrieval method is

that it is based on the business objects while at the

same time accounting for the behavioural aspect of a

business process. To our knowledge, this work is the

ﬁrst in proposing this method. Besides the retrieval

method, our reuse method deﬁnes a set of instantia-

tion operators which are aware of the model quality.

In future work, we aim to apply our SB2P construc-

tion method, instantiation operators and search algo-

rithms on large and complex process models in order

to study the impact of scalability.

REFERENCES

Awad, A. (2007). Bpmn-q: A language to query business

processes. In EMISA, pages 115–128.

Awad, A., Polyvyanyy, A., and Weske, M. (2008). Semantic

querying of business process models. In Proceedings

of the 2008 12th International IEEE Enterprise Dis-

tributed Object Computing Conference, EDOC ’08,

pages 85–94, Washington, DC, USA. IEEE Computer

Society.

Awad, A. and Sakr, S. (2012). On efﬁcient processing of

bpmn-q queries. Computers in Industry, 63(9):867–

881.

ICSOFT-EA2014-9thInternationalConferenceonSoftwareEngineeringandApplications

Becker, J., Rosemann, M., and von Uthmann, C. (2000).

Guidelines of business process modeling. In In,: Busi-

ness Process Manegement: Models, techniques and

empirical studies.eds, pages 30–49. Springer-Verlag.

Beeri, C., Eyal, A., Kamenkovich, S., and Milo, T. (2008).

Querying business processes with bp-ql. Inf. Syst.,

33(6):477–507.

Cardoso, J., Mendling, J., Neumann, G., and Reijers, H. A.

(2006). A discourse on complexity of process mod-

els. In Proceedings of the 2006 International Con-

ference on Business Process Management Workshops,

BPM’06, pages 117–128. Springer-Verlag.

Choi, I., Kim, K., and Jang, M. (2007). An xml-based pro-

cess repository and process query language for inte-

grated process management. Knowledge and Process

Management, 14(4):303–316.

Fettke, P. and Loos, P. (2003). Classiﬁcation of reference

models: a methodology and its application. Inf. Syst.

E-Business Management, 1(1):35–53.

Gottschalk, F., van der Aalst, W. M. P., Jansen-Vullers,

M. H., and Rosa, M. L. (2008). Conﬁgurable work-

ﬂow models. Int. J. Cooperative Inf. Syst., 17(2):177–

221.

Haddar, N. Z., Makni, L., and Abdallah, H. B. (2012). Lit-

erature review of reuse in business process modeling.

Software & Systems Modeling.

Hallerbach, A., Bauer, T., and Reichert, M. (2010). Captur-

ing variability in business process models: The provop

approach. Journal of Software Maintenance and Evo-

lution: Research and Practice, 22(6-7):519–546.

Indulska, M., Green, P. F., Recker, J., and Rosemann, M.

(2009). Business process modeling: Perceived ben-

eﬁts. In Laender, A. H. F., Castano, S., Dayal, U.,

Casati, F., and de Oliveira, J. P. M., editors, ER,

volume 5829 of Lecture Notes in Computer Science,

pages 458–471. Springer.

Jin, Tao, J. W. W. N., Rosa, M. L. R., and ter Hofstede, A.

H. M. (2010). Efﬁcient and accurate retrieval of busi-

ness process models through indexing - (short paper).

In Meersman, R., Dillon, T. S., and Herrero, P., edi-

tors, OTM Conferences (1), volume 6426 of Lecture

Notes in Computer Science, pages 402–409. Springer.

Jin, T., Jianmin, W., Nianhua, W., Marcello, L. R., and ter

Hofstede, A. H. M. (2013). Efﬁcient querying of large

process model repositories. Computers in Industry,

64(1):41–49.

Jin, T., Wang, J., and Wen, L. (2011). Querying business

process models based on semantics. In DASFAA (2),

pages 164–178.

Keller, G. and Teufel, T. (1998). Sap R/3 Process-Oriented

Implementation: Iterative Process Prototyping. SAP

databases. Addison Wesley Professional.

La Rosa, M., Dumas, M., Uba, R., and Dijkman, R. (2013).

Business process model merging: An approach to

business process consolidation. ACM Trans. Softw.

Eng. Methodol., 22(2):11:1–11:42.

Makni, L., Haddar, N. Z., and Ben-Abdallah, H. (2011).

Semantic design patterns for business processes. In

Cuaresma, M. J. E., Shishkov, B., and Cordeiro, J.,

editors, ICSOFT (1), pages 83–87. SciTePress.

Makni, L., Haddar, N. Z., and Ben-Abdallah, H. (2012). De-

tection of semantic relations between business process

activity labels. In ICEIS (3), pages 273–277.

Makni, L., Khlif, W., Haddar, N. Z., and Ben-Abdallah, H.

(2010). A tool for evaluationg the quality of business

process models. In ISSS/BPSC, pages 230–242.

Nicola, A. D., Missikoff, M., Proietti, M., and Smith, F.

(2010). An open platform for business process mod-

eling and veriﬁcation. In DEXA (1), pages 76–90.

OMG (2013). Bpmn 2.0.

http://www.omg.org/spec/BPMN/2.0.2/.

Oryx-Editor (2010). Web-based graphical business process

editor. http:// code.google.com/p/ oryx-editor/.

Rosa, M. L. (2009). Managing variability in process-aware

information systems. PhD thesis, Queensland Univer-

sity of Technology.

Rosa, M. L., Dumas, M., and ter Hofstede, A. H. (2009).

Modelling business process variability for design-time

conﬁguration. In Cardoso, J. and van der Aalst, W. M.,

editors, Handbook of Research on Business Process

Modeling, pages 204–228. Information Science Ref-

erence (IGI Global), Hershey, PA. Access to the

author-version is currently restricted pending permis-

sion from the publisher. For more information, please

refer to the publisher’s website (see hypertext link) or

contact the author.

Rosa, M. L., Lux, J., Seidel, S., Dumas, M., and ter Hof-

stede, A. H. M. (2007). Questionnaire-driven conﬁg-

uration of reference process models. In Krogstie, J.,

Opdahl, A. L., and Sindre, G., editors, CAiSE, volume

4495 of Lecture Notes in Computer Science, pages

424–438. Springer.

Rosemann, M. and van der Aalst, W. M. P. (2007). A

conﬁgurable reference modelling language. Inf. Syst.,

32(1):1–23.

Scheidegger, C. E., Vo, H. T., Koop, D., Freire, J., and

Silva, C. T. (2008). Querying and re-using work-

ﬂows with vstrails. In Proceedings of the 2008 ACM

SIGMOD International Conference on Management

of Data, SIGMOD ’08, pages 1251–1254, New York,

NY, USA. ACM.

Shao, Q., Sun, P., and Chen, Y. (2009). Wise: A workﬂow

information search engine. In Ioannidis, Y. E., Lee,

D. L., and Ng, R. T., editors, ICDE, pages 1491–1494.

IEEE.

ter Hofstede, A. H. M., Ouyang, C., Rosa, M. L., Song,

L., Wang, J., and Polyvyanyy, A. (2013). Apql: A

process-model query language. In AP-BPM, pages

23–38.

Weber, B., Reichert, M., and Rinderle-Ma, S. (2008).

Change patterns and change support features - enhanc-

ing ﬂexibility in process-aware information systems.

Data Knowl. Eng., 66(3):438–466.

ReuseofSemanticBusinessProcessPatterns