According to Smith (and an untangled interpretation by Charlotte Herzeel), computation can be modeled as a mapping between three distinct domains: a “syntactic” domain, an “internal representational” domain and the “real world”. Syntactical domain consists of description of a system and the internal domain consists of all entities that realize the language constructs by which we describe the system. The real world consists of natural objects and abstract concepts that stakeholders of the system want to refer to in systems, but interpretation of these concepts are obviously out of reach of a computer. Mapping a description to its internal representation is called “internalization” (cf. “parsing”). The mapping from one element in the internal representation to another one in it is called “normalization”. In normalization, an element is reduced to simplest form. The mapping from an internal representation to its meaning in the world is called “denotation”.
Let’s get back to the reflection. Generally, reflection is about inspecting (observing and therefore reasoning about) and changing the internal representation (structural reflection) and also reasoning about the normalization (behavioral reflection) of a system. To be more specific, the inspection of the internal representation is typically called introspection and changing the internal representation and also reasoning about the normalization is well-known as intercession and the mechanism that enable these manipulations is called reification.
The computational reflection as a concept is originated by Brian Cantwell Smith and it was elaborated by Pattie Maes (in “concepts and experiments in computational reflection“) and Gregor Kiczales (in “The Art of the Metaobject Protocol“) and his colleagues in programming languages. Afterward, by emerging new paradigms and the need for distributed and transparent systems by embracing the component-based concepts, the computational reflection found its way all the way down to distributed systems and their underlying middleware infrastructures to make them highly adaptive. As a result of these efforts, a number of reflective component model specifications (Fractal) and middleware implementation (Julia) had been emerged. Finally, by arising the need for dynamic software evolution in self-* systems, the need for explicitly maintaining the architectural description which causally connected to run-time model has been emerged. These concepts have been extensively explored by Walter Cazzola, Peyman Oreizy, Nenad Medvidovic, Richard Taylor, Jeff Magee, Jeff Kramer and their colleagues with the theme of “Architecture-Based Runtime Software Evolution”.