# Dynamic Controllability of Processes without Surprises
## 2 Background and Motivation  
### Dynamic Execution Strategies  
The goal of all this research into correctness of temporally constrained process models is to check at _design time_, whether it is possible to avoid temporal problems at _run time_. Temporal problems are primarily time failures, i.e., the violation of a temporal constraint. So let us first have a look at run time. A process controller dispatches tasks according to the process model and the evolving execution history. The process model defines a partial order on tasks expressed typically by sequence, split and join nodes in the process model [4]. For all tasks the minimum and the maximum duration are known. The process controller has to observe temporal constraints, which are defined as maximum or minimum time gaps between the start and end event of tasks. The controller assigns a time-point when a task has to be started. For each task the controller can do this assignment up to this very start-time. When does a task end? For some tasks the duration is determined by the environment, by \"nature\", by other parties. The controller only knows that the end-time of such a task is between minimum and maximum duration after its start-time. These _contingent_ durations [10] can only be observed by the controller, but the controller cannot influence them. For an example, the (regular) transfer of some funds between accounts at different banks in the EU takes between a minimum of 0 and maximum of 4 days, without the possibility for sender or receiver to influence the duration. The controller has to take this imponderability into account when controlling the execution of a process. For _non-contingent_ durations, however, the controller might set not only the start-time but also the end-time (to any value between minimum and maximum duration after start). For some process models, the controller is able to assign time-points for the events (start and end of tasks) such that the execution does not violate any temporal constraint, before the whole process even starts. We call such process models _strongly controllable_[6]. However, not all process models are strongly controllable. For an example, a process transfers some amount from one account to another at another bank. A constraint requires that within two days after the transfer is finished (the amount is credited at the recipient account) a notification should be sent out. It is easy to see that it is not possible to set a start date for the send-notification task before it is known how long the transfer took (between 0 and 4 days). Nevertheless, if the controller reacts dynamically after observing the actual duration, it is always possible to assign a start date for the send-notification task such that the constraint is satisfied. The controller can have a dynamic strategy for assigning execution time-points. In general, at a time-point \(\tau\) the controller knows about all events (start and end of tasks) that happened before \(\tau\). According to this information the controller assigns time points greater than \(\tau\) to some start- and end-events of tasks, which did not yet take place. The controller applies an _execution strategy_ determining at a given time point \(\tau\) which values to assign to which event as a function of the process model and the history of the process execution up to \(\tau\). Such an execution strategy has to consider, in particular, the observed contingent duration of tasks. If such a dynamic execution strategy exists, which guarantees that for all possible contingent durations the controller can assign time-points dynamically in a way that no constraint is violated, we call the process _dynamically controllable_[6]. Of course, not all process models are dynamically controllable. For an example, there is no dynamic execution strategy to avoid violating the constraint \"the notification has to be sent 2 days before the amount is credited at the receiving account\". The process with this constraint is not dynamically controllable.