Smalltalk is an object-oriented, dynamically typed, reflective
Smalltalk was created as the language to
underpin the "new world" of computing exemplified by "human–computer
symbiosis." It was designed and created in part for educational
use, more so for constructionist learning, at the Learning Research
Group (LRG) of
Xerox PARC by Alan Kay, Dan Ingalls, Adele Goldberg,
Ted Kaehler, Scott Wallace, and others during the 1970s.
The language was first generally released as Smalltalk-80.
Smalltalk-like languages are in continuing active development and have
gathered loyal communities of users around them. ANSI
ratified in 1998 and represents the standard version of Smalltalk.
Smalltalk took second place for "most loved programming language" in
Stack Overflow Developer Survey in 2017, but it was not among
the 26 most loved programming languages of the 2018 survey.
3 Object-oriented programming
5.2 Variable declarations
5.6 Code blocks
6 Control structures
7.2 Instantiating classes
8 Hello World example
9 Image-based persistence
10 Level of access
11 Just-in-time compilation
12 List of implementations
13 See also
15 Further reading
16 External links
There are a large number of
Smalltalk variants. The unqualified
Smalltalk is often used to indicate the Smalltalk-80 language,
the first version to be made publicly available and created in 1980.
Smalltalk was the product of research led by
Alan Kay at
Alto Research Center (PARC);
Alan Kay designed most of the early
Smalltalk versions, Adele Goldberg wrote most of the documentation,
Dan Ingalls implemented most of the early versions. The first
version, known as Smalltalk-71, was created by Kay in a few mornings
on a bet that a programming language based on the idea of message
passing inspired by
Simula could be implemented in "a page of
code." A later variant actually used for research work is now known
as Smalltalk-72 and influenced the development of the Actor model. Its
syntax and execution model were very different from modern Smalltalk
After significant revisions which froze some aspects of execution
semantics to gain performance (by adopting a Simula-like class
inheritance model of execution), Smalltalk-76 was created. This system
had a development environment featuring most of the now familiar
tools, including a class library code browser/editor. Smalltalk-80
added metaclasses, to help maintain the "everything is an object"
(except private instance variables) paradigm by associating properties
and behavior with individual classes, and even primitives such as
integer and boolean values (for example, to support different ways of
Smalltalk-80 was the first language variant made available outside of
PARC, first as Smalltalk-80 Version 1, given to a small number of
firms (Hewlett-Packard, Apple Computer, Tektronix, and DEC) and
universities (UC Berkeley) for "peer review" and implementation on
their platforms. Later (in 1983) a general availability
implementation, known as Smalltalk-80 Version 2, was released as an
image (platform-independent file with object definitions) and a
virtual machine specification. ANSI
Smalltalk has been the standard
language reference since 1998.
Two of the currently popular
Smalltalk implementation variants are
descendants of those original Smalltalk-80 images.
Squeak is an open
source implementation derived from Smalltalk-80 Version 1 by way of
VisualWorks is derived from Smalltalk-80 version 2 by
way of Smalltalk-80 2.5 and ObjectWorks (both products of ParcPlace
Xerox PARC spin-off company formed to bring
the market). As an interesting link between generations, in 2001
Vassili Bykov implemented Hobbes, a virtual machine running
Smalltalk-80 inside VisualWorks. (
Dan Ingalls later ported Hobbes
During the late 1980s to mid-1990s,
support, training and add-ons—were sold by two competing
organizations: ParcPlace Systems and Digitalk, both California based.
ParcPlace Systems tended to focus on the Unix/Sun microsystems market,
while Digitalk focused on Intel-based PCs running Microsoft Windows or
IBM's OS/2. Both firms struggled to take
Smalltalk mainstream due to
Smalltalk's substantial memory needs, limited run-time performance,
and initial lack of supported connectivity to SQL-based relational
database servers. While the high price of ParcPlace
its market penetration to mid-sized and large commercial
organizations, the Digitalk products initially tried to reach a wider
audience with a lower price. IBM initially supported the Digitalk
product, but then entered the market with a
Smalltalk product in 1995
called VisualAge/Smalltalk. Easel introduced Enfin at this time on
Windows and OS/2. Enfin became far more popular in Europe, as IBM
introduced it into IT shops before their development of IBM Smalltalk
(later VisualAge). Enfin was later acquired by
Cincom Systems, and is
now sold under the name ObjectStudio, and is part of the Cincom
Smalltalk product suite.
In 1995, ParcPlace and Digitalk merged into ParcPlace-Digitalk and
then rebranded in 1997 as ObjectShare, located in Irvine, CA.
ObjectShare (NASDAQ: OBJS) was traded publicly until 1999, when it was
delisted and dissolved. The merged firm never managed to find an
effective response to Java as to market positioning, and by 1997 its
owners were looking to sell the business. In 1999, Seagull Software
acquired the ObjectShare Java development lab (including the original
Smalltalk/V and Visual
Smalltalk development team), and still owns
VisualSmalltalk, although worldwide distribution rights for the
Smalltalk product remained with ObjectShare who then sold them to
VisualWorks was sold to
Cincom and is now part of Cincom
Cincom has backed
Smalltalk strongly, releasing multiple
new versions of
ObjectStudio each year since 1999.
Cincom, Gemstone and Object Arts, plus other vendors continue to sell
Smalltalk environments. IBM has 'end of life'd VisualAge Smalltalk
having in the late 1990s decided to back Java and it is, as of
2006[update], supported by Instantiations, Inc. which has renamed
the product VA
Smalltalk and released several new versions. The
Squeak implementation has an active community of developers,
including many of the original
Smalltalk community, and has recently
been used to provide the Etoys environment on the
OLPC project, a
toolkit for developing collaborative applications Croquet Project, and
Open Cobalt virtual world application.
GNU Smalltalk is a free
software implementation of a derivative of Smalltalk-80 from the GNU
Smalltalk is a fork of
Squeak oriented towards research
and use in commercial environments.
A significant development, that has spread across all current
Smalltalk environments, is the increasing usage of two web frameworks,
Seaside and AIDA/Web, to simplify the building of complex web
applications. Seaside has seen considerable market interest with
Cincom, Gemstone and Instantiations incorporating and extending it.
Smalltalk was one of many object-oriented programming languages based
Smalltalk is also one of the most influential
programming languages. Virtually all of the object-oriented languages
that came after—Flavors, CLOS, Objective-C, Java, Python,
Ruby, and many others—were influenced by Smalltalk. Smalltalk
was also one of the most popular languages with the Agile Methods,
Rapid Prototyping, and Software Patterns communities. The highly
productive environment provided by
Smalltalk platforms made them ideal
for rapid, iterative development.
Smalltalk emerged from a larger program of ARPA funded research that
in many ways defined the modern world of computing. In addition to
Smalltalk, working prototypes of things such as hypertext, GUIs,
multimedia, the mouse, telepresence, and the Internet were developed
by ARPA researchers in the 1960s.
Alan Kay (one of the
inventors of Smalltalk) also described a tablet computer he called the
Dynabook which resembles modern tablet computers like the iPad.
Smalltalk environments were often the first to develop what are now
common object-oriented software design patterns. One of the most
popular is the
Model–view–controller pattern for User Interface
design. The MVC pattern enables developers to have multiple consistent
views of the same underlying data. It's ideal for software development
environments, where there are various views (e.g., entity-relation,
dataflow, object model, etc.) of the same underlying specification.
Also, for simulations or games where the underlying model may be
viewed from various angles and levels of abstraction.
In addition to the MVC pattern the
Smalltalk language and environment
were tremendously influential in the history of the Graphical User
Interface (GUI) and the
What You See Is What You Get
What You See Is What You Get (WYSIWYG) user
interface, font editors, and desktop metaphors for UI design. The
powerful built-in debugging and object inspection tools that came with
Smalltalk environments set the standard for all the Integrated
Development Environments, starting with
Lisp Machine environments,
that came after.
Main article: Object-oriented programming
As in other object-oriented languages, the central concept in
Smalltalk-80 (but not in Smalltalk-72) is that of an object. An object
is always an instance of a class. Classes are "blueprints" that
describe the properties and behavior of their instances. For example,
a GUI's window class might declare that windows have properties such
as the label, the position and whether the window is visible or not.
The class might also declare that instances support operations such as
opening, closing, moving and hiding. Each particular window object
would have its own values of those properties, and each of them would
be able to perform operations defined by its class.
Smalltalk object can do exactly three things:
Hold state (references to other objects).
Receive a message from itself or another object.
In the course of processing a message, send messages to itself or
The state an object holds is always private to that object. Other
objects can query or change that state only by sending requests
(messages) to the object to do so. Any message can be sent to any
object: when a message is received, the receiver determines whether
that message is appropriate.
Alan Kay has commented that despite the
attention given to objects, messaging is the most important concept in
Smalltalk: "The big idea is 'messaging'—that is what the kernel of
Squeak is all about (and it's something that was never quite
completed in our
Xerox PARC phase)."
Smalltalk is a "pure" object-oriented programming language, meaning
that, unlike Java and C++, there is no difference between values which
are objects and values which are primitive types. In Smalltalk,
primitive values such as integers, booleans and characters are also
objects, in the sense that they are instances of corresponding
classes, and operations on them are invoked by sending messages. A
programmer can change or extend (through subclassing) the classes that
implement primitive values, so that new behavior can be defined for
their instances—for example, to implement new control
structures—or even so that their existing behavior will be changed.
This fact is summarized in the commonly heard phrase "In Smalltalk
everything is an object", which may be more accurately expressed as
"all values are objects", as variables are not.
Since all values are objects, classes themselves are also objects.
Each class is an instance of the metaclass of that class. Metaclasses
in turn are also objects, and are all instances of a class called
Metaclass. Code blocks—Smalltalk's way of expressing anonymous
functions—are also objects.
Reflection is a term that computer scientists apply to software
programs that have the capability to inspect their own structure, for
example their parse tree or datatypes of input and output parameters.
Reflection was first primarily a feature of interpreted languages such
Smalltalk and Lisp. The fact that statements are interpreted means
that the programs have access to information created as they were
parsed and can often even modify their own structure.
Reflection is also a feature of having a meta-model as
The meta-model is the model that describes the language itself and
developers can use the meta-model to do things like walk through,
examine, and modify the parse tree of an object. Or find all the
instances of a certain kind of structure (e.g., all the instances of
the Method class in the meta-model).
Smalltalk-80 is a totally reflective system, implemented in
Smalltalk-80 itself. Smalltalk-80 provides both structural and
Smalltalk is a structurally reflective
system whose structure is defined by Smalltalk-80 objects. The classes
and methods that define the system are themselves objects and fully
part of the system that they help define. The
compiles textual source code into method objects, typically instances
of CompiledMethod. These get added to classes by storing them in a
class's method dictionary. The part of the class hierarchy that
defines classes can add new classes to the system. The system is
extended by running Smalltalk-80 code that creates or defines classes
and methods. In this way a Smalltalk-80 system is a "living" system,
carrying around the ability to extend itself at run time.
Since the classes are themselves objects, they can be asked questions
such as "what methods do you implement?" or "what
fields/slots/instance variables do you define?". So objects can easily
be inspected, copied, (de)serialized and so on with generic code that
applies to any object in the system.
Smalltalk-80 also provides computational reflection, the ability to
observe the computational state of the system. In languages derived
from the original Smalltalk-80 the current activation of a method is
accessible as an object named via a pseudo-variable (one of the six
reserved words), thisContext. By sending messages to thisContext a
method activation can ask questions like "who sent this message to
me". These facilities make it possible to implement co-routines or
Prolog-like back-tracking without modifying the virtual machine. The
exception system is implemented using this facility. One of the more
interesting uses of this is in the Seaside web framework which
relieves the programmer of dealing with the complexity of a Web
Browser's back button by storing continuations for each edited page
and switching between them as the user navigates a web site.
Programming the web server using Seaside can then be done using a more
conventional programming style.
An example of how
Smalltalk can use reflection is the mechanism for
handling errors. When an object is sent a message that it does not
implement, the virtual machine sends the object the doesNotUnderstand:
message with a reification of the message as an argument. The message
(another object, an instance of Message) contains the selector of the
message and an Array of its arguments. In an interactive Smalltalk
system the default implementation of doesNotUnderstand: is one that
opens an error window (a Notifier) reporting the error to the user.
Through this and the reflective facilities the user can examine the
context in which the error occurred, redefine the offending code, and
continue, all within the system, using Smalltalk-80's reflective
By creating a class that understands (implements) only
doesNotUnderstand:, one can create an instance that can intercept any
message sent to it via its doesNotUnderstand: method. Such instances
are called transparent proxies. Such proxies can then be used to
implement a number of facilities such as distributed
messages are exchanged between multiple
Smalltalk systems, database
interfaces where objects are transparently faulted out of a database,
promises, etc. The design of distributed
Smalltalk influenced such
systems as CORBA.
This section needs additional citations for verification. Please help
improve this article by adding citations to reliable sources.
Unsourced material may be challenged and removed. (June 2014) (Learn
how and when to remove this template message)
Smalltalk-80 syntax is rather minimalist, based on only a handful of
declarations and reserved words. In fact, only six "keywords" are
reserved in Smalltalk: true, false, nil, self, super, and thisContext.
These are actually called pseudo-variables, identifiers that follow
the rules for variable identifiers but denote bindings that the
programmer cannot change. The true, false, and nil pseudo-variables
are singleton instances. self and super refer to the receiver of a
message within a method activated in response to that message, but
sends to super are looked up in the superclass of the method's
defining class rather than the class of the receiver, which allows
methods in subclasses to invoke methods of the same name in
superclasses. thisContext refers to the current activation record. The
only built-in language constructs are message sends, assignment,
method return and literal syntax for some objects. From its origins as
a language for children of all ages, standard
Smalltalk syntax uses
punctuation in a manner more like English than mainstream coding
languages. The remainder of the language, including control structures
for conditional evaluation and iteration, is implemented on top of the
built-in constructs by the standard
Smalltalk class library. (For
performance reasons, implementations may recognize and treat as
special some of those messages; however, this is only an optimization
and is not hardwired into the language syntax.)
The adage that "
Smalltalk syntax fits on a postcard" refers to a code
snippet by Ralph Johnson, demonstrating all the basic standard
syntactic elements of methods:
true & false not & (nil isNil) ifFalse: [self halt].
y := self size + super size.
#($a #a "a" 1 1.0)
do: [ :each
Transcript show: (each class name);
show: ' '].
^x < y
The following examples illustrate the most common objects which can be
written as literal values in Smalltalk-80 methods.
Numbers. The following list illustrates some of the possibilities.
The last two entries are a binary and a hexadecimal number,
respectively. The number before the 'r' is the radix or base. The base
does not have to be a power of two; for example 36rSMALLTALK is a
valid number equal to 80738163270632 decimal.
Characters are written by preceding them with a dollar sign:
Strings are sequences of characters enclosed in single quotes:
To include a quote in a string, escape it using a second quote:
'I said, ''Hello, world!'' to them.'
Double quotes do not need escaping, since single quotes delimit a
'I said, "Hello, world!" to them.'
Two equal strings (strings are equal if they contain all the same
characters) can be different objects residing in different places in
memory. In addition to strings,
Smalltalk has a class of character
sequence objects called Symbol. Symbols are guaranteed to be
unique—there can be no two equal symbols which are different
objects. Because of that, symbols are very cheap to compare and are
often used for language artifacts such as message selectors (see
Symbols are written as # followed by a string literal. For example:
If the sequence does not include whitespace or punctuation characters,
this can also be written as:
#(1 2 3 4)
defines an array of four integers.
Many implementations support the following literal syntax for
#[1 2 3 4]
defines a ByteArray of four integers.
And last but not least, blocks (anonymous function literals)
[... Some smalltalk code...]
Blocks are explained in detail further in the text.
Smalltalk dialects implement additional syntaxes for other
objects, but the ones above are the essentials supported by all.
The two kinds of variables commonly used in
Smalltalk are instance
variables and temporary variables. Other variables and related
terminology depend on the particular implementation. For example,
VisualWorks has class shared variables and namespace shared variables,
Squeak and many other implementations have class variables, pool
variables and global variables.
Temporary variable declarations in
Smalltalk are variables declared
inside a method (see below). They are declared at the top of the
method as names separated by spaces and enclosed by vertical bars. For
declares a temporary variable named index which contains initially the
Multiple variables may be declared within one set of bars:
declares two variables: index and vowels. All variables are
initialized. Variables are initialized to nil except the indexed
variables of Strings, which are initialized to the null character or
ByteArrays which are initialized to 0.
A variable is assigned a value via the ':=' syntax. So:
vowels := 'aeiou'
Assigns the string 'aeiou' to the previously declared vowels variable.
The string is an object (a sequence of characters between single
quotes is the syntax for literal strings), created by the compiler at
In the original Parc Place image, the glyph of the underscore
character (_) appeared as a left-facing arrow (like in the 1963
version of the
Smalltalk originally accepted this
left-arrow as the only assignment operator. Some modern code still
contains what appear to be underscores acting as assignments,
hearkening back to this original usage. Most modern Smalltalk
implementations accept either the underscore or the colon-equals
The message is the most fundamental language construct in Smalltalk.
Even control structures are implemented as message sends. Smalltalk
adopts by default a synchronous, single dynamic message dispatch
strategy (as contrasted to the asynchronous, multiple dispatch
strategy adopted by some other object-oriented languages).
The following example sends the message 'factorial' to number 42:
In this situation 42 is called the message receiver, while 'factorial'
is the message selector. The receiver responds to the message by
returning a value (presumably in this case the factorial of 42). Among
other things, the result of the message can be assigned to a variable:
aRatherBigNumber := 42 factorial
"factorial" above is what is called a unary message because only one
object, the receiver, is involved. Messages can carry additional
objects as arguments, as follows:
2 raisedTo: 4
In this expression two objects are involved: 2 as the receiver and 4
as the message argument. The message result, or in
the answer is supposed to be 16. Such messages are called keyword
messages. A message can have more arguments, using the following
'hello world' indexOf: $o startingAt: 6
which answers the index of character 'o' in the receiver string,
starting the search from index 6. The selector of this message is
"indexOf:startingAt:", consisting of two pieces, or keywords.
Such interleaving of keywords and arguments is meant to improve
readability of code, since arguments are explained by their preceding
keywords. For example, an expression to create a rectangle using a C++
or Java-like syntax might be written as:
new Rectangle(100, 200);
It's unclear which argument is which. By contrast, in Smalltalk, this
code would be written as:
Rectangle width: 100 height: 200
The receiver in this case is "Rectangle", a class, and the answer will
be a new instance of the class with the specified width and height.
Finally, most of the special (non-alphabetic) characters can be used
as what are called binary messages. These allow mathematical and
logical operators to be written in their traditional form:
3 + 4
which sends the message "+" to the receiver 3 with 4 passed as the
argument (the answer of which will be 7). Similarly,
3 > 4
is the message ">" sent to 3 with argument 4 (the answer of which
will be false).
Notice, that the Smalltalk-80 language itself does not imply the
meaning of those operators. The outcome of the above is only defined
by how the receiver of the message (in this case a Number instance)
responds to messages "+" and ">".
A side effect of this mechanism is operator overloading. A message
">" can also be understood by other objects, allowing the use of
expressions of the form "a > b" to compare them.
An expression can include multiple message sends. In this case
expressions are parsed according to a simple order of precedence.
Unary messages have the highest precedence, followed by binary
messages, followed by keyword messages. For example:
3 factorial + 4 factorial between: 10 and: 100
is evaluated as follows:
3 receives the message "factorial" and answers 6
4 receives the message "factorial" and answers 24
6 receives the message "+" with 24 as the argument and answers 30
30 receives the message "between:and:" with 10 and 100 as arguments
and answers true
The answer of the last message sent is the result of the entire
Parentheses can alter the order of evaluation when needed. For
(3 factorial + 4) factorial between: 10 and: 100
will change the meaning so that the expression first computes "3
factorial + 4" yielding 10. That 10 then receives the second
"factorial" message, yielding 3628800. 3628800 then receives
"between:and:", answering false.
Note that because the meaning of binary messages is not hardwired into
Smalltalk-80 syntax, all of them are considered to have equal
precedence and are evaluated simply from left to right. Because of
this, the meaning of
Smalltalk expressions using binary messages can
be different from their "traditional" interpretation:
3 + 4 * 5
is evaluated as "(3 + 4) * 5", producing 35. To obtain the expected
answer of 23, parentheses must be used to explicitly define the order
3 + (4 * 5)
Unary messages can be chained by writing them one after another:
3 factorial factorial log
which sends "factorial" to 3, then "factorial" to the result (6), then
"log" to the result (720), producing the result 2.85733.
A series of expressions can be written as in the following
(hypothetical) example, each separated by a period. This example first
creates a new instance of class Window, stores it in a variable, and
then sends two messages to it.
window := Window new.
window label: 'Hello'.
If a series of messages are sent to the same receiver as in the
example above, they can also be written as a cascade with individual
messages separated by semicolons:
This rewrite of the earlier example as a single expression avoids the
need to store the new window in a temporary variable. According to the
usual precedence rules, the unary message "new" is sent first, and
then "label:" and "open" are sent to the answer of "new".
A block of code (an anonymous function) can be expressed as a literal
value (which is an object, since all values are objects.) This is
achieved with square brackets:
[ :params <message-expressions> ]
Where :params is the list of parameters the code can take. This means
[:x x + 1]
can be understood as:
or expressed in lambda terms as:
displaystyle lambda x
[:x x + 1] value: 3
can be evaluated as
Or in lambda terms as:
displaystyle (lambda x:x+1)3_ beta rightarrow 4
The resulting block object can form a closure: it can access the
variables of its enclosing lexical scopes at any time. Blocks are
Blocks can be executed by sending them the value message (compound
variations exist in order to provide parameters to the block e.g.
'value:value:' and 'valueWithArguments:').
The literal representation of blocks was an innovation which on the
one hand allowed certain code to be significantly more readable; it
allowed algorithms involving iteration to be coded in a clear and
concise way. Code that would typically be written with loops in some
languages can be written concisely in
Smalltalk using blocks,
sometimes in a single line. But more importantly blocks allow control
structure to be expressed using messages and polymorphism, since
blocks defer computation and polymorphism can be used to select
alternatives. So if-then-else in
Smalltalk is written and implemented
expr ifTrue: [statements to evaluate if expr] ifFalse: [statements to
evaluate if not expr]True methods for evaluationifTrue:
trueAlternativeBlock ifFalse: falseAlternativeBlock
False methods for evaluationifTrue: trueAlternativeBlock ifFalse:
falseAlternativeBlock ^falseAlternativeBlock value
positiveAmounts := allAmounts select: [:anAmount anAmount
Note that this is related to functional programming, wherein patterns
of computation (here selection) are abstracted into higher-order
functions. For example, the message select: on a Collection is
equivalent to the higher-order function filter on an appropriate
Control structures do not have special syntax in Smalltalk. They are
instead implemented as messages sent to objects. For example,
conditional execution is implemented by sending the message ifTrue: to
a Boolean object, passing as an argument the block of code to be
executed if and only if the Boolean receiver is true.
The following code demonstrates this:
result := a > b
ifTrue:[ 'greater' ]
ifFalse:[ 'less or equal' ]
Blocks are also used to implement user-defined control structures,
enumerators, visitors, exception handling, pluggable behavior and many
other patterns. For example:
aString := 'This is a string'.
vowels := aString select: [:aCharacter aCharacter isVowel].
In the last line, the string is sent the message select: with an
argument that is a code block literal. The code block literal will be
used as a predicate function that should answer true if and only if an
element of the String should be included in the Collection of
characters that satisfy the test represented by the code block that is
the argument to the "select:" message.
A String object responds to the "select:" message by iterating through
its members (by sending itself the message "do:"), evaluating the
selection block ("aBlock") once with each character it contains as the
argument. When evaluated (by being sent the message "value: each"),
the selection block (referenced by the parameter "aBlock", and defined
by the block literal "[:aCharacter aCharacter isVowel]"), answers a
boolean, which is then sent "ifTrue:". If the boolean is the object
true, the character is added to a string to be returned. Because the
"select:" method is defined in the abstract class Collection, it can
also be used like this:
rectangles aPoint collisions
rectangles := OrderedCollection
with: (Rectangle left: 0 right: 10 top: 100 bottom: 200)
with: (Rectangle left: 10 right: 10 top: 110 bottom: 210).
aPoint := Point x: 20 y: 20.
collisions := rectangles select: [:aRect aRect containsPoint:
The exception handling mechanism uses blocks as handlers (similar to
CLOS-style exception handling):
] on:Error do:[:ex
The exception handler's "ex" argument provides access to the state of
the suspended operation (stack frame, line-number, receiver and
arguments etc.) and is also used to control how the computation is to
proceed (by sending one of "ex proceed", "ex reject", "ex restart" or
This is a stock class definition:
Object subclass: #MessagePublisher
Often, most of this definition will be filled in by the environment.
Notice that this is actually a message to the "Object"-class to create
a subclass called "MessagePublisher". In other words: classes are
first-class objects in
Smalltalk which can receive messages just like
any other object and can be created dynamically at execution time.
When an object receives a message, a method matching the message name
is invoked. The following code defines a method publish, and so
defines what will happen when this object receives the 'publish'
Transcript show: 'Hello World!'
The following method demonstrates receiving multiple arguments and
returning a value:
quadMultiply: i1 and: i2
"This method multiplies the given numbers by each other and the
result by 4."
mul := i1 * i2.
^mul * 4
The method's name is #quadMultiply:and:. The return value is specified
with the ^ operator.
Note that objects are responsible for determining dynamically at
runtime which method to execute in response to a message—while in
many languages this may be (sometimes, or even always) determined
statically at compile time.
The following code:
creates (and returns) a new instance of the MessagePublisher class.
This is typically assigned to a variable:
publisher := MessagePublisher new
However, it is also possible to send a message to a temporary,
MessagePublisher new publish
Hello World example
Hello world program
Hello world program is used by virtually all texts to new
programming languages as the first program learned to show the most
basic syntax and environment of the language. For Smalltalk, the
program is extremely simple to write. The following code, the message
"show:" is sent to the object "Transcript" with the String literal
'Hello, world!' as its argument. Invocation of the "show:" method
causes the characters of its argument (the
String literal 'Hello,
world!') to be displayed in the transcript ("terminal") window.
Transcript show: 'Hello, world!'.
Note that a Transcript window would need to be open in order to see
the results of this example.
Most popular programming systems separate static program code (in the
form of class definitions, functions or procedures) from dynamic, or
run time, program state (such as objects or other forms of program
data). They load program code when a program starts, and any prior
program state must be recreated explicitly from configuration files or
other data sources. Any settings the program (and programmer) does not
explicitly save must be set up again for each restart. A traditional
program also loses much useful document information each time a
program saves a file, quits, and reloads. This loses details such as
undo history or cursor position. Image based systems don't force
losing all that just because a computer is turned off, or an OS
Smalltalk systems, however, do not differentiate between program
data (objects) and code (classes). In fact, classes are objects
themselves. Therefore, most
Smalltalk systems store the entire program
state (including both Class and non-Class objects) in an image file.
The image can then be loaded by the
Smalltalk virtual machine to
restore a Smalltalk-like system to a prior state. This was
inspired by FLEX, a language created by
Alan Kay and described in his
Smalltalk images are similar to (restartable) core dumps and can
provide the same functionality as core dumps, such as delayed or
remote debugging with full access to the program state at the time of
error. Other languages that model application code as a form of data,
such as Lisp, often use image-based persistence as well. This method
of persistence is powerful for rapid development because all the
development information (e.g. parse trees of the program) is saved
which facilitates debugging. However, it also has serious drawbacks as
a true persistence mechanism. For one thing, developers may often want
to hide implementation details and not make them available in a run
time environment. For legal reasons as well as for maintenance
reasons, allowing anyone to modify the program at run time inevitably
introduces complexity and potential errors that would not be possible
with a compiled system that does not expose source code in the run
time environment. Also, while the persistence mechanism is easy to use
it lacks the true persistence capabilities needed for most multi-user
systems. The most obvious is the ability to do transactions with
multiple users accessing the same database in parallel.
Level of access
Everything in Smalltalk-80 is available for modification from within a
running program. This means that, for example, the IDE can be changed
in a running system without restarting it. In some implementations,
the syntax of the language or the garbage collection implementation
can also be changed on the fly. Even the statement true become: false
is valid in Smalltalk, although executing it is not recommended. When
used judiciously, this level of flexibility allows for one of the
shortest required times for new code to enter a production
Main article: Just-in-time compilation
Smalltalk programs are usually compiled to bytecode, which is then
interpreted by a virtual machine or dynamically translated into
List of implementations
Smalltalk scripting engine for Java ≥ 1.6
Cincom has the following
Smalltalk products: ObjectStudio, VisualWorks
Smalltalk Enterprise, and family, including Smalltalk/V
Cuis Smalltalk, open source, modern Smalltalk-80 
Cog, JIT VM written in
Talk Systems, GemStone/s
Étoilé Pragmatic Smalltalk,
Smalltalk for Étoilé, a GNUstep-based
StepTalk, GNUstep scripting framework uses
Smalltalk language on an
Gravel Smalltalk, a
Smalltalk implementation for the JVM
Smalltalk being the follow-on to IBM VisualAge
Object Arts, Dolphin Smalltalk
Smalltalk for Windows
Objective-C runtime with extensions
for Software Architecture
Smalltalk have partnered with Object Arts
Panda Smalltalk, open source engine, written in C, has no dependencies
Pharo Project's open-source multi-platform Smalltalk
Cog, JIT VM written in
Pocket Smalltalk, runs on Palm Pilot
Redline Smalltalk, runs on the Java virtual machine
Refactory, produces #Smalltalk
Squeak, open source Smalltalk
Cog, JIT VM written in
CogDroid, port of non-JIT variant of Cog VM to Android
eToys, eToys visual programming system for learning
Squeak interpreter port for iOS devices, iPhone/iPad
Squeak interpreter written in Java
Squeak interpreter written in Java, a direct derivative of
RoarVM, RoarVM is a multi- and manycore interpreter for
Strongtalk, for Windows, offers optional strong typing
CalmoSoft Project for Vista Smalltalk
GLASS (software bundle)
Distributed Data Management Architecture
^ a b c d e f g h i Kay, Alan; Stefan Ram (2003-07-23). "E-Mail of
Alan Kay on the Meaning of “Object-Oriented
Programming”. Retrieved 2009-01-03.
^ a b c Kay, Alan. "The Early History of Smalltalk". Retrieved
^ "Smalltalk.org™ versions ANSIStandardSmalltalk.html".
Smalltalk.org. Archived from the original on 2006-02-16. Retrieved
Stack Overflow Developer Survey 2017
Stack Overflow Developer Survey 2018
^ "Versions". Smalltalk.org. Archived from the original on 2015-09-08.
Smalltalk Standard". Smalltalk.org. Archived from the original
on 2015-09-07. Retrieved 2007-09-13.
^ "History". Seagull Software. Archived from the original on
2002-08-06. Retrieved 2007-09-13.
Smalltalk Transition FAQ
Simula language was also object-oriented and preceded (and was
acknowledged as an influence on)
Smalltalk but it was a simulation
language, not a general purpose programming language.
^ Cannon, Howard. "Flavors A non-hierarchical approach to
object-oriented programming" (PDF). softwarepreservation.org.
Retrieved 17 December 2013.
^ "About Ruby". ruby-lang.org. Retrieved 17 December 2013.
^ "Where Did Refactoring Come From?". sourcemaking.com. Retrieved 17
^ "DARPA / ARPA". livinginternet.com. Retrieved 16 December 2013. To
meet this need, ARPA established the IPTO in 1962 with a mandate to
build a survivable computer network to interconnect the DoD's main
computers at the Pentagon, Cheyenne Mountain, and SAC HQ.
^ "Engelbart's Role in Early Computer Networking". dougengelbart.org.
Retrieved 17 December 2013.
^ Kay, Allen. "The Early History of Smalltalk". gagne.homedns.org.
Retrieved 16 December 2013.
^ Krasner, Glen; Stephen Pope (August–September 1988). "A Cookbook
for Using the Model-View-Controller User Interface Paradigm in
Smalltalk -80". Journal of Object-Oriented Programming.
^ "Our Influence". cincomsmalltalk.com. Retrieved 16 December
^ Kay, Alan (October 10, 1998). "Prototypes vs Classes (e-mail on
^ Goldberg, Adele; David Robson (1989). Smalltalk-80 The Language.
Addison Wesley. pp. 31, 75–89. ISBN 0-201-13688-0.
^ Clark, A.N. (1997). "Metaclasses and Reflection in Smalltalk".
^ Ducasse, St ́ephane; Adrian Lienhard; Lukas Renggli. "Seaside – A
Multiple Control Flow Web Application Framework" (PDF). scg.unibe.ch.
Software Composition Group Institut f ̈ur Informatik und angewandte
Mathematik Universitaat Bern, Switzerland. Retrieved 16 December
^ Foote, Brian; Ralph Johnson (1–6 October 1989). "Reflective
Facilities in Smalltalk-80". OOPSLA '89. Retrieved 16 December
^ Smith, Brian C (1982-01-01). "PROCEDURAL REFLECTION IN PROGRAMMING
LANGUAGES". MIT Technical Report (MIT-LCS-TR-272). Retrieved 16
^ Denker, Marcus; Mariano Martinez Peck; Noury Bouraqadi; Luc
Fabresse; St ́ephane Ducasse. "Efficient Proxies in Smalltalk"
^  
^ Goldberg, Adele; David Robson (1989). Smalltalk-80 The Language.
Addison Wesley. pp. 17–37. ISBN 0-201-13688-0.
^ Goldberg, Adele; David Robson (1989). Smalltalk-80 The Language.
Addison Wesley. pp. 39–53. ISBN 0-201-13688-0.
^ "Image-Based Persistence". book.seaside.st. Retrieved 17 December
^ Kay, Allen (1968). "FLEX – A flexible extendable language".
University of Utah MsC Thesis.
^ Fowler, Martin. "Memory Image". martinfowler.com. Retrieved 17
^ "Redline Smalltalk". Redline.st. Retrieved 2014-06-07.
^ "Smalltalk/X Programming Language eXept Software AG". exept.de.
Goldberg, Adele (December 1983). Smalltalk-80: The Interactive
Programming Environment. Addison-Wesley.
Adele Goldberg & Alan Kay, ed. (March 1976). Smalltalk-72
Instruction Manual (PDF). Palo Alto, California:
Xerox Palo Alto
Research Center. Retrieved 2011-11-11.
Goldberg, Adele; Robson, David (May 1983). Smalltalk-80: The Language
and its Implementation (PDF). Addison-Wesley.
Goldberg, Adele; Robson, David (11 January 1989).
Smalltalk 80: The
Language. Addison-Wesley. ISBN 0-201-13688-0.
Kay, Alan C. (March 1993). "The Early History of Smalltalk" (PDF). ACM
SIGPLAN Notices. ACM. 28 (3): 69–95.
Glen Krasner, ed. (August 1983). Smalltalk-80: Bits of History, Words
of Advice. Addison-Wesley. ISBN 0-201-11669-3.
Nierstrasz, Oscar; Ducasse, Stéphane; Pollet, Damien; Black, Andrew
Squeak by Example. Kehrsatz, Switzerland: Square
Bracket Associates. ISBN 3-9523341-0-3.
Nierstrasz, Oscar; Ducasse, Stéphane; Pollet, Damien; Black, Andrew
P. (February 23, 2010).
Pharo by Example. Kehrsatz, Switzerland:
Square Bracket Publishing.
ISBN 978-3-9523341-4-0. [permanent dead link]
Winston, Patrick Henry (September 3, 1997). On to Smalltalk. MIT, USA:
Addison Wesley. ISBN 978-0201498271.
Brauer, Johannes (2015). Programming
Smalltalk - Object-Orientation
from the Beginning. Springer. ISBN 978-3-658-06823-3.
Special Issue on Smalltalk". BYTE. McGraw-Hill. 6 (8). August 1981.
Goldberg, Adele (August 1981). "Introducing the Smalltalk-80 System".
BYTE. McGraw-Hill. 6 (8). Retrieved 2013-10-18.
Ingalls, Dan (August 1981). "Design Principles Behind Smalltalk".
BYTE. McGraw-Hill. 6 (8). Retrieved 2011-11-11.
Tesler, Larry (August 1981). "The
Smalltalk Environment". BYTE.
McGraw-Hill. 6 (8). Retrieved 2016-05-02.
Wikibooks has a book on the topic of: Programming:Smalltalk
The World of Smalltalk,
Smalltalk books and videos, implementations,
frameworks and tools, blogs and mailing lists
Planet Smalltalk, an aggregator of
Smalltalk blog posts
Downloadable books on Smalltalk, permission obtained to make these
books freely available, over 25 full texts scanned from print
Smalltalk at Curlie (based on DMOZ)
Smalltalk Users Group), non-profit organization with
commercial and academic members, has various promotion activities
including a yearly event since 1993
Smalltalk Industry Council), promoting
Smalltalk on behalf of
La Fundacion Argentina de
Smalltalk (FAST), Organizer of annual
Smalltalk conference in Argentina
ClubSmalltalk, a Latin American group with a website in English to
Squeak, Free smalltalk IDE
Pharo, Another free smalltalk IDE
Visual Basic .NET
Visual Basic .NET (VB.NET)