On Thu, Mar 20, 2003 at 11:40:47AM -0600, Kendall Grant Clark wrote:
> It works in -- among others, I'm sure -- Erlang, Smalltalk, and Common
> Lisp long-running processes; I'm curious about which Python features or
> semantics (or implementation details, for that matter) prevent it from
> accomplishing this attainable goal. (It really is a very nice capability
> to have, obviously.)

I think the general problem is that objects defined in the module can
survive the reload if they are referenced from outside the module.  If
that happens, you have objects in your process that do not correspond to
source code.  Very confusing.

One common example is an instance being referenced from outside the
module.  When the module is reloaded the instance will continue to use
the old class object.  There are many other ways this problem can bite,
e.g.

    # module a
    class A:
        pass

    # module b
    import a
    class B(b.A):
        pass

Even if module "a" gets reloaded, class B will continue using the old
class A object.  There are lots of other ways this can bite.  Fixing it
properly would be very difficult.  A 90% solution probably wouldn't be
too hard.  Class and function objects know which module they were
defined in.  A smarter reload to seek them out and mutate them to use
the new code.

  Neil