here - Stefan-Marr.de

6. Evaluation: The OMOP as a Unifying Substrate
Furthermore, this section shows that the OMOP satisfies the requirements
stated in Sec. 3.4. Tab. 6.2 recapitulates these requirements and the concrete
properties an implementation needs to facilitate. Based on this table, this section
demonstrates that the OMOP satisfies the requirements for managed
state, managed execution, a notion of ownership, and controllable
enforcement.
For each case study, this section gives a brief introduction to the implementation
and then details the ad hoc as well as the OMOP-based implementation.
In order to evaluate the OMOP, it summarizes for each case study how the
OMOP supported the solution of common implementation challenges.
Table 6.1.: Common Challenges for the Implementation of Concurrent Programming
Concepts on top of Multi-language VMs.
Enforcement of
Isolation
Scheduling Policies
Immutability
Execution Policies
State Access Policies
• challenge to guarantee state encapsulation and safe message passing
• by-value semantics problematic without proper ownership transfer
• custom scheduler needs control over executed code
• computational and primitive operations are problematic
• used as as workaround to track mutation
• reflection should obey it, when required
• reflection should obey them, when required
• implementation can be challenging without notion of ownership
• reflection should obey them, when required
• primitives need to be manageable to cover all state access
• implementation can be challenging without notion of ownership
6.2.1. Clojure Agents
Introduction The main idea of Clojure agents (cf. Sec. 2.4.3) is to ensure that
only a single process, the process executing the agent’s event-loop, can write
the agent’s state and to enforce immutability of all data structures referenced
by an agent. To that end, an agent asynchronously receives update functions
and processes them one by one. Note that Sec. 5.3.2 used agents earlier as an
example to introduce the OMOP.
In Clojure, the implementation is constructed in a way such that it is not
possible to change the state by other means than by sending asynchronous
142