Dynamic binding

[Fare Rideau]

> 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' -- rideau@ens.fr -- 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
URL: "http://www.eleves.ens.fr:8080/home/rideau/Tunes/"