Sun Jan 10 11:03:59 CET 2010
Reflection and self-hosted compilation
Why is this relevant?
Let's abuse terminology and call what was called "incremental
bootstrap" a special case of reflection: the ability of a language to
change its own semantics in some way.
Note that in our case, we change compile-time semantics (macros) in a
bottom-up, linear fashion. I.e. code, once compiled, does not change
semantics. This can then be augmented by either early or late binding
of run-time code (redefining procedures).
- Interactive console acces is useful for debugging.
- Some form of compilation (to native or VM code) is necessary for
From this follows that we need an in-image compiler to compile source
code to executable format.
- Using reflection (i.e. giving up phase separation allowing compiler
extension to change language semantics on the fly) can lead to very
small run-time systems.
Two examples that illustrate this: Forth and COLA. The downside of
powerful reflection is the absence of clear compile-time semantics:
there is essentially only behaviour, no static meaning. I.e. the only
way to get any information about what a program means is to feed it
into the system and see what it does.
It seems to me that the difficulty associated with incremental
bootstrap (the ``puzzle'' factor) translates directly into smaller
code size, probably as a consequence of the very aggressive factoring
Reflection in the form of incremental compiler extensions gives up
static semantics and gets small code size in return.