What is a ``reflective'' system?

BRIAN SPILSBURY zhivago@iglou.com
Mon, 12 May 1997 08:41:19 -0400 (EDT)

JH> Well, one potential big win is to make the LispVM handle all of low, low
JH> level stuff like Virtual Memory (to bad that the term 'VM' is overloaded),
JH> GC, threads, exception support, etc.  We then have a completely reflexive,
JH> portable system defined with the LispVM assembler.  This system could run
JH> on top of other OS's or be run with multiple versions on the same physical
JH> machine by just varying the LispVM implementation.
JH> The problem with this is that it pushes a lot of the important, hard 
JH> work down into the LispVM.  We would have a clear development path by
JH> bringing up a LispVM in C in some hosted environment with lots of
JH> good tools.  Then, bring up the LispVM in C under Flux, adding in the
JH> tough stuff like Virtual Memory, etc. that we deferred and we are done.

Well, one thing to consider is that if you're using word-codes then
you have 4 billion of them. That is before you start to fold arguments into
'em. But this means that we can for example have 'defun' create a new
word-code. Essentially word codes can be any reference.

This gives you your reflectivity as we can now also redefine word-codes
not only in terms of other word codes, but in native code.

It also means that you can have the idea of a lispVM word-code vm
merge into a more common lisp. Its good to remember that lisps are in
many respects themselves virtual machinesm, one reason that they're close
to operating systems anyhow.

I don't know how useful these idea are to you, but it does mean that
we can work in any given direction probably in the two different
directions at the same time and still be able to have them integrated.

If word-codes are for example implemented as immediate values inside a
reference, ie as the value of the pointer not what its pointing at,
and we tag them as we would immediates, then we've already sliced the
word-code space such that we can have 'word-codes that aren't word-codes'
looking at whatever is on the other side of the reference, and then handling
it as appropriately as possible.

This lets us cheat and plug in 'format' as a word-code, it also lets us
prototype word-codes in plain lisp, without hacking the word-code
interpreter itself.

Does this seem like a good thing or a bad thing?

JH> I dunno, I may be full of crap.

I don't think so :)