Meaning

[Fare Rideau]

Dear Tunesmiths,

>: David E. Manifold <tril@bespin.ml.org>

> The meta-object describes an object's type system, including what
> functions can operate on the object.
This is true in usual "reflective" object systems, whereby for every object
has a unique meta-object (including meta-objects themselves), that
allows some meta-operations on it. However, my feeling is that this is
a gross limitation on what reflection can bring: this "reflective tower"
model means that there is unicity of the meta- aspects of an object,
that sharing of aspects by an object or of objects by an aspect is
made unexpressible directly (though it can be emulated).

In my opinion, users should be able to independently specify multiple
meta- (implementational) aspects of an object, in as much as these
aspects are compatible and a that common implementation can be actually
found by the system. These various aspects form a natural hierarchy
by the ordering "aspect 1 fully implements aspect 2" (note that some
aspects may "overlap" without one fully implementing the other),
and any static outside ordering (nth metaobject) only gets in the way,
as far as specification goes (though they might be quite a useful
meta-implementation trick).


> To use an object you apply a function to it.  When you apply
> the function, the system looks up the metaobjects describing the type
> system, and verifies that the objects can combine (typechecking).
>
Well, in case someone might get bitten by it, let's remind that
this is only the observable semantics; as usual, actual implementation
need not perform any check at runtime (yuck), if it could be statically
proven before that it is unnecessary.


> type system is higher-order, meaning you can use any language or semantics
> in the system for specifying which objects can combine.
>
Higher-order doesn't mean that (though "that" is true, too, in as much
as I understand it). Higher-order means that there are functions are
actually first-class citizens, as opposed to first-order systems where
only "actual values" can be passed as arguments or returned.
I also used the term (though incorrectly, I think) to imply that
types were first-class citizens, too, though that is not without problems
(see various paradoxes about `Type: Type` not being allowed as is
in proof systems).


> I think a main difference between Tunes and all existing systems is that
> the functions performing the operation, the objects being operated on, and
> the metaobjects describing the type system are ALL first-level objects,
> and are all treated equivalently.  None are more special than the others,
> they just have different specifications and different arguments.  (high
> order uniformity)
>
Well, actually, some other systems kind of do it, too.
What I'd like to do is do it in a meaningful way that allows
for expression of static invariants and proofs, too.
Even then, NuPrl seems to do it, too...


>> <<< As you travel up the hierarchy to the nth order meta-object, you reach
>> the object that provides the entire framework of how objects are treated.
>> >>>
>>
>> Is it really hierarchical? What about changing the hierarchy?
>
> It is hierarchical in the sense that objects depend on other objects, and
> you can trace a tree of dependencies between objects.  Being able to
> change the hierarchy dynamically is the nature of Tunes (high order
> dynamic reflection).  You might want to stick modularity in there, too.
> (any part of the hierarchy can be replaced)
>
Well, let's say that there is a natural (partial) hierarchy at any moment
between the various aspects of an object, and that the system's
responsibility is to maintain the consistency between them.
There need not be a static total order between the set of aspects;
there only need be a all-encompassing aspect that fully implements
all others. This aspect can rightly be called the "actual implementation".

No big deal: a computational object can exist if and only if it
can ultimately be actually implemented in terms of basic constructors.
Why can't other systems bring this simple, natural view on computing?
They all impose drastic requirements that tie abstract objects to
a particular, human-writeable, way of implementing them.


== Faré -=- (FR) François-René Rideau -=- (VN) Уng-Vû Bân -=- rideau@ens.fr ==
Join a project for a free reflective computing system! | 6 rue Augustin Thierry
TUNES is a Useful, Not Expedient System.               | 75019 PARIS     FRANCE
http://www.eleves.ens.fr:8080/home/rideau/Tunes/ -=- Reflection&Cybernethics ==