The Smalltalk Evolution

by Richard Kenneth Eng

A common criticism about Smalltalk in the modern age is that the language is not adapting to the latest language research, which is pursuing things like multi-core concurrency and type system safety. Mozilla’s Rust language is often trotted out as a prime example.

The intent of the Smalltalk campaign is not necessarily to compete with cutting-edge languages. Smalltalk is trying to compete with well-entrenched mainstream languages such as Java, JavaScript, and Python.

Moreover, Smalltalk has been continually evolving for many years, as evidenced by numerous dialects that experiment with new features. The Pharo Project continues this tradition. However, one important point must be made: if Smalltalk changes too much, it will no longer be Smalltalk. The beauty of Smalltalk lies in its simplicity and elegance. Tacking on too many major new features will complicate the language and detract from this quality.

The world doesn’t need more complicated languages; it needs simpler languages. That’s the trend we’ve been seeing in recent years, e.g., in Go and Dart. The idea that piling on new features will solve our development woes is misguided. Simple languages that can be easily mastered, in combination with sound project management, will go a lot further than arcane features. I am not convinced that Rust, or any of its ilk, will ever become mainstream. I still remember the hype that surrounded Ada in the 1980s. It was supposed to provide all kinds of safety guarantees. But Ada never achieved significant popularity.

I am bemused by the spate of new programming languages that have popped up over the past 20 years. Very few of them have incorporated new concepts. For the most part, they are merely shuffling around different sets of language features in pursuit of some mythical software engineering advantage. They are basically chasing after their own tails.

For example, Python and Ruby doesn’t really add anything new that wasn’t already in Smalltalk. Dart has type annotations, a feature of questionable value that in the best case hardly upends conventional development practices. Such incremental changes will change nothing in the large. The proliferation of new languages is really a silly exercise in futility.

While Smalltalk is technically of the past, its image-based, “live” development environment has still not been surpassed by all the latest IDEs such as Eclipse, IntelliJ, and Visual Studio. Smalltalk maintains a huge productivity advantage because its tools are simpler, easier to use, and at their roots incredibly powerful. I have always been put off by the complexity of Eclipse and Visual Studio.

So with these two advantages – language simplicity and powerful environment – Smalltalk can still find a place in modern software engineering. It may not push aside Java, but it can certainly carve out a healthy portion of the market.


6 thoughts on “The Smalltalk Evolution

  1. James Ladd ( comments:

    I really admire your efforts to bring a renaissance to Smalltalk.

    ‘A common criticism about Smalltalk … in the modern age is that the language is not adapting to the latest language research’

    This isn’t true of all Smalltalks and I think there needs to be separation of flavours. Redline Smalltalk for example compiles to bytecode and enables you to make use of any class (compiled bytecode) that runs on the JVM, including the ability to generate specific bytecode within Smalltalk (think inline assembler) – to say the JVM is not embracing multi-core or other ‘new’ things would be wrong.


  2. Brad Gilbert says:

    Replying to your comment on InfoWorld interview with Larry Wall about Perl 6, and this post:

    Not every new language is created by … merely shuffling around different sets of language features … .

    Perl 6 is both a simple language and a complex one.

    Simple things are simple (to write, and comprehend).

    For example if you want a list of powers-of-two, it’s as simple as typing the first few elements, 3 dots, and the Whatever star. Perl 6 then deduces the rest of the sequence for you.

    my @powers-of-two = 1, 2, 4, 8, 16 ... *;

    Simple right?

    Unless you realize, Perl 6 had to figure out that it was a given quadratic sequence; without any hint provided by the programmer.

    If you wanted it to stop on 2**32 you would replace the Whatever star.

    my @powers-of-two = 1, 2, 4, 8, 16 ... 2**32;

    Perhaps you wanted the list to stop before the first 5 digit number

    my @powers-of-two = 1, 2, 4, 8, 16 ...^ * >= 10000;

    The * >= 10000 creates a code ref that returns true when it’s one input is greater than or equal to 10000. The ...^ basically means “deduce up-to”.

    If your sequence is more complex you can give Perl 6 a code ref that will be used to find the next
    value or values.

    my @fibonacci = 0, 1, 1, sub ( $a, $b ){ $a + $b } ... *;

    Of course this isn’t very simple looking, instead you could use a block with placeholder variables.

    my @fibonacci = 0, 1, 1, { $^a + $^b } ... *;

    A pointy block:

    my @fibonacci = 0, 1, 1, -> $a, $b { $a + $b } ... *;

    A Whatever code ref:

    my @fibonacci = 0, 1, 1, * + * ... *;

    or even the addition operator (subroutine) itself: ( did I mention that all of the basic operators are just specially named subroutines? )

    my @fibonacci = 0, 1, 1, &[+] ... *;
    my @fibonacci = 0, 1, 1, &infix:<+> ... *;

    You may wonder why have all these ways to write the same thing, well for starters there are some places where some of them don’t make sense syntactically.

    if $a.very-expensive-method-call -> $temp { say $temp }

    Mainly it’s so that the programmer is free to choose the one that is the best for any given situation.

    As to what languages Perl 6 is competing against: none of them, and all of them.

    While us Perl 6 programmers would love for others to come and enjoy our language, we will begrudgingly accept that it is not everyones cup of tea.

    It is most definitely not just one of the myriad of new languages.

    ( Note that I didn’t even mention any of the cool parts of the language, like meta operators and auto-threading )


    • Well, I’m sure many will still consider it “just another language.” While Perl 6 sounds very expressive, so are many other languages, such as Haskell, Clojure, D, and C#. The feature you cite is interesting, but I don’t believe it’s groundbreaking. It certainly doesn’t make Perl 6 stand head and shoulders above everyone else.


  3. Paul Graham said, “programming languages are not merely technologies, but habits of mind as well, and nothing changes slower.” The world is habituated on tier 1 languages like Java and JavaScript. It is unrealistic to think that Smalltalk could ever unseat these languages. But it is definitely within the realm of possibility for Smalltalk to become a tier 2 language, such as Scala or Haskell or Go.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s