
The Rise and Fall of Commercial Smalltalk - matt_d
http://www.wirfs-brock.com/allen/posts/914
======
travisgriggs
One of the things that Allen only barely hints at and I'm not sure Gilads
piece really touches on was the shifting economics in Software development. In
1995/96 when Java gut punched the wind out of Smalltalk and the other OO
solutions (CLOS, Eifel, Beta, etc), they spent a butt load on marketing and
gave the stuff away for free. In other industries it would be called
"dumping." It wasn't just Sun giving Java away. It was also the beginning of
the rise of Linux, also free. I remember a colleague pointing out "there is no
money in tools anymore, there's a few niche islands left, but they'll fail
too."

I think neither of these articles aptly covers this counter trend enough.
Whilst Smalltalk had come out of the kind of freeish academic research zone
with its small band of developers of un-patroned developers trying to eke out
a living, the industry was clamoring to free and open source.

What I wouldn't give to have closures that were as simple and robust and
approachable as Smalltalk in any of the languages I work in today (Swift,
Kotlin, Python, Dart, C).

(Did 20 years of Smalltalk, including 6 years at Cimcom)

~~~
jecel
Not only did Sun lose a lot of money on Java, they got other people (I
remember Borland and IBM but there were probably others) to throw away money
for a few critical years. Why the new CEO of the merged ParcPlace/Digitalk
thought it would be good idea to abandon the lucrative Smalltalk niche to
focus his company on this bloodbath I will probably never know.

[https://www.cbronline.com/news/parcplace_throws_in_smalltalk...](https://www.cbronline.com/news/parcplace_throws_in_smalltalk_towel_heads_for_java/)

~~~
dws
ParcPlace hired a CEO who knew how to solve problems by buying and selling
companies. It worked for him once or twice (he previously sold Ashton Tate to
Borland).

------
dws
From inside ParcPlace, it looked like we were starting to gain traction.
There'd been a number of spectacular C++ project failures, and people seemed
to be willing to try this weird, new (to them) thing that let them get
prototypes up quickly and then grow them.

Then Java arrived and sucked all of the air and mindshare out of the
ecosystem.

Java lucked into ideal circumstances, and Sun Marketing played their hand very
well. The Web was just taking off, VCs were looking for something new and hot,
publishers were looking for the next big thing, and programmers were looking
for something that wasn't C++. Java looked familiar enough, cost nothing, had
Garbage Collection and Interfaces (putting Gang of Four Patterns within reach
of many), and let programmers keep their favorite tools and editors instead of
adopting Smalltalk's strange model of doing everything in a (mostly) sealed
environment.

~~~
mardifoufs
>There'd been a number of spectacular C++ project failures,

Do you have any examples in mind? Big corporate software project failures are
always super interesting imo. Especially those that happened during such
pivotal times as rhe 1990s.

~~~
chubot
I wasn't there, but apparently Taligent was a failed C++ operating system from
Apple and IBM in the 90's.

I think there is a talk on YouTube by Bryan Cantrill that gives some color on
it...

[https://en.wikipedia.org/wiki/Taligent](https://en.wikipedia.org/wiki/Taligent)

[http://bobcongdon.net/blog/2004/06/the-taligent-
effect/](http://bobcongdon.net/blog/2004/06/the-taligent-effect/)

~~~
sgerenser
Might be the video you were referring to:
[https://www.infoq.com/presentations/os-
rust/](https://www.infoq.com/presentations/os-rust/)

Skip to 24:30 for the Taligent part.

~~~
chubot
Yes that's it, thanks!

------
alrs
I took my first college-level programming class in 1997, learning Smalltalk.

1\. IBM VisualAge didn't run in Linux, so I had to buy a second hard drive and
a copy of Windows 95.

2\. I wanted to be working in a terminal, Smalltalk only let you work in an
IDE. I couldn't figure it out. I couldn't believe that anyone would want to
mouse-around to poke through the available classes and methods.

3\. The text was the IBM manual. It was terrible.

4\. I failed the class twice, so I changed majors.

I didn't come back to coding until ten years later.

I'm a contributor to Kubernetes, the Go Standard Library, and I'm a full-time
Go developer. Things turned out OK.

Smalltalk, OO, and IDE-based development set my career back by ten years.
Don't believe the hype.

~~~
non-entity
> I couldn't believe that anyone would want to mouse-around to poke through
> the available classes and methods.

So I dont know a ton about smalltalk outside of what I've read and poking
aside in squeak for a few minutes, but is this how smalltalk apps were
supposed to be distributed and run? Inside a sandboxes system like that?

~~~
hboon
On certain systems, there are tools that make them feel more native. Eg. on
Dolphin Smalltalk which ran on Microsoft Windows, you can run a utility to
stripped off the unnecessary parts (eg. the browser/editors and unused
classes) of the image and it gets bundled into an .exe which includes a VM. A
user wouldn't know it's running Smalltalk.

It turned out to be an excellent tool to write Windows app during its time.
The live environment worked extremely well in working with and figuring out
ActiveX and COM objects.. Even better than VS Studio at that time.

~~~
kryptiskt
No need for past tense there, Dolphin Smalltalk is still being developed and
is open source now,
[https://github.com/dolphinsmalltalk](https://github.com/dolphinsmalltalk).

~~~
hboon
Haha. True. It's history for me, but the great product lives on.

The nick "blairmc-msft" is interesting though. He's at Microsoft, or was at
some point?

------
hodgesrm
Speaking as a Smalltalk programmer active in the 1990s we pretty much dropped
everything when Java showed up. It had the things we loved in Smalltalk
(portable virtual machine, garbage collection, self-documenting APIs,
collection classes, etc.) with the familiar syntax of C++ and concurrency.

In a way Smalltalk prepared the way for Java in that it showed how great VMs
and garbage collection were.

~~~
G4BB3R
I can't understand. People says that ST ecosystem is much superior to nowadays
languages, so why people at that time switched to the starter version of java,
that is so bad compared to today? After the shift, did you miss something?

~~~
hodgesrm
I worked on a project at Sybase that attempted to rewrite the Sybase SQL
Server using VM-based technologies.

We looked at Smalltalk early on but found a number of problems. They included
slow execution speed (there was no JIT), lack of static typing (hard for
maintenance), and difficulty to strip the VM environment to create an
efficient runtime. Finally it had very limited ability to manage storage and
memory directly. Without these it's difficult to build fast database systems.

Sybase tried to acquire a Smalltalk vendor in order to fix the VM problems but
could not reach a deal so we ended up moving to other technologies. When Java
came along we felt it was the language we had been looking for even with the
early performance problems.

~~~
pjmlp
Interesting, I always felt that Oracle was the first RDMS vendor to take that
path (with Java's early adoption and NC).

I was at their shared session (together with Sun) in Lisbon about NC and how
it would change the workplace.

Thanks for sharing.

~~~
hodgesrm
I would guess pretty much all the DBMS vendors in the early 1990s had people
looking at VMs and were mentally prepared for Java when it arrived.

In addition to other advantages DBMS designers were looking for better ways to
compile queries into executable representations (aka bytecode). That path
still exists but I think the tendency now is to harness tools like LLVM and do
JIT compilation.

------
mark_l_watson
As other people here have said, Java was a death knoll to large Smalltalk
adoption.

I had some early experience. A Xerox Special Information Systems salesperson
gave me a one month Smalltalk license for my 1108 Lisp Machine. I really
enjoyed it but I had already gone down the Lisp rabbit hole. Years later, a
friend at Parcplace gave me a license but I got sucked into the Java world
soon after (Sun had a link for a year on their main Java web page to a blog
article I wrote on Java; for about 10 years I was the number one search result
for 'java consultant').

I am back to using Common Lisp almost exclusively for my own projects and
research but I do enjoy Pharo Smalltalk, and can't help but wonder if a free
Pharo had been available in the mid to late 1990s how that might have changed
things. Probably not much because Java does fit a good enterprise niche, but
with the high license costs of Smalltalk, that war was lost.

------
jecel
Those are all very good points.

Since Allen was there and I was not he is in a far better position to know.
But my impression was that the Smalltalk group had been reasonably happy with
their 8086 based NoteTaker computer and expected their partners (HP,
Tektronix, Apple and DEC) to use commercial processors instead of designing
custom ones. Even if they were far slower than the Xerox Dorado.

About Squeak in a web browser, it was a completely different project than the
current SqueakJS. Alan was frustrated that the IT people at schools wouldn't
allow Squeak to be installed on their machines. So the native code VM was
bundled into a plugin for the then popular web browsers and it became as easy
to use Squeak as Flash. Except that the IT people allowed Flash but not Squeak
so it ended up not helping. But in terms of performance it was better than
Flash, Java (not Hotspot) or Javascript.

~~~
allenwb
Dan Ingalls talks about Notetaker/Smalltalk-78 in his forthcoming HOPL 4 paper
which should be available within the next two weeks.

There were only a few Notetaker machines built and apparently they were quite
slow and not really very useful. But the Notetaker image and VM was also
ported to the Dorado. In 1979-80 that was the primary version that was being
used within the LRG and was used as the starting point for creating
Smalltalk-80.

In my article is a link to the the invitation letter to Tektronix to
participate in the Smalltalk-80 dissemination processed. In it they said: "We
estimate about one work year for a very expert systems programmer to implement
the microcode for the virtual machine and implement the i/o primitives." In
the following discussions and visits they only showed us and talked about the
microcoded Dorado and Dolphin implementations. They we repeated said words to
the effect of "We want you to design a computer to run Smalltalk". LRG was
quite secretive about some things and I don't think I had ever heard of
Notetaker until 1993 when I read Alan's HOPL-2 paper.

One interesting thing I recently learned from Dan was that NoteTaker used a
linear stack with overlapping activation records. This was dropped for the
Dorado implementation and Smalltalk-80. That was unfortunate as the overhead
of heap allocated stack frames was one of the major performance bottlenecks
when implementing Smalltalk-80 on conventional processors. It took those of us
doing such implementations a couple years to develop techniques for "cheating
without getting caught" while using hidden linear stacks. In retrospect, the
poor performance of Smalltalk-80's heap allocated activation contexts in
combination with reference counting significantly delayed the viability of
microprocessor based Smalltalk-80 implementations.

~~~
codefrau
Yep, I was surprised by the linear stack when I implemented the NoteTaker JS
VM with Dan. In the Lively interface, you can stop the running VM and enable
the two little checkboxes on the top right to see the whole stack, rather than
just the current frame.

Re "the NoteTaker image and VM was also ported to the Dorado": both the
NoteTaker image (a.k.a. Smalltalk-78) and the Dorado image were initially
generated from Smalltalk-76 running on the Alto. In the Notetaker image there
still are branches depending on what system it's running on (see e.g.
UserView>>buttons).

Smalltalk-80 was also built on Smalltalk-76 by "backporting" some of the more
interesting changes from the Notetaker version, plus adding much more.

~~~
jecel
Didn't Digitalk Methods and Smalltalk/V also use a linear stack? Self did as
well and to make that simpler they made using a block from a method that had
already returned an error (an optimization that some have regretted).

About the NoteTaker being too slow to be usable, having used Squeak on 386 and
486 machines I am hardly shocked. On the other hand people would be being
Osborn 1 a few years after the Notaker with just a fraction of the speed (but
not trying to run Smalltalk, of course).

By the way, quite a bit of information about the NoteTaker on the web is
wrong. So I was really glad when Bitsavers got hold of all the original
material (mostly memos):

[http://bitsavers.trailing-
edge.com/pdf/xerox/notetaker/](http://bitsavers.trailing-
edge.com/pdf/xerox/notetaker/)

------
ken
> the Smalltalk value proposition was: Pay a lot of money to be locked in to
> slow software that exposes your IP, looks weird on screen and cannot
> interact well with anything else; it is much easier to maintain and develop
> though!

Sounds like another framework we’ve got today, except now at least it’s free.

------
trashburger
Discussions about Smalltalk almost always remind me of Self[0] from Sun. It is
an extremely simple prototype-based programming language. An object can have
many "parents", and defines properties on itself to expose an interface. It's
really fun to mess around with. The Morphic UI is kind of archaic though.

[0]: [https://selflanguage.org/](https://selflanguage.org/)

~~~
discreteevent
Do you mean that the morphic ui is archaic _looking_? Because my impression of
it is that it is still ahead of its time technically.

~~~
Rochus
What you can download from
[https://selflanguage.org/](https://selflanguage.org/) looks rather archaic,
not the improved version implemented on top of Squeak which looks and feals
really fancy.

~~~
russellallen
Unfortunately the version in Squeak is, in my opinion, fancy looking but a
backwards step from the Self version in terms of the underlying system.
Morphic doesn't seem to really fit all that well with class based systems.

~~~
jecel
While being class based does make Squeak's Morphic a bit more awkward than
Self's, the big difference is that it is a hybrid system that can run older
MVC (Model View Controller) applications with little or no modification. That
means that there are two different ways of doing most things and someone
looking for examples to copy might run across the MVC version instead of the
"proper" Morphic version.

~~~
russellallen
My experience of doing morphic stuff in both Squeak and Self, is that in
Squeak there was a bit of a disconnect between the instance side and the class
side - you could click together morphs, but in the end you had to write code
in morphic classes to reconstruct those morphs.

There wasn't any automatic way to go from the morph instances to equivalent
morph constructors, or any way to save the morph instances to copy and use
later. So I ended up ignoring the instance manipulation and just coded morph
creation methods.

In this way, the morph class hierarchy became much like a hierarchy of
factories.

This mattered when I was doing a GUI to run on my Compaq iPaq because a lot of
morphs (such as menus) were being created afresh each time they were needed.
This was really slow and I only made it usable by caching the created menus
and only displaying them when needed.

On Self I would have just copied the previously constructed menuMorph
prototype and displayed it (if of course I had been able to port the huge pile
of C++ that is the Self VM to the iPaq :)

This was ages ago though and I haven't played properly with modern Squeak or
Cuis.

------
soapdog
Anyone here shipping a Smalltalk built application these days? I had fun
playing with Pharo and Squeak, but in terms of shipping desktop apps to
clients I don't know how it could be done with Smalltalk. Maybe Cincom is the
only game in town, not sure. Anyone has a story to tell?

~~~
dws
Scratch ([https://scratch.mit.edu](https://scratch.mit.edu)) on millions of
Raspberry Pis.

~~~
7786655
It looks to me like only Scratch 1.4 is written in Squeak. Scratch 2 is
written in ActionScript, and Scratch 3 in JavaScript.

~~~
dws
Yeah. Looks like that changed after Raspian Jessie. Still, that shipped on a
lot of Pis.

------
ngcc_hk
My first encounter is Visage Smalltalk as part of the study to replace the VSE
mainframe :-). But even the IBM SE is not that confident. Hence, we are off.
(And strangely one of the issue is the source is too available, that the
environment is too open to manipulate ... sorry just too used to COBOL and
Java like fixed program than this dynamic things :-)).

But for the main history, just read about how Steve Jobs during my search of
HOPL 4 about Next history that he missed the two key elements of the Lab
(Ethernet and Smalltalk). He fixed both on the Next computer and in fact the
prototyping and performance of Interface Builder and the underlying Objective
C is so much practical than Smalltalk is too complicated.

------
Rochus
It's also recommended to have a look at other pages from Allan's site such as
[http://www.wirfs-brock.com/allen/things/smalltalk-
things/tek...](http://www.wirfs-brock.com/allen/things/smalltalk-
things/tektronix-smalltalk-document-archive) which is full of interesting
facts and documents.

------
adamfeldman
Has anyone recently used Pharo Smalltalk? How did its IDE functionality
enhance your experience?

"Pharo is a pure object-oriented programming language and a powerful
environment, focused on simplicity and immediate feedback (think IDE and OS
rolled into one)."

[https://pharo.org/features](https://pharo.org/features)

~~~
gambler
After trying it, going back to Java/C#/JavaScript was kind of rough. I realize
that despite their external polish popular IDEs/languages today have some
glaring, fundamental deficiencies.

------
coldcode
I never used Smalltalk directly, but it's (weirdly) related cousin,
Objective-C. My first exposure to OO was reading the Byte Magazine edition
about Smalltalk (the one with the Balloon on the cover) which led me to
experiment with adding OO to plain C in the late 80's (I did not have access
to C++ or Objective-C at that time).

~~~
markc
Yes, I remember there was a OO programming style/discipline layered on C that
was floating around in the mid 80's and I tried it out. (just found out
there's a whole book about it - [https://book.huihoo.com/pdf/object-oriented-
programming-with...](https://book.huihoo.com/pdf/object-oriented-programming-
with-ansi-c/ooc.pdf))

Shortly thereafter, C++ arrived in the form of "cfront" which was a cross-
language translator that would generate .c and .h files from .cxx and you'd
compile those with a C compiler. There was no actual C++ compiler at first.

------
entha_saava
I have a question to people who used smalltalk. Maybe I have read it somewhere
but couldn't understand the unique advantage in modern day terms.

What is so different in smalltalk that is not possible / easy in modern
IDE+Debugger environments? Especially those with hot reload or 'Edit &
Continue' features?

~~~
pjmlp
You have access to the full stack, whereas even on .NET and Java there is a
certain separation between runtime and lets call it user space.

On a proper Smalltalk environment, beyond a set of pre-defined VM intrinsics
you can access and change everything, GC, JIT compiler, compiler, how the
debugger works, IDE like features, you name it. Then it is very uniform,
everything is an object, even it isn't implemented as such, it is transparent
for your as developer.

The only other kind of environments that went as far were the Interlisp-D and
Lisp Machines, to some extent the surviving commercial Common Lisps.

~~~
entha_saava
> you can access and change everything, GC, JIT compiler, compiler, how the
> debugger works, IDE like features, you name it.

Do you mind explaining what is use case for this?

------
rongenre
It was pretty amazing going to JDK 1 and seeing names in the source code I
remembered from doing VisualWorks Smalltalk.

------
poulsbohemian
For those of you smalltalk fans, what are you working in today / what would
you prefer to be working in today given your history with smalltalk?

~~~
Rochus
I'm not actually a "Smalltalk fan", but I recently re-implemented the
Smalltalk-80 virtual machine and some additional tools to analyze the original
Smalltalk-80 sources and virtual image files. My goal is to run it on LuaJIT
and compare the performance with other Smalltalk implementations. See
[https://github.com/rochus-keller/Smalltalk](https://github.com/rochus-
keller/Smalltalk). I'm also working on a Simula 67 compiler, and a Golang to
LuaJIT bytecode compiler is also on my list. As you can see I write everything
in C++, which also says something.

~~~
codefrau
Cool. If I had a few free weekends I'd want to make that Smalltalk image run
on my SqueakJS VM. One of theses days ...

~~~
Rochus
Have a look at
[http://www.squeaksource.com/Hobbes/](http://www.squeaksource.com/Hobbes/),
but don't expect impressive performance. It's not the code in the Bluebook
part 4 though. If you want to implement it yourself be prepared that it might
take many weekends until it runs as expected; debugging Bluebook errors took
many hours.

------
mkl
Does anyone know where the strange name VisualAge came from? Wikipedia says
"The name "VisualAge" is the result of a contest between the members of the
development team." with no reference, and I can't understand how such an
opaque and irrelevant-seeming name could win such a contest. "Visual" I get,
but "Age"?

~~~
orthoxerox
They likely implied that there was a Console Age that was coming to an end and
their software would usher in the new age of computing.

------
Ice_cream_suit
The infantile interface and oh-so-precious baby talk that accompanies Squeak
(a modern vision of Smalltalk 80) put me off the several times that I started
to use it.

~~~
dragonwriter
So, why not just go to Pharo, which is both more modern and less child-
oriented in presentation than Squeak, from which it derives?

