Hi Jason and all!

Jason Dufair <jase at dufair.org> wrote:
> I've been following this thread with great interest and have a few 
> questions.
> 
> I really like the idea of modules and, more specifically, of Squeak 
> being declarative (i.e. build images from the ground up rather than 
> strip images).
> 
> As I understand it, modules will contain classes which implement 
> functionality on top of some base set of modules upon which that module 
> depends.  Delta modules will contain new and updated methods on other 
> classes in other modules.  Is this understanding correct?

Yes, so far it sounds correct (even if a DM can contain other changes
than new/updated methods).

> If this is the case, how are we going to deal with interface conflicts? 
>  The scenario I'm wondering about is this:
> 
> First, I load module A.  Class Foo in module A implements #bar which 
> calculates the size of the universe and answers a LargeInteger.  Now I 
> load delta module B which redefines Foo>>bar to answer a random string 
> from Shakespeare's "Romeo and Juliet".  What happens when I load module 
> C which sends bar to Foo and expects the size of the universe back? 
>  Will these interfaces be overloaded based on module dependencies?

Well, one of the "fuzzy distinctions" that IMHO perhaps hasn't been
established completely is that when Henrik (I believe) say module X he
means module X version Y. Not just module X "any version". One reason is
that versioning in Modules is a bit sketchy at the moment.

But if I have understood this correctly (not certain at all) this means
that module C in your example depends not only on module A "any version"
but module A version 1.0. And then when you load module B which has a DM
for module A it will change module A into version 1.1. So now you
suddenly have a conflict that needs to be resolved somehow.

Stephen Pair would probably at this point join the thread and present
his "selector spaces" which can handle this situation I think. :-)

regards, Göran