What are the biggest myths about Smalltalk?

The biggest myth is that Smalltalk is a dead or dying language. Nothing could be further from the truth.

Smalltalk has an active worldwide community in ESUG. FAST is a notable Smalltalk user organization in Argentina. Cincom, Instantiations, and GemTalk Systems are three major Smalltalk vendors with lots of global enterprise customers. I have friends who work at a major Smalltalk house in Ottawa, Canada called Simberon.

There are no fewer than six open source dialects of Smalltalk: Pharo, Squeak, GNU Smalltalk, Dolphin Smalltalk, Amber Smalltalk, and Cuis Smalltalk.

A related myth is that Smalltalk was never popular. In fact, in the 1990s, Smalltalk became the most popular OOP language after C++. According to a 1995 IDC report, OOP language market shares were:

1. C++ — 71.3%
2. Smalltalk — 15.1%
3. Objective-C — 5.7%
4. Object Pascal — 4.2%
5. CLOS — 2.5%
6. Eiffel — 1.1%
7. all others — 0.2%

Here’s a page from Computerworld, November 6, 1995, showing Smalltalk and C++ duking it out:

Smalltalk was so good for business use that IBM chose it as the centrepiece of their VisualAge enterprise initiative to replace COBOL:

In the early 2000s, the U.S. joint military used Smalltalk to write a million-line battle simulation program called JWARS. It actually outperformed a similar simulation called STORM written in C++ by the U.S. Air Force. That by itself was an astonishing testament to the capabilities of the language.

Smalltalk was used by JP Morgan to write their massive financial risk management system called Kapital. In fact, Smalltalk is quite popular in the financial industry; other users include Desjardins and UBS.

Orient Overseas Container Lines used Smalltalk to develop their IRIS-2 shipping management system.

Other major users include Florida Power & Light, Texas Instruments, Telecom Argentina, BMW, and Siemens AG.

In my home country, Smalltalk is used by Communications Security Establishment (CSE), Canada’s national cryptologic agency.

The second biggest myth is that Smalltalk’s system image is weird or unusual, and doesn’t play well with conventional toolchains like text editors and version control systems.

However, Smalltalk’s image is no different from the system image found in virtualization software like VMware and VirtualBox. Imagine you have Linux running in a VirtualBox image. Imagine that you’re developing Java software using Eclipse. Imagine that you run your Java software in the image. How is this different from Smalltalk?

In Smalltalk, you’re using an IDE called the System Browser. You run your Smalltalk application in the image. It’s the exact same thing.

In our hypothetical Linux image, you can use version control systems like Git, CVS, and Subversion. In Smalltalk, you use version control systems like Monticello (Pharo), ENVY (VA Smalltalk), and Store (VisualWorks). You can also use Git.

In Smalltalk, you can “File Out” your source code into a conventional text file. This allows you to use Git, Vim, Emacs, Visual Studio Code, whatever you like.

Some Smalltalk dialects even let you work entirely from the command line. GNU Smalltalk was the original, but Pharo recently provided this capability, as well.

The third biggest myth is that Smalltalk’s syntax is weird and difficult to learn. This complaint typically comes from programmers using C, C++, Java, or any other C-derived syntax language.

Smalltalk syntax isn’t so weird when compared to Python (off-side rule syntax), Ruby, Clojure, Haskell, Erlang, J, Forth, Rebol. There is a whole universe of programming languages that look different from C. Should we only learn C-like languages till the end of time?

/* In C and C++, the brace brackets style of syntax has spread tomany other languages like Java, JavaScript, PHP, Perl, etc. */if (x < y) {    x++;    printf("x is %i\n", x);}else    printf("*** warning\n");

""" In Python, whitespace indentation is part of the syntax used to delineate blocks of code. Now, that is strange! """if x < y:    x += 1    print 'x is', xelse:    print '*** warning'

=beginIn Ruby, there are no brackets for delineating blocks of code!=endif x < y then    x += 1    puts "x is #{x}"else    puts "*** warning"end

"In Smalltalk, nearly all syntax is based on message passing.The message ifTrue:ifFalse: is sent to Boolean objects."x < y ifTrue: [ x := x + 1.                Transcript show: 'x is ',x printString; cr ]    ifFalse: [ Transcript show: '*** warning' ].

It is very easy to acclimate to Smalltalk syntax. I was a C developer for over 15 years. It took me less than a week to get comfortable with message passing. The parallels between Smalltalk, Python, Ruby, and C are easy to recognize.

The fourth biggest myth is that Smalltalk programs are too slow. Too slow for what? How is Smalltalk slower than other dynamically typed languages like Python, Ruby, Perl, PHP, Erlang, Racket? Python and Ruby are still quite popular; Perl and PHP used to be quite popular. In most instances, performance was not an issue for these languages.

It’s worth pointing out that some Smalltalk dialects are very fast. Pharo’s Cog VM is notably impressive. Smalltalk MT is optimized for maximum performance.

Is Smalltalk slower than C++ and Java? Unquestionably. And if for some applications, Smalltalk isn’t fast enough, then don’t use it. Always choose the right tool for the job.

The fifth biggest myth is that Smalltalk programs cannot scale. The truth is, Smalltalk may well be the only object-oriented language of note that is easily and painlessly scalable. This is because of Alan Kay’s brilliant conception of OOP. Let him explain it (starting from 2:18):

Some more insight comes from Alan Kay’s “The Early History Of Smalltalk” (©1993 ACM):

Smalltalk is a recursion on the notion of computer itself. Instead of dividing “computer stuff” into things each less strong than the whole — like data structures, procedures, and functions which are the usual paraphernalia of programming languages — each Smalltalk object is a recursion on the entire possibilities of the computer. Thus its semantics are a bit like having thousands and thousands of computers all hooked together by a very fast network.

and

Smalltalk’s contribution is a new design paradigm — which I called object-oriented — for attacking large problems of the professional programmer, and making small ones possible for the novice user. Object-oriented design is a successful attempt to qualitatively improve the efficiency of modeling the ever more complex dynamic systems and user relationships made possible by the silicon explosion.

Languages like C++ and Java treat object-oriented programming as the application of Abstract Data Types, whereas languages like Smalltalk and Ruby view object-oriented programming as developing a network of cooperative virtual computers (objects).

All the complaints you’ve heard about object-oriented programming and inheritance and scalability issues have come from using C++, Java, C#, etc. The Abstract Data Type philosophy is detrimental to large-scale software development.

Alan Kay famously said:

Actually, I made up the term “object-oriented,” and I can tell you I did not have C++ in mind.

Said Alan Kay: “The Internet was done so well that most people think of it as a natural resource like the Pacific Ocean, rather than something that was man-made. When was the last time a technology with a scale like that was so error-free?”

Alan Kay likened his object-oriented philosphy to how the Internet was built, or how biological organisms consisting of billions of cells are built. Smalltalk is fantastic for truly scalable solutions.

What are the biggest myths about Smalltalk? was originally published in Hacker Noon on Medium, where people are continuing the conversation by highlighting and responding to this story.