Today it is common to replicate data across machine boundaries but what of execution behavior? Whilst remote procedure call (RPC) middleware has allowed us to move execution across process and machine boundaries, at a very coarse granularity, these calls do not necessarily represent the replication of inherent software behavior, but merely a form of service delegation. The type of mirroring I am referring to here is the simulated playback, online or offline, of a softwares execution behavior in which a thread performs a local function or procedure call that is near simultaneously mirrored in one or more "paired" runtimes. Within such runtimes a paired thread is created, if not already done so, to mirror the real application thread and in tandem, when online, perform pushing and popping of stack frames as they occur within the application. This does not mean that the mirroring runtime needs to be implemented in the same language of the application. It should be possible for a C# application to be mirrored within a Java runtime as long as the mapping maintains the same representation of the execution flow, consisting of events marking entry and exit into methods within a particular thread. As you will read later I see no reason why the flow cannot be a representation of organizational and human activity.
Whilst some of the contextual data, driving execution behavior, can be mirrored, the replaying of the software execution behavior does not have the same side effects or outputs as it does within the real application runtime. It is immutable, in that mirrored behavior cannot change the course of what has already occurred, but mutable in that it can augment what has already occurred with new side effects that potentially extend beyond the applications own reach.
In the mirrored runtime software engineers can inject new code routines into interception points, typically the entry and exit of stack frames, and perform additional processing of such behavior as if the injected code was within the application at the time the execution behavior occurred (the illusion of time). This is not to say that the simulated environment fully constitutes the state of the real application runtime. In fact the application code, a form of state, does not exist here. The simulation merely plays back thread stack frame operations, push and pop, but within the frames nothing happens other than more nested stack frame operations but these are driven by more streamed events and not the content of a frame or code block (that does not exist in the simulation).