[Newbies] Re: new vs. initialize
Greg A. Woods; Planix, Inc.
woods at planix.ca
Wed Dec 10 01:51:09 UTC 2008
On 9-Dec-2008, at 11:26 AM, Tim Johnson wrote:
>
> On Dec 8, 2008, at 8:56 PM, Greg A. Woods; Planix, Inc. wrote:
>
>> Initially though this recommendation didn't make any sense to me
>> because I didn't know how the implementation of #new in Behaviour
>> is different from strict Smalltalk-80 as I understand it. I.e.
>> originally in Smalltalk-80 #new did not also send #initialize, but
>> now in Squeak it does.
>
> This recent (!) change to auto-initialize puzzles me as well. So
> much existing code was written with the opposite case being true,
> that it seems so risky to change! To diverge from the ST-80
> standard is even more risky, I would think.
Well what really angers me about this change is that it's not properly
documented in any way shape or form. There's just the code, and even
with all the code browsing tools in Squeak it still took me far longer
than it should have to figure this out. Part of that was my
unfamiliarity with Behaviour and ProtoObject, but most of it was the
total and complete lack of documentation about this difference. Even
outside the image itself there's just one very out-of-date page on the
swiki about this, and it gives no details or proper rationalization
whatsoever, and indeed it gives caution to some of the issues. It
certainly doesn't say it's a done deal -- in fact it's still in the
"improving" section. There's a very long and convoluted thread in the
mailing list archives but as yet I haven't even read anywhere of any
true consensus being reached (though many folks just seem to have been
beaten into submission).
I am annoyed that anyone would want to change this fundamental little
part of the basic Object protocol too. #new is supposed to answer a
new instance of the receiver. Period. Not also do any callbacks back
to any other instance methods. None. RTFM. Maintaining the status
quo is very important when you're talking about fundamental parts of
the object protocol. Now Squeak documents Behaviour>>new as returning
a new _initialized_ instance, but that's not (universally) true so
it's very confusing.
Now every book, every paper, every web page, including tons of
"squeak.org" web pages, are now (still) incompatible with the current
(and previous) release of Squeak. Squeak is now incompatible with its
own earlier versions. Squeak is now incompatible with code that used
to work in Squeak, and at least one of the classes right in the main
release, one which is used by a package still in the default package
universes, has been broken by a naive change (a relatively long time
ago) by someone who presumably should have known better (i.e. who was
probably aware of the change to #new) and who obviously didn't test
their change.
It seems to me that Squeak users _must_ now be experienced developers
in order to be able to file in old code and actually make it work in
far too many cases. I.e. this change is a total failure when it comes
to supporting _users_. If I had given out code that somehow relied on
the old #new protocol and then disappeared now only someone with
enough experience and knowledge can make use of it in a new Squeak
release. Indeed this happens all the time in the world of software,
all too often. But that doesn't mean it should happen. I'm beginning
to understand why many serious Smalltalk programmers I've met in
recent years consider Squeak to be no more than a toy.
I'm also beginning to understand why the gurus around me more than 20
years ago were telling me that default initialization was a "Bad
Thing(tm)". First off, not everything needs to be initialized. Also,
as was discussed in some detail before, this most basic form of
parameter-less initialization doesn't work for probably the majority
of classes which really do need initialization upon instantiation so
what exactly is the benefit anyway? Even the Blue book effectively
gives caution to why auto-initialization can be very tricky and far
less helpful than it may at first appear to be (p. 274).
Finally I think that some of the apparent justification for this
change, a topic that was bandied about on the mailing list way back
when, is also naive in and of itself. I'm referring to the claim that
this change will help educators avoid having to deal with the meta-
level of how classes are implemented. Don't get me wrong though --
I've never taught Smalltalk, this is just from my experience of
(trying to) learning it. First off I think the problem with the
concept of metaclasses in Smalltalk is that they're not exposed
clearly and plainly enough in the first place. The chapter(s)
describing them in sufficient detail comes far too late in all the
textbooks (especially the original one -- #16!?!?!?!). The default
code browsers have never been easily shown metaclass information in
any decent way that properly lays out the structure and hierarchy of
metaclasses and their protocols. There's always been this attempt to
smush metaclass and class stuff together so much that metaclasses are
effectively invisible and that's always confused me. Secondly,
although I recognize there are limitations and constraints on teaching
this stuff, I don't buy the argument that it's good to avoid talking
about the meta stuff to students, especially not if it's just so that
you can spend more time on "other things". Not knowing that I should
read ch#16 in the Blue book right away as soon as I needed to learn
about the meta level left me confused and knowing that I was missing
something fundamental for a very long time. Maybe the "class" button
in the browser should actually be a "metaclass" button as a reminder?
I don't really buy the "fragile instance" argument either. Especially
not for this most mundane change to just the two forms of #new and
#new:. There's just _way_ too much variation in existing practice of
how to take a blank instance of an object into a well formed (ready to
use) instance. And there _should_ be!
I don't know if this change to add #initialize to #new is a big deal
fundamentally or not -- I'm just blowing off steam. My fundamental
problem is that none of this was properly documented in the image
despite the fact that Smalltalk includes excellent built-in
documentation capabilities. In reply to my problems with
BDFFontReader I read something that seemed contrary to my fundamental
20-year old understanding of Smalltalk-80. I tried looking for
answers. I re-read books. I re-read web pages. I searched the WWW
(it didn't help that the logical keywords here are very common) and
most of my own printed material (books, papers, guides, etc.). I
grovelled around in the image for far longer than I probably needed to
(I'm not yet familiar enough with all the available tools). Nothing I
read said anything about the magic of a #initialize method being part
of the core Object protocol. Finally I found where #initialize is
sent from Behaviour>>new and where the default method is. This
contradicted _everything_ I read _everywhere_ about object creation
and instantiation and initialization in Smalltalk-80. Nowhere did any
documentation in Squeak or about Squeak lead the way for me to
understand this difference in Squeak's fundamental Object protocol, or
give any explanation or rationale for this difference in Squeak.
Sadly the changes in the image were compacted so I couldn't even see
that this fundamental old protocol had been changed.
Shame on anyone who writes any class or method that ends up in the
core image without proper detailed documentation! Double shame on
anyone who makes any change to any core protocol without documenting
its purpose and rationale! Document first, code later. Those
responsible for making changes to core protocols are, IMNSHO, also
responsible for at least making sure outside documentation is also
updated to reflect the new reality, if not actually doing the updates
themselves. You have a responsibility to the community, your peers
and colleagues, and indeed all those interested stake-holders outside
the immediate community too!
--
Greg A. Woods; Planix, Inc.
<woods at planix.ca>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: PGP.sig
Type: application/pgp-signature
Size: 186 bytes
Desc: This is a digitally signed message part
Url : http://lists.squeakfoundation.org/pipermail/beginners/attachments/20081209/9e457f22/PGP.pgp
More information about the Beginners
mailing list