1.8 Separation of Phases
Explanation of the conceptIn the case of phase separation, a distinction is made between systems in operation and systems which are manufactured, rebuilt or maintained by the systems in operation. Thus, one system is active because it acts, while the other systems are passive, because something happens to them. The passive systems must be considered as "workpieces", which are located in action fields where active agents have access to. Such a situation is described in the biblical story of creation (Genesis, chapter 2, verse 7): "Then the Lord God formed a man from the dust of the ground and breathed into his nostrils the breath of life, and the man became a living being." Here, a phase transition takes place from passive to active. This is also the case when a surgeon performs an operation on an anesthetized patient on the operating table, and this patient subsequently awakens from anesthesia. The reverse phase transition, i.e. from active to passive, takes place before surgery, when the patient falls into anesthesia. Such phase transitions are very easy to implement in the software field. Since all software-determined agents consist of software and an interpreter executing this software, each beginning of an interpretation represents a phase transition from passive to active. Accordingly, a phase transition takes place from active to passive when the interpreter interrupts or terminates an execution process. As long as the program code is not interpreted, it is a passive workpiece that can be edited; but as soon as it is read and executed by an interpreter, it is part of an active agent.
|
In the first composition diagram shown at the left, there is an agent 1 who, in his action field, builds up a system which he subsequently activates
so that he can then communicate with the newly created agent 2 via the channel which connects him to it. One can recognize this by the fact that
agent 1 has two different ways of access to this action field: There is an access to the entire action field, from which it can be concluded
that there is something passive in this action field. However, there is also an access to a channel located in this action field, which makes sense
only if this channel belongs to an active system. One may associate this composition diagram with the biblical story of the creation of man and interpret
the agent 1 as God. But it is also possible to view agent 1 as a technician who builds a robot, activates it and then communicates with it. In the composition diagram underneath the first one, there is also an action field in which a system configuration is shown. However, no agent accesses the entire action field, but the accesses are made only to the internal channels. It follows that the system located in this field of action does not experience a phase transition, but is exclusively active. The reason for enclosing the system consisting of an interpreter and two channels in an action field is a possibility of abstraction: The enclosing action field can be viewed as a channel between the two diplomats. In this case, we abstract from the fact that none of the two diplomats understands the language of the other. |
An example from practice
Now an example is presented which shows that the succession of passive and active phases is quite common during software execution and is by no means a rare phenomenon. At first, we consider a process diagram which shows a sequence of explicit activations. The corresponding passivations do not appear in this diagram in form of explicit requests; they occur implicitly at the end of the actions of the activated agents.
|
When a computer user starts his dialogue with the system, he can only communicate with the operating system at first, since, apart
from this, no other agent is active at the beginning. The goal of the user, however, is to communicate with an agent whose role was previously
formulated in the language A and stored under the designation P in the background store. Therefore, the user asks the operating system to activate
the compiler for the language A. Once this compiler has become active, it asks the user for the information about
which text formulated in the language A is to be translated into the machine language which can be interpreted by the computer hardware. After the compiler has reported the successful completion of its work, the user reverts to the operating system and gives the instruction to activate the agent P. As soon as this agent has become active, it reports to the user, who now can enter into a dialogue with this agent. In the course of this dialogue, the agent P recognizes the need to expand its role. The agent knows that the role extension is formulated in the language B under the designation E in the background memory. Thus the agent P turns to the operating system with the request to activate the compiler for the language B. When the compiler then reports to the agent P that it is ready, it receives the task of compiling the text E from language B into the machine language. When the compilation is completed, the agent P can request that his previous role is extended. The agent P does not get a new name, but its role now consists of the combination of the original part and the extension. The extended agent P can now continue its dialog with the user. |
|
|
The composition diagram at the left shows the agents whose actions appear in the process diagram above. Though these actions
do not occur explicitly in the composition diagram, their sequence can nevertheless be derived by interpretation of the composition diagram. This diagram shows three beige action fields containing system structures including agents. The only agent which has access to the entire contents of of these action fields is the operating system. This means that the structures inside are passive workpieces for the operating system which can create these structures and finally activate the created agents. The agents to be activated are the compiler for the language A, the unextended agent P, the compiler for the language B and finally the extended agent P. The sequence of the activations follows from the requirement that an agent cannot be activated before its program in machine language is available. Thus, the extended agent P cannot be activated before the compiler for language B has been activated and finished the requested compilation. The channel for requesting this compilation comes from the unextended agent P from which follows that the unextended agent P must have been activated before the compiler for language B. The unextended agent P can only be activated after the compiler for language A has been activated and finished the requested compilation. Thus, from all agents to be activated sequentially, the compiler for language A must be the first one. |