here - Stefan-Marr.de

1.2. Problem Statement
and garbage collection [Jones et al., 2011] led to highly efficient VM implementations
that can support a wide variety of use cases. The diversity
in supported use case as well as availability turned these VMs into relevant
targets for language implementation. With the invokedynamic
bytecode [Rose, 2009; Thalinger and Rose, 2010], the JVM improved its
support for dynamic languages even further. Moreover, other language
paradigms may benefit from improved support.
1.2. Problem Statement
While many domains, e. g., web applications or single-use scripts, are sensitive
to programmer productivity, the field of concurrent and parallel programming
frequently requires a tradeoff in favor of performance. In practice,
the need for parallel execution only arises when certain performance properties
like minimal latency, responsiveness, or high throughput are required
and these requirements cannot be fulfilled with sequential implementations.
Sequential performance improvements eventually level off because of physical
and engineering limitations, known as the power wall, memory wall, and
instruction-level parallelism wall [Asanovic et al., 2006]. Additionally, the rise of
devices that are sensitive to energy efficiency further increases the need for
parallelization. Compared to today’s personal computers, the restricted energy
budget of mobile and autonomous devices effectively reduces available
sequential processing power. Thus, it becomes more common for application
developers to consider performance, further increasing the necessity to utilize
parallel and concurrent programming techniques.
When exploiting parallel hardware, the diversity of concurrent and parallel
programming concepts and the absence of a one-size-fits-all solution
suggest using problem-specific abstractions to enable application developers
to address the inherent complexity. However, today’s VMs support only a
small and often low-level set of such concepts. While the rise of dynamic languages
led, for example, to explicit support of customizable method lookup
strategies in the JVM through the invokedynamic bytecode, VMs do not
provide similar mechanisms to enable library and language implementers to
build custom abstractions for concurrent and parallel programming. On the
contrary, platforms such as the JVM and CLI, which feature shared memory
semantics and thread-based concurrency models, make it hard to faithfully
implement abstractions like the actor model [Karmani et al., 2009]. On such
platforms, implementation simplicity or correct language semantics are often
3