[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Generative record types
I would like to weigh in against opacity. I particularly like the
fact that the language has explicit support for breaking abstractions.
This is one of the best parts of Lisp-derived languages, as it removes
the distinction between systems programming, environmental support,
and other programming tasks.
So how do you square this with procedures being opaque?
I'm not arguing for opacity here, just curious.
Actually, I would rather that there be limited methods of examining
and modifying procedures. Such features are essential when using Lisp
expressions as a medium for encoding procedural information as a kind
of data that might be studied or manipulated by a program or a user.
For example, Bill Rozas wrote a PhD thesis that introduced a rather
intriguing notion of translucency, which gives limited access to the
content of a procedure without depending on the actual
MIT Scheme provides a means of determining details of the formal
parameters of a procedure, and more generally a means of obtaining
the sources (when available in a separate file provided by the
In my world it is also essential to have EVAL/COMPILE as a means of
coercing such a representation back into an executable form, so it
can be run as well as looked at.
In my favorite programming language/environment I also want a means
of editing and replacing the executable part of a procedure on the
fly, and a means of editing the environment structure it depends
upon. Note that this does not imply that the actual executable
representation of the information is constrained by the
representation that these editor mechanisms act on -- just that the
effect of performing the edits would change the behavior as
expected. Of course, I would expect that the means of editing would
be implemented in a set of primitive procedures that I could depend
I know that this sounds reactionary, but I persist in viewing
computational processes as living organisms, which often contain
valuable information. There are times to kill them and to reconstruct
them genetically (from a textual program) and there is time to do
surgery or other in vivo experiments. I have consistently held this
view since the I started thinking about computation. The problem is
that this vision appears to be in direct conflict with the real need
to obtain safety and reliability by erecting firewalls that dominates
the software engineering scene. Probably, the kind of experimental
programming that I enjoy and depend upon is just incompatable with a
language structure that can be used for software engineering, sigh.