The Meta in Meta-object Architectures

Abstract

Abstract. Behavioral reflection is crucial to support for example functional upgrades, on-the-fly debugging, or monitoring critical applications. However the use of reflective features can lead to severe problems due to infinite meta-call recursion even in simple cases. This is especially a problem when reflecting on core language features since there is a high chance that such features are used to implement the reflective behavior itself. In this paper we analyze the problem of infinite meta-object call recursion and solve it by providing a first class representation of meta-level execution: at any point in the execution of a system it can be determined if we are operating on a meta-level or base level so that we can prevent infinite recursion. We present how meta-level execution can be represented by a meta-context and how reflection becomes contextaware. Our solution makes it possible to freely apply behavioral reflection even on system classes: the meta-context brings stability to behavioral reflection. We validate the concept with a robust implementation and we present benchmarks.

Execution levels for aspect-oriented programming

“…On the one hand, this allows for a stable semantics, where issues of conflation can be avoided [3,8]. On the other hand, this boils down to reconsidering AOP as just a form of metaprogramming.…”

“…Indeed, a metaobject runs, by definition, at the metalevel [18]. This makes it possible to consider metaobject activity as fundamentally different from base level computation, and this can be used to get rid of infinite regression [8]. In AOP, infinite regression can also happen, and does happen, easily 1 : it is sufficient for a piece of advice to trigger a join point that is potentially matched by itself (either directly or indirectly).…”

Object spaces for safe image surgery

“…A simple example would be adding a breakpoint in the iterator method Array » do:. In Pharo Smalltalk, adding this breakpoint impacts about 90000 Array instances and the image freezes [5]. It is thus very difficult to debug or change this code in a realistic setting, without risking to impact the whole image.…”

“…In [5], Denker et al solve this problem by tracking the degree of metaness of the execution context. Meta-objects can only reflect on objects of a lower metaness, thus simulating the semantics of an infinite tower of distinct meta-interpreters.…”

“…While it enables to save the image in the middle of a debugging session, and re-open it on another physical machine to find the debugger and halted program in the same bit-identical state, it also makes it very easy to inadvertently break code on which critical systems like the compiler or debugger depend. Moreover, it is not à priori obvious which code is safe to change; an example of such sensitive code is the pervasively used iterator method Array » #do: [5].…”