I'm cherry picking again. Gotta love it.

On Thu, 28 Feb 2002, Lex Spoon wrote:

[snip]
> Extensibility leaves me cold.  I'd like to figure out *one* system of
> classs, modules, namespaces, etc., before worrying about how to let
> programmers develop other ones.

So you prefer to develop Object before ProtoObject :)

>  For production applications, it even
> seems like a bad idea to define new kinds of namespaces.  It in fact
> such a practice would even seem non-OO: OO design is centered around
> class (and interface) definitions, not language redefinitions.

Er...well, an OO meta-object protocol let's you do just that, center your
langauge redefinitions around class and interface definitions.

Given that Squeak is an experimental, evolving system where the langauge
itself *is* evolving, such things seem *very* much on the table.

Of course we can just hack the system, but isn't that what we're trying to
get away from with the module inititive? Structured, manageable ways to
perform the kinds of experiments we want to perform in inter-compatible
ways?

Plus, there's a bit of work in using Squeak for multi-langauge
implementation (SqueakNet? HORK!). Why *not* support that in a nice high
level way?

> OO guys don't go to the drawing board and say "for this project, we
> could redefine global variables to work like this".

C.f., the module discussion :)

>  They say "for this
> project, it makes sense to define Thingwitches and Frobnikas".  This is
> Smalltalk, not Lisp, and in fact I'm starting to think a pervasive
> difference between the two language families is that Smalltalk picks
> some specific program organizations that work well, while Lisp leaves
> extremely basic things open to design.

Eh, c'mon. Lisp picks some specific program organizations! Indeed, it's
nice and clear about MI order, etc.

What it does is pick some specific ways to organize those organizations
that work well. Why shouldn't we do the same?

These are *not* mutually exclusive choices.

>  ie, in Smalltalk freedom comes
> from form, while in Lisp freedom comes from freedom.


Eh. I disagree. As I said, Lisp provides plenty of form, indeed, *more*
form covering *more* freedom!

[end stirring music]

We've had this debate on comp.lang.smalltalk. I think, in fact, people
hack the object model *all the time*. Lot's of uses of dictionaries do
this, especially when combined with blocks. (Take ComSwiki as a *perfect*
example.) These *ad hoc* measures are handy, but in aggregation they're a
mess. The tools don't work well for them. They're a pain in the rear to
figure out all the slightly different variations, etc.

Cheers,
Bijan Parsia.