Discussion:
Design Patterns and Collection Classes
(too old to reply)
Richard A. O'Keefe
2012-01-28 11:13:43 UTC
Permalink
"David Griswold" <***@acm.org> wrote:

So if there is any overall message here, it is: be very careful
with code in classes like this, and show great restraint by
making changes as minimal as possible. The code in Collection
is simple, but not simple-minded. Don't underestimate the
subtlety of why these simple-seeming methods are the way they are.

In another context, Brian Foote and Joseph Yoder wrote
[http://www.laputan.org/mud/mud.html; capitals are theirs and were links]:

... when you are prototyping a system, you are not usually concerned with
how elegant or efficient your code is. You know that you will only
use it to prove a concept. Once the prototype is done, the code will
be thrown away and written properly. As the time nears to demonstrate
the prototype, the temptation to load it with impressive but utterly
inefficient realizations of the system's expected eventual functionality
can be hard to resist. Sometimes, this strategy can be a bit too
successful. ...

Does this sound a bit like the history of Smalltalk? It should. A whole
new language every two years. A research goal that was not "how do we
build ideal collection classes" but "how do we take the idea of object
orientation and build a language and system around it that can be
understood ("Personal Mastery") and used in powerful ways, how can we
develop a whole new approach to programming?"

... Time, or a lack thereof, is frequently the decisive force that drives
programmers to write THROWAWAY CODE. Taking the time to write a
proper, well thought out, well documented program might take more
time than is available to solve a problem, or more time than the
problem merits. Often, the programmer will make a frantic dash to
construct a minimally functional program, all the while promising
him- or herself that a better factored, more elegant version will
follow thereafter. They may know full well that building a reusable
system will make it easier to solve similar problems in the future,
and that a more polished architecture would result in a system that
was easier to maintain and extended.

Quick-and-dirty coding is often reationalized as being a stopgap
measure. All too often, time is never found for this foloow-up work.
The code languishes, while the program flourishes.

THEREFORE [and this is their recommendation], produce, by any means
available, simple, expedient, disposable code that adequately
addresses just the problem at hand.

... while this approach [that is, the approach used in a particular
example, not throwaway code as such] is, in general, a lousy way to
address this [particular example's] problem, it is perfectly
satisfactory within the confines of the particular purpose for which
[it] has ever actually been used. Such practical constraints are
typical of THROWAWAY CODE, and are more often than not undocumented.
For that matter, everything about THROWAWAY CODE is more often than
not undocumented. When documentation exists, it is frequently not
current, and often not accurate.

Does this sound like #removeAll: and #addAll:? It should!

... [Two example] systems might be good candidates for RECONSTRUCTION,
were the resources, interst, and audience present to justify such an
undertaking. In the mean time, these [particular] systems, which are
still sufficiently well suited to the particular tasks for which they
were built, remain in service. Keeping them on the air takes far
less energy than rewriting them. They continue to evolve, in a
PIECEMEAL fashion, a little at a time.

Doesn't this sound like _everything_ about Squeak? From the core classes
to Morphic? Isn't piecemeal (community) improvement part of the _point_
of Squeak?


So David Griswold claims that the Collection classes are subtle,
simple but not simple-minded, and that the methods (including the ones I
claim are broken) are the way they are for excellent reason and should
not be altered without great [indeed, to my thinking, extreme] restraint,
while I claim that the Collection classes are a "Ball of Mud" where most
methods are the simplest thing that could possibly work, except they don't.

Obviously, eyewitness testimony from the original developers could settle
this. Except that it couldn't; it could only tell us how they remember
what they thought they were doing. We need some more objective criterion
to help us decide what kind of code we are dealing with here. If we are
dealing with entire and perfect chrysolite, what we need is documentation.
If we are dealing with mud, we need documentation AND repairs.

So let's look away from #removeAll: and #addAll:. Let's even look away
from #union:, #intersection:, and #difference:, enchanting though their
perversity may be.

----------------------------------------------------------------
A Design Principle.
----------------------------------------------------------------

Every class should have a class invariant.
It does not need to be expressed as code, but it needs to be thought
about and written down.

Initialisation methods have the obligation of setting up an object's
state so that its class invariant is true.

Other (externally accessible) methods get to assume that the invariant
is true and have the obligation to ensure that it is still true when
they complete. If you cannot rely on sufficient knowledge about the
object's state at the beginning of a method, the only thing you can
do to restore the invariant is reinitialise.

If the invariant of a class depends on the state of a mutable object,
and that object is accessible outside this class, then you DON'T have
an invariant and you cannot expect your methods to work.

So the design principle is:
a class's invariant should depend only on the values of its instance
variables and the states of such objects as are immutable or are
not shared with other objects.

----------------------------------------------------------------
The Collection Classes
----------------------------------------------------------------

Do the collection classes heed this warning?
Many of them do.

OrderedCollection, for example, never hands out its array, and does not
provide any non-private methods for changing its instance variables.
(At least, by putting methods in the 'private' category it is warning
"don't call these lest the heavens fall".)

Set, for another example, depends on the exact state of its array, but
never hands out access to that array. BUT it also depends on the state
of the elements; it requires that the hash code of an element not change.
Oddly enough, it _does_ provide a repair procedure that can be called.
You could mutate the elements of a Set, taking care that the Set itself
was not used while this was happening, and then invoke the #rehash
method. Except that #rehash is private. With the exception of numbers
and symbols, there are no immutable values that one might use as keys.
There is no equivalent of OPAL's InvariantArray, for example. (I'm trying
to write one and it's a nightmare. Array has so *many* methods that think
it's OK to smash, even when they are making copies.)

But what about Dictionary?

Dictionary cannot make up its mind whether it's about Sets of Associations
or keyed collections of values, and tries to be both. Considered as a
keyed collection of values, a Dictionary's Associations are part of its
private internal structure. Dictionary's invariant concerns the structure
of its hash table, which depends on the state of these Associations. Yet
it is perfectly happy to hand those Associations out to anyone who asks.

Consider
d := Dictionary new.
d at: #red put: Color red.
d associationsDo: [:each | each key: #green].
d inspect
==> (shows #green -> nil)
d at: #green
==> (Error: key not found)
d at: #red
==> (Error: key not found)

Had Dictionary been designed with class invariants in mind, it could still
have looked much the way it does now, but the Associations it hands out
would be InvariantKeyAssociations, where

Association subclass: #InvariantKeyAssociation
instanceVariableNames: ''
classVariableNames: ''
poolDictionaries: ''
category: 'Collections-Support'

"private methods"
pvtKey: k value: v
key := k.
value := v.

"accessing methods"
key: k
self shouldNotImplement

"class instance creation methods"
key: k value: v
^self new pvtKey: k value: v

Except that this won't work; practically the only time I ever really
need 'pvt' methods is so that a class can initialise a new instance
without the initialisation method being exposed to another class, but
the 'pvt' machinery will not let you do this: "private messages may
only be sent to self". If only there were a category of private messages
that a class could send to 'self new'. So the method _really_ has to be
called #privateKey:value: and we just have to _hope_ that no outsider
will use it. So much for private methods.

It's all very well to say that competent programmers wouldn't even _try_
to change the key of an association that came from a dictionary, but if
there are two things that the last fifty years of programming and the
recent history of the Internet have taught us, they are
- EVERYONE makes mistakes
- some people deliberately try to break other people's programs.

Oh yes, what if no Association is changed, but a key is?
Just like Set, Dictionary _could_ let you make a series of changes to
keys (as long as no previously unequal keys became equal) and then
repair the state of the dictionary using #rehash, _except_ that #rehash
is a private method. (Which means you _can_ do this, but you shouldn't.)
#rehash depends on a rather weaker invariant: it requires that keys
still be non-nil and unequal, but it doesn't require that their values or
hashes be unchanged.

Is there another Collection class that exposes its internal structure?
Yes, MappedCollection.

MappedCollection collection: c map: m

in effect constructs the composition of two tabulated functions:

(MappedCollection collection: c map: m) at: index
=
c at: (m at: index)

The base collection c and the map m are not copied when you do this.
Indeed, that's the point. But it leads to some very odd consequences.

For example,
i ~= j and: [
(mc at: j) ~= 0 and: [
mc at: i put: 0.
mc at: j = 0]]
can come out true. For every other keyed collection, setting the element
at one key doesn't alter any elements at other keys. So DON'T try to
sort a MappedCollection!

It's also the only Collection class I can find in Squeak 3.2 where
(coll contents) is not the receiver but a copy with different properties.

One of the nasty things about the fact that the collection and mapping
are shared with unknown numbers of other objects is that

foo: aCollection bar: aBlock
|index value|

index := aCollection size.
value := aBlock value: (aCollection at: index).
aCollection at: index put: value

may fail, even though aBlock value: ... doesn't send any messages whatsoever
to aCollection. How? aBlock could make the mapping smaller, or alter its
last element so that it is no longer a valid key for the other collection,
or could alter the other collection so that the key disappears, &c.

Oh yes, imagine the fun when you do
a := #(3 1 4 1) copy.
m := MappedCollection collection: a map: a.
m ==> a MappedCollection(4 3 1 3)
m at: 2 put: 2.
m ==> a MappedCollection(1 2 1 2)
m at: 3 put: 3
m ==> a MappedCollection(1 2 3 4)
a ==> #(2 1 4 3)

MappedCollection *tacitly* assumes that the collection and mapping are
different objects OR that neither will be changed, but it does not say
this anywhere.

At the very least the class comment for MappedCollection
should be changed from

I represent an access mechanism for a sequenceable collection
re-ordering or filtering its elements.

(which is quite untrue because it doesn't in the least depend on the
collections being sequenceable) to

I represent the composition of two collection.
(MappedCollection collection: c map: m) at: index
is always the same as c at: (map at: index).
The collection and map could be any combination of sequenceable
collections and dictionaries as long as the elements of m all
are (and remain) acceptable keys for c.

My instances are sequenceable precisely when their maps are
sequenceable.

If you plan to use #at:put: with one of my instances,
the collection c and map m should be different objects.

Note that the collection c and map m are NOT copied, but are
shared. If you change them, the mapped collection you made
from them will also change. Changes to the elements of the
collection are normally safe; changes to the key space of
the collection or the elements of the map may make the
mapped collection invalid. Do not change the map while you are
iterating over the map or the mapped collection.

Hey, there's another oversight, found while writing that new class comment.
There's a missing method:

"in category 'testing'"
isSequenceable
^map isSequenceable

Alternatively, if the (otherwise pointless and unnecessary) restriction to
sequenceable collections is to be preserved, then #setCollection:map:
should be

setCollection: aCollection map: aDictionary
self assert: [aCollection isCollection].
self assert: [aDictionary isSequenceable].
domain := aCollection.
map := aDictionary

except that the names of the method parameters (which I have not changed)
*strongly* suggest that the map should be allowed to be a dictionary, which
is NOT sequenceable. But the instance creation method calls the very same
parameter aSequenceableCollection.

Whatever this code may be, it is not 'subtle'. It's confused and confusing.

Are there any other collection classes that violate this design principle?
Yes, there is one that doesn't so much violate it as cut its breast off and
eat half of one of its kidneys: LinkedList.

Most container libraries regard a linked list as a container for general
objects, with the link nodes being part of the private structure of the
list. From the outside, it should not matter whether the nodes are allocated
one at a time, or in chunks (a good way to combine the flexibility of lists
with the space efficiency of arrays is to have a linked collection of arrays;
the well known "piece table" representation used in some editors is related
to this). However, Smalltalk LinkedLists are very different: all their
elements must be Link nodes. This makes them utterly unlike arrays; any
number of arrays may refer to the same object as an element, and an array
may include an object as element any number of times. Not so LinkedLists:
each Link may be an element of at most one LinkedList, and then at most
once.

In other words, LinkedList does not encapsulate.

Serious weirdness can result. Consider
c1 add: c2 first.
where c1 and c2 are *separate* collections sharing no objects at all
before this message is sent. If c1 is any other kind of collection
that can support #add:, this is fine. Now c1 and c2 have a common
element. But if c1 and c2 are both LinkedLists, now a node is shared
between the two lists. While #add: is defined to be #addLast:, it need
not actually true that c2 first is now the last element of c1! (Because
c2 might have had more than one element.)

I could multiply examples of how easy it is to break LinkedLists
without exploiting (initial) aliasing, but the main consequence is
that Smalltalk programmers should never _ever_ use LinkedList, not
even after making their own subclasses of Link. Arguably, LinkedList
should be outside the Collection hierarchy. (As noted in an earlier
message, LinkedList is amongst the SequenceableCollections, but does
not support #at:, surely a defining characteristic of such collections.)


Make no mistake:
- I am not saying Smalltalk is unusable.
- I am not saying the Collection classes are unusable.
- I am not saying that the Smalltalk designers are culpable.
What I _am_ saying is that the Smalltalk designers weren't _trying_ to
produce highly polished code but were engaged in research of a completely
different kind, so that they produced 'good enough for the immediate task'
code which after 20-odd years outside the lab is overdue for an overhaul.
The Collection classes are a means to an end, not Holy Writ, and mortals
may dare to criticise and revise them.
Andrew C. Greenberg
2012-01-28 11:13:43 UTC
Permalink
Post by Richard A. O'Keefe
So if there is any overall message here, it is: be very careful
with code in classes like this, and show great restraint by
making changes as minimal as possible. The code in Collection
is simple, but not simple-minded. Don't underestimate the
subtlety of why these simple-seeming methods are the way they are.
Snip...
Post by Richard A. O'Keefe
- I am not saying Smalltalk is unusable.
- I am not saying the Collection classes are unusable.
- I am not saying that the Smalltalk designers are culpable.
I am relieved.
Post by Richard A. O'Keefe
What I _am_ saying is that the Smalltalk designers weren't _trying_ to
produce highly polished code but were engaged in research of a
completely
different kind, so that they produced 'good enough for the immediate
task'
code which after 20-odd years outside the lab is overdue for an
overhaul.
Reasonable people may differ on these conclusions, yes?
Post by Richard A. O'Keefe
The Collection classes are a means to an end, not Holy Writ, and
mortals
may dare to criticise and revise them.
Richard fails to understand that he is not being challenged merely for
criticizing or proposing to revise the Collection classes -- he is
being challenged on the merits of his criticism and proposals. To the
extent a question is a close one, no doubt, David is strongly
suggesting that a conservative view is warranted, and this does not
seem unreasonable. To the extent Richard prefers to think that this is
the corpus of David's criticism, he misses the point and is arguing
against a straw man.

Here, Richard does seem to challenge the possibility that those who
disagree with the conclusions he proposes might have provided reasoned
or reasonable arguments. All evidence, I believe, is to the contrary
-- everyone on both sides seems to be doing a fine job of writing
persuasively in support of their positions.

However, where Richard here presumes to lecture Ralph Johnson about
Design Patterns without greater particularity on the merits, between
them, I shall defer to the views of one of the Gang of Four until I see
clear evidence to the contrary.
Torge Husfeldt
2012-01-28 11:13:44 UTC
Permalink
Hi Richard,
[snip]
Post by Richard A. O'Keefe
But what about Dictionary?
Dictionary cannot make up its mind whether it's about Sets of Associations
or keyed collections of values, and tries to be both. Considered as a
keyed collection of values, a Dictionary's Associations are part of its
private internal structure. Dictionary's invariant concerns the structure
of its hash table, which depends on the state of these Associations. Yet
it is perfectly happy to hand those Associations out to anyone who asks.
Consider
d := Dictionary new.
d at: #red put: Color red.
d associationsDo: [:each | each key: #green].
d inspect
==> (shows #green -> nil)
d at: #green
==> (Error: key not found)
d at: #red
==> (Error: key not found)
Had Dictionary been designed with class invariants in mind, it could still
have looked much the way it does now, but the Associations it hands out
would be InvariantKeyAssociations, where
Association subclass: #InvariantKeyAssociation
instanceVariableNames: ''
classVariableNames: ''
poolDictionaries: ''
category: 'Collections-Support'
"private methods"
pvtKey: k value: v
key := k.
value := v.
"accessing methods"
key: k
self shouldNotImplement
"class instance creation methods"
key: k value: v
^self new pvtKey: k value: v
Except that this won't work; practically the only time I ever really
need 'pvt' methods is so that a class can initialise a new instance
without the initialisation method being exposed to another class, but
the 'pvt' machinery will not let you do this: "private messages may
only be sent to self". If only there were a category of private messages
that a class could send to 'self new'. So the method _really_ has to be
called #privateKey:value: and we just have to _hope_ that no outsider
will use it. So much for private methods.
But there is a pattern to ensure initialization methods are only called once (which basically is what you want to do here).
Just add a check inside the initialization method that the object is not yet initialized. All you need for this is the ability to tell initialized object from unitialzed ones. In this case the invariant "keys are never nil" might do. Otherwise you might have to invent a new instance variable.
In this case this would give us the new method:
InvariantKeyAssociation>>key:aKey value: aValue
"I don't accept nil as a key. Once set my key will never change.
To change my value call #value: instead"
aKey ifNil:[^self error:'provide a meaningful key'].
key ifNotNil:[^self error:'already initialized'].
key := aKey.
value := aValue.

Just my two cents
[snip]
Ian Piumarta
2012-01-28 11:13:44 UTC
Permalink
The instant response from my subconscious (the only part working right
now, headcold has turned off all higher functions) is that you might
simply be making use of more _space_ now that you have bigger headers.
Nahr. (We'll forgive you because you have a headcold. ;)
Thanks...that must be it.
Skeptical.
I was thinking that IGC was triggered by
exceeding an object allocation threshold
Correct.
but in this case it must be
getting triggered more often by running low on space...
Nope. The additional space should make absolutely no difference
whatsoever. The benchmark in question never gets anywhere remotely
close to running out of memory.
Try changing the allocation threshold and see if that makes any
difference.
I doubt that this will change anything very much (other than making full
GCs happen more frequently).
In the normal vm, I see 1503 IGCs taking 3,308 ms and 9% of the time.
There are 150 tenures with 10 GCs/tenure.
In the modified vm, I see 6339 IGCs taking 14,443 ms and 23% of the
time. There are 173 tenures with 36 GCs/tenure.
Conclusion: lots more garbage is being created (more IGCs).
Both VMs seem show the same time (2ms) per GC...so I don't think
having the extra class header has much of an impact on the marking
performance.
Correct. (Although it would be the compaction time that would suffer
more than mark time [most classes being old], very slightly, from
having to copy an extra word around.)

However, the above shows that almost all of the additional garbage is
being collected immediately (the # of GCs/tenure is a lot higher, meaning
each IGC is collecting on average a higher % of objects than before,
meaning that the number of "significant" [w.r.t. the application] objects
created per GC is a lot lower than before). (If many more objects were
surviving then the IGC time would go up noticably due to the increased
volume of stuff being compacted and/or the # of tenures would be a lot
higher due to the survivor threhold being exceeded much more frequently).

Here's my humble suggestion: verify that you've modified the method

ObjectMemory>>recycleContextIfPossible: cntxOop

appropriately to compensate for the lack of compact class headers in
your image.

Regards,

Ian
Helge Horch
2012-01-28 11:13:44 UTC
Permalink
Post by Richard A. O'Keefe
"class instance creation methods"
key: k value: v
^self new pvtKey: k value: v
Except that this won't work; practically the only time I ever really
need 'pvt' methods is so that a class can initialise a new instance
without the initialisation method being exposed to another class, but
the 'pvt' machinery will not let you do this: "private messages may
only be sent to self". If only there were a category of private messages
that a class could send to 'self new'. So the method _really_ has to be
called #privateKey:value: and we just have to _hope_ that no outsider
will use it. So much for private methods.
But we can make it allow that! It's just a small tweak in the
Compiler, find my first hack at it attached.

This hack could be extended to also allow "super new" and "super
new:", and maybe even check that it's compiling a class side method.
I'll leave that open for discussion.

HTH,
Helge

P.S. Thanks, BTW, for mentioning
Post by Richard A. O'Keefe
Anyone read the paper about Smalltalk collections in OOPSLA 92?
I googled that you probably meant William R. Cook's "Interfaces and
Specifications for the Smalltalk-80 Collection Classes", and CiteSeer
was able to come up with a location on the web. A *very* interesting
read indeed.
-------------- next part --------------
Skipped content of type multipart/appledouble
Stephen Pair
2012-01-28 11:13:44 UTC
Permalink
Bingo! You are the man!

Actually, it is #isMethodContextHeader: that was causing the problem.
Thanks a bunch!

- Stephen
Post by Ian Piumarta
Here's my humble suggestion: verify that you've modified the method
ObjectMemory>>recycleContextIfPossible: cntxOop
appropriately to compensate for the lack of compact class
headers in your image.
Regards,
Ian
Richard A. O'Keefe
2012-01-28 11:13:45 UTC
Permalink
***@t-online.de (Helge Horch) provided LessPvt.1.cs.

Ta muchly.
Post by Richard A. O'Keefe
Anyone read the paper about Smalltalk collections in OOPSLA 92?
I googled that you probably meant William R. Cook's "Interfaces and
Specifications for the Smalltalk-80 Collection Classes", and CiteSeer
was able to come up with a location on the web. A *very* interesting
read indeed.

That's the one.
Richard A. O'Keefe
2012-01-28 11:13:45 UTC
Permalink
Torge Husfeldt <***@gmx.de> wrote:
[You _can_ use soft private initialisers without letting anyone
use them to smash existing objects if you make them check that
the object hasn't been initialised yet.]

Thank you very much for this suggestion.
While I don't like "cluttering up" my code with such tests,
there isn't any efficiency argument against this because
such a test happens only once in the lifetime of an object.
(All going well.) I must remember this technique.

n this case the invariant "keys are never nil" might do.

Ah. Time to come out into the open. There are two things that I am
not happy with about Set and Dictionary.
(1) In some of my tests, removing a bunch of elements from a Set seems
to be rather slow. Make that "extremely slow".
(2) The fact that you cannot put nil in a Set or use it as a key in
Dictionary smells to me more like a quirk of the implementation
(which uses 'nil' in slots to indicate that they are empty) than
something motivated by considerations of what people might want
to *do* with a Set or Dictionary. For example, you might want
to eliminate duplicates from a collection, so you do
aCollection := aCollection asSet asArray.
But that doesn't work if nil could be in aCollection. And yes,
I have wanted to do that.

So I've made my own "NewSet" class (so as not to change an existing class)
and "NewDictionary" is in the works. As far as I'm concerned, keys MAY be
nil. #includes: and #remove:ifAbsent: are pleasantly faster in NewSet
than in Set; #add: is about the same (it allocates a new object, which
Set>>#add: does not).

Otherwise you might have to invent a new instance variable.

While an "already initialized?" test happens only once in the lifetime
of an object, an extra slot takes up space all the time.

I guess if I propose a change to existing things I'll be howled down again,
but it _would_ be nice if the compiler accepted
(<self | super> <new | new:...>) pvtMessage...
in a class.
Helge Horch
2012-01-28 11:13:46 UTC
Permalink
Post by Richard A. O'Keefe
I guess if I propose a change to existing things I'll be howled down again,
but it _would_ be nice if the compiler accepted
(<self | super> <new | new:...>) pvtMessage...
in a class.
Well, *I* think it's a reasonable request. The #pvtXXX support is in
the image anyway, this submission enhances it (I think), and it comes
down to a choice of style you choose to code in. As long as you
don't request the system to be rewritten, or that #perform: and
friends should also check it... ;-)

So, herewith is LessPvt.3.cs, this time with a preamble (but still no
checking for "Am I compiling in a metaclass context?" -- do we really
need that safety net?):

---snip---
Widens the Compiler's special handling of #pvtXXX selectors, to allow
the following usage patterns in class methods:

self new pvtXXX
(self new: n) pvtXXX
super new pvtXXX
(super new: n) pvtXXX

Previously, the Compiler allowed #pvtXXX method sends in instance methods only.
---snip---

Flame away :-)

Cheers,
Helge
-------------- next part --------------
Skipped content of type multipart/appledouble
David Griswold
2012-01-28 11:13:46 UTC
Permalink
Post by Richard A. O'Keefe
Ta muchly.
Post by Richard A. O'Keefe
Anyone read the paper about Smalltalk collections in OOPSLA 92?
I googled that you probably meant William R. Cook's
"Interfaces and
Specifications for the Smalltalk-80 Collection
Classes", and CiteSeer
was able to come up with a location on the web. A
*very* interesting
read indeed.
That's the one.
Cook's work on cleaner specification of the Collection classes was
incorporated into the Strongtalk libraries. The Extensible protocol I
mentioned earlier is an example of that. Since I had a type system at
my disposal, I was also able to do a lot more formal verification of
signature compatibility in the hierarchy. Additionally, lots of
semantic substitutability cleanups were made, that go beyond the typing
issues.

So if anyone is interested in what an actual implementation of such a
cleaner heirarchy would look like, it is right there in Strongtalk (and
is freely borrowable, as well).

Cheers,
Dave
Brian T Rice
2012-01-28 11:13:46 UTC
Permalink
Hi David,

Would someone be kind enough to produce ascii-text (or at least
non-binary) versions of the Strongtalk sources, since I don't have a
readily-handy new Windows machine, and the Strongtalk system is totally
unusable on older Windows versions? (I gave up after the hundredth blue
screen.)

I'm working on a new language, and want to incorporate the best ideas that
I can into my collection hierarchy. I've already ported and augmented,
trimmed, and modified Squeak's collection types, but without real access
to Strongtalk, there are some aspects of this that aren't apparent.

TIA,
~
Post by David Griswold
Cook's work on cleaner specification of the Collection classes was
incorporated into the Strongtalk libraries. The Extensible protocol I
mentioned earlier is an example of that. Since I had a type system at
my disposal, I was also able to do a lot more formal verification of
signature compatibility in the hierarchy. Additionally, lots of
semantic substitutability cleanups were made, that go beyond the typing
issues.
So if anyone is interested in what an actual implementation of such a
cleaner heirarchy would look like, it is right there in Strongtalk (and
is freely borrowable, as well).
Cheers,
Dave
David Griswold
2012-01-28 11:13:47 UTC
Permalink
Post by Brian T Rice
Hi David,
Would someone be kind enough to produce ascii-text (or at least
non-binary) versions of the Strongtalk sources, since I don't have a
readily-handy new Windows machine, and the Strongtalk system
is totally
unusable on older Windows versions? (I gave up after the
hundredth blue
screen.)
I'm working on a new language, and want to incorporate the
best ideas that
I can into my collection hierarchy. I've already ported and augmented,
trimmed, and modified Squeak's collection types, but without
real access
to Strongtalk, there are some aspects of this that aren't apparent.
Hi Brian,

Let me think about the best way to accomplish this. It would be easy to
just file-out the Strongtalk collection classes, but that wouldn't be
file-in-able on any other Smalltalk, and isn't that great a read by
itself ;-). I've been considering a compatibility-fileout, but there
still would be lots of name clashes without namespaces or something, and
I would also have to do ugly things like expand mixins etc to make it
work, which would destroy some structure.

It is a such damn shame that the system has become so unstable on
Win95/98. It wasn't always that way- the system was developed on Win95
and NT, and I used to run it all day long on 95 with maybe a crash a day
or something (we were doing all our coding in the programming
environment at that point, so it obviously *had* to be stabler than it
is now). Changes that were made at Sun (not with my approval) just
before release to recompile and slightly clean up the VM seem to have
resulted in this instability, and I did not have a chance to test it
after those changes :-(. I hoped most programmers would have access to
XP by now, where it runs much better (altho still not as well as it
originally did), but I guess in the Smalltalk community that hasn't
happened.

I'll get back to you.

Cheers,
Dave
David Griswold
2012-01-28 11:13:49 UTC
Permalink
Brian Rice and all:

As Brian asked, I have attached the extracted sources for the core
classes in the Strongtalk collection hierarchy. I have filtered out
subclasses that are not part of the core hierarchy.

It differs from standard hierarchies in two things: 1) it is
type-annotated and typechecked 2) it incorporates Cook's collection
hierarchy improvements. The Blue-Book classes are there and have the
same names, however the hierarchy is shaped differently, because of the
above two changes, and so the abstract superclasses differ
significantly.

The biggest consequence of the above two differences is that unlike
other collection hierarchies, it is truly subtype-compatible. This
means two things: 1) the classes and interfaces form a true subtype
hierarchy as far as the type annotations go, and 2) in addition they are
much more *semantically* substitutable. The single biggest change that
most programmers will notice as a consequence is that #include: messages
should be used instead of #add: messages (include is like just like add,
except that it only adds the element if the element is not already in
the collection). This lets you do things that you can't do in other
Smalltalks, like use OrderedCollections as Sets (since
OrderedCollections implement the full Set semantics, which is not true
because of #add: behavior in other Smalltalks).

If you want to read this, you will need to get used to reading
Strongtalk file-out format, which is similar to other ones except that
the reflective messages (class constructors etc.) use the Strongtalk
mirror interface. Note: you will see the global Delta mentioned a lot
in the constructors; that was just the code name for the project, and
probably would have become Strongtalk or somesuch if it had reached
production. You will also need to understand mixins, since they are
used heavily in the Collection hierarchy. If you have any questions,
let me know.

Cheers,
Dave
Post by Brian T Rice
Hi David,
Would someone be kind enough to produce ascii-text (or at least
non-binary) versions of the Strongtalk sources, since I don't have a
readily-handy new Windows machine, and the Strongtalk system
is totally
unusable on older Windows versions? (I gave up after the
hundredth blue
screen.)
I'm working on a new language, and want to incorporate the
best ideas that
I can into my collection hierarchy. I've already ported and augmented,
trimmed, and modified Squeak's collection types, but without
real access
to Strongtalk, there are some aspects of this that aren't apparent.
-------------- next part --------------
A non-text attachment was scrubbed...
Name: collections.zip
Type: application/x-zip-compressed
Size: 55836 bytes
Desc: not available
Url : http://lists.squeakfoundation.org/pipermail/squeak-dev/attachments/20020902/1dd94708/collections.bin
Brian T Rice
2012-01-28 11:13:50 UTC
Permalink
Hi David,
Thanks very much for this. Most of these ideas are making it into my
libraries as we speak.

~
Post by David Griswold
As Brian asked, I have attached the extracted sources for the core
classes in the Strongtalk collection hierarchy. I have filtered out
subclasses that are not part of the core hierarchy.
Cheers,
Dave
Post by Brian T Rice
Hi David,
Would someone be kind enough to produce ascii-text (or at least
non-binary) versions of the Strongtalk sources, since I don't have a
readily-handy new Windows machine, and the Strongtalk system
is totally
unusable on older Windows versions? (I gave up after the
hundredth blue
screen.)
David Griswold
2012-01-28 11:16:55 UTC
Permalink
This is a multi-part message in MIME format.

------=_NextPart_000_0002_01C25281.38B092B0
Content-Type: text/plain;
charset="iso-8859-1"
Content-Transfer-Encoding: 7bit

Brian Rice and all:

As Brian asked, I have attached the extracted sources for the core
classes in the Strongtalk collection hierarchy. I have filtered out
subclasses that are not part of the core hierarchy.

It differs from standard hierarchies in two things: 1) it is
type-annotated and typechecked 2) it incorporates Cook's collection
hierarchy improvements. The Blue-Book classes are there and have the
same names, however the hierarchy is shaped differently, because of the
above two changes, and so the abstract superclasses differ
significantly.

The biggest consequence of the above two differences is that unlike
other collection hierarchies, it is truly subtype-compatible. This
means two things: 1) the classes and interfaces form a true subtype
hierarchy as far as the type annotations go, and 2) in addition they are
much more *semantically* substitutable. The single biggest change that
most programmers will notice as a consequence is that #include: messages
should be used instead of #add: messages (include is like just like add,
except that it only adds the element if the element is not already in
the collection). This lets you do things that you can't do in other
Smalltalks, like use OrderedCollections as Sets (since
OrderedCollections implement the full Set semantics, which is not true
because of #add: behavior in other Smalltalks).

If you want to read this, you will need to get used to reading
Strongtalk file-out format, which is similar to other ones except that
the reflective messages (class constructors etc.) use the Strongtalk
mirror interface. Note: you will see the global Delta mentioned a lot
in the constructors; that was just the code name for the project, and
probably would have become Strongtalk or somesuch if it had reached
production. You will also need to understand mixins, since they are
used heavily in the Collection hierarchy. If you have any questions,
let me know.

Cheers,
Dave
Post by Brian T Rice
Hi David,
Would someone be kind enough to produce ascii-text (or at least
non-binary) versions of the Strongtalk sources, since I don't have a
readily-handy new Windows machine, and the Strongtalk system
is totally
unusable on older Windows versions? (I gave up after the
hundredth blue
screen.)
I'm working on a new language, and want to incorporate the
best ideas that
I can into my collection hierarchy. I've already ported and augmented,
trimmed, and modified Squeak's collection types, but without
real access
to Strongtalk, there are some aspects of this that aren't apparent.
------=_NextPart_000_0002_01C25281.38B092B0
Content-Type: application/x-zip-compressed;
name="collections.zip"
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
filename="collections.zip"
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------=_NextPart_000_0002_01C25281.38B092B0--
Brian T Rice
2012-01-28 11:16:55 UTC
Permalink
Hi David,
Thanks very much for this. Most of these ideas are making it into my
libraries as we speak.

~
Post by David Griswold
As Brian asked, I have attached the extracted sources for the core
classes in the Strongtalk collection hierarchy. I have filtered out
subclasses that are not part of the core hierarchy.
Cheers,
Dave
Post by Brian T Rice
Hi David,
Would someone be kind enough to produce ascii-text (or at least
non-binary) versions of the Strongtalk sources, since I don't have a
readily-handy new Windows machine, and the Strongtalk system
is totally
unusable on older Windows versions? (I gave up after the
hundredth blue
screen.)
Continue reading on narkive:
Loading...