A COLA is a pair of mutually-sustaining abstractions. One provides representation and the other (behavioural) meaning. A minimum of each is imposed: the most desirable end-user structures and abstractions are not the goal, but rather the simplest that can produce a fully self-describing (and self-implementing) system. Representation is provided by prototype-like objects exchanging messages, organised into clone families (somewhere between lightweight classes and instance-specific behaviour); the semantics of messaging are defined recursively, by sending messages to objects. Meaning is imposed on these representations by transforms that convert structures (similar to symbolic expressions in the lambda calculus) into executable forms; the semantics of structures are defined recursively, by representing transforms as structures indistinguishable from those that they transform. One such executable form provides the implementation of methods installed in the objects of the representation; the overall implementation is circular. The implementation language and abstractions of the system are precisely the language and abstractions that the system implements. Providing a dynamic execution model, for which both dynamic and static code can be generated, eliminates the need for a central interpreter- or VM-like agent, and ensures that everything (including the deepest ‘kernel’ behaviour) can be modified, dynamically, on-the-fly.
~
PIUMARTA, Ian, 2006. Accessible language-based environments of recursive theories. Viewpoints Research Institute. pdf 
, p. 6.