Generative record types

[Gerald Jay Sussman <gjs@martigny.ai.mit.edu>]

     You wrote:

	 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
  representation.

  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 
  compiler).

  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
  upon.

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.