Clipboards + Meaning

[Fare Rideau]

>   As an object changes in ways that affect those that have references to
> it, are messages somehow sent to those objects, so they know to
> re-evaluate themselves?
>
Not exactly. In a reactive model, not the object but its *metaobject*
would be notified of implementation changes. Objects do not evaluate self
(no well-founded theory allows that); rather, meta-objects evaluate objects
(the "ultimate" meta-object being the physical world).
The idea is to that by distinguishing the observed meaning of objects
from their implementation, you leave room for more auto/manual optimizations,
while allowing for correctness guarantees thru all involved dirty
transformations.

The user-visible difference is that when two objects are specified to
be synchronized, then they are actually synchronized;
you don't get to see how they synchronize unless you really want to.
That's really like cache memory or virtual memory having transparent
semantic to non-hard-real-time programs: you typically don't have
to know when cache or TLB misses happen, and how the system hardware
recovers from them. Similarly, you typically won't have to know how
the system will handle persistence by using RAM as a cache
to persistent data with software-enforced (rather than hardware-implemented)
consistency.

So implementation tactics are separated from specification, and hidden from
"casual users", whatever that means in the considered context.
Of course, for any such given context, there will have been meta-programmers
who'll have got get a kick out of specifying implementation tactics
(and meta-meta-programmers for meta-implementation tactics, etc, until
something simple enough is reached).


>   Something like this would allow someone to write static image processing
> code that becomes animatable when the input changes, or you could also use
> it for batch rendering.
I'm not sure what you mean. I you want to use a static image processor
as a functor transforming animations into animations, there's no problem
with that. Similarly for A->B processors transforming A-animations into
B-animations, where A and B are arbitrary.

>   Hase anything been done about units?  I've been thinking about this for
> a while.  It seems like you care about three things, with respect to data:
> 	1) organization of units
> 	2) type of units (meaning range, scale (log, linear, exponential,
> etc.)
> 	3) meaning of the units
>
Units are sure something that could be covered by suitable meta-objects.
There once was an extension to the type system of the Caml-light language
that did manage units (though not logarithmic of exponential stuff).
One of the challenges of the Tunes HLL sure is to allow such type extensions,
as well as arbitrary other extensions (e.g. real-time and/or
real-space annotations) to be dynamically expressed.


> 	By the way, were you just talking about (I forget the formal name
> of it), but objects can dynamically determine who they're derived from?
> That seems like a reasonable way to implement the behavior you were
> talking about.
>
Again, objects are. They can't determine for sure where they come from,
or anything, unless this was specifically given in the object's definition.
However, the meta-object for a given object might very well be aware of more
than what's in the object's defined observable semantics; hence, the
meta-object might take into account historical information to efficiently
implement the object, or otherwise extend its semantics.
Hence, if a picture was transformed through a variety of filters,
and you want to extract data that was much more easily available
before filtering, and your original picture is still cached,
then the meta-object might well get the information without reversing
the filtering. The object doesn't know about such hacks; it just
embodies its declared semantics.

Why do I insist on having well-distinguished meta-objects and objects?
Because if you want to give meaning to things, hence if you want
to apply formal methods, be it for proofs or efficient compilation,
you do need a well-defined, clean semantics. And if you mix implementation
levels without caring, you end up with an unusable mess that cannot be
reasoned about, compiled, migrated, maintained, or anything, by either
man or computer.

== 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 ==