here - Stefan-Marr.de

5.3. The OMOP By Example
The process that has been spawned during the initialization of the agent object
tries indefinitely to process these update blocks in #processUpdateBlock.
It waits for the next update block, evaluates it with the current state as argument,
and sets the result value as new state.
This implementation is simplified but represents the essence of Clojure
agents. The differences with the Clojure implementation sketched in Sec. 2.4.3
originate from language differences between SOM and Clojure. For instance,
SOM does not have the notion of private methods, which leaves the implementation
methods #initialize and #processUpdateBlock exposed to arbitrary
use. Thus, these methods could be called from another thread and violate
the assumption that only one update function is executed at a time. The remaining
differences originate from the use of the OMOP. Note that the #read,
#initialize, and #send: method are annotated with unenforced. They are
by themselves not subject to the OMOP’s enforcement, guaranteeing that it
does not come to meta recursion during their execution.
Providing extended Guarantees based on the OMOP While Clojure guides
developers to use agents in conjunction with immutable data structures, at the
same time it makes the pragmatic decision not to enforce any such guarantees
on top of the JVM. One reason for this is the anticipated performance impact.
Another issue is the integration with Java itself, which makes it impossible
to provide such guarantees consistently. This section uses this example to
demonstrate how the OMOP can be used to express and in return enforce
such guarantees concisely.
To this end, Lst. 5.3 defines the AgentDomain. The domain implements the
intercession handler #requestExecOf:on:with: to ensure that only a single
thread of execution modifies the agent and that the agent is not reinitialized.
In this simple example, this is done by using a list of selectors that are allowed
to be executed. In case any other selector is sent to an agent, an error is raised
to report the violation. 5
As the ImmutableDomain in Sec. 5.3.1 shows, adding the guarantee of immutability
is also possible in a concise manner. Using the ImmutableDomain
of Lst. 5.1 in this example, the agent ensures in #processUpdateBlock that the
state is an immutable object. This is done by requiring the immutable domain
to #adopt: the return value of an update block. 6
5 Our actual implementation of agents goes beyond what is presented here. For brevity, the
example leaves out operations such as #await and #send:with:.
6 In the current implementation #adopt: performs a shallow adopt only and thus, only the
root object of the object graph is made immutable.
123