Softw Syst Model (2003) 2: 37–58 / Digital Object Identifier (DOI) 10.1007/s10270-003-0018-x
Dealing with forward and backward jumps
in workflow management systems
Manfred Reichert1, Peter Dadam1,ThomasBauer
2
1University of Ulm, Dept. Databases and Information Systems, D-89069 Ulm, Germany;
E-mail: {reichert,dadam}@informatik.uni-ulm.de
2DaimlerChrysler Research and Technology Ulm, Dept. RIC/ED, Postfach 2360, D-89013 Ulm, Germany;
E-mail: th[email protected]
Received: 6 October 2002/Accepted: 8 January 2003
Published online: 27 February 2003 – Springer-Verlag 2003
Abstract. Workflow management systems (WfMS) of-
fer a promising technology for the realization of process-
centered application systems. A deficiency of existing
WfMS is their inadequate support for dealing with ex-
ceptional deviations from the standard procedure. In the
ADEPT project, therefore, we have developed advanced
concepts for workflow modeling and execution, which aim
at the increase of flexibility in WfMS. On the one hand
we allow workflow designers to model exceptional exe-
cution paths already at buildtime provided that these
deviations are known in advance. On the other hand au-
thorized users may dynamically deviate from the pre-
modeled workflow at runtime as well in order to deal with
unforeseen events. In this paper, we focus on forward and
backward jumps needed in this context. We describe so-
phisticated modeling concepts for capturing deviations in
workflow models already at buildtime, and we show how
forward and backward jumps (of different semantics) can
be correctly applied in an ad-hoc manner during runtime
as well. We work out basic requirements, facilities, and
limitations arising in this context. Our experiences with
applications from different domains have shown that the
developed concepts will form a key part of process flexibil-
ity in process-centered information systems.
Keywords: Workflow management – Adaptive workflow
– Exception handling – Forward/backward jump
1 Introduction
E-Business has significantly increased the competitive
pressure companies must face [4]. To meet this chal-
This paper is a revised and extended version of [40]. The de-
scribed work was partially performed in the research project “Scal-
ability in Adaptive Workflow Management Systems” funded by the
Deutsche Forschungsgemeinschaft (DFG).
lenge enterprises are developing a growing interest in sup-
porting their business processes more effectively and in
streamlining their application systems such that they be-
have “process-oriented”; i.e., to offer the right tasks at
the right point in time to the right persons along with
the information and application functions needed. Work-
flow management systems (WfMS) like MQSeries Work-
flow, Staffware, or INCOME Workflow offer a promising
technology for this [33,58]. Designed for a distributed en-
vironment they increase the number of work processes
(workflow; abbr. WF) that can pass through an elec-
tronic workplace. For this purpose, the business process
logic is extracted from application code. So, instead of
a large, monolithic program package we obtain a set of
WF activities which represent the application functions.
The process logic between them (i.e, control and data
flow) is specified in a separate WF schema. Usually, for
WF modeling graphical formalisms like Petri Nets [1, 38,
58], Statecharts [32, 60], UML Activity Diagrams [16],
or block-structured description languages [13, 36, 41] are
used. They allow the WF designer to quickly define and
modify WF schemes at a high semantic level, and en-
able the buildtime components of the WfMS to detect
behavioral inconsistencies and errors in a very early im-
plementation stage [46, 47, 52, 58].
Long regarded as technology for the automation of
well-structured, repetitive processes, showing only lit-
tle variations in their possible execution sequences, WF
management is in the throes of transformation as more
and more non-traditional applications require compre-
hensive process support as well. In many domains, like
hospitals, engineering environments, or E-Commerce,
however, process-oriented information systems will not
be accepted if rigidity comes with them [4, 8, 14, 18, 26].
Instead users must be able to flexibly deviate from the
standard process (e.g., by skipping WF activities or by
working on a WF activity ahead of the normal sched-
ule), in particular to handle exceptional situations [45,
38 M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems
50]. (In this paper exceptions constitute events which
may occur during WF execution and which require de-
viations from the standard business process.) In doing
so, it is very important that the use of the WfMS is
not more cumbersome and time-consuming than simply
handling the exception by a telephone call to the right
person. As reported by several groups, insufficient flexi-
bility and adaptability have been primary reasons why
many WfMS failed in process automation projects in the
past [17, 19, 41].
Generally, we have to differ between deviations that
can be pre-planned and deviations for which this is not
possible. Concerning pre-planned deviations, their con-
text as well as the actions necessary to handle them are
known beforehand. They, therefore, can be already con-
sidered at buildtime in order to achieve a flexible WF exe-
cution behavior. As opposed to this, deviations that can-
not be pre-planned may become necessary to deal with
unforeseen events and must be dynamically handled dur-
ing WF execution. In practice, both kinds of deviations
frequently occur and must therefore be adequately sup-
ported by WfMS.
The present work is embedded in the ADEPT project
which aims at the flexible support of enterprise-wide busi-
ness processes [5, 14, 41]. We have developed and imple-
mented advanced concepts for the modeling, execution,
and monitoring of workflows as well as for the dynamic
change of in-progress WF instances. Our work is based
on first-hand knowledge with clinical as well as engineer-
ing workflows [8, 14]. We have observed that many ex-
ceptions are known in advance and can therefore be con-
sidered already at buildtime, which decreases the neces-
sity of “expensive” ad-hoc interventions during runtime.
To enable users to cope with unforeseen exceptions as
well, additionally, we offer advanced concepts for dynamic
WF changes. They are based on the ADEPTflex calculus
which enables authorized users to dynamically change the
structure, the state, and the attributes of in-progress WF
instances in a consistent manner and at a high semantic
level [41].
In this paper we develop advanced concepts for both,
the increase of flexibility at buildtime and its enhance-
ment during runtime. Thereby, we focus on the support of
forward and backward jumps, which are indispensable to
flexibly deal with exceptions in WfMS [14]. While the for-
mer enable deviations in forward direction (e.g., to skip
unnecessary activities or to work on a particular activity
ahead of the normal schedule), backward jumps make it
possible to partially roll back the flow to a previous ex-
ecution state and to re-continue work in this state (e.g.,
when activity execution fails). We present concepts for
both, the pre-modeling of jumps at buildtime and their
dynamic application during runtime. To better under-
stand related issues and problems, we consider the view-
point of the WF designer as well as of the end user. In
some respects forward and backward jumps bear resem-
blance to GOTO statements in programming languages.
However, deviations from standard procedures concern
exception handling at a higher semantic level, which is
indispensable for WfMS to cover a broad spectrum of
processes. (Note that the need for supporting jump oper-
ations has been approved by several other research groups
as well [1, 27, 36, 42, 50].) Nevertheless, jumps must not be
complicated for users or lead to an undefined execution
behavior. For this reason, ADEPT imposes several re-
strictions for their use, which either have to be checked at
buildtime (pre-planned jumps) or must be ensured when
applying the jump during runtime (ad-hoc jumps). Back-
ward jumps, for example, must always result in a former
state of the WF instance in order to guarantee a consis-
tent execution behavior. Forward jumps, in turn, must
not lead to activity program invocations with missing in-
put data or to skipping of imperative activities. Finally,
jump operations must be properly integrated with re-
spect to authorization and documentation.
Although very important for realizing and adaptive
workflows, forward and backward jumps do not cover all
exception handling procedures needed in practice. As we
have reported in earlier papers [14, 41], ADEPT provides
other facilities as well. Examples include the ad-hoc in-
sertion or deletion of WF activities, the late modeling of
sub-workflows, and the dynamic change of WF attributes
(e.g., activity work assignments). In addition, several re-
search groups have used the ADEPT WfMS for imple-
menting sophisticated exception handling procedures on
top of it, like the automatic adaptation of workflows or
the dynamic creation of WF instances as response to
occurring exceptions [4, 53]. In this context, ECA rules
(Event – Condition – Action) can be used to describe the
conditions leading to an exception and the actions neces-
sary to handle them [11, 36]. Other exception handling
approaches are discussed in Sect. 5.
The outline of this paper is as follows: Sect. 2 furnishes
basic information about WF modeling and execution in
ADEPT – background information which is necessary for
a further understanding of this paper. Section 3 describes
how pre-planned as well as ad-hoc forward jumps can be
flexibly realized in WfMS. In Sect. 4 we set out how back-
ward jumps have to be handled. We discuss related work
in Sect. 5 and conclude with a summary in Sect. 6.
2 Background information
For each business process type to be supported, a corres-
ponding WF schema has to be defined and stored in the
WfMS. An example is depicted in Fig. 1. Among other
things, the diagrammed WF schema defines WF activi-
ties as well as the control and data flow between them.
The work presented in this paper uses the ADEPT for-
malism [39, 41] for WF modeling and execution. On the
one hand this WF meta model is expressive enough to
adequately model real-world processes [14], on the other
hand, the resulting WF models are easy to understand
M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems 39
perform
examination
prepare
p
atient
make
a
pp
ointment
inform
p
atient
order medical
examination
generate
re
p
ort
validate
report
patientId
report
data element
AND join
data flow control flow
yes
no
role = doctor
role = radiologist
Actor =
Actor("peform examination")
STARTLOOP
AND split
ENDLOOP
write data edge
read data edge
loop backward edge
(ET =LOOP_E)
normal control edge
(ET =CONTROL_E)
Fig. 1. Workflow modeling in ADEPT
for WF designers as well as for end users. ADEPT allows
to model aspects like control and data flow, work assign-
ments, or time constraints. Furthermore it has proven
itself by enabling correctness saving rules (e.g., no dead-
locks, no data losses, no temporal inconsistencies, no un-
defined work assignments), ad-hoc changes of in-progress
WF instances [41], and distributed WF execution [5, 6].
By implementing these concepts in a powerful proto-
type [29], we have demonstrated that they work in con-
junction with each other as well. In the meantime, the
ADEPT prototype is used by research groups from differ-
ent application domains for the implementation of flexi-
ble, process-centered information systems [4, 53].
2.1 Control flow modeling and execution
The control flow schema of a WF is represented by an at-
tributed WF graph with distinguishable node and edge
Table 1. Predecessor and successor functions defined on WF graphs
c_succ(n)/c_pred(n) set of all direct successors/predecessors of activity n
considering control edges with type CONTROL_E
c_succ∗(n)/c_pred∗(n) set of all direct or indirect successors / predecessors of activity n
considering control edges with type CONTROL_E (transitive closure)
succ(n)/pred(n) set of all direct successors/predecessors of activity n
referring to control edges with type CONTROL_E or SYNC_E
succ∗(n)/pred∗(n) set of all direct and indirect successors/predecessors of activity n
referring to control edges with type CONTROL_E or SYNC_E
types. As shown in [41] this enables efficient correctness
checks (see below) and eases the handling of loop backs.
Formally, a control flow schema Scorresponds to a tuple
S=(N, E, ...)withnodesetNand edge set E.Toeach
control flow edge e∈Ean edge type ET(e)fromtheset
EdgeTypes ={CONTROL_E,SYNC_E,LOOP_E}is assigned:
CONTROL_E denotes “normal” order relations between ac-
tivities, SYNC_E “wait-for” relations between activities
of parallel branches, and LOOP_E loop backs. Similarly,
each node n∈Nhas a node type NT(n)∈NodeTypes
(with NodeTypes:= {STARTFLOW,ENDFLOW,ACTIVITY,
STARTLOOP,ENDLOOP,AND Split,XOR Split,AND Join,
XOR Join}). Based on these ingredients, sequences, paral-
lel branchings (AND split,AND join), conditional branch-
ings (AND/XOR split,XOR join), and loops (STARTLOOP,
ENDLOOP) can be easily modeled. For this we have adopted
concepts from block-structured process description lan-
guages [15] and enriched them by additional control
structures. Branchings as well as loops have exactly one
entry and one exit node. Control blocks may be nested
but are not allowed to overlap. As this limits expressive
power, in addition, the already mentioned synchroniza-
tion edges are offered to WF designers, which allows them
to describe more complex control structures if required.
We have selected this block structure because it is rather
quickly understood by users, it allows the provision of
user-friendly, syntax-driven model editors, and it makes it
possible to implement efficient algorithms for control and
data flow analyses. – Table 1 informally summarizes pre-
decessor and successor functions on WF graphs which are
needed for the following considerations.
Based on a given WF schema Snew WF instances can
be created and started. To determine which activities are
to be executed next, for each WF instance we maintain
information about its current state by assigning mark-
ings NS(n)andES(e) to each activity node nand to
each control edge e. Corresponding to this, a WF graph
with associated markings is denoted as a WF instance
graph.1An example is depicted in Fig. 2. It shows two
WF instances created from the WF schema from Fig. 1.
1Note that this must not mean that for each WF instance a sep-
arate WF graph is maintained. A WF instance graph represents
a logical view on a WF instance, and does not give any hint con-
cerning its physical representation.
40 M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems
perform
examination
prepare
p
atient
make
a
pp
ointment
inform
p
atient
order medical
examination
generate
re
p
ort
validate
report
patientID
report
LOOP_E
true
false
user = "Dr. Quincy"
role = radiologist
WF instance graph I1
patientId = "Smith"
current value: "Smith"
NS=NodeState,
NS = ACTIVATED
NS = RUNNING
NS = COMPLETED
ES = EdgeState
ES = TRUE_SIGNALED
perform
examination
prepare
p
atient
make
a
pp
ointment
inform
p
atient
order medical
examination
generate
re
p
ort
validate
report
patientID
report
LOOP_E
true
false
Actor = "Dr. Bond"
Actor = "Dr. Kitchen"
WF instance graph I2
patientID = "Major"
current value: "Major"
Actor = "Dr. Kitchen"
report = Id4763
patientID = "Major"
report = Id4763
Fig. 2. WF instance graphs (with different marking)
Similar to Petri Nets [58], markings are determined by
well defined firing rules [41]. In doing so, markings of al-
ready passed regions are maintained (except loop backs).
Furthermore nodes and edges belonging to non-selected
branches of a conditional branching will be explicitly
marked as SKIPPED and FALSE_SIGNALED, respectively.
ADEPT ensures well-defined dynamic properties, includ-
ing the absence of deadlocks, the proper termination of
the flow, and the reachability of markings which enable
activity execution (for details see [39, 41]). The described
block structuring as well as the used node and edge types
help us to accomplish this in an efficient manner. Dead-
locks, for example, can be excluded if the WF graph does
finish
start
start
select
disable
deselect
NOT_A CTIVATED ACTIVATED
WAITI NG
SUSPENDED STARTED
RUNNI NG
suspend
FAILE D COMPLE TE D
SKIPPED
SELECTED
TE RM I NA TED
enable
resume
abort
skip
disable
skip
skip
super state
(sub-) state
ac
ti
on
l
ea
di
ng
t
o
state transition
Fig. 3. Statechart for activity state transitions
not contain cycles over control and synchronization edges
(see [39] for details).
State transitions of a single activity instance are de-
picted in Fig. 3. Initially, the activity status is set to
NOT_ACTIVATED. It is changed to ACTIVATED when all pre-
conditions for executing this activity are met. In this case
corresponding work items are inserted into the worklists
of authorized users (determined by role-based work as-
signments). If one of them selects the respective item from
his worklist, activity status changes to RUNNING and re-
spective work items are removed from other worklists.
Furthermore, an application component associated with
the activity is started. At successful termination, activity
status passes to COMPLETED.
2.2 Data flow modeling and data context management
Data exchange between activities is realized by the use
of global process variables (called data elements in the
following). Data elements are connected with input and
output parameters of WF activities. Each activity in-
put parameter is mapped to exactly one data element
by a read data edge and each activity output parame-
ter is connected to a data element by a write data edge.
An example is depicted in Fig. 1. Activity “order med-
ical examination” writes the data element “patientID”
which is read by the subsequent activity “perform exam-
ination”. The total collection of data elements and data
edges is called the data flow schema. For its modeling,
a number of correctness properties must be satisfied. The
most important one ensures that all data elements read
by an activity Xmust have been written by preceding ac-
M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems 41
tivities before Xcan be started, independently from the
execution path leading to activation of X. Note that this
property is crucial for the proper invocation of external
activity programs during WF execution. In particular, it
must be ensured in conjunction with forward jumps as
well (cf. Sect. 3). Other correctness constraints concern
the avoidance of lost updates due to parallel or subse-
quent write operations on data elements (see [39]). At
runtime, if required, ADEPT stores different versions of
a data object for each data element. In more detail, for
each write access to a data element, always a new ver-
sion of the data object is created and stored in the WfMS
database; i.e., data objects are not physically overwrit-
ten. This allows us, for example, to use different versions
of a data element within different branches of an AND-
/XOR-branching (cf. Sect. 3). As we will see in Sect. 4,
however, maintaining data object versions is not only im-
portant for the context-dependent reading of data elem-
ents but also for the correct rollback of WF instances in
case of failures.
3Forwardjumps
In this section we present both, pre-planned and ad-hoc
forward jumps for exception handling. While the former
are known at buildtime and can therefore be captured
in the WF schema, ad-hoc jumps become necessary to
deal with unforeseen events. That means they cannot be
pre-modeled and must therefore be defined by users at
runtime. We motivate the need for both kinds of forward
jumps, discuss general issues related to them, and show
how forward jumps of different semantics have been real-
ized in ADEPT.
3.1 Motivation
During WF execution it may be required to omit un-
necessary activities or to immediately execute activities
though not all steps normally preceding them in the flow
of control have been finished yet.
Example 1 (Forward jumps in a flow): The pro-
cessing of a medical examination for an inpatient nor-
mally comprises several steps: The examination must be
ordered, an appointment with the examination unit be
made, the patient be prepared and notified about po-
tential risks, the intervention be performed, and medical
reports be generated, obtained and validated. Even for
this simple process chain, it must be possible for physi-
cians and nurses to flexibly deviate from the standard
procedure, in particular to handle exceptional situations
(e.g., if the patient’s state of health gets worse during
the process or the physician finds out that some prepara-
tory steps are unnecessary for the respective patient). In
such cases it must be possible to skip steps or to imme-
diately perform the examination; i.e., without making an
appointment or waiting until all preparatory steps (re-
quired in the normal case) have been finished. Note that
corresponding situations may occur at any time during
process execution. (A presentation of more sophisticated
examples is given in [49].)
Our experiences with clinical as well as engineering
processes [8, 14, 49] have shown that very often deviations
from standard processes can be pre-planned. If excep-
tional situations, in which a particular activity or a set of
activities is to be processed ahead of the normal schedule,
are known in advance, it must be possible to capture them
at buildtime. This, in turn, enables the WfMS to offer
respective activities as exceptional steps to users though
the pre-conditions for their regular execution have not
been fully met; i.e., users may work “untimely” on these
pre-scheduled activities, but the WfMS indicates them
that activity execution constitutes a deviation from the
preferred execution path in the current WF state. How
this can be accomplished is described in the following
subsection.
3.2 Defining and changing execution priorities
for WF activities
In this section we introduce simple, but useful extensions
of the ADEPT base model, which allow the WF designer
to differentiate between normal and exceptional execu-
tion paths.
3.2.1 Defining activity priorities at build-time
To enable WF designers to express whether a sched-
uled activity is to be offered as a “normal” or as an
“exceptional” step within worklists, we allow them to
associate execution priorities with activities. If an ac-
tivity is to be treated as an exceptional step when it
is activated, priority EXCEPTIONAL will have to be as-
signed to it at buildtime; otherwise the setting REGULAR
will be chosen as priority for this activity (default set-
ting). Internally, the WF engine schedules activities in-
dependently from their execution priority; i.e., execu-
tion of an activity with priority EXCEPTIONAL follows
the same rules (with respect to activation and termi-
nation) as execution of regular activities. The way how
activities are offered in user worklists, however, may de-
pend on the priority assigned to them and is left to
WF client applications. Possible worklist visualizations
include the fade-in/fade-out of exceptional activities,
the use of different colors for activities with different
priorities, or the display of the work items related to
these activities within different windows. Combined with
AND-split/XOR-join branchings – called AND-/XOR-
branching for short – activity priorities turn out to be
very useful: When the AND-split node of such a branch-
ing completes, its outgoing branches are activated and
42 M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems
can be worked on concurrently. As opposed to paral-
lel branchings (with AND-split/AND-join), however, the
workflow may proceed at the XOR-join as soon as one
of its incoming branches is terminated.2In ADEPT, in
2Synchronization of incoming branches at an XOR-join is serial-
ized, i.e., there will be always one branch that terminates first. By
default, this branch is selected as “winner” and the other branches
⇓
Completion of D (lower branch)
Activate E
A
B
D
C
E
Rollback upper branch
A
B
D
C
E
AND split XOR join
A
B
D
C
E
... and mark its nodes as SKIPPED
COMPLETED
ACTIVATED
RUNNING
TRUE_SIGNALED
SKIPPED
FALSE_SIGNALED
⇓
Fig. 4. Operational semantics of an
AND-/XOR-branching
Fig. 5. Activity priorities
such a case activities from other branches are removed
from user worklists, aborted or compensated 3depending
on their current state. An example showing the opera-
tional semantics of an AND-/XOR-branching is depicted
in Fig. 4.
Based on this, WF designers are able to differentiate
between preferred execution paths and exceptional ones.
A simple example is given in Fig. 5. In the depicted WF
instance graph activities Band Xare concurrently active.
Due to the assigned priorities Bis offered as regular step
in user worklists whereas Xis treated as exceptional ac-
tivity. According to this, the preferred activity sequence is
defined by A,B,C,andD(in the given order) whereas the
sequence A,X,andDconstitutes an exceptional path (indi-
cated by priority EXCEPTIONAL of activity X); i.e., instead
of Band Cactivity Xmay be executed.
3.2.2 Pre-planned changes of activity priorities
during run-time
Depending on the state of a WF instance it must be pos-
sible to treat a particular activity differently with respect
to its prioritization. Under certain circumstances its ex-
ecution may constitute a deviation whereas in other WF
states it can be treated as normal step. As an example,
take an activity Xwhich normally is to be executed after
some preceding steps have been finished. Due to excep-
tional situations, however, it may become necessary to
work on Xahead of the normal schedule. In this case, ex-
ecution of Xconstitutes a deviation from the preferred
activity sequence which must be indicated to users; i.e.,
this exceptional state must be preserved as long as not all
activities normally preceding Xin the flow have been com-
pleted. If the latter case occurs, however, priority of Xis to
be changed accordingly.
Static priorities are not sufficient for modeling such
cases. In addition, it must be possible to dynamically
are rolled back. Alternatively, ADEPT allows more than one in-
coming branch to be completed such that the user can explicitly
select the most suited one (e.g., depending on the output data gen-
erated by related activities).
3Whether a completed activity can be compensated or not may
depend on the kind of activity as well as on the current state of the
WF.
M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems 43
Fig. 6. Changing priorities during the execution of a WF instance
modify priorities during WF execution. In order to be
able to capture such priority changes in the WF model we
introduce prioritization edges as an additional modeling
concept. A prioritization edge ep=src →dst links two ac-
tivities src and dst, but without enforcing an execution
order between them. Each prioritization edge epis associ-
ated with a priority eppriority ∈{REGULAR,EXCEPTIONAL}
which has the following semantics: When the source node
src is completed, edge epis signaled as TRUE and the pri-
ority of its destination node dst is modified to eppriority .
As an example take an activity Ywith (static) priority
EXCEPTIONAL. If an incoming prioritization edge (with
priority REGULAR) of this activity is signaled as TRUE dur-
ing runtime, the priority of Ywill be set to REGULAR as
well; i.e., from this point in time the execution of Yno
longer constitutes an exception.
Figure 6 shows an example for the combined use of
prioritization edges and activity priorities. In the WF in-
stance graph depicted in Fig. 6a, activities Cand Dare
concurrently active whereas Cis treated as normal step
and the execution of Dis considered as an exception (cor-
responding to the static priorities assigned to Cand D).
After completion of Cits outgoing prioritization edge
C→D(with priority REGULAR) is signaled as TRUE.Ac-
cordingtothis,priorityofactivityDis changed from
EXCEPTIONAL to REGULAR such that Dcan be offered as
normal step in user worklists (cf. Fig. 6b). Recapitulating
this, the preferred activity sequence is A,B,C,D,E, though
Dmay be executed directly after completion of A.
3.3 Modeling forward jumps at buildtime
As motivated, it often becomes necessary to give prior-
ity to execution of activities though the steps normally
preceding them have not been completely finished yet.
ADEPT provides the needed flexibility by allowing users
to jump forward to selected activities and, therefore, to
bring forward their execution. To better understand the
problems arising in this context, we must consider both,
the viewpoint of the designer and of the end user. For
the designer it must be possible to differentiate between
the normal course a workflow shall take and exceptional
deviations. Furthermore, by incorporating pre-planned
jumps the clarity of the WF model must not suffer and
the complexity for its creation must not be significantly
increased. From the viewpoint of end users, it is very im-
portant that they are able to differ between activities
scheduled along the normal flow and activities whose ex-
ecution (currently) constitutes a deviation.
3.3.1 General issues
When deviating from the preferred activity sequence, one
has to decide how bypassed activities are to be treated.
Generally, they may either be skipped or be continued
and finished concurrently to the untimely executed activ-
ities. ADEPT supports both variants as well as mixtures
of them. In the following, we show how the modeling con-
cepts from Sect. 3.2 can be used to define pre-planned
forward jumps at buildtime. As a prerequisite the WF
states in which the forward jump shall be applicable and
the activities of which the execution shall be brought for-
ward due to the jump must be known in advance. Pre-
planned jumps can be defined at a high semantic level.
For this, a graphical WF description language is offered
which comprises the elements of the ADEPT base model
(cf. Sect. 2) as well as modeling elements for defining
jumps. For the definition of forward jumps a special edge
type – called shortcut – can be used. Internally, a short-
cut nSC
s→nSC
dis transformed into a representation of
the ADEPT base model whereby a precise operational se-
mantics can be guaranteed.
A simple example is depicted in Fig. 7. The dia-
grammed shortcut A→Freflects a forward jump as it is
modeled by the designer. It has the following semantics:
After successful completion of source activity nSC
s(ac-
tivity Ain our example), both, direct successors of nSC
s
over normal control edges (activity Bin our example) and
the target activity nSC
dof the shortcut (activity Fin our
example) are activated. While Bis treated as a normal
Fig. 7. Modeling shortcuts (viewpoint
of the WF designer)
44 M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems
step (with priority REGULAR), the “untimely” execution
of activity Fis considered as an exceptional case. This
exceptional status is preserved as long as Fis not sched-
uled along the “normal” control flow. In our example, Fis
offered as exceptional step (with priority EXCEPTIONAL)
in worklists until it will either be finished or its direct
predecessor Ewill be completed.
Independent of the semantics of a shortcut nSC
s→
nSC
dits transformation into an executable representa-
tion of the ADEPT base model requires the following
conditions:
– The source node nSC
sof the shortcut must be a pre-
decessor of its target node nSC
dover normal control
edges (with edge type CONTROL_E). Formally: nSC
d∈
c_succ∗(nSC
s)
– The shortcut must not partially overlap with a loop
control block (LoopStart, LoopEnd), but loop control
blocks and shortcuts may contain each other:4
nSC
s∈Lbody ⇔nSC
d∈Lbody(with
Lbody := c_succ∗(LoopStart)∩c_pred∗(LoopEnd))
Assume that a user wants to follow shortcut nSC
s→
nSC
d; i.e., he wants to jump forward to activity nSC
dand
work on it though not all steps normally preceding nSC
d
have been finished yet. When deviating from the pre-
ferred execution order, it must be clear how to deal with
bypassed activities from the jump region; i.e., with activi-
ties located between the source and the target node of the
shortcut (nodes B,Cor D,Ein our example). We present
two alternative approaches which either allow to skip by-
passed activities or to finish them concurrently to activity
nSC
d.
3.3.2 Skipping bypassed activities
One possibility to deal with bypassed activities is to
undo, abort, or abandon their execution depending on
their current state; i.e., if a user deviates from the pre-
ferred execution path by following a shortcut nSC
s→nSC
d,
all activities located between the source and the target
activity of the shortcut will be compensated, aborted,
or abandoned – these activities form the jump region
of the shortcut and are defined by the set Nbypass :=
c_succ∗(nSC
s)∩c_pred∗(nSC
d) (nodes B,C,D,andEin
our example from Fig. 8). Afterwards, the execution of
the flow will proceed with node nSC
d(node Fin our
example).
The WF graph Wmod in Fig. 8a contains a shortcut
(A→F) as it is modeled by the WF designer. The WF
graph Wtransform in Fig. 8b shows the transformation of
this shortcut into a representation of the ADEPT base
model. As one can easily see, this transformation is based
4Concerning the schema from Fig. 1, for example, shortcut
“order medical examination” →“perform examination” would be
allowed. As opposed to this, it would not be possible to model
a shortcut leading from activity “order medical examination” to an
activity succeeding the end node of the depicted loop.
Fig. 8. Forward jump (with skipping
bypassed activities)
on the combined use of an AND-/XOR-branching (de-
fined by nodes Aand Fin our example) and activity pri-
orities. In more detail, the upper branch of the created
AND-/XOR-branching consists of a single jump activity
with priority EXCEPTIONAL and with label <“Jump to
” + target node>(“Jump to F” in our example). The
lower branch, in turn, constitutes the jump region and
corresponds to that subgraph of Wmod induced by nodes
from the set Nbypass ({B,C,D,E}in our example). Ac-
cording to Wtransform the jump activity (“Jump to F”)
is selectable (with priority EXCEPTIONAL)assoonasthe
source activity of the shortcut (activity Ain our ex-
ample) is completed. If the jump activity is executed
the upper branch of the AND-/XOR-branching will be
immediately completed. According to the specified op-
erational semantics, the lower branch (i.e., the jump re-
gion) will then be aborted and rolled back. Afterwards
the flow can proceed at the target activity of the shortcut
(node Fin our example). As opposed to this, if activi-
ties from the lower branch (B,Cor D,Ein our example)
are finished, activation of the jump activity will be can-
celled and corresponding work items be removed from
worklists.
Mapping the shortcut into a representation
of the ADEPT base model at buildtime
Generally, the mapping of a shortcut nSC
s→nSC
d
(with the described semantics) into a representation of
the ADEPT base model can be accomplished by applying
Algorithm 1 (which has complexity O(n) where n denotes
the number of activity nodes of the WF graph; the same
complexity results from the algorithms necessary to check
the conditions described in Sect. 3.3.1).
M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems 45
Algorithm 1: Transforming a shortcut nSC
s→nSC
d
(with skipping of bypassed activities) into ADEPT base
model:
1. If nSC
scorresponds to a split node, insert a null ac-
tivity n1(i.e., an activity without associated action)
which takes over the output firing behavior and out-
going control edges of nSC
s. Set the output firing be-
havior of activity nSC
sto ONE_Of_ONE (i.e., nSC
sis no
split node anymore) and add control edge nSC
s→n1
(cf. Fig. 9a)
2. Set the output firing behavior of activity nSC
sto
ALL_Of_ALL; i.e., nSC
sis converted into an AND split
node (cf. Fig. 9b).
3. If nSC
dcorresponds to a join node, insert a null activ-
ity n2which takes over the input firing behavior and
incoming control edges of nSC
d. Set the input firing be-
havior of activity nSC
dto ONE_Of_ONE (i.e., nSC
dis no
join node anymore) and add control edge n2→nSC
d
(cf. Fig. 9c).
4. Set the input firing behavior of nSC
dto ONE_Of_ALL;
i.e., nSC
dis converted into an XOR join node (cf.
Fig. 9d).
5. Insert an additional branch between nSC
sand nSC
d
which contains a jump activity (with priority EXCEP-
TIONAL) labeled as <“Jump to” + nSC
d>. The other
branch, in turn, corresponds to that sub-graph of Wmod
induced by the nodes of the jump region (cf. Fig. 9e).
Formal pre-conditions and required checks at buildtime
Obviously, when transforming a shortcut with the de-
scribed semantics into a representation of ADEPT base
Fig. 9. Shortcut transformation
(cf. Algorithm 1), steps 1–5 generate an AND-/XOR-
branching with two branches: One corresponds to the
jump activity (with exceptional priority) and the other
to the jump region. In order to ensure structural correct-
ness (i.e., a proper block structuring of the WF graph and
the absence of cycles; cf. Sect. 2) and a correct dynamic
behavior of the flow (e.g., no deadlocks), in addition to
the already mentioned pre-conditions (see above), the fol-
lowing restrictions must be met for the use of a shortcut
nSC
s→nSC
d:
– The subgraph induced by the node set Nskip :=
Nbypass ∪{nSC
s,n
SC
d}must constitute a regular con-
trol block; i.e., nodes from branchings and loops are
either not contained within Nskip or they are com-
pletely covered by nodes from this set.
– Different shortcuts nSC
s→nSC
dand mSC
s→mSC
d
must not overlap but may contain each other. For-
mally: nSC
s∈Mskip ⇔nSC
d∈Mskip (with Mskip :=
c_succ∗(mSC
s)∩c_pred∗(mSC
d))
Both conditions can be easily checked. If the shortcut
is applied to a correct control flow schema (i.e., proper
block structure, no cycles except loop backs) and if the
above conditions are satisfied, steps 1–5 of Algorithm 1
will result in a correct control flow schema again; i.e.,
structural and dynamic properties as required by the
ADEPT base model will be further valid (for a formal
treatment see [39]).
When transforming a shortcut into a representation
of the ADEPT base model, in addition, we have to check
whether the related data flow schema remains correct. As
described in Sect. 2, the most important correctness prop-
erty requires that all data elements read by an (arbitrary)
activity Xmust have been written by at least one pre-
ceding activity before Xcan be started; in particular, this
condition must hold independently of the execution path
leading to activation of X. This property is ensured by cor-
responding data flow analyses at buildtime, which make
use of the presented block structure and which have com-
plexity O(n2). The presentation of algorithms, however,
is outside the scope of this paper (see [39]).
Necessary data flow analyses can be reduced if the
data flow schema statisfies the above correctness property
already before the shortcut is defined. It is then suffi-
cient to check whether there are successors of nSC
d(incl.
nSC
d) which are data-dependent on (skipped) activities
from the jump region. Only for this case there may be
missing input data due to the defined shortcut. As an
example take the scenario depcited in Fig. 10 a). The
upper WF schema for which shortcut A→Dis defined
contains data dependencies between Aand C(Creads the
data element d1written by A) as well as between Dand E
(Ereads the data element d2written by A). As shown in
the lower WF schema, these dependencies persist when
the shortcut is transformed into an ADEPT represen-
tation. Furthermore, the data flow schema remains cor-
rect since d1(d2) will always be written before C(E)
46 M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems
Fig. 10. Checking data flow correctness when transforming a shortcut
is activated. This does not apply, for example, with re-
spect to the scenario from Fig. 10b). It is very similar
to the one shown in Fig. 10a) but takes Eas target ac-
tivity of the shortcut instead of D.SinceDis now con-
tained within the jump region it will be compensated,
aborted or skipped when applying the forward jump
(“Jump to E”). This, in turn, will lead to invocation of
Eor – more precisely – of its associated activity pro-
gram with missing input data, which may cause incon-
sistencies (e.g., wrong outputs) or errors (e.g., program
crashes). In ADEPT, therefore, the shortcut from Ato
Ewill be either not allowed or the designer will have to
restore correctness of the data flow; e.g., by re-linking
the corresponding input parameter of Eto another data
element.
3.3.3 Finishing bypassed activities
When a user wants to apply a jump in order to bring
forward the execution of a certain activity, it is not al-
ways required to skip activities of the jump region. In-
stead, it may be desired to continue and finish them
concurrently to the pre-scheduled activities. With re-
spect to activities from the jump region, this means that
the effects of already completed activities are to be pre-
served, the execution of already started activities be con-
tinued, and activities not yet activated be scheduled as
planned. ADEPT allows the modeling of such forward
jumps as well. For this, the designer has to specify a short-
cut nSC
s→nSC
dandanactivitynSC
nfor synchronizing
bypassed steps. At runtime, authorized users may then
bring forward the execution of nSC
das soon as nSC
sis com-
pleted. As opposed to the shortcut semantics described
above, activities from the jump region are further pro-
cessed in case the shortcut is followed. In doing so, it is
important to synchronize their execution with the over-
all flow. As mentioned, for this a synchronizing activity
nSC
nhas to be specified which then may be only acti-
vated if its normal preconditions hold and – additionally
to this – all activities from the jump region are com-
pleted. A simple example is depicted in Fig. 11a). The
WF graph Wmod contains a shortcut A→Fas it is mod-
eled by the designer. In addition, activity node nSC
s=H
serves for synchronizing the execution of bypassed activ-
ities. According to this, F(and its successor G)maybe
executed ahead of the normal schedule (i.e., before ac-
tivity Eis completed) as soon as Ais finished. In case
this forward jump is followed, however, the processing of
activities from the jump region (B,Cor D,Ein our ex-
Fig. 11. Forward jump (with finishing bypassed activities)
M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems 47
ample) must be continued and finished before Hcan be
activated.
The transformation of this shortcut is shown in Fig. 11
b). Activity Anow represents an AND-split and Hthe
corresponding AND-join. The execution behavior is as
follows: After completing Aits successor Bcan be exe-
cuted as activity with priority REGULAR and the shortcut’s
target Fas activity with priority EXCEPTIONAL.Ifnode-
viation from the preferred execution order occurs during
runtime (i.e., only activities with priority REGULAR are
processed), the lower branch will be completed before F
is started. For this case, the outgoing prioritization edges
of Eare signaled as TRUE such that the priorities of Fand
Gare changed to REGULAR. As opposed to this, if a user
starts Fbefore Eis completed this will correspond to a de-
viation from the preferred activity sequence (indicated by
priority EXCEPTIONAL of activity F).
Mapping the shortcut into a representation
of the ADEPT base model at buildtime
Assume that shortcut nSC
s→nSC
dis to be applied to
a correct WF schema and bypassed activities are to be
finished before the (synchronizing) activity nSC
nmay be
activated. This semantics can be realized by the combined
use the modeling concepts of the ADEPT base model
and its extensions as described in Sect. 3.2. To transform
a shortcut specification into an executable representa-
tion of the ADEPT base model, Algorithm 2 (which has
complexity O(n)) must be applied (for an example see
Fig. 12):
Algorithm 2: Transforming a Forward Jump (with Fin-
ishing Bypassed Steps) into ADEPT base model:
1. Determine the minimal control block (nstart,nend)
that contains activities nSC
s,nSC
d,andnSC
n.
Fig. 12. Transforming a shortcut into ADEPT base representation
2. Create an AND split n1which represents a null ac-
tivity and takes over the input firing behavior as well
as the incoming control edges (of type CONTROL_E)of
nstart.Linknstart as a direct successor to n1.
3. Create an AND join node n2corresponding to n1;n2
shall represent a null activity and take over the output
firing behavior as well as the outgoing control edges of
nend.Linknend as a direct predecessor to n2.
4. Detach the subgraph induced by
Npreschedule := nSC
d∪c_succ∗(nSC
d)∩c_pred∗(nSC
n)
from its current graph context, and insert it as addi-
tional branch to the branching defined by (n1,n2). Let
xstart:= nSC
dbe the start and xend be the end node of
this subgraph or branch.
5. Add two synchronization edges from nSC
sto xstart and
from xend to nSC
n.
6. Assign priority EXCEPTIONAL to each node from
Npreschedule and add prioritization edges (with edge
priority REGULAR) from the end node of the jump re-
gion to each node of this set.
7. Apply ADEPT reduction rules to eliminate unneces-
sary nodes and edges (for details see [39,41]).
Formal pre-conditions and required checks at buildtime
For the correct use of a shortcut nSC
s→nSC
dwith
described semantics and its transformation into an ex-
ecutable representation of the ADEPT base model the
following conditions must be checked (corresponding al-
gorithms make use of the block structuring and have com-
plexity O(n)):
–IfnSC
dis contained within a branch of an XOR-
branching, node nSC
smust be contained within the
same branch; i.e., it is not allowed to model a forward
jump from an activity preceding an XOR-branching to
an activity contained within one of its branches.
48 M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems
–Let Npreschedule := {nSC
d}∪c_succ∗(nSC
d)∩c_pred∗
(nSC
n) comprise activities that may be executed ahead
of the normal schedule according to the defined short-
cut (cf. Fig. 12). In order to obtain a proper block
structure we require that the subgraph induced by
Npreschedule itself constitutes a block (as it is the case
in Fig. 12 where the respective subgraph corresponds
to a sequence).
–LetN∗
preschedule be another set of activities that may
be executed ahead of the normal schedule according
to another defined shortcut. Then Npreschedule and
N∗
preschedule must not partially overlap. Formally:
(Npreschedule ⊆N∗
preschedule)∨
(Npreschedule ⊃N∗
preschedule)∨
(Npreschedule ∩N∗
preschedule =∅)
For shortcuts with same target we require that these
sets are identical. This may be relevant for forward
jumps from different branches of an XOR-branching
to the same target activity.
If these restrictions are satisfied the structural and
dynamic properties of the WF graph (proper block struc-
ture, no cycles except loop backs, no deadlocks, etc.) can
be guaranteed for the resulting control flow schema as
well. Formal proofs can be found in [39]. Concerning the
data flow schema, we must check whether the described
transformations may lead to invocation of activities with
missing input data or may cause data losses (due to lost
updates). If the data flow schema is correct before apply-
ing Algorithm 2 the following checks will be sufficient:
–Checks for avoiding missing input data: Due to
the described transformations, activities from the sets
Npreschedule and Nbypass may now be executed concur-
rently to each other. For each activity x∈Npreschedule,
therefore, we must check whether data elements read
by x are further written by preceding steps. Obviously,
if this is the case before introducing the shortcut, it
will be sufficient to restrict these checks to those data
elements written by activities from Nbypass.Notethat
only order relations of activities from this set are rear-
ranged with respect to nodes from Npreschedule.
–Checks for avoiding data losses due to lost up-
dates:LetDbypass/Dpreschedule denote the set of data
elements to which activities from Nbypass/Npreschedule
have write access. Parallel write operations on data
elements (and data loss due to lost updates) will not
arise, if Dbypass ∩Dpreschedule =∅holds. If this does
not apply, however, the shortcut edge must either be
removed or additional synchronization edges between
nodes from Nbypass and Npreschedule have to be in-
serted.
3.3.4 Concluding remarks
The presented modeling concepts can be generalized.
ADEPT also allows the definition of hybrid forms of
shortcuts. With respect to nodes from the jump region,
for each activity the designer has the choice whether its
execution is to be skipped or continued when the jump is
applied. Though the graph transformations needed in this
context are more complex, from the conceptual point of
view no new issues arise. We, therefore, omit a more de-
tailed presentation. In summary, pre-planned deviations
as described above form a key part of process flexibility
in WfMS. In addition, they do not require expensive user
interactions as it is the case for ad-hoc changes. Unfortu-
nately, it will not always be possible to capture all jumps
in the WF schema at buildtime. For this reason, we re-
quire additional techniques that allow authorized users
to perform forward jumps in an ad-hoc manner as well if
need be.
3.4 Performing dynamic forward jumps during runtime
Our experience with clinical workflows has shown that
the WF designer is generally not capable to predict all
possible deviations in advance and to capture them in
the WF schema [14]. To adequately cope with such un-
foreseen exceptions, in addition to the described con-
cepts, ADEPT supports ad-hoc deviations from the pre-
modeled WF schema at the instance level as well (e.g.,
to insert, to delete, or to shift activities). In the follow-
ing, we restrict our considerations to dynamic forward
jumps (e.g., skipping of a set of activities or immediate
execution of an activity though not all predecessors have
been completed yet). In this context, it is very important
that change definition is not complicated for users; i.e.,
all complexity associated with missing activity input data
(e.g., due to skipping of activities), data losses (e.g., due
to lost updates), deadlocks (e.g., due to cyclic waits of ac-
tivities), or state adaptations must be hidden to a large
degree from users. Instead, they must be able to define
a dynamic forward jump at a high semantic level with-
out requiring that they are familiar with the used WF
description formalism.
3.4.1 Dynamic forward jumps in ADEPT
Generally, dynamic jumps make only sense if there is
no risk of activity program crashes, data losses, or any
other obscure system behavior. We have spent much ef-
fort on the design of high-level change operations that
allow users to adapt in-progress WF instances while pre-
serving the mentioned correctness properties (cf. Sect. 2).
As response to a dynamic change request, ADEPT, in
essence, first checks data dependencies and ordering con-
straints to detect whether the problem of missing in-
put values, lost updates, or cyclic waits (deadlocks) may
occur in the modified WF instance graph. In case of
missing input values, we offer the possibility to generate
an electronic form and to prompt users for these values
(either immediately or when needed). Only if no con-
sistency problem occur or if it is explicitly tolerated by
M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems 49
the user the change request will be accepted and the
necessary graph transformations be performed. In add-
ition, the markings of nodes and edges are automatically
adapted when the change is applied. In ADEPT, users
are not burdened with this. They may express a jump re-
quest in a rather declarative way and at a high semantic
level (e.g., “work immediately on X”, “skip X1,X2, ..., Xn”).
For this, high-level modification operators are offered
which are based on the combined use of basic change
operations.
Move operation: The move operation constitutes
a basic change operation for the (dynamic) rearrange-
ment of activities. In more detail, it allows to shift an
activity (or a whole block) from its current position in
the WF instance graph to another place provided that the
actual state of the instance does not prohibit this. The
restructuring of the instance graph, necessary in this con-
text, may be more or less complex depending on the tar-
get position the activity is to be re-inserted. For example,
an activity detached from its current position may be re-
inserted between two succeeding activities, between two
sets of succeeding activities, or parallel to a certain activ-
ity or control block. A simple example for the use of the
move operation is depicted in Fig. 13. Assume that for the
WF instance from Fig. 13a) a user wants to work imme-
diately on activity Cthough Bhas not yet been finished.
In principle, this is possible since Cis not data-dependent
on B. Depending on the concrete change scenario the user
may desire to skip execution of B, first execute Cand then
work on B(i.e., to swap Band C), or continue the pro-
cessing of Bconcurrently to C. While the skipping of B
is internally based on the delete operation [39] the other
two changes can be realized by using the move operation.
Figure 13b) shows the WF instance graph after detach-
ing activity Cfrom its current position and re-inserting it
between Aand B. Note that the re-evaluation of the WF
state, which is automatically done in ADEPT, results in
activation of Cand deactivation of B. Figure 13c) shows
the WF instance graph as it results when Cis moved to
a position parallel to B.
Concerning this example certain pre-conditions must
be met in order to correctly apply the move operation. For
instance, it would not be possible to move Cto a position
before Asince Aand its predecessors have been already
finished and therefore an undefined marking would result.
But even if activity Ahad not yet been started, the desired
A B C D
C
D
A BA C B D
a) b) c)
dd
d
TRUE_SIGNALEDCOMPLETED ACTIVATED AND split AND join
Fig. 13. a Original WF instance graph and WF instance graph resulting after moving C from its current
position to the position, b... located between A and B, c... located parallel to B
operation would be prohibited by ADEPT, since Cwould
then be invoked with missing input data.
Jump forward operation: Basedonthesketched
move operation we have realized several high-level op-
erations for dynamic forward jumps. Generally, these
jump operations enable authorized users to pass the con-
trol or to jump forward to an activity ntarget which has
not yet been activated by the WfMS. When applying
such a dynamic jump different policies are offered to
users in order to deal with uncompleted activities from
the jump region (i.e., uncompleted activities preceding
the node ntarget in the flow of control): Nbypass := {n∈
pred∗(ntarget)|NS(n)∈{NOT_ACTIVATED,ACTIVATED,
RUNNING}}.
Activities from this set may be aborted, skipped, or
processed anyway depending on what the user desires. In
the latter case, their execution must be synchronized with
a dynamically specified activity nsync ∈c_succ∗(ntarget)
similar to the static case described in Sect. 3.3. In any case
the applied transformation steps lead to a proper block
structure again in which additional synchronization edges
may be used if necessary (see below). Since the structural
constraints as well as the graph transformations neces-
sary to realize dynamic forward jumps are very similar
to the static case, we omit further details at this point
(a more comprehensive treatment can be found in [39]).
Instead, in the following subsection we present an ex-
ample working out important issues related to dynamic
forward jumps.
3.4.2 Example
Let us assume that at a certain point in time an instance
graph looks like as the one depicted in Fig. 14: Aand Bare
completed and Cis currently executed. Let us further as-
sume that an exceptional situation occurs which makes it
necessary to immediately perform D(i.e., to jump forward
to D) but to maintain the order relationship between all
other activities (Eafter D;Gafter Eand F,etc.).
At first, data dependencies for activity Dare checked:
Dis executable, in principle, because it receives its input
data from the already completed activity Band it does
not produce any output data such that no problem of lost
updates occurs. Thus the restructuring of the instance
graph can be started. In order to make it possible that D
can be immediately activated, Dmust no longer be a suc-
50 M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems
B
DE
F
G
C
AND
p
li
t
j
oin
d1 d2 data elements
TRUE_SIGNALED COMPLETED RUNNING ACTIVATED
AH
Fig. 14. WF instance graph (for which a user wants to jump
forward to D)
Fig. 15. Dynamic forward jump – intermediate WF instance
graph
cessor of C.Instead,Dhas to be placed in a branch parallel
to E. This means that the control edge from Cto Dhas to
be removed and replaced by a control edge from Bto D.
Figure 15 illustrates how the (intermediate) WF in-
stance graph looks like at this point in time. Dhas become
a parallel step with respect to C, its direct predeces-
sor now is B. This transformation alone would not be
correct, however, because not all of the previously ex-
isting constraints are obeyed any longer. It would be
possible, for example, that Eis being started (once C
has been completed) in parallel or even before D.To
enforce the correct execution sequence, a synchroniza-
tion edge from Dto Eis introduced which enforces that
Ecannot be started until Dhas been completed (cf.
Fig. 15). Finally, the WF state is reevaluated. In par-
ticular, the control edge from Bto Dis marked with
TRUE_SIGNALED which means that Dcan be immediately
executed. The final WF instance graph is depicted in
Fig. 16.
It is important to mention that, in general, the appli-
cability of a dynamic change depends on the current state
Fig. 16. Dynamic forward jump – final WF instance graph
of the WF instance graph as well. Concerning a dynamic
forward jump, we require that its target activity has not
yet been activated; otherwise the application of this oper-
ation would not make sense. With respect to other change
operations, the required state constraints may be more
or less complex, depending on the kind of change. For
example, a new activity must not be inserted as a pre-
decessor of an already running or completed step and
a completed step must not be deleted. This would cause
an inconsistent marking and therefore an undefined exe-
cution behavior of the WF instance graph. It is therefore
prohibited in ADEPT. Generally, for each basic change
operation ADEPT defines formal and easy to check com-
pliance rules with (complexity O(n)) to decide whether
the intended change can be applied in the current WF
state or not.
Also very challenging is the question how to adapt
the markings of a WF instance graph when a dynamic
forward jump or, more general, a dynamic change is ap-
plied. ADEPT uses a sophisticated approach for setting
markings of activity nodes and edges, and for adapting
them in a consistent manner when a dynamic change
is applied (an algorithm for this with complexity O(n)
is described in [43]). The corresponding rules are in-
dependent from the kind of change, which enables the
WfMS to efficiently and automatically adapt markings
even in case of complex changes. Taking our example
from Figs. 15 and 16, for instance, the newly inserted
control edge B→Dis evaluated to TRUE_SIGNALED since
Bhas been already marked as COMPLETED.This,in
turn, leads to re-evaluation of activity Dof which the
marking is set to ACTIVATED, such that users can now
work on D. Note that this is exactly the desired re-
sult. Generally, when introducing a dynamic change,
already activated activities may have to be deactivated
or vice versa. In doing so, ADEPT updates user worklists
accordingly.
3.5 Discussion
We have discussed general issues related to the support
of pre-planned as well as dynamic forward jumps. In par-
ticular, we have shown how corresponding facilities can
be offered to users. Our most important goal was to
ease the use of corresponding facilities and to hide the
complexity associated with them from users. By allow-
ing designers to describe deviations already at buildtime,
the flexibility of WF-based applications can be signifi-
cantly increased. In order to enable users to adequately
deal with unforeseeable events, in addition, ADEPT pro-
vides support for dynamic changes and dynamic forward
jumps. Corresponding changes will be only allowed if
they do not violate the correctness properties set out
by the ADEPT base model. Furthermore, in the imple-
mented ADEPT WfMS all changes and deviations are
properly integrated with respect to authorization and
documentation.
M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems 51
4 Backward jumps
In practice, it is very important to allow authorized users
to perform backward jumps to former execution states
if need be. In ADEPT, WF designers can model normal
loop backs as well as failure backward jumps (called back-
ward jumps for short). While loop backs specify iterative
executions, backward jumps can be used to partially roll
back the flow as response to semantic failures (cf. Ex-
ample 2). More precisely, a rollback operation (partially)
resets the effects of previous activity executions. Among
other things this includes the resetting of markings, the
undoing of write operations on data elements, and the
compensation of external effects if possible and reason-
able (e.g., by invoking compensating activities). ADEPT
allows the modeling of different kinds of backward jumps.
Additionally, to deal with unforeseen situations that can-
not be pre-planned at buildtime, it enables users to per-
form ad-hoc backward jumps.
Example 2 (Semantic Failure of an Activity Exe-
cution): We refer to Example 1. Regarding the described
workflow, a medical examination may fail due to several
reasons. For instance, it may not be possible to examine
the patient if preparatory measures have been omitted
or the patient does not agree with the intervention. De-
pending on the concrete reason of a semantic failure, the
actions necessary for exception handling may vary. For
example, the workflow may have to be aborted or it may
be sufficient to suspend its execution, to roll back the flow
to a former state, and then to resume work in this state.
4.1 Semantic failures and failure backward edges
For handling (semantic) activity failures (cf. Example 2)
and for the modeling of related backward jumps, we in-
troduce two additional concepts: failure codes and failure
backward edges.
To each activity the WF designer may assign an arbi-
trary number of failure codes provided that correspond-
ing semantic failures are known at buildtime. In our ex-
ample, activity “perform examination” may be associ-
ated with the two failure codes OMITTED_PREPARATIONS
and MISSING_AGREEMENT. Generally, a failure code cor-
responds to a semantic failure that may occur during
activity execution and that makes it impossible to suc-
cessfully complete this activity. The task of the WF de-
signer is to identify these semantic failures and to define
adequate exception handling actions for them. Possible
reactions supported by ADEPT include the repetitive ex-
ecution of failed activities, the execution of alternative
steps, the skipping of the failed activity, the (partial) roll-
back of the flow, or its controlled abortion. In the follow-
ing we concentrate on issues related to partial rollback.
For the definition of rollback operations, failure back-
ward edges (called failure edges for short) are offered.
A failure edge f=nfail →nbwd links two activities nbwd
and nfail together (in backward direction) and is associ-
ated with a failure code ec of the source activity nfail.If
this activity fails and returns ec as failure code, the pro-
cessing of the WF instance will be (partially) suspended,
the failure edge fbe signaled, and the flow be rolled back
to the state that had been valid before the execution of
nbwd was started. In doing so, the scope of the rollback is
limited to activities from the backward region which cor-
responds to that subgraph induced by the nodes from the
set Nbwd with Nbwd := (c_succ∗(nbwd)∩c_pred∗(nfail))∪
{nbwd,n
fail}.
Examples for the use of failure edges are depicted in
Fig. 17:
–I→Hdescribes a partial rollback whose scope is re-
stricted to a branch of the parallel branching (D,I);
i.e., Nbwd ={I,H}. The signaling of I→Hdoes not
affect the processing of other branches.
–K→Fdefines a partial rollback from an activity out-
side a parallel branching (Kin our example) back to
activity F, which is located within a branch of this
branching (Nbwd ={F,G,J,K}). If K→Fis signaled
at runtime, activities J,G,andFwill be reset and the
flow will continue with F. Note that activities from the
lower branch (Hand I) are not affected by this partial
rollback.
– A special semantics is captured by the failure edge
B→start. It links a failure code of Bwith a rollback
operation to the start activity of the flow (Nbwd =
{start,A,B}). When signaling this edge the flow
will be aborted and its execution be completely rolled
back.
How the state markings and data elements of a WF in-
stance graph are reset when a failure edge is signaled is
shown in Fig. 18. To ensure a correct WF execution be-
havior afterwards, the use of a failure edge nfail →nbwd
must meet the following restrictions:
– The target activity nbwd of the backward jump must
precede the source node nfail in the (normal) flow.
–Ifnbwd is contained within a branch of an XOR-
branching nfail must be contained within the same
branch. Otherwise the backward jump may refer to an
activity that was not previously executed and there-
fore lead to an undefined state. Formally: Let jbe the
XOR-join of an XOR-branching with corresponding
split node s. Then we require:
nbwd ∈Z:= c_succ∗(s)∩c_pred∗(j)⇒nfail ∈Z
A
C
B
start D
HI
J K end
F
failure edge
E G
failure edge
failure edge
ec1
XOR split XOR join/
AND split
AND join
Fig. 17. Modeling backward jumps with failure edges
52 M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems
Fig. 18. Partial rollback of a flow due to the signaling of a failure edge. aAdaptation of state markings
and breset of write operations on data elements
–Ifnbwd is contained within a loop body we require that
nfail must be contained within the same subgraph.
Otherwise it remains unclear to which iteration of the
loop the WF is to be rolled back.
These conditions can be easily checked; algorithms
with complexity O(n) are presented in [39].
4.2 Automatic backward jumps
Automatic backward jumps can be linked to semantic
failures of WF activities. They can be simply modeled by
the use of failure edges and codes. When performing the
backward jump at runtime, markings of nodes from the
backward region (i.e., nodes from the set Nbwd) will be re-
set. This becomes necessary in order to correctly proceed
with the flow afterwards. Furthermore, for all completed
or running activities from the backward region, write op-
erations on data elements will be undone. In addition,
external effects of these activities (e.g., modifications of
application data) may have to be undone as well by in-
voking corresponding compensation programs. However,
whether compensation is possible or not is highly depen-
dend on the respective application. Concerning compen-
sation and data context management, ADEPT follows an
approach similar to Sagas [21] and Contracts [42]. In the
following, however, we put the focus on modeling aspects;
a treatment of transactional properties and other runtime
issues is outside the scope of this paper.
An example for a pre-planned, automatic backward
jump is depicted in Fig. 18. Let us assume that during the
execution of Ka semantic failure (with failure code ec1)
occurs. This, in turn, leads to the signaling of the failure
edge K→F, which causes a partial rollback of the flow. In
more detail, activity Kis aborted and activities J,G,andF
are undone (by invoking associated compensation steps).
In doing so, their effects on state markings as well as on
data elements are reset. For example, the write operation
of activity Fon dis undone and the old value of d(written
by activity D) is restored. Note that the rollback defined
by K→Fonly concerns nodes from the backward region
(Nbwd ={F,G,J,K}) and therefore does not affect activi-
ties from the lower branch of the parallel branching (Hand
Iin our example).
4.3 User-initiated backward jumps
Up to now, we have only dealt with automatic backward
jumps which are applied when an activity execution fails.
In exceptional situations, for authorized users it must be
also possible to directly intervene in the control of a flow
by aborting the WF instance or by jumping back to al-
ready passed regions. Since corresponding jumps are very
often performed as response to external events they can
be more or less determined with respect to context and
predictability. Depending on this, we have to differenti-
ate between (user) backward jumps, which can be pre-
planned and therefore be captured in the WF schema at
buildtime, and ad-hoc backward jumps.
Example 3 (User-initiated Backward Jumps): We
refer to Example 1. Assume that the patient’s state of
health gets worse or the physician wants to revise previ-
ous decisions concerning patient treatment. In such cases
it must be possible for him or her to regain control and
M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems 53
to jump back to previously executed steps. (This should
at least be possible as long as the medical examination
has not taken place.) This, in turn, may require that run-
ning activities (e.g., “preparation of the patient”) may
have to be aborted or completed ones (e.g., “making an
appointment”) may have to be undone. In many cases,
the context for the application of such user initiated back-
ward jumps is known in advance such that they can be
considered at buildtime.
4.3.1 Pre-planned user backward jumps
Similar to shortcuts, ADEPT offers a special edge type
to designers – called regainControl – for the modeling of
user-initiated backward jumps. A regainControl nRC
s→
nRC
dlinks an activity nRC
swith a preceding activity
nRC
d∈pred∗(nRC
s) and has the following semantics: After
completing nRC
dand before activating nRC
s,usersmayini-
tiate a rollback of the flow to the state which had been
valid before nRC
dwas started. An example is depicted
in Fig. 19a). Comparable to the modeling of shortcuts
it shows the viewpoint of the WF designer. A backward
jump from Cto Ais defined by the regainControl edge
C→A. It is selectable after completing Aand before ac-
tivating C. If the backward jump is chosen by a user, the
flow will be rolled back to the state that had been valid
before Awas started. Similar to a shortcut, a regainCon-
trol is internally transformed into a representation of the
ADEPT base model in order to guarantee a precise and
correct execution behavior (cf. Fig. 19b). Since the ba-
Fig. 19. RegainControl (modeler view) and its internal realization
in ADEPT
sic principles of such a transformation have been already
discussed in conjunction with shortcuts, we omit a more
detailed presentation at this point. The same applies with
respect to pre-conditions that must hold for the correct
applicability of a regainControl.
4.3.2 Ad-hoc backward jumps
Generally, it will not always be possible to foresee and to
pre-model all semantic failures that might occur during
WF execution. Furthermore there are backward jumps
for which a pre-modeling is not possible or is too com-
plex. As an example take a backward jump to an activity
that is contained within a branch of an XOR-branching.
Since at buildtime it is not known whether the corres-
ponding branch will be selected for execution, the pre-
modeling of such a backward jump does not make sense.
To adequately deal with such cases as well, ADEPT al-
lows authorized users to perform ad-hoc backward jumps
in order to roll back the WF to a previous execution state
if need be. Basic to such an ad-hoc deviation (in backward
direction) are the WF instance graph, the execution his-
tory, and the data element history of the respective WF
instance. The execution history, for example, logs data
about start and completion of activity executions, which
can be used when a rollback has to be performed (cf.
Fig. 20). To initiate an ad-hoc backward jump the user
may dynamically select a target activity from the list of
already completed or running activities. Afterwards the
flow can be rolled back to the state that had been valid be-
fore this activity instance was started. It is also possible to
roll back the WF instance to earlier iterations of a loop,
i.e., the scope of the rollback may comprise activity exe-
cutions from different loop iterations. A simple example
illustrating this is depicted in Fig. 20. Note that markings
have to be adapted in case of a backward jump as well.
4.4 Discussion
The presented concepts allow us to capture a broad spec-
trum of pre-planned as well as dynamic backward jumps.
Concerning transactional guarantees in combination with
backward jumps, usually, for long-running workflows we
cannot ensure full ACID properties (and we also do not
need this in most cases in practice). We, therefore, have
adopted concepts from the field of extended transaction
models [21, 42] by allowing the WF designer to (option-
ally) associate activities with compensation programs,
which are then invoked in case these activities have to
be undone due to a rollback. Currently, we are working
on several other issues arising in this context. They in-
clude the handling of backward jumps in modified WF
instance graphs (e.g., backward jump to a previously in-
serted activity), the undoing of temporary changes (e.g.
modifications caused by a dynamic forward jump) in con-
nection with rollback operations, and the definition of
compensation scopes in order to flexibly adapt the com-
54 M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems
Fig. 20. Dynamic backward jump and concomitant adaptation of state markings
pensation behavior of WF instances depending on their
state.
5 Related work
A widespread formalism for WF modeling is offered by
Petri Nets [38, 58]. Petri Nets have proven themselves
as very useful if structural and dynamic properties of
WF models have to be analyzed and verified (e.g., live-
ness, reachability of marking situations, net invariances).
Concerning exception handling, many approaches assume
that all exceptions which might occur during WF exe-
cution are known in advance and can therefore be cap-
tured in the Petri Net model [37]. Most of them, how-
ever, do not offer special modeling elements for this.
In particular, backward jumps as described in this pa-
per have not been addressed at all. Instead, exceptions
and deviations have to be described with the same lan-
guage elements that are used for modeling the “stan-
dard” token flow. Very often this leads to complex net
structures, which are difficult to understand and to main-
tain for users [19]. The adaptation of nets is addition-
ally aggravated by the fact that Petri Nets formalisms
very often lack a clear separation between control and
data flow and do not provide concepts for the explicit
modeling of loop backs. Recent work from the field of
Petri Nets has picked up this criticism and has offered
more flexible concepts for exception handling. In detail,
these approaches support the late binding and model-
ing of WF subnets [24, 25], the dynamic adaptation of
net markings during WF execution [1, 20], the ad-hoc
migration of a WF instance between two net configura-
tions [3, 55], or the dynamic change of the net structure
during runtime [18, 19, 56, 57].
Simple,butuseful approaches are offeredbyHOON[25]
and MOVE [24]. HOON uses high-level Petri Nets for
WF modeling and execution. In particular, late binding
of activity components or subnets is supported to increase
flexibility. Deviations from the pre-modeled net or dy-
namic changes, however, are not possible once a subnet
is bound to an activity. A more advanced approach is
offered by MOVE, which supports late modeling of sub-
nets [24]. At buildtime, the designer may specify activity
nodes for which a subnet may be dynamically defined or
modified during runtime as long as the corresponding ac-
tivity is not activated. While this approach is sufficient
for supporting dynamically evolving workflow structures,
it does not provide the necessary flexibility to deal with
exceptional situations. MOBILE [28] follows a descrip-
tive approach for WF modeling. In particular, the WF
designer may omit those aspects of a WF model (e.g., the
order of tasks), which have to be defined by end users dur-
ing run-time. Although this approach allows to combine
activities in a very flexible way, it is only applicable as
long as the activity programs are encapsulated and au-
tonomous such that they may be executed in arbitrary
order.
One of the first approaches for the dynamic adapta-
tion of net markings has been offered by MWMS [1, 2].
MWMS uses a simple Petri Net formalism. In par-
ticular, MWMS allows users to apply backward and
M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems 55
forward jumps within a net instance during runtime.
Such “roll forwards” and “roll backs” [1] can be ap-
plied without violating the consistency of the flow (e.g.,
no deadlocks). This is achieved, however, by abandon-
ing important elements needed for WF modeling in
practice (e.g., no loops, no conditional branchings, no
data flow tokens). Though this approach is interest-
ing from a theoretical point of view, due to its restric-
tive WF meta model it will not work in real-world
environments.
One of the first frameworks for dynamic WF changes
has come from the Petri Net community [19] as well.
For WF modeling so-called flow nets are used. A dy-
namic change is accomplished by substituting a marked
subnet (old change region) by another marked net (new
change region). The most interesting issues arising in
this context are how to adapt net markings at all and
how to accomplish this in a consistent manner; i.e., with-
out causing an undesired dynamic behavior (e.g., dead-
locks) in the sequel (cf. Fig. 21). Many of the proposals
made in this context assume that users are familiar with
Petri Nets or that they are able to manually shift tokens
from the old to the new net or to add new tokens, if re-
quired [20]. Concerning clinical workflows, for example,
such an approach does not work in practice. Apart from
this, correctness and consistency checks necessary in this
context require expensive reachability analyses for each
WF instance. To avoid “dynamic change bugs” [54, 57],
several proposals have been made: In [54], for example,
the authors require that instances of a given net may
be only changed if they are not currently executed on
modification hit regions. To correctly adapt net mark-
ings, in addition, it is proposed to introduce functions
a)
B
A C D E
Old Change Region
Token
activity
D A
B
C
E
New Change
Region
b)
DEADLOCK!
arrange B and C as
parallel steps!
Fig. 21. Dynamic structural changes in Petri nets
and the problem of adapting markings
that map markings between the old and the new net [55].
Corresponding mapping functions either have to be spec-
ified by the designer or are limited to special kinds of
changes (i.e., completeness is not ensured). In our ex-
perience this is not realistic when looking at real-world
processes.
As opposed to these approaches, ADEPT automati-
cally preserves the consistency of markings when a jump
operation is applied. In particular, node and edge mark-
ings are automatically adapted in an efficient and consis-
tent way. Basic to this are the described execution prop-
erties of the ADEPT base model and the chosen marking
rules. When compared to existing approaches, ADEPT
covers a broader spectrum of deviations. In addition, we
have dealt with many challenging issues that have not
been systematically addressed in the WF literature so
far (e.g., concerning the modeling of backward and for-
ward jumps, the correct application of jump operations
in connection with loops and conditional branchings, the
support of jump operations with different semantics, or
the use of automatic jumps).
Several approaches use State- and Activity-Charts for
WF modeling [22, 51, 60]. HieraStates [51], for example,
tries to increase flexibility by allowing users to dynam-
ically add new states or state transitions during run-
time. Furthermore, simple forward jumps can be modeled
by the use of a special transition type. As opposed to
ADEPT, backward jumps cannot be expressed in a direct
way, and dynamic jumps are not supported at all. An-
other interesting approach has been presented in [22]. It
uses Statecharts for WF modeling and deals with issues
related to semantic preserving changes. This may be of
interest, for example, when more complex modifications
become necessary.
Other approaches from the literature combine graph-
ical WF description formalisms with ECA rules in order
to increase flexibility [11, 12, 30, 36]. AgentWork [36], for
example, uses global rules to enable the WfMS to dynam-
ically restructure the control flow of a WF instance at
the occurrence of logical exceptions. The implementation
of AgentWork has been partially based on the ADEPT
prototype [29, 53]. Hence the two approaches complement
one another. In MOKASSIN [30] rules serve as the basis
for extending the WF meta model by user-defined con-
structs, if need be. In addition, WF designers may con-
figure the WF behavior (e.g., with respect to dynamic
changes) in a very flexible manner. Although this ap-
proach provides a great flexibility for WF designers, it
will be not applicable in many application domains, since
no correctness or consistency guarantees can be made.
In the WF community, several other work on is-
sues related to dynamic WF changes has been done
(e.g., [9, 10, 17, 26, 31, 35, 48, 59]). WIDE [10], TRAM [31],
WASA2[59] and BREEZE [48], for example, focus on
WF schema evolution and on the migration of in-progress
WF instances to the new schema, if possible and desired.
In Obligations [9] a WF instance graph is dynamically
56 M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems
composed of multiple process templates which reflect dif-
ferent views on the WF instance. Exception handling is
possible through the dynamic addition or removal of tem-
plates. Correctness issues are not discussed. Finally, in
CONSENSUS [4] combined e-negotiations are modeled
and enacted using WF technology. To support dynamism,
runtime WF modifications are supported. Like Agent-
Work, CONSENSUS has used the ADEPT WfMS for
implementation purposes.
Finally, several other proposals for the support of
adaptive workflows have been made in the literature.
They are based on different formalisms, like graph gram-
mars [9,27, 44], process grammars [23], planning tech-
niques [7], inheritance mechanisms [56], or transactional
models [17, 21, 34].
6 Summary
We have presented a sophisticated approach for the flexi-
ble support of pre-planned as well as dynamic deviations
in WfMS. For WF designers, high-level concepts are of-
fered for the modeling of forward and backward jumps.
By transforming them into an executable representation
of the ADEPT base model, a correct and efficient exe-
cution by the ADEPT WF engine can be ensured. Fur-
thermore, the separation of standard process descriptions
from exceptional paths contributes to a better structur-
ing of the WF models. We have shown that a flexible
execution behavior can be achieved when capturing de-
viations in WF models at buildtime provided that they
are known in advance. To increase WfMS flexibility at
runtime and to enable users to deal with unforeseen ex-
ceptions, in addition, we offer high-level operations to dy-
namically intervene into the control of in-progress work-
flows. Authorized users may work on activities ahead of
the normal schedule by jumping forward to them or they
may roll back the flow to a former execution state by
applying a corresponding backward jump. In any case,
ADEPT ensures that the correctness and consistency of
the flow is preserved when applying such a jump and
that the complexity arising from the support of dynamic
changes is hidden to a large degree from users.
In this paper we have concentrated on issues related
to forward and backward jumps in WfMS. How to de-
fine other kinds of changes, how to “physically” perform
them, how to adapt state markings and user worklists
in this context, or how to deal with concurrent change
definitions (and with synchronization issues arising in
this context) are other important questions addressed
by our research as well. Some of them have been al-
ready reported in other papers of our group (e.g. [41,43])
and been considered in our prototypical WfMS imple-
mentation as well [29]. Indeed, the ADEPT prototype
proves that one can really build a flexible and robust
WfMS which offers the described functionality within one
system.
Acknowledgements. We would like to thank the anonymous re-
viewers and our colleague Stefanie Rinderle for their valuable
suggestions.
References
1. Agostini, A., De Michelis, G.: Simple workflow models. In:
Proc. of the Workshop on Workflow-Management: Net-bases
Concepts, Models, Techniques, and Tools., Lissabon, Juni
1998, pp. 146–163
2. Agostini, A., De Michelis, G.: Improving flexibility of workflow
management systems. In: Proc. Business Process Management
(BPM’2000), LNCS 1806, Lissabon, June 2000, pp. 218–234
3. Badouel, E., Oliver, J.: Reconfigurable nets – a class of
high level petri nets supporting dynamic changes. In: Proc.
of the Workshop on Workflow-Management: Net-bases Con-
cepts, Models, Techniques, and Tools, Lissabon, Juni 1998, pp.
129–145
4. Bassil, S., Benyoucef, M., Keller, R., Kropf, P.: Addressing dy-
namism in e-negotiations by workflow management systems.
In: Proc. DEXA Workshop, September 2002
5. Bauer, T., Dadam, P.: Efficient distributed workflow manage-
ment based on variable server assignments. In: Proc. CAiSE
’00, Stockholm, June 2000, pp. 94–109
6. Bauer, T., Reichert, M.: Dynamic change of server assign-
ments in distributed workflow management systems. Daten-
bank Spektrum, 2(4): 59–67, 2002
7. Beckstein, C., Klausner, J.: A planning framework for work-
flow management. In: Proc. Workshop on Intelligent Workflow
and Process Management., Stockholm, August 1999
8. Beuter, T., Dadam, P., Schneider, P.: The WEP model: Ad-
equate workflow-management for engineering processes. In:
Proc. Europ. Concurrent Engineering Conf. 1998, Erlangen,
April 1998
9. Bogia, D.: Supporting Flexible, Extensible Task Descriptions
In and Among Tasks. PhD Thesis, University of Urbana, Illi-
nois, 1995
10. Casati, F., Ceri, S., Pernici, B., Pozzi, G.: Workflow evolution.
Data and Knowledge Engineering, 24(3): 211–238, 1998
11. Casati, F., Fugini, M., Mirbel, I.: An environment for de-
signing exceptions in workflows. Information Systems, 24(3):
255–273, 1999
12. Chiu, D., Li, Q., Karplapalem, K.: A meta modeling approach
to workflow management systems supporting exception hand-
ling. Information Systems, 24(2): 159–184, 1999
13. Curbera, F., Goland, Y., Klein, J., Leymann, F., Roller, D.,
Thatte, S., Werawarana, S.: Business Process Execution Lan-
guage for Web Services (V 1.0). Initial Public Draft Release,
2002, see http:// www.ibm.com/developerworks/library/
ws-bpel, 2002
14. Dadam, P., Reichert, M., Kuhn, K.: Clinical workflows – the
killer application for process-oriented information systems? In:
Proc. 4th Int’l Conf. on Business Information Systems (BIS
’00), Poznan, Poland, 2000, pp. 36–59
15. Dijkstra, E.: Cooperating sequential processes. In: Genuys, F.
(ed.) Programming Languages. Academic Press, 1968
16. Dumas, M., ter Hofstede, A.H.M.: UML activity diagrams as
a workflow specification language. In: Proc. Int’l Conf. on the
Unified Modeling Language, Toronto, 2001
17. Eder, J., Liebhart, W.: Contributions to exception handling in
workflow-management. In: Proc. EDBT Workshop on Work-
flow Management Systems, Valencia, 1998, pp. 3–10
18. Ellis, C.A., Keddara, K.: A workflow change is a workflow.
In: Proc. Business Process Management (BPM’2000), LNCS
1806, 2000, pp. 201–217
19. Ellis, C.A., Keddara, K., Rozenberg, G.: Dynamic change
within workflow systems. In: Proc. Int’l Conf. on Org. Comp.
Sys., Milpitas, CA, August 1995, pp. 10–21
20. Ellis, C.A., Maltzahn, C.: The Chautauqua workflow system.
In: Proc. 30th Int’l Conf. on System Science, Maui, 1997
21. Elmargarmid, A.K. (ed.): Database Transaction Models for
Advanced Applications. Morgan Kaufmann Publ., 1992
M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems 57
22. Frank, H., Eder, J.: Equivalence transformations on state-
charts. In: Proc. 12th Int’l Conf. on Software and Knowledge
Eng., Chicago, July 2000, pp. 150–158
23. Glance, N., Pagani, D., Pareschi, R.: Generalized process
structure grammars (gpsg) for flexible representations of work.
In: Proc. 7th Intl Conf. on Computer Supported Cooperative
Work (CSCW96), Boston, MA, 1996, pp. 180–189
24. Hagemeyer, J., Hermann, T., Just-Hahn, K., Striemer,
B.: Flexibility in workflow management systems. In: Proc.
Software-Ergonomie’97, Dresden, Germany, 1997, pp. 179–190
(in German)
25. Han, Y.: Software Infrastructure for Configurable Workflow
Systems. PhD Thesis, TU Berlin, 1997
26. Han, Y., Sheth, A.: On adaptive workflow modeling. In: Proc.
4th Int’l Conf. on Information System Analysis and Synthesis,
Orlando, 1998
27. Heimann, P., Joeris, G., Krapp, C., Westfechtel, B.: DYNA-
MITE: Dynamic task nets for software process management.
In: Proc. 18th Int’l Conf. Software Engineering, Berlin, 1996,
p. 331341
28. Heinl, P., Schuster, H., Stein, K.: Support of ad-hoc workflows
in the mobile workflow model. In: Proc. Softwaretechnik in
Automation und Kommunikation, Munich, March 1996, pp.
229–242
29. Hensinger, C., Reichert, M., Bauer, T., Strzeletz, T., Dadam,
P.: ADEPTworkflow – advanced workflow technology for the
efficient support of adaptive, enterprise-wide processes. In:
Proc. Software Demonstration Track (EDBT ’00), Konstanz,
March 2000
30. Joeris, G.: Defining flexible workflow execution behaviors.
In: Proc. GI-Workshop, Enterprise-wide and Cross-enterprise
Workflow-Management (Informatik ’99), October 1999, pp.
49–55
31. Kradolfer, M., Geppert, A.: Dynamic workflow schema evolu-
tion based on workflow type versioning and workflow migra-
tion. In: Proc. CoopIS ’99, Edinburgh, September 1999, pp.
104–114
32. Lei, Y., Singh, M.P.: A comparison of workflow metamodels.
In: Proc. ER’97 Workshop on Behavioral Models and Design
Transformations, Los Angeles, 1997
33. Leymann, F., Roller, D.: Production Workflow. Prentice Hall,
2000
34. Liu, L., Pu, C.: Methodical restructuring of complex work-
flow activities. In: Proc. 14th Intl Conf. On Data Engineering
(ICDE98), Orlando, Florida, 1998, pp. 342–350
35. Luo, Z., Sheth, A.: Defeasible workflow, its computation
and exception handling. In: Proc. CSCW’98 Workshop To-
wards Adaptive Workflow Systems, Seattle, WA, November
1998
36. M¨uller, R., Rahm, E.: Dealing with logical failures for collab-
orating workflows. In: Proc. Int’l 5th Conf. on Cooperative
Information Systems, Eilat, 2000, pp. 210–223
37. Oberweis, A.: Specification of techniques for handling excep-
tions with petri nets. Automatisierungstechnik – at, 40(1):
21–30, 1992 (in German)
38. Oberweis, A.: Modeling and Execution of Workflows Based on
Petri Nets. Teubner, 1996 (in German)
39. Reichert, M.: Dynamic Changes in Workflow-Management-
Systemen. PhD thesis, University of Ulm, 2000 (in German)
40. Reichert, M., Bauer, T., Fries, T., Dadam, P.: On modeling
predictable deviations in workflow management systems. In:
Proc. Modellierung ’02, pp. 183–194, Tutzing, March 2002 (in
German)
41. Reichert, M., Dadam, P.: ADEPTflex – supporting dynamic
changes of workflows without losing control. JIIS, Special
Issue on Workflow Management Systems, 10(2): 93–129,
1998
42. Reuter, A., Schwenkreis, F.: Contracts a low-level mechanism
for building general-purpose workflow management systems.
IEEE Bulletin of the Technical Committee on Data Engineer-
ing, 18: 4–10, 1995
43. Rinderle, S., Reichert, M., Dadam, P.: Efficient compliance
checks and automatic migration of workflow instances to sup-
port workflow schema evolution. Informatik, Forschung und
Entwicklung, 17(4): 177–197, 2002 (in German)
44. Rozenberg, G.: Handbook of Graph Grammars and Com-
puting by Graph Transformation – Volume 1: Foundations.
1997
45. Saastamoinen, H.: On the Handling of Exceptions in Informa-
tion Systems. PhD thesis, University of Jyvaskyla, Finland,
1995
46. Sadiq, S.: On Verification Issues on Conceptual Modeling of
Workflow Processes. PhD thesis, University of Queensland,
Australia, 2001
47. Sadiq, S., Orlowska, M.: Analyzing process models using
graph reduction techniques. Information Systems, 25(2): 117–
134, 2000
48. Sadiq, S., Orlowska, M.: On capturing exceptions in workflow
process models. In: Proc. 4th Int’l Conf. on Business Informa-
tion Systems (BIS ’00), Poznan, Poland, April 2000
49.Schultheiss,B.,Meyer,J.,Mangold,R.,Zemmler,T.,Re-
ichert, M.: Process design for therapeutic treatment of inpa-
tients. DBIS-5, University of Ulm, November 1995 (in Ger-
man)
50. Strong, D., Miller, S.: Exceptions and exception handling in
computerized information processes. ACM ToIS, 13(2): 206–
233, 1995
51. Teege, G.: Flexible workflows. In: Proc. Workshop Flexi-
bilit¨at und Kooperation in Workflow-Management-Systemen,
p. 1321, 1998 (in German)
52. ter Hofstede, A.H.M., Orlowska, M., Rajapakse, J.: Verifica-
tion problems in conceptual workflow specifications. Data &
Knowlege Engineering, 24(3): 239–256, 1998
53. Rahm, E., Greiner, U.: Webflow: A system for the flex-
ible execution of web-based, cooperative workflows. In:
Proc. Database Systems For Business, Technology and Web
(BTW’2003), Leipzig, February 2003 (in German)
54. van der Aalst, W.M.P.: Exterminating the dynamic change
bug: A concrete approach to support workflow change. Infor-
mation Systems Frontiers, 3(3): 297–317, 2001
55. van der Aalst, W.M.P.: How to handle dynamic change and
capture management information: An approach based on
generic workflow models. Int’l Journal of Computer Systems,
Science, and Engineering, 16(5): 295–318, 2001
56. van der Aalst, W.M.P., Basten, T.: Inheritance of workflows:
An approach to tackling problems related to change. Theoret-
ical Computer Science, 270(1–2): 125–203, 2002
57. van der Aalst, W.M.P., Jablonski, S.: Dealing with work-
flow change: Identification of issues an solutions. Int’l Journal
of Comp. Systems, Science and Engineering, 15(5): 267–276,
2000
58. van der Aalst, W.M.P., van Hee, K.: Workflow Management.
MIT Press, 2002
59. Weske, M.: Flexible modeling and execution of workflow ac-
tivities. In: Proc. 31st Int’l Conf. on System Sciences, Hawaii,
1998, pp. 713–722
60. Wodtke, D., Weikum, G.: A formal foundation for distributed
workflow execution based on state charts. In: Proc. Int’l Conf.
on Database Theory (ICDT’97), Delphi, Greece, 1997
Manfred Reichert is assis-
tant professor in the Depart-
ment Databases and Informa-
tion Systems at the University
of Ulm, Germany. He finished
his PhD thesis on flexible work-
flow management in May 2000.
He is author and co-author of
many articles and conference pa-
pers on hospital information sys-
tems and workflow management.
Current research topics include
enterprise-wide and cross-organizational workflows, enter-
prise application integration and workflow, and different as-
pects related to workflow technology.
58 M. Reichert et al.: Dealing with forward and backward jumps in workflow management systems
Peter Dadam has been full
professor at the University of
Ulm and director of the Depart-
ment Databases and Information
Systems since 1990. Before he
came to the University he had
been director of the research de-
partment for Advanced Infor-
mation Management (AIM) at
the IBM Heidelberg Science Cen-
ter (HDSC). At the HDSC he
managed the AIM-P project on
advanced database technology and applications. Current re-
search areas include distributed, cooperative information sys-
tems, workflow management, and database technology and its
use in advanced application areas.
Thomas Bauer is a researcher
at the DaimlerChrysler Research
Centre in Ulm where he is work-
ing in the area of engineering
process management. Before, he
was a member of the Department
Databases and Information Sys-
tems at the University of Ulm
where he finished his PhD the-
sis on the efficient management
of enterprise-wide workflows in
2001. Current research areas in-
clude engineering processes, workflow management, and en-
terprise application integration.