reflective architecture

[Tril]

On Mon, 24 May 1999, Ken Evitt wrote:

> If a computing system was composed of fundamentally uniform entities that
> are manipulated in a consistent manner and the system contains entities that
> represent itself--then what else is necesary for the system to be
> reflective? In other words, if a computing system has unified system
> abstractions (with abstractions of itself) then is the system reflective? My
> question concerns the implementation of the TUNES functionality. Is the fact
> that TUNES is objects all the way down and that some objects represent the
> system itself enough of a reflective architecture to allow "anything to be
> programmed that could possibly be programmed"?
> 
> I am wondering because it seems to me that Retro is where things are
> happening. What I see as the means to TUNES is to implement it at not a low
> level, but at a low layer, meaning that TUNES should be the fundamental
> layer of abstraction and everything should be an extension of it. Can
> Brian's Arrow System be implemented within Retro or something similiar? And
> if so then could we just work within the realm of the Arrow system from then
> on? What is it that other people are wanting to do? Do you want to implement
> the HLL on top of something? I don't really see how that would work because
> I don't really see that the HLL could every be on top of the operating
> system--it IS the operating system. Or am I wrong?

You are basically right, but the problem is that having just one model
which is reflective is not enough.  You have to support all possible
reflective models, and switch between them at the drop of a hat.  E.g.
Brian may do some work in Arrow and I work in my little world of types and
objects, but the system allows us to see what each other is doing in our
native viewpoint.  If Brian writes some arrow construction that is
complicated to express in types and objects, then I'd rather look at the
Arrow version.  But I'd do it by emulating Arrow inside my system.  Then
the reflection of my own system allows me (somehow) to reify the emulated
Arrow system back into the running objects+Types system.  In Arrow, Brian
would do the reverse.  Except that we're not really in different systems
at the high level since they interchange, and we may not be at different
systems at the low level since we could be using the same implementation
of tunes. If we have completely different implementations it is separate
from the high level view that we choose to use.

David Manifold <dem@tunes.org>
This message is placed in the public domain.