If we look at executable processes, we will have process instances. A process instance obviously lives from the time, it is created, to the time it is terminated. During the lifetime of the process events occur, that need to be assigned to or correlated to a certain process instance, if not to many process instances.
The more process instances are created in the system, the more care needs to be taken that they all are managed correctly. Some unwanted effects may occur:
- An event is not correlated to the process instance it should have been correlated to (e.g. because of wrong correlation rules)
- As a effect the event disappears without any effect.
- As another effect the process instance, that the event should have been correlated to is stuck in an unwanted state.
- A subsequent event, that is correlated again to this process instance, may find the process in the wrong state, causing more problems.
- An event is correlated to a process, that it should not have been correlated to.
- As an effect the event is consumed and may not be correlated to the process instance, that it correctly should have been correlated to.
- As another effect, the event will cause a problem in the wrong target process.
- Process instances may be started, even if there is already a process for the same thing, because of wrong correlation rules.
- This may lead to starvation of other processes.
- There is no guarantee, that an event is correlated to any process.
So in the end there may be a system with many problematic process instances. Especially if not care is taken, that the correlation rules are absolutely consistent. This is difficult to achieve, especially if they can be maintained independently from each other.
So many problems? Well, at least problem recognition is the first step to the cure.