RE: [Gcl-devel] RE: [Maxima] Re: Maxima cmucl patch

[Stavros Macrakis]

> Is there any available real-world system making use of
> 'dynamically-defined' programs and routines?  If your system 
> generates a function at runtime and decides to compile it, 
> why does it need to know where it is on a dependency tree?

I'm thinking of simpler scenarios:

I find a bug while in my Maxima session.  I edit the source in Emacs.
Now I want to load that into the Maxima and continue working or testing.
It may depend on macro definitions when run interpretively.  Clearly I
can't use 'make' in a case like this.  The traditional solution in the
Lisp world was (is?) to have each loadable file responsible for its own
dependencies, using load-time and/or compile-time executable code.

I don't much like that system -- I'd rather it be declarative -- but it
does work to some extent.  Now consider the following scenario:

I am in a Maxima session.  I edit foo.lisp (an existing Maxima module
which is already loaded into the system).  I edit bar.lisp, which
depends on new function definitions (not macro definitions) in foo.lisp.
Now I load bar.lisp.  There is nothing to pull in the new version of
foo.lisp in traditional Lisp systems, which assume that if something is
defined in the running image, it is validly defined and doesn't need to
be updated.

---------

> While your at it, though this is somewhat off topic -- could
> you please explain to me to what lisp development experts are 
> referring when they tout the ability to modify a running 
> program?

I would guess (based on zero context...) that they're talking about not
losing one's workspace when one redefines a function, or being able to
redefine a function within a break level (for debugging).  That sort of
thing.

> Perhaps is 
> meant executing a saved image, modifying, saving the image, 
> and copying that to the location used in future invocations?

I am not sure what you mean here.  Are you talking about unexec-type
functionality?  Yes, that can be useful, too -- Maxima is presumably
built in some such way.  But I think that's another matter.

      -s