ArticlePDF Available

Abstract and Figures

As a result of the growing adoption of Business Process Management (BPM) technology, different stakeholders need to understand and agree upon the process models that are used to configure BPM systems. However, BPM users have problems dealing with the complexity of such models. Therefore, the challenge is to improve the comprehension of process models. While a substantial amount of literature is devoted to this topic, there is no overview of the various mechanisms that exist to deal with managing complexity in (large) process models. As a result, it is hard to obtain an insight into the degree of support offered for complexity reducing mechanisms by state-of-the-art languages and tools. This paper focuses on complexity reduction mechanisms that affect the abstract syntax of a process model, i.e., the formal structure of process model elements and their interrelationships. These mechanisms are captured as patterns so that they can be described in their most general form, in a language- and tool-independent manner. The paper concludes with a comparative overview of the degree of support for these patterns offered by state-of-the-art languages and tools, and with an evaluation of the patterns from a usability perspective, as perceived by BPM practitioners.
Content may be subject to copyright.
This is the author’s version of a work that was submitted/accepted for pub-
lication in the following source:
La Rosa, Marcello, Wohed, Petia, Mendling, Jan,ter Hofstede, Arthur
H.M., Reijers, Hajo A., & Aalst, Wil M.P. van der (2011) Managing pro-
cess model complexity via abstract syntax modifications. (Submitted (not
yet accepted for publication))
This file was downloaded from:
Copyright 2011 The Authors
Notice:Changes introduced as a result of publishing processes such as
copy-editing and formatting may not be reflected in this document. For a
definitive version of this work, please refer to the published source:
Managing Process Model Complexity via
Abstract Syntax Modifications
Marcello La Rosa, Petia Wohed, Jan Mendling, Arthur H.M. ter Hofstede, Hajo A. Reijers
and Wil M.P. van der Aalst, Member, IEEE
Abstract—As a result of the growing adoption of Business
Process Management (BPM) technology different stakeholders
need to understand and agree upon the process models that
are used to configure BPM systems. However, BPM users have
problems dealing with the complexity of such models. Therefore,
the challenge is to improve the comprehension of process models.
While a substantial amount of literature is devoted to this topic,
there is no overview of the various mechanisms that exist to deal
with managing complexity in (large) process models. It is thus
hard to obtain comparative insight into the degree of support
offered for various complexity reducing mechanisms by state-
of-the-art languages and tools. This paper focuses on complexity
reduction mechanisms that affect the abstract syntax of a process
model, i.e. the structure of a process model. These mechanisms
are captured as patterns, so that they can be described in their
most general form and in a language- and tool-independent
manner. The paper concludes with a comparative overview of
the degree of support for these patterns offered by state-of-the-
art languages and language implementations.
Index Terms—Process model, pattern, complexity, understand-
ability, process metric.
Business Process Management (BPM) is increasingly rec-
ognized as an overarching approach to improve performance
at an operational level. Companies typically utilize BPM
technology to reduce costs, save cycle time, and react to
changes in a more agile way. While many BPM concepts
have already contributed to various business improvements in
industrial practice, there are still significant challenges, which
need to be addressed by BPM research.
One of the challenges in this context relates to complexity
management of process models. The capability of a process
model to be easily understandable plays an important role for
the success of process redesign projects [57]. Business process
models in practice often contain dozens of activities and
Manuscript received May X, 2011; revised X X, 2011.
Copyright c
2011 IEEE. Personal use of this material is permitted.
However, permission to use this material for any other purposes must be
obtained from the IEEE by sending a request to
M. La Rosa and A.H.M. ter Hofstede are with the Queens-
land University of Technology. e-mail: see and Ter Hofstede is also with Eindhoven Uni-
versity of Technology.
P. Wohed is with Stockholm University, Sweden. e-mail: see
J. Mendling is with Humboldt University of Berlin, Germany. e-mail: see
H.A. Reijers and W.M.P. van der Aalst are with Eindhoven University
of Technology, The Netherlands. e-mail: see and Van der Aalst is also with Queensland University
of Technology.
complex behavioral dependencies between them. An increase
in size and complexity of a business process model beyond
certain thresholds can lead to comprehension problems by
its stakeholders. For complex models it becomes difficult to
validate it, to maintain it, and to utilize it as a means of
The empirical connection between complexity and process
model understanding has been demonstrated in recent publica-
tions (e.g. [68], [80], [83], [7], [104], [96], [98]), as much as
mechanisms have been proposed to alleviate specific aspects of
complexity (e.g. [109], [117], [48]). However, what is lacking
is a systematic classification of the various operations that exist
for reducing complexity in process models. A comprehensive
account of such mechanisms would contribute to improved
support for complexity management in process modeling lan-
guages, standards and tools. A corresponding classification
may be beneficial to research and practice, for instance to
initiatives towards process modeling language standardization,
to academic and industrial tool evaluation, and to vendors
seeking to incorporate innovative features in their tools.
In this paper we address this research gap by compiling
a collection of patterns, which define an extensive range
of desired capabilities. The approach of capturing design
knowledge as patterns has been used in various engineering
disciplines including architecture, software engineering, and
workflow modeling [121]. The patterns described in this paper
capture mechanisms for managing process model complexity.
They stem from the literature, process modeling language
specifications, and tool implementations.
Essentially, mechanisms for managing complexity of pro-
cess models can be defined on two different levels [84]: (a)
concrete syntax of a model and (b) abstract syntax of a model.
The concrete syntax of a process models deals with its visual
appearance including symbols, colors and position, and is also
referred to as secondary notation [88]. A collection of patterns
for concrete syntax modifications has been presented in [66].
These patterns include mechanisms for arranging the layout,
for highlighting parts of the model using enclosure, graphics,
or annotations, for representing specific concepts explicitly
or in an alternative way, and for providing naming guidance.
The abstract syntax of a process model relates to the formal
structure of process elements and the relationships among
them. The patterns presented in this paper work on the abstract
syntax and complement the patterns collection for concrete
syntax modifications presented in [66]. They relate to model
operations such as transforming a model into a set of modules
or omitting elements to provide a more abstract view on the
process. Clearly, a change on the structure of a process model,
also indirectly affects the model’s visual appearance.
In this paper we aim for a language-independent description
of abstract syntax related patterns. Each pattern is accom-
panied with a discussion of its intended effect on model
complexity and of different realizations to clarify its scope
and to demonstrate its relevance. The pattern description is
complemented by an overview of its support in tools and
modeling languages, which sheds light on its comparative
strengths and weaknesses. Additionally, we evaluate each of
the patterns from a usability perspective as perceived by BPM
The paper is structured accordingly. Section II describes
and justifies the methodology, which we used to identify the
patterns. Section III presents the collection of patterns in detail.
Section IV evaluates the pattern support of various process
modeling languages and tools. Section V presents the results
of a usability evaluation with BPM practitioners. Section VI
discusses related work while Section VII concludes the paper.
In this paper we identify patterns to reduce the model
complexity on the level of the abstract syntax, i.e., the goal
is to simplify the structure of the process model.
The original idea to organize design knowledge in terms
of patterns stems from the architect Christopher Alexander,
who collected rules and diagrams describing methods for
constructing buildings [11]. In this context, a pattern provides a
generic solution for a recurring class of problems. The general
idea of design patterns has been introduced to information
systems engineering by Gamma, Helm, Johnson and Vlissides
[41], who describe a set of recurring problems and solutions
for object-oriented software design. The design patterns by
Gamma et al. inspired many patterns initiatives in computer
science, including the Workflow Patterns Initiative [121].
The patterns for abstract syntax modifications, which are
defined in this paper, have been collected though a series
of steps. The starting point has been an extensive analysis
of the BPM literature, as well as the specifications and
standard proposals that are managed by organizations such as
OASIS, OMG, W3C and WfMC. Subsequently, we inspected
commercial BPM tools and the operations they offer for
modifying abstract syntax. The initial set derived in this way
was presented to a panel of experts, which resulted in a further
identification of two additional patterns. This extended set was
evaluated with respect to their support by reported research
approaches, languages, and tools with the goal to distinguish
those which are most frequently used. We decided to focus
on those patterns that are at least supported by five research
approaches/languages/tools, which resulted in a final set of 12
patterns. Finally, we evaluated this final set on its ease of use
and usefulness by a group of nine BPM professionals.
Each of the 12 patterns in the final set is illustrated in
this paper by the use of BPMN (Business Process Model and
Notation), an industry standard for modeling processes [87].
Figure 1 shows the notational elements of BPMN which are
used in this paper. The example models are intentionally
kept simple such that they can be understood without deep
knowledge of this standard.
When referring to a model, we use the term model element
to indicate any element which has a corresponding concept
in the language’s meta-model. Model elements can be nodes
(e.g. a task, a gateway or a business object) or arcs. We also
use the term fragment to indicate a set of model elements in
a process model that are organized via control-flow relations,
and the term module to indicate a process model which is part
of a larger business process (e.g. a subprocess or the portion
of model enclosed by a lane).
We use a fixed format to document the twelve patterns
and to discuss their support in languages, tools and in the
literature. This format contains: (a) description, (b) purpose,
(c) example, (d) metric, (e) rational and (f) realization of
a pattern. The purpose describes the use case in which the
pattern is commonly used, while the rationale provides a
justification grounded in the literature, as to why a given
pattern reduces the complexity of the process model it is
applied to. Moreover, we relate each pattern that operates on a
process model to a desired improvement of a structural metric.
In fact, it has been shown that certain structural metrics can
be related to ease of making sense of process models [80].
For example, intuitively, the smaller the size of a model, the
easier it is to understand it. We discuss the following metrics
in this context:
module size, the number of nodes in a module;
model size, the summed size of all modules in a process
model [76];
repository size, the summed size of all models in a
process model repository;
models, the number of models in a process model repos-
itory [117];
depth, the number of modular levels appearing in a
process model [117];
diameter, the longest path from a start to an end element
in a process model [76];
average gateway degree, the number of nodes a gateway
in a specific process model is on average connected
to [76];
structuredness, the restructuring ratio of an unstructured
model to a structured variant of it [69];
modules overhead, the ratio between modules and model
fan-in, the average number of references to a module [67].
For example, Fig. 5 shows a BPMN model consisting of three
levels with one root module and three subprocess modules.
This model has the following metrics: depth=3, modules=4,
model size=25, average gateway degree=3, etc. Similarly, we
can infer metrics for specific modules. For example the root
module has module size=9 and diameter=8.
From an analysis of relevant BPM languages, tools and
approaches, we identified twelve patterns operating on the
abstract syntax of a process model and classified them ac-
cording to the hierarchy in Fig. 2. The patterns are categorized
Flow XOR
Gateway OR
Activity End
Task Collapsed
Fig. 1. BPMN 2.0 concepts used in this paper.
into two main groups: Model modification (including patterns
that directly modify a process model or set thereof) and
Language Modification (including patterns that have more
profound changes because they affect the underlying process
language). Model modification includes Behavior Abstraction
and Behavior Neutral patterns. Behavior Abstraction includes
those patterns that operate on a single model and provide a
more abstract one as a result. Omission simply skips elements
of the original model while Collapse aggregates a set of
elements into a single, semantically more abstract element. Be-
havior Neutral patterns preserve the behavior being described
in a single model or in a set of models, but organize this
behavior in a different representation. Restructuring refers to
transformations that reorganize the control-flow of a process
model in a more understandable way, either in terms of
Block-Structuring or Compacting the process model, while
Duplication introduces model element redundancy in order to
simplify its structure. Three Modularization patterns, Vertical,
Horizontal and Orthogonal, capture different ways in which a
process model is decomposed into modules. Two Integration
patterns, namely Composition and Merging, refer to features
for combining information which is scattered across different
modules or models into a single one. While Composition
uses references among different modules or models to achieve
integration, Merging relies on an overlap of elements. Finally,
Meta-model Modifications involve Restriction and Extension.
Pattern 1 (Block-Structuring)
Description This pattern refers to methods to structure a
process model in blocks. In a block-structured process model,
each split element has a corresponding join element of the
same type, and split-join pairs are properly nested [74].
Purpose To improve understandability and maintenance
through a simpler process model structure.
Example Fig. 3a shows an unstructured model where split
gateways are not matched by corresponding join gateways.
Fig. 3b shows a behavior-equivalent model which is structured.
Metrics Increases structuredness of a process model.
Rationale Structured models are easier to understand [80], [81]
and less error-prone [76], [69] than unstructured models.
Realization The problem of structuring process models has
been extensively analyzed in the literature both from an
empirical and from a theoretical point of view. Lau and
Mendling [69] report the results of a study showing that
structured models are less error-prone than unstructured equiv-
alent models. Mendling et al. [81] propose seven guidelines
to model easily-understandable process models. One of these
guidelines is to model processes as structured as possible,
which was ranked by a pool of practitioners as the guide-
line with the highest relative potential for improving process
model understandability. Kiepuszewski et al. [56] provide a
first attempt to classifying unstructured process models that
can be transformed to structured equivalents, and show that
structured models are less expressive than unstructured ones,
thus unstructured model fragments cannot always be replaced
with structured fragments that are behavior-equivalent. Liu and
Kumar [74] present an alternative taxonomy of unstructured
process models which also covers acyclic models, and sketch
a method to transform some types of unstructured models
into structured trace-equivalent alternatives. Different trans-
formation strategies are also illustrated in [78]. In a similar
vein, [51] proposes a classification of (unstructured) process
models using region trees, and provides a set of rules to
transform certain types of unstructured regions into structured
equivalents. An alternative classification of process models
based on the RPST decomposition [114] (a refinement of [51])
is proposed in [89], showing how unstructured regions can
be generated by composing structured process fragments. A
method specifically tailored to untangling unstructured cyclic
models and transforming them into structured BPEL [12]
models is presented in [58], [52]. A complete characteriza-
tion of unstructured acyclic process models that cannot be
transformed into block-structured ones is presented in [90],
[35]. This method is based on the RPST decomposition and
is accompanied by a tool to automatically structure acyclic
process models that are not in this class. Finally, Weber
et al. [117] propose a set of refactoring mechanisms for
process models wherein they devise (but do not operationalize)
a mechanism to replace a process fragment with a trace-
equivalent fragment having simpler structure.
Pattern 2 (Duplication)
Description Duplication (aka Cloning) introduces controlled
redundancy in a process model by repeating model elements.
Two model elements are duplicated if they point to the same
conceptual definition.
Purpose To improve understandability and maintenance
through a simpler process model structure. Often required to
block-structure an unstructured process model.
Example Fig. 4 shows a behavior-equivalent representation of
the model in Fig. 3a after repeating task “Reject loan”. This
alternative representation of the same model does not have any
crossing lines nor OR-join gateways.
Metrics Despite increasing model size, this pattern typically
also increases structuredness.
Rationale Less cluttered and more structured process models
are easier to comprehend [80], [81] and less error-prone [76],
Realization Process modeling languages generally provide the
possibility of creating duplicate model elements. For example,
Restriction Extension
HorizontalVertical Orthogonal
structuring Compacting
Ommission Collapse
Composition Merging
Single Module/Model Operation Multiple Module/Model Operation
Fig. 2. Patterns for abstract syntax modification.
High liability
and no debts
start date
& interest
money Notify
High liability
Low liability
start date
& interest
money Notify
No debts
Low liability
and/or debts
Fig. 3. a) An unstructured BPMN model. b) A behavior-equivalent model which is structured.
in YAWL [112] tasks can be duplicated by associating multiple
tasks to the same Task Decomposition, so that these tasks
have same operationalization. Still, the two duplicates can be
allocated to different resources for their execution. In BPMN
2.0 [87] two Service Tasks can be associated with the same
Service Reference and Service Endpoint, thus pointing to the
same Web service implementation. To duplicate other types of
tasks, such as Manual and User Tasks, BPMN 2.0 provides the
Global Task construct, which is a reusable atomic Task that can
be called from within any process model via an atomic Call
Activity. Similar to Service Tasks, a Call Activity can override
the Resources attribute of the invoked Global Task. Global
Tasks replace Reference Tasks in BPMN 1.2 [86], which
supported duplication within the same process model only. In
eEPCs [55], [29], an element (e.g. an Event or Function) can
point to the same definition, thus allowing the repeated use of
the same concept. Since different Functions may be preceded
or succeeded by the same Events, it may be useful to duplicate
all preceding/subsequent Events of a given Function so as to
line them up close to the corresponding Function’s symbol,
instead of having crossing arcs. In the Activity Diagrams
(ADs) of UML 2.3 [47], duplication is supported by the Call-
BehaviorAction, which is an Action that points to an Activity
Definition. The mechanisms offered by these languages are
generally supported by the respective tool implementations.
For example, in ARIS one can navigate from the Occurrence
of a Definition in a process model back to the Definition Object
stored in the ARIS Database, and when creating Occurrence
copies of a Definition, all attributes will also be copied. In
Tibco Business Studio a BPMN 1.2 Task can be identified as
a Reference Task and assigned to another task within the same
model, while a function “Reveal” allows highlighting the task
being referenced by a Reference Task. In Signavio a task can
be set as Call Activity, but it cannot be linked to a global task.
In the literature, duplication is used to block-structure process
models. For instance, the block-structuring approach in [90]
uses unfolding techniques from Petri net theory to construct
an occurrence net [37]. In an occurrence net, each XOR-join
is unfolded by repeating the subsequent net. The result is a
structured, but often much bigger model. The possibility to
have multiple tasks having identical labels may increase the
expressiveness of the language. A classical example can be
found in the Theory of Regions for Petri nets. To construct a
bisimilar Petri net for a transition system, it may be necessary
to do “label splitting” (multiple transitions referring to the
same task) [26].
Pattern 3 (Compacting)
Description This pattern refers to methods to remove re-
dundant or superfluous elements in a process model, e.g.
redundant transitive arcs, gateways or duplicated tasks. Thus,
it may revert the effects of Duplication.
Example Fig. 3b can also be obtained by compacting the
two occurrences of task Reject loan and the two XOR-split
gateways from the model in Fig. 4.
Purpose To reduce model size and thus improve the overall
model representation, especially in large process models or
models that have undergone a number of updates.
Metrics Reduces model size.
Rationale Reducing model size positively affects model un-
derstanding [80].
Realization Methods for eliminating superfluous elements
have been defined for Petri nets. The work by Berthelot defines
so-called implicit places [17], [16]. An implicit place does
not contribute to the overall behavior captured in a process
model, since it always has a token when other places have
tokens too. Thus, it can be deleted without impacting the
model behavior. A related reduction rule is defined by Desel
and Esparza [32] with the notion of transitively dependent
arc. While this concept is defined for verification purposes,
it can also be used to eliminate superfluous arcs from a
process model without an effect on the behavior. The concept
of transitive reduction is also exploited in an approach to
synthesize process models from behavioral profiles such that
transitive order dependencies are deleted [108]. Furthermore,
[33] proposes an approach to merge subsequent connectors of
the same type. The same idea is utilized in [77].
Pattern 4 (Vertical Modularization)
Description This pattern captures features to decompose a
model into vertical modules, i.e. subprocesses, according to
a hierarchical structure.
Purpose To increase understandability of large process mod-
els by “hiding” process details into sub-levels. To decrease
redundancy and foster reuse by referring to a subprocess
from several places within the same process model or from
different process models in a repository. The maintenance of
a process model (repository) is also decreased, as a change to
a subprocess needs only be performed in one place.
Example Fig. 5 shows the vertical modularization of the model
in Fig. 3b in three hierarchical levels.
Metrics Increases depth and models, and reduces module size
by replacing a model fragment with a single element referring
to that module. It may increase the overall model size if the
fan-in of the module being introduced is one, because for
each extracted module a node needs to be inserted in the root
model to refer to that module. Modules overhead needs to
be controlled (i.e. it is pointless to factor out single model
elements or very small process fragments to subprocesses).
Rationale Hiding process details into sub-levels increases
understanding [99] and fosters reuse [5], [71]. Smaller models
are less error-prone [79] and easier to maintain [81] than
larger ones. Reducing redundancy helps avoid inconsistencies,
since redundant fragments may be edited by different users
simultaneously [113].
Realization Most languages offer modeling constructs to cap-
ture vertical modularization. UML ADs provide the notion of
Activity to encapsulate subprocesses, as opposed to atomic
Actions. In eEPCs models of different types can be assigned
to different element types. For example, a Function can
be decomposed into an eEPC capturing a subprocess, an
Event can be decomposed into an Event diagram capturing
more detailed sub-events, and an Organizational unit can be
decomposed into an Organizational chart. In BPMN 2.0 a
Task can be decomposed into a Collapsed Subprocess (the
subprocess is available as a separate module) or as an Ex-
panded Subprocesses (the subprocess is represented within
the Task box itself). BPMN requires a different construct (the
Collapsed Call Activity Task) if the subprocess to be invoked
is external (i.e. it is a standalone process model), rather than
an internal module. In YAWL, BPEL and Protos subprocesses
can only be invoked internally via a Compound Task (YAWL),
Scope Activity (BPEL) or Sub-process element (Protos). For
correctness purposes, YAWL and BPEL only accept single-
entry single-exit subprocesses. Tools offer different degrees of
support for this pattern. Some simply allow the specification of
pointers to subprocesses (e.g. the YAWL Editor), others allow
process hierarchies to be traversed (e.g. Oracle JDeveloper,
Signavio), and some also offer a tree-like representation of the
hierarchy (e.g. Protos and ARIS). General recommendations
are also available for modularizing a process model vertically:
[70], [13] suggest to encapsulate only single-entry single-
exit (SESE) fragments in subprocesses and [114] provides a
method for automatically detecting SESE fragments based on
the RPST decomposition. Moreover, [54], [105] suggest to
introduce subprocesses in models with 5–15, resp., 5–7 nodes,
while [81] suggests to decompose models with more than 50
nodes based on empirical evidence. The positive effects of
vertical modularization on process model understanding have
been studied in [99]. A mechanism to automatically extract
cloned fragments in large process model repositories and
capture them as globally available subprocesses, is envisaged
in [117], while an algorithm to detect such clones is defined
and implemented in [113].
start date
& interest
money Notify
High liability
and no debts
Low liability
and/or debts
Check loan
Fig. 5. Vertical Modularization: the model in Fig. 3b has been decomposed
into three levels.
High liability
Low liability
No debts
Debts Reject
start date
& interest
money Notify
Fig. 4. A behavior-equivalent representation of the model in Fig. 3a after repeating Task “Reject loan” (the top “Reject loan” task is the Global Task while
the bottom one is the Call Activity referring to that task).
Pattern 5 (Horizontal Modularization)
Description This pattern captures features to partition a pro-
cess model into peer modules.
Purpose To increase maintainability by breaking down a
process model into smaller and more easily manageable parts,
the ownership of which may be assigned to different users.
Hence, to facilitate collaboration. To reduce clutter in those
models where long or crossing edges cannot be avoided. To
foster reuse of modules within the same process model or
across different process models.
Example Fig. 6a shows how the model in Fig. 3b has been
decomposed into two parallel modules: “Home Loan” and
“Sign”, which communicate via message exchange. Process
model “Sign” can now also be used by a third model, namely
“Student Loan”, thus increasing reusability. The model in
Fig. 3b actually focuses on the loan registration part of a larger,
end-to-end process model for handling loans, where “Register
Loan” is preceded by “Merchandize” and followed by “Handle
Loan”. This model can thus also be decomposed into multiple
sequential modules, e.g. one per logical part. Fig. 6b shows
the “Register Loan” module which is connected to the other
modules via Link Events. Moreover, the “Sign Loan” part has
been extracted from “Register Loan” and modeled separately.
Metrics Reduces module size (by replacing a model fragment
with a single element referring to that module), and increases
models. It may also increase model size if the fan-in of the
module being introduced is one.
Rationale Reducing model size positively affects model un-
derstanding [80]. Decomposing a process model into modules
fosters reuse of shared modules [5], [71].
Realization UML ADs, BPMN and BPEL offer features to
represent parallel process modules via message exchange.
UML ADs offers the concept of Partitions to divide a process
model in peer modules. BPMN provides Pools to create peer
modules and Message Flows to connect a source node in
one Pool to a target node in another Pool. BPEL supports
synchronous and asynchronous inter-process communication
via the Invoke, Receive and Reply activities, which link to
a BPEL process counterpart via a PartnerLink. BPMN also
offers the Signal event to synchronize the control-flow in dif-
ferent modules. The different between these languages is that
only in BPEL the modules are completely independent, while
in UML ADs and BPEL reuse of a module is limited within
the same process model. Other languages such as eEPCs and
Protos provide constructs to capture external connections (e.g.
Events in eEPCs and Triggers in Protos) but these cannot be
used to formally link two process modules. Sequential modules
can be obtained in BPMN via the Link Event which interrupts
the flow after a source node and before a target node. The
corresponding construct in UML ADs is the Activity Edge
Connector, in eEPCs it is the ProcessInterface while in Protos
it is the Off-Page Connector. Generally, the above concepts are
supported by tools. For example, both Signavio and Protos
allow users to jump from two corresponding Link Events,
resp., Off-Page Connectors. In the literature, [34] defines a
mechanism to partition large BPMN models sequentially by
cutting those edges with numerous bends and crossings and
inserting two pointers at the two ends of each cut edge. The
objective is to obtain subgraphs of nearly equal size while
keeping the number of cut edges low. Worklets [9] are a
mechanism to deal with highly-flexible process models. A
Worklet is a process fragment capturing a specific process
scenario, i.e. variant within a given process model. Various
Worklets can exist for a given variation point and one of them
will be activated at run-time based on the evaluation of a set
of ripple-down rules. This approach has been implemented in
the YAWL system where Worklets can be defined to tasks
via the Rules Editor, and instantiated via the Worklet Service.
A similar mechanism is provided in [38], where a large,
unstructured Petri net can be represented as a set of partially-
ordered, acyclic process fragments called Oclets. Each Oclet
captures a specific scenario of a given process together with
information indicating when the scenario occurs. This idea of
capturing a process model as a set of partially-ordered runs
is also put forward in [31], [15]. Proclets [6] are lightweight
Workflow nets which interact via message exchange and have
knowledge of previous interactions. A process model is a set
of Proclets that are instantiated and coupled according to an
underlying business object model. This approach is introduced
to deal with highly-interactive business processes.
Pattern 6 (Orthogonal Modularization)
Description This pattern captures features to decompose a
process model along the crosscutting concerns of the modeling
domain, which are scattered across several model elements
or modules. Examples of concerns are security, privacy and
exception handling.
Purpose To enable separation of concerns and distribution
of responsibilities. To facilitate maintenance of individual,
concern-specific process models.
Example Fig. 7a shows a more detailed representation of the
“Process loan” subprocess from Fig. 5, which includes further
tasks to deal with the security aspect related to loan processing.
approve loan
No debts
liabilities High liability
and no debts
Low liability
and/or debts
Sign Loan
contract Notify
High liability
and no debts
Low liability
and/or debts
(to Sign Loan) B.2
(from Sign Loan)
Register Loan)
(to Register Loan)
(to Handle
Sign Loan Register Loan
Home Loan
Student Loan
contract Notify
sent for
sent for
Fig. 6. Horizontal Modularization: (a) the model in Fig. 3b has been partitioned in two parallel modules via message exchange (“Home Loan” and “Sign”),
and (b) the end-to-end process model for handling loans has been partitioned in four sequential modules two of which are shown.
Fig. 7b shows the orthogonal modularization of this process
across its security aspect. The tasks related to this aspect have
been extracted and captured in a separate model which is
accessible by the first two activities of “Process loan”. These
activities are instantiated at the join point in the “Security
aspect” model.
Metrics Increases models, as “concern-specific” process mod-
els are introduced. Decreases the model size when a concern
is associated with several process models, as its specification
is defined in a single place.
Rationale Reducing model size positively affects model un-
derstanding [81], [85]. Decomposing a process model into
modules fosters reuse of shared modules [5], [71].
Realization Aspect-oriented modularization [24] is an appli-
cation of this pattern. This approach is inspired by aspect-
oriented programming and defines extensions to workflow
languages in general [23], BPEL [24] and BPMN [22], to
represent non-functional aspects of a business process such
as security and logging, as separate, reusable modules. The
notions of joint point,pointcut and advice used in aspect ori-
ented programming, are adopted in this context. For instance,
Fig. 7 shows a BPMN model extended with such notions.
During process execution, when the task associated with a
pointcut is reached, the module (i.e. advice) specified for the
corresponding aspect is triggered. Its join point task is then
substituted with the task triggering that advice. An advice
can be executed before or after a join point, although more
advanced mechanisms can be envisaged, e.g. in parallel to the
join point. Various aspects can be associated with the same
activity and a concern may include more than one module, e.g.
different levels of security could be captured via different mod-
ules. Orthogonal modularization is also applied to deal with
exceptions. The basic idea is to avoid unnecessary cluttering of
a process model by extrapolating those procedures to handle
possible exceptions from the main process flow. In BPMN 2.0,
exceptions can be handled outside the normal process flow via
an Event Subprocess. These subprocesses are triggered by the
occurrence of a given event, and can either run in parallel to
the main process flow (Non-Interrupting Event Subprocess) or
in alternative to the main flow (Interrupting Event Subprocess).
In UML ADs exception routines are specified in separate
Exception Handler activities which are connected to the main
activities where exceptions may occur via an Interrupt Flow
arc. Similarly, in BPEL Fault Handlers can be attached to a
Scope activity or to a global process model. These features
are generally provided by the respective tools. [8] proposes
to capture exception handling routines via the notion of Exlet.
An Exlet specifies how an exception influences a running task,
process instance, or all instances of a process model, and can
be assigned a compensating routine in the form of a Worklet to
be performed when the given exception occurs. This approach
is supported in the context of the YAWL language by the
Rules Editor and the Exception Service available in the YAWL
Pattern 7 (Composition)
Description This pattern describes features for constructing a
consolidated process model from different disjoint modules.
Modules may be organized vertically in a hierarchy (in this
case Composition will flatten the hierarchy), or horizontally, or
orthogonally (where each module represents a domain-specific
concern). As such, this pattern may reverse the effects of
Purpose To consolidate a family of interrelated modules
into a single process model. The effect may be increased
maintainability and understandability when there are too many
or too small modules, e.g. due to subsequent modifications.
It is useful when the process depth is too high or when a
module contains only one or two nodes. The advantages are
situation-dependent (e.g. flattening a model may be useful
when presenting it to a business user).
Example Fig. 3b can be obtained by composing either the
vertical modules in Fig. 5, or the horizontal modules “Home
Loan” and “Sign Loan” in Fig. 6a.
Metrics Decreases modules and their fan-in, but increases
model size. Reduces depth and modules overhead when ap-
plied to a process hierarchy.
Rationale Extracting information from fewer modules or from
a single model may be easier than dealing with many small
Process loan (enhanced with security)
Code Enter
Key Validate
Key Key ok
not ok
money Notify
Code Enter
Key Validate
not ok
start date
& interest
Code Enter
Key Validate
not ok
start date
& interest
money Notify
Process loan Security aspect
Fig. 7. Orthogonal Modularization: (a) extracting the security aspect from the “Process loan” subprocess in Fig. 5 and (b) capturing it in a separate module.
modules [99].
Realization The concept of this pattern has been defined as a
refactoring mechanism in [117]. Here the authors recommend
to inline process fragments when the induced navigation
overhead of a modularization is not justified. A corresponding
change pattern is specified in [118]. Composing vertical mod-
ules is also defined as a transformation strategy to convert
BPEL models to BPMN [78], and adapted to OWL-S in
[42]. [63] proposes a method for composing state machines
describing the lifecycle of independent objects involved in a
business process, into a single UML AD capturing the overall
process. This work assumes that the lifecycles to be composed
are disjoint and consistent. The concept of composition is
also widely supported by business process modeling tools.
For instance, ARIS provides the model generator command
to construct a flattened model from a subprocess hierarchy, or
to compose sequential modules into one model. This concept
is also described in detail in [29].
Pattern 8 (Merging)
Description This pattern describes features for merging similar
process models based on their commonalities, i.e. their iden-
tical model elements. The result is a single merged model.
Purpose To consolidate a family of similar process models (i.e.
process variants) into a single “reference” process model, by
removing redundancies.
Example Fig. 8 shows the model resulting from merging the
“Home Loan” and “Student Loan” modules in Fig. 6a.
Metrics Decreases models. It also decreases repository size
since redundancies among variants are minimized. However,
the resulting reference model may be more complex.
Rationale Consolidating a process family improves its un-
derstandability, since a single model is kept instead of many
variants. It also improves the maintainability of a repository,
given that the total number of models is reduced [117], [65].
Removing redundancies helps decrease the risk of inconsis-
tencies due to independent changes to the repository [117].
Realization [111] proposes, but does not fully automate,
an approach for merging block-structured Workflow nets by
using a set of merge patterns between mapped tasks. [82]
proposes a merging operator that takes two different EPCs
each representing a specific process view, as well as a mapping
of their correspondences, and produces a merged EPC. Since
the models to be merged represent partial views of a same
process, the resulting merged model allows the various views
to be executed in parallel. [44] merges pairs of EPCs by
performing the union of each of the two models. The nodes to
be merged must have identical labels and the input EPCs must
have single start and end events and no connector chains. This
approach is operationalized as a ProM plug-in. [65] presents
an algorithm to merge process variants into a configurable
process model [102] where divergencies between common
and variant-specific fragments are marked via configurable
connectors. The mapping between two input variants relies on
the similarity of their nodes’ labels (including resource and
object nodes) and of their graph structures. The algorithm is
language-independent (it has been validated on BPMN and
eEPC models) and has been implemented on the AProMoRe
process model repository. Tools deriving from research initia-
tives such as Greta [39] and VipTool [15] allow the automatic
synthesis of a Petri net from a set of partially-ordered Petri
nets (called Oclets in Greta). This is closely related to the
topic of process mining where example behavior is folded
within a single model [1]. [72] proposes to construct a single
generic model from a set of model variants, such that the
sum of the change distances between each variant and the
generic model is minimal. This approach only works for
block-structured process models with AND and XOR blocks
and has been implemented on the MiniADEPT tool. The
problem of maintaining merged EPCs has been explored in
[97]. Here the authors propose an alternative (mostly manual)
method which is applicable if the need for maintaining merged
models is identified before the actual process modeling effort
is started. Finally, [62] describes the requirements of a process
merging tool for version conflict resolution. The aim is to assist
modelers in resolving differences manually, by identifying
changes via the technique in [61].
Pattern 9 (Omission)
Description Omission (aka Elimination) captures features to
remove one or more elements from a process model and
reconnect the remaining ones. It implies information lost.
Purpose To focus on specific parts of a process model while
abstracting from the rest, due to the requirements of a project
or specific audience.
Example Fig. 9a shows an example of Omission by displaying
only the tasks from the process in Fig. 3b which are performed
by a Loan Clerk, and omitting the automated tasks.
Metrics Decreases model size, and may also decrease diameter
and average connector degree.
Student: no debts/
Home: low liability
and no debts
approve loan
Home: low liability
and/or debts
Loan sent
for signature Signed loan
Fig. 8. The models “Home Loan” and “Student Loan” from Fig. 6a have been merged in a single reference process model for registering loans.
Rationale Simpler process models which focus on specific
aspects relevant to a given audience are easier to understand
by the latter [107].
Realization Omitting process behavior is related to the notion
of inheritance of workflow behavior [3]. Accordingly, process
model behavior can be restricted by applying two operators
to Petri net transitions: hiding (an hidden transition remains
in the model but its behavior is no longer observable) and
blocking (a blocked transition is removed from the model with
possible consequences to the control-flow). [109] proposes a
decimation algorithm to remove model nodes that are less
relevant, and reconstructing the process flow. The relevance
of a node is determined according to a text search (the nodes
whose labels contain a given string are kept), and to structural
importance (the main model structure is kept). [91] proposes a
slider approach for building process model abstractions based
on thresholds such as execution frequency, time and cost of
nodes. [25] applies Omission to create public process views
for inter-organizational cooperation, driven by the need to
hide business data for confidentiality reasons. Users specify
which process tasks represent cooperative tasks that can be
safely shared with partners, and then a public process is
derived which shows these tasks only. These approaches are
close to the separation of concerns between BPEL public
processes, containing communication tasks only, and BPEL
private processes, also containing internal tasks [12]. Deriving
customized process views for specific audiences is also the
purpose of [46], where a method for removing EPC functions
based on the organizational structure is proposed. Process
configuration is another research area where Omission is
applied. It consists in removing from a configurable process
model those fragments that are not relevant to a specific sce-
nario. This is done via the application of an individualization
algorithm. Individualization algorithms have been defined for
various languages, including UML ADs [27], LTSs [43], EPCs
[30], [102], integrated EPCs (an extension of eEPCs) [64],
YAWL [45] and Petri Nets [4]. Finally, Omission also occurs
in [36] and in [19], [20] for achieving customized process
views, and in [49] for simplifying process models that have
been mined from logs. These approaches apply Omission
in combination with Collapse mechanisms (more details are
given in the realization of Collapse).
Pattern 10 (Collapse)
Description Collapse (aka Aggregation) describes features to
synthesize multiple model elements into a single one of more
abstract nature, where the distinction among the constituent
elements is no longer relevant. It implies information synthe-
Purpose To simplify a process model for a specific audience.
Example Fig. 9b shows an example of Collapse between single
control-flow elements from the model in Fig. 3b. Here tasks
Check debts and Check liability, and all tasks in the lower
path of the XOR-split, have been collapsed into a single task
for performing the required checks, resp., a single task for
approving and processing loans.
Metric Decreases model size, and may also decrease diameter
and average connector degree.
Rationale Simpler process models which focus on specific
aspects relevant to a given audience are easier to understand
by the latter [107].
Realization [109] proposes an algorithm to incrementally
simplify a process model by applying a set of reduction rules
via which nodes with low relevance are gradually collapsed to
their predecessor nodes. The order of the collapsed elements
can be stored should the user wish to reverse the collapse
effects. [36] uses a combination of Omission and Collapse
to derive models for cross-organization collaboration. The
approach contains two steps: aggregation and customization.
In the first step, the provider selects those internal tasks that
they wish to hide to a specific customer, and these tasks
are collapsed accordingly. Afterwards, the customer specifies
the tasks they are interested in and the remaining tasks are
either collapsed with each other, or omitted from the model.
Similarly, the Proviado approach [19], [20] applies a combi-
nation of graph reduction (Omission) and graph aggregation
(Collapse) techniques to obtain customized process views,
based on a user query, e.g. “Show the tasks of a particular
user only”. Attribute values of aggregated tasks, e.g. data
information, are also collapsed – a feature that is not available
in other approaches, which only focus on control-flow. Process
views of workflow models are also obtained in [73] by
collapsing connected sets of tasks. The approach in [93], [94]
proposes an algorithm for abstracting process models. It uses
the model’s RPST decomposition to identify fragments that are
structurally suitable for collapse. Then transformation rules
are applied to produce an abstracted fragment by collapsing its
tasks. This algorithm lifts the limitations of another abstraction
algorithm from the same authors [92]. The latter work aimed
to collapse those tasks that are observed less often based on
the identification of abstraction patterns (dead-end, sequential,
block, and loop abstractions). As such, it was limited by the
occurrence of these patterns in a model. [108] proposes an
approach based on the notion of behavioral profiles [119]. A
and sign
High liability
& no debts
liability and
a) Reject
High liability
& no debts
liability Approve
Low liability
and/or debts Low liability
and/or debts
Fig. 9. Two patterns applied to the model in Fig. 3b: (a) the Omission pattern was used to remove the automated tasks, and (b) the Collapse pattern was
used to join the tasks in the lower branch following the XOR-split into a single task.
behavioral profile describing the behavior of a process model
in terms of task order relations if first inferred from a process
model. Then this profile is used together with an user-defined
grouping of tasks to produce an abstract process model where
selected tasks are collapsed based on the defined grouping
of tasks. The degree of collapse is determined by the user.
Collapse has also been applied in process mining [1]. [49]
presents an algorithm in which both Collapse and Omission are
used to identify non-essential details when extracting process
models from logs. The algorithm applies a number of metrics
(derivable from the logs) to establish the significance of
and correlation between model elements, according to which
process models are either collapsed or omitted.
Pattern 11 (Restriction)
Description This pattern captures features to restrict the syntax
and semantics of a process modeling language, by removing
modeling concepts from the language’s meta-model or restrict-
ing the existing ones. This pattern impacts all process models
described by the restricted meta-model.
Purpose To improve understandability and maintenance
through a simplified process model.
Example Fig. 10a shows the restriction of the “Home Loan”
model in Fig. 6a after removing the concept of Event from
the BPMN meta-model.
Rationale A smaller number of element types is easier to
learn for modeling novices [50], [123]. For this reason,
modelers tend to use only a subset of language elements in
practice [123].
Realization Different conformance classes have been intro-
duced in BPMN 2.0 to restrict the meta-model in a con-
trolled way [87]. There are four classes for Process Modeling,
Process Execution, BPEL Process Execution, and Choreog-
raphy Modeling. Another example of meta-model restriction
is the proposal by Silver [106]. It introduces three levels
of BPMN usage: Level 1 for business people, Level 2 for
analysts, and Level 3 for developers. The more business-
oriented levels only contain a subset of the overall BPMN
notation. A similar distinction is sometimes also made by
software vendors. In Tibco’s iProcess Suite, for instance, a
process model can be classified according to its purpose, i.e.
business analysis, deployment or simulation, where the meta-
models for deployment and simulation implement a subset of
the BPMN notation. Similarly, the BPEL standard defines a
subset for abstract processes [12]. Becker and et. [14] outline
an approach for creating process model projections based on
the restriction of the process’ meta-model. These projections
are achieved by applying so-called configuration parameters
to meta-model elements in order to simplify the notation for
a specific audience. For example, one can hide the resource
perspective in the eEPC meta-model so that all the roles and
organizational units that are associated with eEPC Functions
are removed. This functionality is also implemented in the
form of filters by tools such as ARIS [29].
Pattern 12 (Extension)
Description This pattern captures features to extend the syntax
and the semantics of a process modeling language, by adding
new modeling concepts to the language’s meta-model, or
refining the existing ones. This pattern impacts all process
models described by the extended meta-model. It has the
reverse effect of Restriction.
Purpose To obtain either a closer match to the concepts of
a particular domain, or a straightforward transformation to
executable software.
Example Fig. 10b shows the “Home Loan” model in Fig. 6a
after extending the BPMN meta-model with two Task sub-
types, namely Approval and Rejection, and with one Message
Event subtype, namely Fax (each captured by a stereotype).
In Fig. 10b the Approval and Rejection Task stereotypes have
been applied to task Reject loan, resp., Approve Loan, while
the Fax stereotype has been applied to the two message events.
Rationale Extending a language’s meta-model to the specific
concepts of a domain makes the process models described by
this language easier to understand for the audience of that
domain [85], [40].
Realization Both UML ADs and BPMN benefit from the
extension capabilities of the Meta-Object Facility (MOF) [53],
which provides a standardized way for refining existing ele-
ment types based on stereotyping. For instance, this mech-
anism has been used in [103] to extend BPMN with the
concepts of variation point and variant, and in [27] to
extend UML ADs with similar concepts. Moreover, various
approaches exist which extend the meta-models of process
modeling languages by adding new elements, rather than
using stereotypes. For instance, [120] provides an extension
to the BPMN meta-model to explicitly capture access control
requirements. [22] extends BPMN to model non-functional
aspects while [24] provides a similar extension to BPEL.
BPEL4People [10] and BPELJ [18] are two further extensions
of the BPEL meta-model to represent human tasks, resp.,
to incorporate java snippets in BPEL. Further, [110] extends
UML ADs with concepts to define role-based access control
aspects. EPCs have also been extended in different works
with real-time concepts, object orientation, risk, and control-
flow constructs of other languages [76]. UML modeling tools
such as Enterprise Architect, typically support the standard
UML extension mechanism of stereotypes. ARIS provides
liabilities High liability
and no debts
Low liability
and/or debts
liabilities High liability
and no debts
Low liability
and/or debts
Loan sent
for signature
Signed loan
Fig. 10. Examples of (a) Restriction and (b) Extension for the “Home Loan” model in Fig. 6a. In (a) the concept of Event has been removed from the
BPMN meta-model. In (b) new stereotypes have been added to specialize the concepts of Task and Message Event.
features to perform limited customizations of an eEPC meta-
model (called ARIS Method). One can rename meta-model
elements and attributes, and regroup attributes. However it is
not possible to add new elements or attributes.
Similar to our previous work in [66], we now report the
results of evaluating several languages and tools against their
support for the identified patterns. The languages we selected
for this evaluation are mainstream process modeling languages
deriving from standardization efforts, large-scale adoptions or
established research initiatives. Specifically, we chose three
languages for conceptual process modeling (UML ADs 2.3,
eEPCs and BPMN 2.0) and four languages for executable
process modeling (BPMN 2.0, BPEL 1.2/2.0, YAWL 2.2 beta
and Protos 8.0.21). For each language, we also evaluated one
supporting modeling tool. For UML ADs we tested Sparx’s
Enterprise Architect 9; for eEPCs we tested ARIS Business
Architect 7.2 from Software AG; for BPMN we tested Sig-
navio Editor 5.0.0; for BPEL we tested Oracle’s JDeveloper; for YAWL we tested the YAWL Editor and Rules
Editor; and for Protos the Protos Editor 8.0.2/BPM|one from
Pallas Athena.
Table 11 shows the results of the analysis, where tool
evaluations are shown next to the evaluations of the supported
languages, except for Protos, where the language cannot be
separated from its tool, because it is vendor specific. For a
tool, we measured the extent by which it facilitates the support
for a pattern, as it is offered by the corresponding language.
We ranked a tool with a ‘-’ if it offers no support for a pattern;
with a ‘+/-’ if the support is only partial or if it is the same
as that offered by the corresponding language; and with a
‘+’ if the support goes beyond that offered by the language,
i.e. if the tool actually facilitates the application of a pattern.
Accordingly, for Duplication we ranked Signavio, JDeveloper
and Protos with a ‘-’. In particular, in Signavio call activity
tasks cannot be linked with global tasks thus this pattern is not
actually supported. For Vertical Modularization, we ranked the
YAWL Editor with a ‘+/-’ as it is not possible to navigate from
a parent model to a subprocess. Enterprise Architect took a
‘+/-’ for Horizontal Modularization as it supports the concept
of UML Partition (to create parallel modules), but not that of
Activity Edge Connector (to create sequential modules). For
Restriction we gave a ‘+/-’ to Signavio as it only provides two
1Protos is now part of the BPM|one suite that allows Protos models to
be executed. However, in most organizations, Protos is still mainly used for
process modeling and analysis rather than for enactment.
predefined meta-model filters which cannot be customized,
while for Extension we gave a ‘+/-’ to ARIS as it only allows
renaming of elements and attributes of the eEPC meta-model,
but not the addition of new concepts.
UML ADs 2.3
Architect 9
ARIS 7.2
BPMN 2.0
Signavio 5.0.0
BPEL 1.2/2.0
YAWL 2.2 beta
YAWL + Rules
Editor 2.2 beta
Protos 8.0.2 /
Fig. 11. Evaluation results.
Six of the twelve patterns that we identified in this paper
(i.e. Block-Structuring, Compacting, Composition, Merging,
Omission and Collapse) are not applicable to languages since
they refer to tool features only (we crossed the corresponding
cells for the languages in Table 11). For these patterns, we
rated a tool with a ‘+’ if it supported the pattern, and with a ‘-
’ otherwise. As per BPEL, even if this language is essentially
block-structured, tool features could still be provided to block-
structure or compact the content of a Flow activity (e.g. by
removing redundant Link arcs). However, since JDeveloper
does not offer any such feature, we rated this tool with a ‘-
’ along these two patterns. In fact, these six patterns are not
supported by any of the evaluated tools, except for ARIS which
caters for Composition. This indicates a clear immaturity of
process modeling tools for such advanced features, which have
only been explored in research.
One would expect that a tool generally offered wider pattern
support than the respective language. Indeed, this is what we
observed in the benchmark of tools for the concrete syntax pat-
terns [66]. However for the abstract syntax patterns the results
are more varied. ARIS supports more patterns than eEPCs,
Enterprise Architect supports as many patterns as UML ADs,
while Signavio, JDeveloper and the YAWL Editors support
less patterns than their respective languages. The reason for
such different level of sophistication among the tools evaluated
may be twofold. First, these tools have different maturity (for
example, ARIS and Enterprise Architect have been around
much longer than the others). Second, the major difference
in support between BPMN 2.0 and Signavio is likely due to
the fact that BPMN 2.0 has only been standardized recently
(a few months before the time of writing). Thus we cannot
yet expect a high level of maturity for its supporting tools.
This difference in patterns support between BPMN 2.0 and
Signavio is even more evident because BPMN 2.0 is the
language that supports the greatest number of patterns, out
of the languages being evaluated. This is clearly a reflection
of the evolution of business process modeling languages.
For the evaluation of the usability of the patterns we drew
inspiration from the technology acceptance model [28] and its
adaptation to conceptual modeling [75]. This theory postulates
that actual usage of an information technology artifact—
patterns in the case of this paper—is mainly influenced by the
perceptions of potential users regarding usefulness and ease
of use. Accordingly, a potential user who perceives a pattern
to be useful and easy to use is likely to actually adopt it.
We conducted a series of focus group sessions with pro-
fessionals to discuss the patterns, in a similar vein as in
our earlier work [66]. Altogether, 9 process modeling experts
participated in these sessions, which took place in Stockholm
(5 participants) and in Berlin (4 participants). On average,
the participants had close to 10 years experience with process
modeling. When we asked them, they estimated that in the past
12 months each on average analyzed slightly over 200 models,
while having created over 60 models in this same period. The
typical size of such a model would include 20 tasks. Due to
this extensive involvement in both process model analysis and
development, the participants can be considered as genuine
experts in the field.
We used a questionnaire with seven-point scale items
adopted from [75] to measure the participants’ perceptions on
usefulness and ease of use for each of the patterns. Our earlier
pattern evaluation using the same set of questions [66] already
pointed at the high internal consistency of these questions,
which is a measure for the reliability of this evaluation. Indeed,
the computation of Cronbach’s alpha as ex post reliability
check for this evaluation provided the values 0.91 for useful-
ness and 0.89 for ease of use, which confirm our confidence
in this instrument. The boxplots in Fig. 12 and 13 display
the outcomes of the data analysis for the patterns’ usefulness
and ease of use respectively (in a boxplot the median value
is shown as a horizontal line in a box, which represents the
interval between the lower and upper quartiles).
As displayed by Fig. 12, all patterns are perceived to be use-
ful (each median at least equals 4). The patterns that received
the highest scores are patterns 4 (Vertical Modularization)
and 11 (Restriction), the latter even receiving the maximum
appraisal by all but 2 of the participants. Figure 13 shows
Fig. 12. Perceived usefulness of the patterns.
Fig. 13. Perceived ease of use of the patterns.
that ease of use is overall considered positively as well, with
median values of 5 or more for all but patterns 6 (Orthogonal
Modularization) and 8 (Merging).
In the follow-up discussion with the participants, we invited
them to explain their scores. One of the Stockholm participants
commented on Pattern 11 (Restriction), which received a high
score on usefulness, stating that it is “very efficient” and
often applied by this person in modeling workshops. The
other pattern that received explicit praise for usefulness in the
discussion was Pattern 3 (Compacting), as it was recognized
to reduce confusion of name similarities in large models. By
contrast, one of the Berlin participants was rather critical about
Pattern 6, noting that it was complicated to understand and to
apply. As he said, “If at all, this might be relevant for very
large repositories of executable process models”. We observe
that the boxplot for this particular pattern covers a wide
spectrum of the evaluation scale for usefulness (see Fig. 12),
meaning that the opinions on this pattern vary. Indeed, two
other participants expressed their belief in the value of this
pattern, in particular to separate exceptions from the normal
flow. These combined insights point at a potentially more
restricted usefulness of Pattern 6 in comparison with the other
In summary, the focus group sessions support the statement
that the patterns can be considered useful and in general easy
to use. It is interesting to note that in comparison to our earlier
evaluation of patterns for concrete syntax modifications [66],
tool support for the abstract syntax patterns was not considered
an issue. This may very well point at a greater adoption of
these patterns in praxis.
This paper should be seen as continuation of the work
presented in [66] where we described and evaluated eight
patterns for concrete syntax modification. The goal of these
patterns is to reduce the perceived model complexity without
changing the abstract syntax, i.e., the goal is to simplify
the representation of the process model without changing its
formal structure. An example of such a pattern is Layout
Guidance, i.e., the availability of layout conventions or advice
to organize the various model elements on a canvas. The
other seven patterns described in [66] are Enclosure Highlight,
Graphical Highlight, Pictorial Annotation, Textual Annotation,
Explicit Representation, Alternative Representation and Nam-
ing Guidance.
The twelve patterns presented in this paper complement
the patterns of [66] as they operate on the abstract syntax
of process models. For example, duplicating a task to make
the model structured changes the abstract syntax whereas
modifying the layout does not.
Many authors have worked on functionality related to
abstract syntax modifications as is illustrated by the many
references provided when describing the possible realizations
of such patterns. However, we are not aware of other ap-
proaches that systematically collect patterns to improve the
understandability of process models.
There have been other approaches to analyze the expres-
siveness or completeness of BPM languages and systems, e.g.,
the workflow patterns framework [2], [121], Bunge, Wand and
Weber’s (BWW) framework [116], and the Semiotic Quality
Framework (SEQUAL) [59]. The workflow patterns [2], [121]
provide a language-independent description of control-flow,
resource, data and exception handling aspects in workflow lan-
guages. Their development started as a bottom-up, comparative
analysis of process modeling languages and tools, with the
purpose to evaluate their suitability and determine similarities
and differences among them. This analysis does not include
mechanisms to improve the understandability and reduce the
complexity of process models.
The BWW framework [116] refers to Wand and Weber’s tai-
loring and application of Bunge’s ontology [21] to information
systems. It was initially used for the analysis and comparison
of conceptual modeling languages, and later, it was also used
for the analysis of process modeling languages [101], [95].
However, the BWW framework lacks conceptual structures
central to process modeling such as various types of splits
and joins, iteration and cancelation constructs, and different
forms of concurrency restrictions. Thus, despite its utilization
in practice, its suitability for evaluating process modeling lan-
guages can be questioned. Also, its application as a theoretical
foundation for conceptual modeling has been criticized [122].
The SEQUAL framework [59] introduces and reasons about
different aspects relevant to model quality. These aspects
span different quality notions, including physical, empirical,
syntactic, semantic, pragmatic and social quality. Particularly
relevant for our work are the empirical quality, which deals
with readability matters such as graph aesthetics, and the
pragmatic quality, which deals with the understanding of
a model by its audience. SEQUAL has been used for the
evaluation of process modeling languages [115], and has later
been extended to deal specifically with the quality of process
models [60]. Nonetheless, the authors themselves acknowledge
SEQUAL’s “disability (sic) to facilitate precise, quantitative
evaluations of models” [60, p. 101]. In contrast, the patterns
collections presented in [66] and in this paper provide a
concrete means to evaluate the pragmatic and empirical quality
of process modeling languages and supporting tools (while
focusing on understandability).
Finally, our work is related to [85], where a theory of
general principles for designing cognitive-effective visual no-
tations is proposed. Specifically, our Modularization patterns
can be seen as an implementation of the Principle of Com-
plexity Management, which prescribes the provision of mod-
ularization and hierarchical abstraction to deal with model
complexity. However, our patterns collection also provides
other mechanisms related to complexity management besides
modularization. Our Restriction pattern is related to the Prin-
ciple of Graphic Economy, according to which the number of
different graphical symbols should be controlled in order to
be “cognitively manageable”. In fact, as a result of restricting
a meta-model, the number of symbols available will also
be restricted. This is particularly valid for languages with
an extensive number of graphical symbols such as eEPCs
and BPMN, where Restriction could be applied to filter-out
irrelevant symbols for particular audiences. Further, Extension
is related to the Principle of Cognitive Fit, which prescribes
the use of different dialects for different audiences. In fact
this pattern can be used to create an audience-specific process
modeling dialect by extending a process’ meta-model.
The main contribution of this paper is a systematic analysis
of abstract syntax modifications for reducing process model
complexity, as they occur in the literature, in process modeling
languages, and tool implementations. This analysis took the
form of a collection of frequently recurring patterns. These
twelve patterns, combined with the eight patterns presented
in [66] provide a comprehensive overview of existing mecha-
nisms and language features to improve the understandability
of process models by reducing complexity. The patterns in [66]
focused on changes to the concrete syntax (e.g., improving the
layout) but did not consider changes to the abstract syntax.
After documenting these patterns, we evaluated state-of-
the-art languages and language implementations in terms of
these patterns, and conducted a usability test with practitioners.
The results of the usability test demonstrate that all identified
patterns are indeed perceived as relevant.
Although most tools provide some support for modifying
models to improve their understandability, there is no real
guidance on how to simplify and clarify the representation of
process models. For example, many tools allow the duplication
of model elements (e.g., two nodes referring to the same
activity), however, automated support to suggest duplication
for increasing the understandability is missing in the current
generation of process model editors. Thus, one could argue
that today’s tools are good for model creation, but provide
little support for model management and maintenance. Since
processes change at an increasing pace and more and more
variants of the same process need to be supported, this
shortcoming is limiting the applicability of BPM technology.
Thus, we hope that tool vendors will use our patterns as a
guide to drive the development of better functionality. We also
intend to extend existing research tools such as the YAWL
Editor, and the process model repository AProMoRe [100],
with innovative features to support the patterns identified.
[1] W.M.P. van der Aalst. Process Mining: Discovery, Conformance and
Enhancement of Business Processes. Springer, 2011.
[2] W.M.P. van der Aalst, A.H.M. ter Hofstede, B. Kiepuszewski, and
A.P. Barros. Workflow Patterns. Distributed and Parallel Databases,
14(1):5–51, 2003.
[3] W.M.P. van der Aalst and T. Basten. Inheritance of Workflows:
An Approach to Tackling Problems Related to Change. Theoretical
Computer Science, 270(1-2):125–203, 2002.
[4] W.M.P. van der Aalst, M. Dumas, F. Gottschalk, A.H.M. ter Hofst-
ede, M. La Rosa, and J. Mendling. Preserving Correctness During
Business Process Model Configuration. Formal Aspects of Computing,
22(3):459–482, 2010.
[5] W.M.P. van der Aalst and K. M. van Hee. Workflow Management:
Models, Methods, and Systems. MIT Press, 2002.
[6] W.M.P. van der Aalst, R.S. Mans, and N.C. Russell. Workflow Support
Using Proclets: Divide, Interact, and Conquer. IEEE Data Eng. Bull.,
32(3), 2009.
[7] A.A. Abdul, G.K.T. Wei, G.M. Muketha, and W.P. Wen. Complexity
Metrics for Measuring the Understandability and Maintainability of
Business Process Models using Goal-Question-Metric (GQM). IJCSNS,
8(5):219–225, 2008.
[8] M. Adams, A.H.M. ter Hofstede, W.M.P. van der Aalst, and D. Ed-
mond. Dynamic, Extensible and Context-Aware Exception Handling
for Workflows. In OTM, volume 4803 of LNCS, pages 95–112.
Springer, 2007.
[9] M. Adams, A.H.M. ter Hofstede, D. Edmond, and W.M.P. van der
Aalst. Facilitating Flexibility and Dynamic Exception Handling in
Workflows through Worklets. In CAiSE (short papers), volume 161., 2005.
[10] A. Agrawal, M. Amend, M. Das, C. Keller, M. Kloppmann, D. K¨
F. Leymann, R. M¨
uller, G. Pfau, K. Plosser, R. Rangaswamy, A. Rick-
ayzen, M. Rowley, P. Schmidt, I. Trickovic, A. Yiu, and M. Zeller. WS-
BPEL Extension for People (BPEL4People), Version 1.0. Technical
report, Active Endpoints, Adobe, BEA, IBM, Oracle and SAP, 2007.
[11] C. Alexander. A Pattern Language: Towns, Building and Construction.
Oxford University Press, 1977.
[12] A. Arkin, S. Askary, B. Bloch, F. Curbera, Y. Goland, N. Kartha,
C.K. Liu, S. Thatte, P. Yendluri, and A. Yiu. Web Services Business
Process Execution Language (WS-BPEL), Version 2.0. OASIS Standard.
Accessed: January 2011.
[13] A. Basu and R.W. Blanning. Synthesis and decomposition of processes
in organizations. Info. Sys. Research, 14:337–355, 2003.
[14] J. Becker, P. Delfmann, A. Dreiling, R. Knackstedt, and D. Kuropka.
Configurative Process Modeling – Outlining an Approach to increased
Business Process Model Usability. In M. Khosrow-Pour, editor, Pro-
ceedings of the 14th Information Resources Management Association
International Conference, pages 615–619. IRM Press, 2004.
[15] R. Bergenthum, J. Desel, S. Mauser, and R. Lorenz. Construction of
process models from example runs. ToPNoC II, 2009.
[16] G. Berthelot. Checking Properties of Nets Using Transformations. In
G. Rozenberg, editor, Advances in Petri Nets 1985, volume 222 of
LNCS, pages 19–40. Springer, 1986.
[17] G. Berthelot. Transformations and Decompositions of Nets. In
W. Brauer, W. Reisig, and G. Rozenberg, editors, Advances in Petri
Nets 1986 Part I: Petri Nets, central models and their properties,
volume 254 of Lecture Notes in Computer Science, pages 360–376.
Springer-Verlag, Berlin, 1987.
[18] M. Blow, Y. Goland, M. Kloppmann, F. Leymann, G. Pfau, D. Roller,
and M. Rowley. BPELJ: BPEL for Java. Technical report, BEA and
IBM, 2004.
[19] R. Bobrik, T. Bauer, and M. Reichert. Proviado - personalized and
configurable visualizations of business processes. In Proc of. EC-Web,
pages 61–71, 2006.
[20] R. Bobrik, M. Reichert, and T. Bauer. View-based process visualization.
In Proc of. BPM, pages 88–95, 2007.
[21] M. Bunge. Treatise on Basic Phylosphy Volume 3: Ontology I – The
Furniture of the World. Kluwer Academic Publishers, 1977.
[22] C. Cappelli, J.C.S.P. Leite, T. Batista, and L. Silva. An Aspect-Oriented
Approach to Business Process Modeling. In Early Aspects of Aspect-
Oriented Software Development, pages 7–12, 2009.
[23] A. Charfi and M. Mezini. Aspect-Oriented Workflow Languages. In
Cooperative Information Systems, volume 4275 of LNCS, pages 183–
200. Springer, 2006.
[24] A. Charfi and M. Mezini. AO4BPEL: An Aspect-oriented Extension to
BPEL. In Proc. of WWW, volume 10, pages 309–344. Springer, 2007.
[25] I. Chebbi, S. Dustdar, and S. Tata. The view-based approach to dy-
namic inter-organizational workflow cooperation. Data & Knowledge
Engineering, 56(2):139–173, 2006.
[26] J. Cortadella, M. Kishinevsky, L. Lavagno, and A. Yakovlev. Deriving
Petri Nets from Finite Transition Systems. IEEE Transactions on
Computers, 47(8):859–882, August 1998.
[27] K. Czarnecki and M. Antkiewicz. Mapping Features to Models: A
Template Approach Based on Superimposed Variants. In Proc. of
GPCE, pages 422–437. Springer-Verlag, Berlin, 2005.
[28] F.D. Davis. Perceived usefulness, perceived ease of use, and user
acceptance of information technology. MIS Quarterly, 13(3):319–340,
[29] R.B. Davis and E. Brabander. ARIS Design Platform: Getting Started
with BPM. Springer, 2007.
[30] P. Delfmann. Adaptive Referenzmodellierung. Methodische Konzepte
zur Konstruktion und Anwendung wiederverwendungsorientierter In-
formationsmodelle. Logos, 2006. (in German).
[31] J. Desel. Validation of process models by construction of process nets.
In BPM, 2000.
[32] J. Desel and J. Esparza. Free Choice Petri Nets, volume 40 of
Cambridge Tracts in Theoretical Computer Science. Cambridge Univ.
Press, Cambridge, UK, 1995.
[33] B.F. van Dongen, W.M.P. van der Aalst, and H.M.W. Verbeek. Veri-
fication of EPCs: Using reduction rules and Petri nets. In In Proc. of
CAiSE, volume 3520 of LNCS, pages 372–386. Springer, 2005.
[34] P. Effinger, M. Siebenhaller, and M. Kaufmann. An Interactive Layout
Tool for BPMN. E-Commerce Technology, 0:399–406, 2009.
[35] F. Elliger, A. Polyvyanyy, and M. Weske. On separation of concurrency
and conflicts in acyclic process models. In EMISA, pages 25–36, 2010.
[36] R. Eshuis and P.W.P.J. Grefen. Constructing customized process views.
Data Knowl. Eng., 64(2):419–438, 2008.
[37] J. Esparza and K. Heljanko. Unfoldings: a partial-order approach to
model checking. Springer-Verlag New York Inc, 2008.
[38] D. Fahland. Oclets – scenario-based modeling with petri nets. In Proc
of Petri Nets, LNCS. Springer, 2009.
[39] D. Fahland and M. Weidlich. Scenario-based process modeling with
greta. In BPM Demos, volume 615. CEUR, 2010.
[40] M. Fowler and R. Parson. Domain-Specific Languages. Addison-
Wesley, 2010.
[41] E. Gamma, R. Helm, R. Johnson, and J. Vlissides. Design Patterns: El-
ements of Reusable Object-Oriented Software. Professional Computing
Series. Addison Wesley, Reading, MA, USA, 1995.
[42] A. Gater, D. Grigori, and M. Bouzeghoub. Ranked matching for owl-s
process model discovery. Technical report, PRISM, 2010.
[43] F. Gottschalk, W.M.P. van der Aalst, and H.M. Jansen-Vullers. Con-
figurable Process Models: A Foundational Approach. In Reference
Modeling, pages 59–78. Springer, 2007.
[44] F. Gottschalk, W.M.P. van der Aalst, and M.H. Jansen-Vullers. Merging
event-driven process chains. In Proc. of CoopIS, volume 5331 of LNCS,
pages 418–426. Springer, 2008.
[45] F. Gottschalk, W.M.P. van der Aalst, M.H. Jansen-Vullers, and M. La
Rosa. Configurable Workflow Models. Int. Journal of Cooperative
Information Systems, 17(2):177–221, 2008.
[46] F. Gottschalk, M. Rosemann, and W.M.P. van der Aalst. My own
process: Providing dedicated views on EPCs. In EPK 2005 -
aftsprozessmanagement mit Ereignisgesteuerten Prozessketten,
volume 167 of CEUR, pages 156–175, 2005.
[47] Object Management Group. OMG Unified Modeling Language 2.3.
OMG,, 2010.
[48] V. Gruhn and R. Laue. Reducing the cognitive complexity of business
process models. In IEEE ICCI, pages 339–345, 2009.
[49] C.W. G¨
unther and W.M.P. van der Aalst. Fuzzy Mining - Adaptive
Process Simplification Based on Multi-perspective Metrics. In Proc.
of BPM, volume 4714 of LNCS, pages 328–343. Springer, 2007.
[50] M. H. Halstead. Elements of Software Science, volume 7 of Operating,
and Programming Systems Series. Elsevier, 1977.
[51] R. Hauser, M. Friess, J.M. Kuster, and J. Vanhatalo. An Incremental
Approach to the Analysis and Transformation of Workflows Using
Region Trees. IEEE Transactions on Systems, Man, and Cybernetics,
Part C, 38(3):347–359, 2008.
[52] R. Hauser and J. Koehler. Compiling Process Graphs into Executable
Code. In GPCE, volume 3286 of LNCS, pages 317–336, 2004.
[53] Brian Henderson-Sellers and Cesar Gonzalez-Perez. Uses and abuses of
the stereotype mechanism in uml 1.x and 2.0. In In Proc. of MoDELS,
volume 4199 of LNCS, pages 16–26. Springer, 2006.
[54] N.F. Kock Jr. Product flow, breadth and complexity of business
processes: An empirical study of 15 business processes in three orga-
nizations. Business Process Re-engineering & Management Journal,
2:8–22, 1996.
[55] G. Keller, M. N¨
uttgens, and A.-W. Scheer. Semantische Processmod-
ellierung auf der Grundlage Ereignisgesteuerter Processketten (EPK).
Technical report, University of Saarland, Germany, 1992 (in German).
[56] B. Kiepuszewski, A.H.M ter Hofstede, and C. Bussler. On Structured
Workflow Modelling. In Advanced Information Systems Engineering,
volume 1789 of LNCS, pages 431–445. Springer, 2000.
[57] N. Kock, J. Verville, A. Danesh-Pajou, and D. DeLuca. Communi-
cation flow orientation in business process modeling and its effect on
redesign success: results from a field study. Decision Support Systems,
46(2):562–575, 2009.
[58] J. Koehler and R. Hauser. Untangling Unstructured Cyclic Flows –
A Solution Based on Continuations. In OTM, volume 3290 of LNCS,
pages 121–138, 2004.
[59] J. Krogstie, O.I. Lindland, and G. Sindre. Defining quality aspects for
conceptual models. In Proc. of ISCO, pages 216–231, 1995.
[60] J. Krogstie, G. Sindre, and H. Jorgensen. Process models representing
knowledge for action: a revised quality framework. Eur. J. Inf. Syst.,
15(1):91–102, 2006.
[61] J.M. K ¨
uster, C. Gerth, A. F¨
orster, and G. Engels. Detecting and
resolving process model differences in the absence of a change log.
In Proc. of BPM, volume 5240 of LNCS, pages 244–260. Springer,
[62] J.M. K¨
uster, C. Gerth, A. F¨
orster, and G. Engels. A tool for process
merging in business-driven development. In Proc. of the CAiSE’2008
Forum, volume 344 of CEUR Workshop Proceedings, pages 89–92.
CEUR, 2008.
[63] J.M. K¨
uster, K. Ryndina, and H. Gall. Generation of business process
models for object life cycle compliance. In Proc. of BPM, volume
4714 of LNCS, pages 165–181. Springer, 2007.
[64] M. La Rosa, M. Dumas, A.H.M. ter Hofstede, and J. Mendling.
Configurable Multi-Perspective Business Process Models. Information
Systems, 36(2), 2011.
[65] M. La Rosa, M. Dumas, R. Uba, and R. Dijkman. Merging business
process models. In OTM, LNCS. Springer, 2010.
[66] M. La Rosa, P. Wohed, A.H.M. ter Hofstede, H.A. Reijers, J. Mendling,
and W.M.P. van der Aalst. Managing process model complexity via
concrete syntax modifications. IEEE Trans. on Industrial Informatics,
7(2), 2011.
[67] R. Laue and V. Gruhn. Complexity metrics for business process models.
In Business Information Systems, volume 85 of LNI, pages 1–12. GI,
[68] R. Laue and V. Gruhn. Technologies for Business Information Systems,
chapter Approaches for Business Process Model Complexity Metrics,
pages 13–24. Springer, 2007.
[69] R. Laue and J. Mendling. Structuredness and its significance for
correctness of process models. Inf. Syst. E-Business Management,
8(3):287–307, 2010.
[70] F. Leymann. Workflows make objects really useful. In EMISA Forum,
[71] F. Leymann and D. Roller. Workflow-based Applications. IBM Systems
Journal, 36(1):102–123, 1997.
[72] C. Li, M. Reichert, and A. Wombacher. The minadept clustering
approach for discovering reference process models out of process
variants. Int. J. Cooperative Inf. Syst., 19(3-4):159–203, 2010.
[73] D.R. Liu and M. Shen. Workflow modeling for virtual processes: an
order-preserving process-view approach. Information Systems, 28:505–
532, 2003.
[74] R. Liu and A. Kumar. An Analysis and Taxonomy of Unstructured
Workflows. In Proc. of BPM, volume 3649, pages 268–284, 2005.
[75] A. Maes and G. Poels. Evaluating quality of conceptual modelling
scripts based on user perceptions. Data & Knowledge Engineering,
63(3):701–724, 2007.
[76] J. Mendling. Metrics for Process Models: Empirical Foundations
of Verification, Error Prediction, and Guidelines for Correctness,
volume 6 of LNBIP. Springer, 2009.
[77] J. Mendling and W.M.P. van der Aalst. Formalization and Verification
of EPCs with OR-Joins Based on State and Context. In J. Krogstie,
A.L. Opdahl, and G. Sindre, editors, In Proc. of CAiSE, volume 4495
of LNCS, pages 439–453, 2007.
[78] J. Mendling, K.B. Lassen, and U. Zdun. On the transformation of con-
trol flow between block-oriented and graph-oriented process modelling
languages. International Journal of Business Process Integration and
Management, 3(2):96–108, 2008.
[79] J. Mendling, G. Neumann, and W.M.P. van der Aalst. Understanding
the occurrence of errors in process models based on metrics. In OTM,
volume 4803 of LNCS, pages 113–130. Springer, 2007.
[80] J. Mendling, H.A. Reijers, and J. Cardoso. What Makes Process Models
Understandable? In Proc. of BPM, volume 4714 of LNCS, pages 48–63.
Springer, 2007.
[81] J. Mendling, H.A. Reijers, and W.M.P. van der Aalst. Seven Process
Modeling Guidelines (7PMG). Information and Software Technology,
52(2):127–136, 2010.
[82] J. Mendling and C. Simon. Business process design by view integra-
tion. In Proc. of BPM Workshops, volume 4103 of LNCS, pages 55–64.
Springer, 2006.
[83] J. Mendling and M. Strembeck. Influence Factors of Understanding
Business Process Models. In BIS, LNBIP, pages 142–153. Springer,
[84] B. Meyer. Introduction to the Theory of Programming Languages.
Prentice-Hall, Englewood Cliffs, New Jersey, 1990.
[85] D.L. Moody. The “Physics” of Notations: Toward a Scientific Basis
for Constructing Visual Notations in Software Engineering. IEEE
Transactions on Software Engineering, 35:756–779, 2009.
[86] OMG. Business Process Modeling Notation (BPMN), ver. 1.2, January
[87] OMG. Business Process Model and Notation (BPMN) ver. 2.0, January
[88] M. Petre. Cognitive dimensions beyond the notation. J. Vis. Lang.
Comput., 17(4):292–301, 2006.
[89] A. Polyvyanyy, L. Gacia-Banuelos, and M. Weske. Unveiling Hidden
Unstructured Regions in Process Models. In OTM, volume 5870 of
LNCS, pages 340–356, 2009.
[90] A. Polyvyanyy, L. Garc´
nuelos, and M. Dumas. Structuring acyclic
process models. In BPM, volume 6336 of LNCS, pages 276–293.
Springer, 2010.
[91] A. Polyvyanyy, S. Smirnov, and M. Weske. Process Model Abstraction:
A Slider Approach. In Proc. of EDOC, pages 325–331. Springer, 2008.
[92] A. Polyvyanyy, S. Smirnov, and M. Weske. Reducing complexity of
large epcs. In Proc of. MobIS, pages 195–207. GI, 2008.
[93] A. Polyvyanyy, S. Smirnov, and M. Weske. On application of structural
decomposition for process model abstraction. In BPSC, pages 110–122.
GI, 2009.
[94] A. Polyvyanyy, S. Smirnov, and M. Weske. The Triconnected Abstrac-
tion of Process Models. In Proc. of BPM, volume 5701 of LNCS, pages
229–244. Springer, 2009.
[95] J. Recker, M. Indulska, M. Rosemann, and P. Green. How Good is
BPMN Really? Insights from Theory and Practice. In Proc. of ECIS,
[96] J. Recker, M. zur Muehlen, K. Siau, J. Erickson, and M. Indulska.
Measuring Method Complexity: UML versus BPMN. In AMCIS, pages
1–12. AIS, 2009.
[97] H.A. Reijers, R.S. Mans, and R.A. van der Toorn. Improved model
management with aggregated business process models. Data Knowl.
Eng., 68(2):221–243, 2009.
[98] H.A. Reijers and J. Mendling. A study into the factors that influence
the understandability of business process models. IEEE Transactions
on Systems Man and Cybernetics, Part A, page In Press, 2010.
[99] H.A. Reijers, J. Mendling, and R.M. Dijkman. Human and automatic
modularizations of process models to enhance their comprehension.
Information Systems, 36(5):881–897, 2011.
[100] M. La Rosa, H.A. Reijers, W.M.P. van der Aalst, R.M. Dijkman,
J. Mendling, M. Dumas, and L. Garcia-Banuelos. APROMORE: An
Advanced Process Model Repository. Expert Systems With Applica-
tions, 38(6), 2011.
[101] M. Rosemann, J. Recker, M. Indulska, and P. Green. A Study of the
Evolution of the Representational Capabilities of Process Modeling
Grammars. In Proc. of CAiSE, pages 447–461, 2006.
[102] M. Rosemann and W.M.P. van der Aalst. A configurable reference
modelling language. Information Systems, 32(1):1–23, 2007.
[103] A. Schnieders and F. Puhlmann. Variability Mechanisms in E-Business
Process Families. In Proc. of BIS, volume 85 of LNI, pages 583–601.
GI, 2006.
[104] M. Schrepfer, J. Wolf, J. Mendling, and H.A. Reijers. The impact of
secondary notation on process model understanding. In A. Persson and
J. Stirna, editors, PoEM, pages 161–175. IFIP, 2009.
[105] A. Sharp and P. McDermott. Workflow Modeling: Tools for Process
Improvement and Application Development. Artech House, 2001.
[106] B. Silver. BPMN Method & Style. Cody-Cassidy Press, 2009.
[107] S. Smirnov, H.A. Reijers, T.Nugteren, and M. Weske. Business
process model abstraction: Theory and practice. Technical Report 35,
University of Potsdam, 2010.
[108] S. Smirnov, M. Weidlich, and Jan Mendling. Business process model
abstraction based on behavioral profiles. In Proc. of ICSOC, volume
6470 of LNCS, pages 1–16, 2010.
[109] A. Streit, B. Pham, and R. Brown. Visualization Support for Managing
Large Business Process Specifications. In BPM, volume 3649 of LNCS,
pages 205–219. Springer, 2005.
[110] M. Strembeck and J. Mendling. Modeling process-related rbac models
with extended uml activity models. Information & Software Technol-
ogy, 53(5):456–483, 2011.
[111] S. Sun, A. Kumar, and J. Yen. Merging workflows: A new per-
spective on connecting business processes. Decision Support Systems,
42(2):844–858, 2006.
[112] A.H.M. ter Hofstede, W.M.P. van der Aalst, M. Adams, and N. Russell,
editors. Modern Business Process Automation: YAWL and its Support
Environment. Springer, 2010.
[113] R. Uba, M. Dumas, L. Garcia-Banuelos, and M. La Rosa. Clone
detection in repositories of business process models. In Proc. of BPM,
LNCS, 2011.
[114] J. Vanhatalo, J. Volzer, and J. Kohler. The refined process structure
tree. DKE, 68(9):793–818, 2009.
[115] T. Wahl and G. Sindre. Advanced Topics in Database Research, vol-
ume 5, chapter An Analytical Evaluation of BPMN Using a Semiotic
Quality Framework. IGI Global, 2006.
[116] Y. Wand and R. Weber. On the Ontological Expressiveness of
Information Systems Analysis and Design Grammars. Journal of
Information Systems, 3:217–237, 1993.
[117] B. Weber, M. Reichert, J. Mendling, and H.A. Reijers. Refactoring
large process model repositories. Computers in Industry, 62(5):467–
486, 2011.
[118] Barbara Weber, Manfred Reichert, and Stefanie Rinderle-Ma. Change
patterns and change support features - enhancing flexibility in process-
aware information systems. Data Knowl. Eng., 66(3):438–466, 2008.
[119] M. Weidlich, J. Mendling, and M. Weske. Efficient consistency
measurement based on behavioural profiles of process models. IEEE
TSE, page (to appear), 2011.
[120] C. Wolter and A. Schaad. Modeling of task-based authorization
constraints in bpmn. In In Proc. of BPM, volume 4714 of LNCS,
pages 64–79. Springer, 2007.
[121] Workflow Patterns Initiative. Home Page. http://www. Accessed: February 2010.
[122] B. Wyssusek. On Ontological Foundations of Conceptual Modelling.
Scandinavian Journal of Information Systems, 18(1):63–80, 2006.
[123] M. zur Muehlen and J. Recker. How much language is enough?
theoretical and practical use of the business process modeling notation.
In Proc. of CAiSE, volume 5074 of LNCS, pages 465–479. Springer,
Marcello La Rosa is a Senior Lecturer with the
BPM research group at the Queensland University
of Technology, Brisbane, Australia. He obtained his
PhD in Computer Science with the same research
group in 2009. His research interests embrace differ-
ent topics in the BPM area, such as management of
large process model collections, process modeling,
configuration and automation. Marcello is a senior
trainer for professional education courses on BPM
and service-oriented architecture topics.
Petia Wohed is an Associate Professor at the
Department of Computer and Systems Sciences at
Stockholm University, where she is a member of
the Information System Laboratory. Since her grad-
uation in 2000, Wohed’s main interest is in the
area of business process management, in which she
has worked on a series of patterns-based analyses
of modern process modeling languages and open-
source workflow systems.
Jan Mendling is a Junior-Professor with the Insti-
tute of Information Systems at Humboldt-Universit¨
zu Berlin, Germany. His research areas include busi-
ness process management, conceptual modeling and
enterprise systems. He has published more than 100
research papers and articles. Jan is member of the
editorial board of three international journals. He
served as co-chair for the Int. Conference on BPM in
2010 and was the initiator of the BPMN workshop
Arthur H.M. ter Hofstede is a Professor at the
Faculty of Science & Technology of Queensland
University of Technology in Brisbane, Australia.
He is co-leader of the BPM research group in this
faculty. He is also a Professor in the Information
Systems group at Eindhoven University of Tech-
nology in Eindhoven, The Netherlands. His main
research interests lie in the area of business process
automation. He is involved in both the Workflow
Patterns Initiative and the YAWL Initiative.
Hajo A. Reijers is an Associate Professor in the
Information Systems group at Technische Univer-
siteit Eindhoven and an Affiliated Professor with
the TIAS/Nimbas Business School of Tilburg Uni-
versity. His research interests cover business process
redesign, business process modeling, workflow man-
agement technology, and simulation. He published
over 75 refereed papers and recently served as the
co-chair of the Int. Conference on BPM in 2009.
Wil M.P. van der Aalst is Full Professor of In-
formation Systems at the Technische Universiteit
Eindhoven and Adjunct Professor at Queensland
University of Technology. His research interests in-
clude workflow management, process mining, Petri
nets, process modeling and analysis. Many of his
papers are highly cited (he has an H-index of 80 as
per Google Scholar, making him the Dutch computer
scientist with the highest H-index) and his ideas
have influenced researchers, software developers and
standardization committees on process support.
... Therefore, different approaches have been developed to enable process designers to deal with the complexity. La Rosa et al. categorize these approaches into two main categories, i.e., concrete syntax modifications [31] and abstract syntax modifications [32]. They also identified different patterns that can be applied in each category. ...
... The concrete syntax modifications refer to (i) using highlights, (ii) following layout guidelines, (iii) following naming guidelines, or (iv) applying different representations techniques, e.g., using icons for tasks, etc. [31]. The abstract syntax modifications refer to applying different abstraction techniques in business process modeling, i.e., vertical, horizontal, or orthogonal modularization techniques [32]. La Rosa et al. evaluated how users perceived the identified patterns' usefulness and ease of use by applying the technology acceptance model [14]. ...
... These measures are widely used to evaluate different information systems, including various business process modeling languages, e.g. [27,29,31,32,44]. ...
Full-text available
Case Management has been evolving to support knowledge-intensive business process management, resulting in different modeling languages, e.g., Declare, Dynamic Condition Response (DCR), and Case Management Model and Notation (CMMN). A language will die if users do not accept and use it in practice—similar to extinct human languages. Thus, evaluating how users perceive languages is important to improve them. Although some studies have investigated how the process designers perceived Declare and DCR, there is a lack of research on how they perceive CMMN—especially in comparison with other languages. Therefore, this paper investigates and compares how process designers perceive these languages based on the Technology Acceptance Model. The paper includes two studies conducted in 2020 and 2022, both performed by educating participants through a course, with feedback on their assignments, to reduce biases. The perceptions are collected through questionnaires before and after feedback on the final practice. Results show that the perceptions change is insignificant after feedback due to the participants being well-trained. The reliability of responses was tested using Cronbach’s alpha. The results of the first study show that both DCR and CMMN were perceived as having acceptable usefulness and ease of use, but CMMN was perceived as significantly better than DCR in terms of ease of use. The results of the second study show that only DCR was perceived significantly better than Declare in terms of usefulness. The participants’ feedback shows potential areas for improvement in languages and tool support to enhance perceived usefulness and ease of use.
... We cross-referenced between these sources to obtain definitive solutions to our questions. [21,[35][36][37][38][39][40][41][42]. ...
Full-text available
The ideology behind process modelling is to visualise lengthy event logs into simple representations interpretable to the end user. Classifying process models as simple or complex is based on criteria that evaluate attributes of models and quantify them on a scale. These metrics measure various characteristics of process models and describe their qualities. Over the years, vast amounts of metrics have been proposed in the community, making it difficult to find and select the appropriate ones for implementation. This paper presents a state-of-the-art meta-review that lists and summarises all the evaluation metrics proposed to date. We have studied the behaviour of the four most widely used metrics in process mining with an experiment. Further, we have used seven healthcare domain datasets of varying natures to analyse the behaviour of these metrics under different threshold conditions. Our work aims to propose and demonstrate the capabilities to use our selected metrics as a standard of measurement for the process mining domain.
... Working with a subset of BPMN elements is common, e.g., as in (Indulska et al., 2009;La Rosa, Wohed, et al., 2011), to reduce the complexity of the proposed techniques. The author considers both well-structured processes (Kiepuszewski et al., 2000), e.g., derived through the process in (Polyvyanyy et al., 2012) and unstructured ones. ...
Full-text available
In response to increasingly competing environments, organisations are examining how their core business processes (BPs) may be redesigned to improve performance and responsiveness. However, there is a lack of approaches for evaluating BPR at design time and systematically applying BPR in the case of eligible models. The aim of this research is to: (a) evaluate the redesign capacity of BP models prior to implementation, (b) create a systematic and versatile BPR methodology, (c) correlate the evaluation and BPR methodologies to a unified and comprehensive approach and (d) demonstrate the above for a particular BPR method. A literature survey on the theoretical foundation of BPR and two separate Systematic Literature Reviews (SLRs) on BPR Evaluation and Application methodologies provide an overview of the current state of research and highlight the gap in systematic, generic methodologies that combine the assessment of redesign capacity of models at design time, with the application of BPR. The lack of a concept in literature that quantitatively depicts BPR applicability, led to the introduction of Model Plasticity. The concept is inspired by Neuroplasticity and is based on the calculation of internal model measures for predicting the applicability of RESEQ and PAR heuristics. Through a series of experiments and the use of logistic regression and the state-of-the-art Bender method, the author extracts and validates internal measure thresholds for the aforementioned heuristics. Following, the BPR Assessment framework is introduced for the systematic evaluation of the BPR capacity of input models based on their plasticity and external quality. The framework was created by applying the established DSRP methodology and incorporates essential redesign components that pass through interconnected phases. Two discrete operation modes of the framework based on partitioning clustering and proximity measurement are also proposed and presented in this research by using a BP model repository from literature. The operation modes are demonstrated for data-centric workflow optimization to highlight the straightforward and convenient application of the framework. A set of sixty-four real-life BP scenarios from the Greek Public Financial Management is modelled in the BPMN2.0 standard and measured for the validation of the framework. The validation demonstrates the multitude of benefits for the agencies of the Ministry of Finance and potentially to the whole Greek public sector, given the constant shift to digital transformation schemes. Finally, the author extended the framework with a new complementary artefact, the BPR Application framework, for the systematic application of BPR methods and combined them into a unified and comprehensive methodology. In this way, this research proposes a fully tested and validated methodology for the evaluation of the BPR capacity of models at design time, and a holistic methodology for systematically applying BPR to eligible cases.
... The Business Process Model and Notation (BPMN) [32], developed by the Object Management Group (OMG), appears to be the most powerful modeling notation for business process modeling which is interdisciplinary understandable [33]. It gains importance and is supported by an increasing number of software tools. ...
Full-text available
Manufacturing Execution Systems (MES) optimize production and business processes at the same time. However, the engineering and specification of MES is a challenging, interdisciplinary process. Especially IT and production experts with different views and background have to cooperate. For successful and efficient MES software projects, misunderstandings in the specification process have to be avoided. Therefore, textual specifications need to be complemented by unambiguous graphical models, reducing the complexity by integrating interdisciplinary views and domain specific terms based on different background knowledge. Today's modeling notations focus on the detailed modeling of a certain domain specific problem area. They do not support interdisciplinary discussion adequately. To bridge this gap a novel MES Modeling Language (MES-ML) integrating all necessary views important for MES and pointing out their interdependencies has been developed. Due to its formal basis, comparable and consistent MES-models can be created for specification, standardization, testing, and documentation of MES software. In this paper, the authors present the formal basis of the modeling language and its core notation. The application of MES-ML is demonstrated taking a yogurt production as an example. Finally, the authors give some evaluation results that underline the effectiveness and efficiency of this new modeling approach with reference to four applications in industrial MES-projects in the domain of discrete and hybrid manufacturing.
... A considerable number of research works exist to deal with the problem of complexity in process mining, proposing diverse approaches to deal with complexity. Studies of complexity reduction and similar techniques were carried out by La Rosa et al. [17] and Schonenberg et al. [18]. However, these reviews are obsolete as they were published early when process mining techniques were still flourishing. ...
Full-text available
Process mining techniques are used to extract knowledge about the efficiency and compliance of an organization’s business processes through process models. Real-life processes are unstructured, and applying process mining to discover such processes often results in complex process models that do not provide actionable insights. Several solutions have been presented to overcome this problem. However, the process mining domain lacks an explicit definition of complexity and its measurement. This vagueness results in ad-hoc solutions that vary according to the approach, modelling construct, and process properties. Additionally, the strength and limitations of the proposed solutions have not been adequately highlighted. Therefore, we conducted a systematic literature review on complexity in process mining over six popular scholarly indexing databases. Based on the review results, an explicit definition of complexity, the main contributing factors and their impact on process mining results were identified. We discovered various process complexity matrices and their application context. The analysis of studies led to the development of a taxonomy consisting of four different approaches for addressing the complexity problem, along with their strengths and limitations. Finally, the open research challenges and potential for future research are discussed.
... As it can be seen in Fig. 1, a DFM can easily become complex due to the existence of several case notions for each the process might have different underlying behavior. Separation of concerns is an approach to dealing with complexity in information systems [11], [12], which can be applied in this context by separating and classifying similar case notions into one category. Discovering process models with several case notions that share similar behavior can simplify the models and enable analyzing interesting aspects from OCEL. ...
Full-text available
Object-centric process mining is a new paradigm with more realistic assumptions about underlying data by considering several case notions, e.g., an order handling process can be analyzed based on order, item, package, and route case notions. Including many case notions can result in a very complex model. To cope with such complexity, this paper introduces a new approach to cluster similar case notions based on Markov Directly-Follow Multigraph, which is an extended version of the well-known Directly-Follow Graph supported by many industrial and academic process mining tools. This graph is used to calculate a similarity matrix for discovering clusters of similar case notions based on a threshold. A threshold tuning algorithm is also defined to identify sets of different clusters that can be discovered based on different levels of similarity. Thus, the cluster discovery will not rely on merely analysts' assumptions. The approach is implemented and released as a part of a python library, called processmining, and it is evaluated through a Purchase to Pay (P2P) object-centric event log file. Some discovered clusters are evaluated by discovering Directly Follow-Multigraph by flattening the log based on the clusters. The similarity between identified clusters is also evaluated by calculating the similarity between the behavior of the process models discovered for each case notion using inductive miner based on footprints conformance checking.
Process models support a variety of tasks, which can be organized differently. Notably one can discern local tasks focusing on a single part of a model and global tasks requiring an overview of several parts. These two task types are assumed to affect users’ understanding of processes differently especially if the processes are decomposed into many interlinked and self-contained models through modularization. Local tasks can benefit from abstraction as they enable information hiding, while global tasks can be impeded by fragmentation caused by the split attention effect. Following a task-centric approach, we substantiate this hypothesis by investigating the cognitive effects of abstraction and fragmentation in modularization. Therein, we focus particularly on horizontal modularization and study users’ cognitive load, comprehension and behavior when solving local and global tasks. Our findings confirm that, compared to abstraction, fragmentation hinders users’ comprehension of the model and raises their cognitive load. Additionally, users exhibit different search and integration behaviors when performing local and global tasks. The outcome of this work motivates the shift from artifact-centric to task-centric empirical studies, raises the need for approaches to mitigate the effect of fragmentation and explores different alternatives to achieve this goal.KeywordsProcess model understandabilitymodularizationcognitive load theoryeye tracking
Process models represent important information artifacts for organizations for documentation, communication and collaboration. Proper understanding of such models is critical for effective application in practice (e.g., to have the right information in the right place at the right time). A key aspect of understanding process models is how visual information represented in process models is extracted and processed by the human visual system. For such visuospatial tasks, the visual system employs a set of elementary operations, the compilation of which gives rise to various visual routines. However, which visual routines and related operations are used in understanding process models has not yet been investigated. To address this question, this paper presents findings from an exploratory eye-tracking study in which visual routines were considered during process model comprehension. Specifically, n = 29 participants were asked to understand m = 18 process models expressed in Business Process Model and Notation 2.0, reflecting three different mapping types (i.e., straight, upward, downward) and complexity levels (i.e., easy, medium, hard). The performance measures showed that even less complex process models were challenging to understand properly. The upward mapping presented greater challenges to par-ticipants’ attention, whereas the downward mapping was better understood. Three gaze patterns were derived from the recorded eye movements to be applied during model comprehension. A general model is then proposed that summarizes a set of applied visual routines and elementary operations during process model comprehension. Finally, implications for practice as well as for research and future work are discussed.
Full-text available
One of the key tasks in the service oriented architecture that seman-tic web services aim to automate is the discovery of services that can fulfill the application or user needs. OWL-S is one of the proposals for describing seman-tic metadata about web services, which is based on the OWL ontology language. The OWL-S ontology is organized in three modules: the Service Profile module describes the functionality of the service; the Process Model module describes how it does it; and the Service Grounding module describes how to access the service. Majority of current approaches for matching OWL-S processes take into account only the input/output service profile. In this paper we argue that, in many situa-tions, the service matchmaking should take into account also the process model. When searching services for integrating in a given application, the process model specifying how to interact with the provider has to be taken into account in the discovery process. Other application example is scientific workflow discovery, where scientists look in a workflow repository for existing workflows that could support their research. We propose to develop matching techniques that operate on OWL-S process models and allow to retrieve in a given repository, the pro-cesses most similar to the request. To do so, we reduce the problem of process matching to a graph matching problem and we adapt existing algorithms for this purpose. We propose a similarity measure that will be used to rank the discovered services. This measure captures differences in process structure and semantic dif-ferences between input/outputs used in the process.
Full-text available
A study developed and validated new scales for perceived usefulness and perceived ease of use, which were hypothesized to be fundamental determinants of user acceptance. The definitions of the 2 variables were used to develop scale items that were pretested for content validity. The items were then tested for reliability and construct validity in 2 studies involving a total of 152 users and 4 application programs. After refining and streamlining the measures, the resulting 2 scales of 6 items each demonstrated reliabilities of .98 for usefulness and .94 for ease of use. The scales also exhibited high convergent, discriminant, and factorial validity. In both studies, usefulness had a greater correlation with usage behavior than did ease of use, though both were significantly correlated with current usage and future usage. Regression analyses suggest that perceived ease of use may actually be a casual antecedent to perceived usefulness, as opposed to a direct determinant of system usage.
Full-text available
As organizations reach higher levels of business process management maturity, they often find themselves maintaining very large process model repositories, representing valuable knowledge about their operations. A common practice within these repositories is to create new process models, or extend existing ones, by copying and merging fragments from other models. We contend that if these duplicate fragments, a.k.a. exact clones, can be identified and factored out as shared subprocesses, the repository's maintainability can be greatly improved. With this purpose in mind, we propose an indexing structure to support fast detection of clones in process model repositories. Moreover, we show how this index can be used to efficiently query a process model repository for fragments. This index, called RPSDAG, is based on a novel combination of a method for process model decomposition (namely the Refined Process Structure Tree), with established graph canonization and string matching techniques. We evaluated the RPSDAG with large process model repositories from industrial practice. The experiments show that a significant number of non-trivial clones can be efficiently found in such repositories, and that fragment queries can be handled efficiently.
Business process management aims at capturing, understanding, and improving work in organizations. The central artifacts are process models, which serve different purposes. Detailed process models are used to analyze concrete working procedures, while high-level models show, for instance, handovers between departments. To provide different views on process models, business process model abstraction has emerged. While several approaches have been proposed, a number of abstraction use case that are both relevant for industry and scientifically challenging are yet to be addressed. In this paper we systematically develop, classify, and consolidate different use cases for business process model abstraction. The reported work is based on a study with BPM users in the health insurance sector and validated with a BPM consultancy company and a large BPM vendor. The identified fifteen abstraction use cases reflect the industry demand. The related work on business process model abstraction is evaluated against the use cases, which leads to a research agenda.
This practical "how-to" guide to both using the ARIS Design Platform and, more importantly, how to use it to create real business models, follows Rob Davis’ hugely successful, Business Process Modelling with ARIS (Springer 2001). This second volume describes the ARIS Business Architect and ARIS Business Designer web clients of the newly released ARIS 7 Design Platform. Rob Davis has teamed up with Eric Brabänder of IDS Scheer to provide practical answers to the following questions using the new web-based ARIS Design Platform: • How do we get started with the ARIS Design Platform? • How do we establish company-wide Business Process Management? • How do we setup a project with ARIS? • Which modelling methods should we use? • How do we structure a process architecture with ARIS? • How do we effectively use the technical architecture of ARIS (Servers, Databases, Objects, Web Clients, etc) Containing tips, techniques and short cuts gained from practical experience, this book show how to use ARIS in an easy way, supporting smart methods and smart models, and displays how ARIS can be used as a powerful tool for BPM. ARIS Design Platform: Getting started with BPM is a must have guide and reference for all existing and new users of ARIS. More information can be found at