Subject: Re: Common LISP: The Next Generation
From: Erik Naggum <>
Date: 1996/09/04
Newsgroups: comp.lang.lisp
Message-ID: <>

[Mike Haertel]

|   Some of us like the additional protection afforded by running different
|   programs in different address spaces.

for lack of an existing more general term, let me call it "non-interference
between processes", and agree that it is a winner.  however, this _need_
not be done through address spaces or separate processes -- as long as the
abstract functionality is available, it is not important how it is
implemented.  also, you're not the only one to desire this, so there should
be a good chance that something smart will be done.

(I prefer to talk about programs as data objects and processes as programs
that have been loaded into an execution environment.)

|   What I dislike most about interactive Lisp environments is the
|   nonreproducibility of results after a session of any serious length.
|   Did that really work, or did it work just because of some definition I
|   accidentally made two hours ago?

sure, this is a real problem.  I think this needs to be solved by having
the source code available alongside any compiled definition, so it can be
reproduced upon request and stuffed in a file.  that would also afford
looking at the real source code of a function, as opposed the source code
before a redefinition somewhere.  it wouldn't take much memory to keep
track of these definitions if they mainly reside in files.

|   I think what I'd really like would be some sort of checkpoint and
|   rollback feature.  So, if some definition doesn't work, there should be
|   a way to undo it as if it had never happened, up to and including
|   restoring the previous definition if any.

yes!  I'd love that.  but this would require that all symbols had a history
of the previous contents of their various slots that worked independently
of scoping.  what should the effect of undoing a macro definition or an
inlined function definition be?  should everything be timestamped such that
code would know whether they had been outdated?  should undo operations
cascade such that dependent definitions are undone, too?  this could become
very messy.

|   Protected OS's where all programs get their own address space give you
|   a crude way to do this: launch a new program.

but... they give a process no chance to permanently affect their "parents"
unless the parent wants to and is prepared to listen.  this is a very
serious liability, insofar as few parents actually listen to wisdom from
their kids.  ahem, sorry.  I mean, insofar as no general protocol has been
defined to handle this well.  in other words, the backing up you desire
should be voluntary, not compulsory, as it usually is.

those who do not know Lisp are doomed to reimplement it