Smalltalk

Smalltalk is not just a programming language - it’s a complete philosophy of computing. Created at Xerox PARC in the 1970s by Alan Kay’s Learning Research Group, Smalltalk introduced many concepts we now take for granted: graphical user interfaces, the modern IDE, and the very idea of object-oriented programming as we know it today.

History & Origins

In 1968, Alan Kay had a vision: computers as “Dynabooks” - personal, portable devices that children could use to learn and create. To realize this vision, he needed a programming environment that was powerful yet accessible. At Xerox PARC in the early 1970s, Kay assembled a team including Dan Ingalls, Adele Goldberg, and others to create Smalltalk.

The Evolution

Smalltalk-72 was the first implementation, featuring the core messaging concept. Every interaction was a message sent to an object.

Smalltalk-76 introduced the class browser, the iconic tool that lets programmers navigate and modify the entire system. It also established the inheritance model.

Smalltalk-80 became the canonical version, developed at PARC around 1980. It was introduced to the wider public through a famous issue of BYTE Magazine in August 1981 and first distributed to selected companies (Apple, DEC, HP, Tektronix) later that year. This version established Smalltalk’s syntax and class library that persist today.

The PARC Legacy

Smalltalk wasn’t developed in isolation. The same Xerox PARC environment produced:

• The graphical user interface (windows, icons, menus, pointing devices)
• The WYSIWYG document editor
• Ethernet networking
• Laser printing

Smalltalk tied these innovations together, demonstrating what personal computing could become.

Core Philosophy

Everything is an Object

In Smalltalk, there are no primitives, no special cases. Numbers are objects. Classes are objects. Even nil, true, and false are objects. This purity makes the system consistent and learnable.

1
2
3

3 + 4           "sends + message to 3 with argument 4"
'hello' size    "sends size message to string 'hello'"
true ifTrue: [ 'yes' ]   "sends ifTrue: message to true"

Everything is a Message

All computation happens through message passing. The syntax is remarkably simple:

• Unary messages: object message (e.g., 3 negated)
• Binary messages: object operator argument (e.g., 3 + 4)
• Keyword messages: object keyword: argument (e.g., list at: 1 put: 'hello')

The Image

Unlike most languages where programs are text files compiled into executables, Smalltalk maintains a living “image” - a snapshot of all objects in memory. When you save your work, you save the entire state of the system. When you restart, you continue exactly where you left off.

The Browser

Smalltalk pioneered the integrated development environment. The class browser lets you:

• Navigate all classes in the system
• Edit methods directly
• See inheritance hierarchies
• Search and refactor code

Modern IDEs owe their existence to Smalltalk’s browser.

Language Features

Clean Syntax

Smalltalk’s syntax fits on a postcard:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

"Comments in double quotes"
| localVariable |           "Variable declaration"
localVariable := 42.        "Assignment"
^returnValue                "Return"

"Blocks (closures)"
[ :x | x * 2 ]

"Control flow through messages"
condition ifTrue: [ doThis ] ifFalse: [ doThat ].

"Collections"
#(1 2 3) do: [ :each | Transcript show: each ].

Blocks as First-Class Objects

Blocks (closures) are fundamental to Smalltalk:

1
2
3
4
5
6
7
8
9

"A block that doubles a number"
doubler := [ :x | x * 2 ].
doubler value: 5.  "Returns 10"

"Blocks enable custom control structures"
10 timesRepeat: [ Transcript show: 'Hello!' ].

"Collection iteration"
#(1 2 3 4 5) select: [ :n | n even ].  "Returns #(2 4)"

Reflection and Metaclasses

Smalltalk is fully reflective. Programs can inspect and modify themselves:

1
2
3
4
5
6
7
8

"Find all classes that inherit from Collection"
Collection allSubclasses.

"List all methods of a class"
String methodDict keys.

"Every class is itself an object, instance of a metaclass"
String class.  "Returns 'String class'"

Live Development

In Smalltalk, you don’t write code and then run it. You interact with living objects:

1. Inspect any object to see its state
2. Modify methods while the program runs
3. Fix bugs without restarting
4. Explore the system interactively

Modern Implementations

Pharo

The most actively developed modern Smalltalk:

• Clean, modern syntax extensions
• Git integration via Iceberg
• Web development with Seaside and Teapot
• Active community and conferences
• MIT licensed

Squeak

Created by Alan Kay, Dan Ingalls, and others at Apple in 1996:

• Educational focus with Etoys
• Morphic graphical framework
• Cross-platform including Raspberry Pi
• Emphasis on multimedia and simulation

GNU Smalltalk

Command-line oriented Smalltalk:

• Script-friendly (no GUI required)
• Package management via packages
• Good for server-side applications
• Traditional Unix tool philosophy

VisualWorks (Cincom)

Commercial Smalltalk:

• Enterprise features
• Web services support
• Used in financial systems
• Professional support

Smalltalk’s Influence

Smalltalk’s ideas permeate modern programming:

Objective-C and Swift

Brad Cox created Objective-C by adding Smalltalk’s messaging to C. This became the language of NeXT and later Apple. Swift continues many Objective-C (and thus Smalltalk) conventions.

Ruby

Matz explicitly based Ruby on Smalltalk’s object model:

• Everything is an object
• Blocks as first-class values
• Dynamic typing
• Message-based design

Java

While Java’s syntax came from C++, its class library design, garbage collection, and object model show clear Smalltalk influence.

Design Patterns

The Gang of Four’s “Design Patterns” book used Smalltalk (alongside C++) for examples. Many patterns originated in the Smalltalk community.

Agile Development

Kent Beck developed Extreme Programming (XP) while working in Smalltalk. The language’s interactive nature encouraged:

• Test-driven development
• Refactoring
• Pair programming
• Continuous integration

JUnit, the grandfather of unit testing frameworks, was inspired by SUnit for Smalltalk.

Why Smalltalk Matters Today

Educational Value

Smalltalk’s consistency makes it excellent for learning OOP:

• One concept (messaging) explains everything
• No magic or special cases
• Immediate feedback
• Self-documenting system

Prototype Development

The live environment excels at exploration:

• Try ideas instantly
• Change anything without recompilation
• Debug interactively
• Refactor fearlessly

Domain-Specific Languages

Smalltalk’s clean syntax makes it ideal for DSLs:

• Keyword messages read like English
• Blocks provide deferred execution
• Metaclasses enable framework building

Web Development

Modern Smalltalk frameworks like Seaside offer:

• Component-based architecture
• Continuation-based control flow
• Live debugging of web apps
• No need for templates

The Smalltalk Community

Despite not being mainstream, Smalltalk has a dedicated community:

• ESUG - European Smalltalk Users Group, annual conference
• Pharo Consortium - Industry support for Pharo
• Smalltalk Discord/Reddit - Active online communities
• Pharoers - Weekly development streams

Many Smalltalkers have decades of experience and are passionate about sharing the language’s elegance.

Learning Smalltalk

Recommended resources:

1. Pharo by Example - Free book for modern Smalltalk
2. Squeak by Example - Introduction using Squeak
3. Smalltalk Best Practice Patterns - Kent Beck’s classic
4. Smalltalk-80: The Language and its Implementation - Adele Goldberg and David Robson

Why So Few Use It?

Given its influence, why isn’t Smalltalk more popular?

• Image-based persistence - Different from file-based workflows
• IDE coupling - Requires learning a specific environment
• Vendor fragmentation - Multiple incompatible implementations
• Timing - C++ and Java gained corporate backing first
• Inertia - Industry momentum favors established choices

Yet those who learn Smalltalk often become lifelong advocates. Its ideas are so powerful that they’ve been copied everywhere - just not the language itself.

Conclusion

Smalltalk represents a vision of computing that’s still ahead of its time in some ways. Its concepts of live development, objects all the way down, and powerful abstraction continue to influence new languages and tools.

Learning Smalltalk isn’t just about picking up another language - it’s about understanding where object-oriented programming came from and experiencing computing as its creators envisioned it. Whether or not you use Smalltalk professionally, studying it will make you a better programmer in any language.

As Alan Kay is widely credited with saying: “The best way to predict the future is to invent it.” Smalltalk invented much of our programming present.