
Design Principles Behind Smalltalk (1981) - molteanu
http://www.cs.virginia.edu/~evans/cs655/readings/smalltalk.html
======
mrexroad
> Natural Selection: Languages and systems that are of sound design will
> persist, to be supplanted only by better ones.

I loved coding in Smalltalk years ago. Guess “better” turned out to be rather
subjective...

~~~
justinpombrio
No, it's just that this principle isn't true. There are a lot of factors that
influence which languages and systems persist. Being of sound design is _a_
factor, but not the biggest one.

Take Javascript, for example. It's the top language on Github. Its not there
because its everyone's favorite language, or because it's an ideal language
for writing reliable software. Its there because its baked into web browsers.
We're now starting to get full-featured reliable compilers into JS with
sourcemaps and whatnot, plus things like webassembly. So it's becoming quite
reasonable these days to write code for the web in a language that isn't JS
and not feel like a second-tier citizen. But that hasn't always been the case,
so people wrote a lot of JS out of necessity. And _that 's_ why it's at the
top.

(I don't mean to riff on JS in this post. There are plenty of other
opportunities for that. The language has improved over the years, and this is
surely _part_ of the reason it's remained at #1, and _part_ of the reason why
browser vendors didn't throw up their hands and try a different language
instead. But the _main_ reason its at the top is because it's the language of
the web.)

If SmallTalk were built into browsers instead of JS, then we'd all be writing
SmallTalk. And it'd be blazing fast. And that has nothing to do with how sound
its design is.

~~~
teapot7
One turning point that saddens me as an ex-Smalltalker - at one point there
were negotiations underway to have Smalltalk installed by default on all new
Sun Workstations (this was back when Sun was a very significant player), but
it fell through for financial reasons. Had this been the case, I'm sure
Smalltalk would be significantly better known and more commonly used.

And as justinpombrio says above, that has nothing to do with how good or bad
the language is.

~~~
_ph_
Had not heard that, but this is truely heartbreaking. I still think that
Smalltalk is the better language than most of the modern object oriented
languages, and be it only that is is a bit more pure and its "successors" are
too much a mix with other paradigms. Just thinking of Python - it is in a wide
range of features equivalent to Smalltalk withtout being as consequent in the
object orientation.

One could only dream of how nice the programming world would be, if Sun had
pushed Smalltalk instead of Java. Ironically, Hotspot started its life as a
Smalltalk VM and only when Sun took over the development was turned into a
Java VM.

~~~
jecel
Actually, Sun tried to license Smalltalk from Parcplace to use in embedded
devices. At that time Parcplace was quite happy to charge $3000 per seat and
didn't make a reasonable offer to Sun, so the Oak (now Java) project was
started instead.

To make things even worse, Parcplace merged with their main rival, Digitalk,
which offered Smalltalks for PCs and Macs for $100 to $500. They promptly
replaced those with "enterprise" products costing way more making it
impossible for new people to learn the language except with toy
implementations like Little Smalltalk and GNU Smalltalk (which later evolved
into a very decent implementation). For some reason the nice Smalltalk/X
(commercial, but free for educational use) only had a small niche in Europe.

Note that Sun already had a Smalltalk in the form of Self, but Java was
created anyway and Sun decided to use it exclusively killing Self and Tcl
(which spun off instead of dieing). Part of the Self group merged with a group
researching Smalltalk with optional type declarations (Dart is the latest
version of that) to create the company Animorphics to develop StrongTalk.

Meanwhile, the Pep project at Sun demonstrated that you could run Java on the
Self VM and greatly outperform all existing Java implementations (which were
simple bytecode interpreters). The Animorphics team did the same and showed
off Java on their VM, which caused Sun to buy them to make this demo into the
HotSpot VM.

------
andrepd
Everything in this article sounds very fine and agreeable to me. But can
anyone actually point me to _use cases_ or _examples_ of the brilliance of
Smalltalk? As it stands, it always leaves me feeling this is all very
abstract/idealised...

------
cmiles74
There is a lot that I like about Smalltalk. I think one of the most
interesting ideas is that everything in the environment is written in the same
language; that it's easy to use code from an installed package when you write
your own code. I also like the idea that it provides its own GUI environment
and IDE, making it easy to interact with and change the way things work.

I don't see myself spending more time working with Smalltalk, as it stands
today. It's single threaded, which is fine for a lot of tasks but is (in my
opinion) a poor fit for a GUI environment. Having looked around at projects
like Pharo, it looks like the Smalltalk community may be moving away from the
idea of Smalltalk presenting the whole environment for the end-user, instead
providing one application (often one that presents no UI, i.e. a web
application).

From a personal standpoint, I would be very interested in a Smalltalk-like
environment that I could use to develop my own software and, hopefully, use to
replace a lot of the smaller bits and pieces I use to get my work done.
Perhaps it could provide an IDE that I could also use to replace Emacs (which
I also use for mail) and an IRC/chat client I could use to replace Weechat
(which I also use for Slack, Google Talk and Facebook Messenger).

I don't feel a great affinity for many of the tools I use daily (email, chat,
calendar, etc.), in part because they are not easy for me to alter or improve.
It's funny: Emacs is clunky and weird, but I stick with it because it's easy
for me to add or change the way it works.

I wonder if a Smalltalk implementation that revolved around objects
implemented as actors passing messages (as opposed to the direct calling of
methods that we have today) would be more amenable to multi-threading, yet
still retain the simplicity that Smalltalk enjoys today.

------
femto
A pity that Scratch is no longer written in Smalltalk. It was a natural move
for a child to discover shift-click-R and progress from Scratch to Smalltalk
hacking.

------
npudar
Smalltalk is still a thing of beauty.

