Smalltalk Simplicity and Consistency

Comment by Troy Brumley

At this level, you're not explaing it enough to make it understandable from magic. Sometimes it helps to understand those underlying mechanics even if we don't want to code them ourselves. Does anyone know of a good example explanation of Smalltalk numeric type coercion that includes enough of the double dispatch stuff to get the point across without sounding too much like "inside baseball"?

But the point that at the level of "my code" I don't have to worry about this is very important. I don't have to worry about what type of numeric variable to use, I just give the variable a name and run with it.

Developers can do that themselves
iirc unlike other objects, SmallIntegers are tagged integers, encoded directly in the object pointer - how can developers do that themselves, with their own objects?

we didn't have to do anything special

"Note that there is a system invariant that requires that any integer that *can* be represented as a SmallInteger *is* represented as a SmallInteger. Methods that create LargeIntegers must send the resulting large integer the message 'compressed' if there is any possibility that the integer could be represented as a SmallInteger."

a pretty simple example
afaict this is an example of arbitrary precision arithmetic and has little to do with "everything is an object" or "dynamic typing". A statically-type-checked functional programming language like SML can provide the same functionality. (Unlike most Smalltalk implementations, SML additionally provides fixed-precision integer representations.)

Comment by James Robertson

Isaac

You might want to look at how collections grow.

James, why might I want to look at how collections grow?

Comment by James Robertson

Expend the effort and you'll see.

James, my guess is that you think the code illustrates a point you wish to make, but I'm afraid looking at the code does not tell me what point you wish to make - you need to do that.

Isaac, the point that James was making was clear: Smalltalk code is much simpler than comparable mainstream languages code like that in Java or C++ or C#. One of the reasons why this is so is that one does not have to specify the type of the variable/result.

 

This also happens to be the way humans think - we think of the factorial of a number as another much larger number, not as a BigInteger. The fact that statically typed languages force you to specify sub-types such as integer, large integer, etc., causes code bloat.

 

This incidentally is a feature of all dynamically typed languages, not Smalltalk in particular.

 

Ravi 

 

Comment by John Rubier

He doesn't care. He never will care. He lost a Smalltalk job and ended up having to be a Java flunkie. Now whenever he doesn't take his meds, he gets upset and defensive and has to justify his existence on James blog and anywhere else ST is mentioned.

Anyone who has used Java and tries Smalltalk will see that it's more efficient and elegant and is true freedom in comparison (not perfect, but what is?)

John Rubier, name calling is not going to make Smalltalk more popular.

Ravi, we can make all kinds of guesses about what James might mean but I'd prefer not to put words in his mouth.

Isaac,   the title of the article conveys the essence - that Smalltalk is simple. James elaborated on it by giving an example that showed that the developer can focus on solving the problem, while the VM takes care of routine things like scale and precision of numbers, data types, etc. He contrasted this with mainstream languages by asking if it could be done so easily in them. I gave my understanding/interpretation of his words.

 

Words are the only means we have on conveying meaning, and so we are restricted to using them. So, I do not think I am putting words into his mouth when I give my interpretation.
 

He contrasted this with mainstream languages by asking if it could be done so easily in them.
No Ravi, you were the first person to mention "mainstream languages code like that in Java or C++ or C#".

And I asked for clarification about James' comment "You might want to look at how collections grow" not about the blog entry.

Here are some words from the article, "The bottom line - Smalltalk stays out of your way, and lets you solve the problem at hand."

Given James's known feelings about the mainstream languages, it is clear that he is implicitly referring to mainstream languages that get in your way.

Anyway, it is not that important who said it explicitly or implicitly, so I won't comment on this anymore.