(oops, forgot the [Modules])

In recent messages there have been various short testimonials regarding 
either (or sometimes both) the virtues working with an image and the 
virtues reliable reconstructible modules.  There was just one thing I 
wanted to point out that I haven't seen mentioned.

Most module work relates to the use of valid, self consistent, 
modules.  For example, under what circumstances is it valid to simultaneous 
load two different modules. Applying the specification of the module system 
should tells you that either that the modules are compatible or that they 
are not.  Generally, such a specification will tell you nothing about what 
happens if you try to do something with to two invalid modules (modules 
whose structure violates the specification) or if you force the 
simultaneous loading of two incompatable modules. Invalid modules or 
combinations of modules simply don't exist within the scope of the 
specification.

Development tools, however, must deal with invalid or illegal modules or 
configurations of modules. After all, it's probably impossible to create or 
edit a module without going through some illegal states.  This is actually 
one of the harder parts of implementing good tools.

My sense, is that many of the "fears" of image people is that the goals of 
the module people will (perhaps inadvertently) take away the current 
flexibility we have of working with code within the image. This will not 
happen. Nobody wants a Smalltalk system where it was hard to create or 
change code? If somebody built it, nobody would use it.  Whatever is done 
in the way of module support the user experience, while programmer, most 
maintain the flavor of we all know.

On a related vain concerning the name space discussions. It's not that hard 
to specify a semantics for name space support for Smalltalk.  It's also not 
heard to come up ways to implement such a thing.  However, in my 
experience, what is extremely hard (as in, I've yet to see it accomplished 
in a manner that I'm satisfied with) is figuring out how to present name 
spaces in the context of the Smalltalk development tools in a manner that 
actually enhances the programmer's experience.

Allen