here - Stefan-Marr.de

3. Which Concepts for Concurrent and Parallel Progr. does a VM need to Support?
for other purposes than optimization and strong guarantees for programmers.
One use case for such weak immutability is provided by VisualWorks
7 [Cincom Systems, Inc., 2002]. It allows marking objects as immutable and
raises an exception when mutation is attempted. The exception handler is
then free to mutate such an object. This behavior is used to map objects to
persistent data storage and enable efficient consistency management. In this
case the programmer does not consider the object to be immutable, instead
this technique is a workaround for the missing capability of tracking mutation.
However, the example also illustrates the relation between immutability
and reflection. In sequential programs, such workarounds do not necessarily
have a negative impact on the guarantees the programmer relies on. In a
concurrent setting however, such workarounds can easily lead to unintended
race conditions.
Benefits of Immutability For a concurrency-aware VM, immutability can be
used for performance optimization, either by avoiding copying of immutable
objects, or replicating them to improve locality of access. In either case, immutability
semantics have to be guaranteed to avoid semantic problems. Using
it as sketched in the above example of VisualWorks is not an option.
When immutability for a particular language is guaranteed by its compiler
only, interactions across language boundaries become problematic, similarly
to the use of reflection. JCoBox and Kilim use the knowledge of immutability
to avoid copying objects in their implementation of safe messaging, but they
rely on the absence of reflection for their semantics. Clojure’s approach to the
problem is different. Its language model of mostly side-effect free concurrency
on immutable data structures creates engineering benefits when direct access
to the underlying Java ecosystem is avoided. However, it is not enforced. On
the contrary, Clojure’s close integration with Java is an important aspect for
its adoption.
Conclusion Immutability is a basic property that needs to be preserved, especially
in concurrent systems. Using it for other purposes such as the tracking
of mutation in VisualWorks 7 should be avoided and the necessary facilities
for such use cases should be provided directly. The main problem with
immutability in a concurrent context is its relation to reflection. While there
are use cases such as deserialization that can require the use of reflection and
setting of final fields, in the context of concurrency, immutability requires
strict guarantees.
78