Wed, 14 May 1997 00:46:42 +0200 (MET DST)
> There is a very good question about how to dynamically affect the
> 'defaults' of some complex operation. Dynamic variables are one way,
> but the other ways all have there problems, as well. E.g., having to
> pass 23 parameters to each function a la large Fortran systems, most
> of which are always the same.
IMO, Reflection could be used to solve this kind of problem:
if you need define an operation without overspecifying it,
then do not overspecify it,
and let the system choose the proper implementation.
* The implementation could very well transform implicit parameters
into those 23 explicit parameters.
* For an optimized implementation, the Compiler can choose
what binding goes where, which is made explicit,
which stays implicit in the environment.
* Dynamic binding is just a particular case
of what reflective programming allows, with broken semantics.
* For an efficient implementation of Reflective programming,
Specialize&Invalidate looks fine to me.
* When it's a matter of querying user-level options,
you don't need much performance anyway.
* In most case what you want is NOT dynamic binding,
all the less in a multi-threaded system.
Instead, you want some kind of generic deferred binding,
as show the (with-...) constructs.
* Globals are just BAD, especially in a persistent/distributed system...
* Among important program analylis;
Tagging packages with the set of (dynamic) variables they use is interesting.
== Fare' -- email@example.com -- Franc,ois-Rene' Rideau -- DDa(.ng-Vu~ Ba^n ==
Join the TUNES project for a computing system based on computing freedom !
TUNES is a Useful, Not Expedient System