Programming Language Smalltalk

What's Smalltalk?

Smalltalk is a language, a complete class library, and an interactive programming environment rolled into one seamless whole. The environment itself is built in Smalltalk. The system includes its own compiler, debugger, and class library browser that combines a text editor, code analyzer, interactive compiler and code refactoring tool. Since these are all written in Smalltalk, they are extensible by the user. Smalltalk is an incrementally compiled system, allowing these tools provide perfect source-level debugging with "debug and continue" facilities.

Smalltalk was developed at the Xerox Palo Alto Research Center in the '70s and '80s. The language was designed to combine comprehensibility with power and malleability, and its use by local school children helped create a system that was responsive (kids get impatient quickly) and fun to use (they won't use anything else!).

In 1988, Xerox spun off ParcPlace Systems as an independent company to commercialize its Smalltalk work. Later, ParcPlace merged with Digitalk to form ParcPlace-Digitalk in 1995, which renamed itself ObjectShare in 1997. In 1999, Cincom Systems acquired the VisualWorks technology and its engineering team.

For brief histories of Smalltalk by two of its principal creators, see:

"The Early History of Smalltalk" by Alan C. Kay,
in History of Programming Languages
Thomas J. Bergin and Richard G. Gibson, Eds.
Addison-Wesley, ISBN 0-201-89502-1.

"The Community of Smalltalk" by Adele Goldberg,
in Handbook of Programming Languages, Vol. 1.
Object-Oriented Programming Languages,
Peter H Salus, Ed.
McMillan, ISBN 1-57870-008-6.

What makes Smalltalk so interesting?

Smalltalk is a mature programming system that has been the testing and proving ground for much of the technology in today's programming environments. Just to consider a few reaaons...

Smalltalk runs on a virtual machine, an abstract computer that can be implemented on different processors to provide a binary-portable execution environment. Virtual machine technology can be traced back to Peter Landin's SECD machine for LISP, designed in the early sixties. In 1983 the Xerox PARC Smalltalk group applied just-in-time (JIT) compilation technology to implement the Smalltalk virtual machine efficiently on commodity hardware, namely the Motorola 68020. This provided the first high-performance implementation of a late-bound implicitly-typed incrementally-compiled system. More recently, Java has popularized this implementation scheme.

In their desire to provide an interactive graphical environment the PARC Smalltalk group invented overlapping windows and pop-up menus, within the Smalltalk environment. Steve Jobs saw the Smalltalk environment at PARC in the eighties, took the ideas back to Apple and incorporated them in the Lisa and the Mac. The windowing environment pioneered in Smalltalk is now the common UI environment on most desktop computers.

Smalltalk performs automatic memory management (known as garbage collection), to relieve the programmer of the error-prone task of reclaiming unused storage. Generation scavenging, the first truly high-performance garbage collection algorithm, was pioneered in Berkeley Smalltalk, and soon incorporated in the 2nd generation ParcPlace virtual machine, HPS. HPS is the engine underneath VisualWorks Non-Commercial. It runs on at least 8 major instruction set architectures (Intel x86, PowerPC/RS6000, SPARC, HPPA, Alpha, MIPS, Motorola 68k and ARM), and runs on the Windows, MacOS and Unix with X11 operating/window systems.

Smalltalk introduced the notion of a reflective programming language, whereby the objects that define the language are themselves built with the language. Hence in Smalltalk, code entities such as classes and methods are themselves programmable and extensible objects, just like any other Smalltalk object. Smalltalk even represents processes and method activations as objects. The use of Smalltalk objects to define the Smalltalk system itself allows the programmer to extend the language and environment in a way that is unparalleled in conventional programming environments.

What are Smalltalk's strengths?

There are many, including:

Smalltalk has been providing high-performance, write-once-run-anywhere execution technology since the early eighties.
Smalltalk is the context in which eXtreme Programming was developed and is still by far the most productive XP environment.
Smalltalk is a dynamic implicitly-typed language where objects, not variables, carry type information, freeing the programmer from declaring variable types, but still providing complete type-safety.
Smalltalk has block closures, anonymous function closures which are more general and much more concise than Java's inner classes, and help make Smalltalk's Collection hierarchy the most powerful set of container classes available.
Smalltalk has always provided an integrated programming environment freeing programmers from the tyranny of the compile-link-debug-edit cycle, allowing them to concentrate on developing great programs.
Smalltalk excels at building large systems that evolve over time. The original Smalltalk implementations were hosted on a bare machine and consequently were the operating system. The combination of a polymorphic, pure object-oriented language which is simple yet powerful with strong encapsulation, an incremental programming environment, a large robust class library and garbage collection make Smalltalk an excellent vehicle for building complex systems that must adapt to a changing world.

Is Smalltalk available from other vendors (other than Cincom)?

Yes. There are a number of commercial Smalltalk vendors, and a vendor-neutral industry council. The Smalltalk Industry Council (STIC) is an umbrella organization for commercial Smalltalk interests.

There are also a number of free versions of Smalltalk:

Visual Works -- a full blown development environment with a graphical user interface builder. Get a non-commerical version for free.
Squeak -- another direct descendant from the original PARC Smalltalk-80. It is being developed by a group that comprised a number of the original researchers from PARC, including Dan Ingalls, the principal language designer of Smalltalk. Squeak has a very active user group and is the context for much innovative work in Smalltalk, user interfaces, and music. To learn more, visit the following sites:
http://www.squeak.org
http://www.create.ucsb.edu/squeak
LearningWorks -- an environment for learning Smalltalk programming built using VisualWorks. LearningWorks takes new users from programming in the small to programming in the large, with a focus on building systems. LearningWorks is being used by the Open University in the U.K., with about 5,200 students using it to learn programming. For more information, see:
http://learningworks.neometron.com
ObjectStudio -- another Smalltalk environment from Cincom Systems, Inc. It features an excellent native Windows and OS/2 GUI and strong database integration. It is included on the Cincom Smalltalk CD. For more information, see:
http://www.cincom.com/objectstudio
SmalltalkExpress -- a version of Digitalk's Smalltalk/V, available for Windows 3.1 and Windows 95. It is available from:
http://scgwiki.iam.unibe.ch:8080/SmalltalkWiki/61
Smalltalk/X -- a commercial Unix-based implementation from Germany that generates C code. A non-commercial version is available from:
http://www.exept.de/sites/exept/english/Smalltalk/frame_uebersicht.html.
Dolphin Smalltalk -- a 32-bit Smalltalk implementation for Windows 95 and NT available for free from Object Arts. See:
http://www.object-arts.com/home.htm
Pocket Smalltalk -- an implementation of the popular programming language Smalltalk for the PalmPilot. To find out more, visit:
http://www.pocketsmalltalk.com
Self (Son of Smalltalk) -- Smalltalk is by no means the end of the story in language design. Self is even simpler and more powerful than Smalltalk. It was designed in the early eighties and, because of its simplicity required novel implementation technologies to achieve good performance. Self has spawned much of the work on high-performance implementation of dynamic object-oriented languages like Smalltalk, Self and Cecil done in the eighties and nineties. Self, including the source for its high-performance virtual machine, is available for Solaris. For details, see:
http://research.sun.com/research/self/.

Enjoy!