Back to the future: the story of Squeak, a practical Smalltalk written in itself

@inproceedings{Ingalls1997BackTT,
  title={Back to the future: the story of Squeak, a practical Smalltalk written in itself},
  author={Daniel H. H. Ingalls and Ted Kaehler and John H. Maloney and Scott Wallace and Alan C. Kay},
  booktitle={Conference on Object-Oriented Programming Systems, Languages, and Applications},
  year={1997}
}
Squeak is an open, highly-portable Smalltalk implementation whose virtual machine is written entirely in Smalltalk, making it easy to. debug, analyze, and change. To achieve practical performance, a translator produces an equivalent C program whose performance is comparable to commercial Smalltalks.Other noteworthy aspects of Squeak include: a compact object format that typically requires only a single word of overhead per object; a simple yet efficient incremental garbage collector for 32-bit… 

Tables from this paper

Smalltalk: Overview and Implementation Issues

In respect to points 1-3, Smalltalk is similar to recently developed object-oriented languages such as Java or C#. However, it includes a GUI which contains a development environment and debugging

The Cog Smalltalk Virtual Machine writing a JIT in a high-level dynamic language

Cog adds a just-in-time compiler for x86 to the existing interpreter, which allows full simulation of generated machine code, and its plumbing of an x86 simulator into its framework is probably of some interest to the VMIL community.

SqueakJS: a modern and practical smalltalk that runs in any browser

The experience in implementing SqueakJS, a bit-compatible implementation of SqueAK/Smalltalk written in pure JavaScript, is reported, notable for simplicity and performance gained through adaptation to the host object memory and deployment leverage gained through the Lively Web development environment.

Design and implementation of Bee Smalltalk Runtime

Bee is a Smalltalk dialect that includes a minimal kernel with on-demand loaded libraries, a JIT compiler, an FFI interface, an optimizing SSA-based compiler, a garbage collector, and native threading support among other things.

Transactional memory for smalltalk

This paper shows how transactional semantics in Smalltalk is introduced by using the reflective facilities of the language, based on method annotations, incremental parse tree transformations and an optimistic commit protocol.

Unix, Plan 9 and the Lurking Smalltalk

The ambitions and trajectories of Smalltalk are contrasted with those of Unix and its descendents, exploring why Dan Ingalls’s vision appears not (yet) to have materialised, and how these two directions of change may yet be convergent within future Unix-derived systems.

How to Build a High-Performance VM for Squeak/Smalltalk in Your Spare Time: An Experience Report of Using the RPython Toolchain

The benefits and drawbacks of RSqueak/VM are discussed as a research vehicle for developing and evaluating Smalltalk language extensions without having to learn the deep secrets of VM development.

Back to the Future in One Week - Implementing a Smalltalk VM in PyPy

The current Spy codebase is able to run a small set of benchmarks that demonstrate performance superior to many similar Smalltalk VMs, but which still run slower than in Squeak itself.

Context Management in VisualWorks 5i

This work presents a new design for contexts and closures that significantly reduces the overall overhead of these features and imposes overhead only in code that actually manipulates execution state in the form of contexts.

The evolution of Smalltalk: from Smalltalk-72 through Squeak

  • D. Ingalls
  • Computer Science
    Proc. ACM Program. Lang.
  • 2020
The forces that brought each generation of Smalltalk into existence are described, the technical innovations that characterized it, and the growth in understanding of object-orientation and personal computing that emerged.
...

References

SHOWING 1-10 OF 27 REFERENCES

Efficient implementation of the smalltalk-80 system

The most significant optimization techniques developed over the course of the Smalltalk-80 programming system are discussed, many of which are applicable to other languages.

QUICKTALK: a Smalltalk-80 dialect for defining primitive methods

QUICKTALK achieves improved performance over bytecodes by eliminating the interpreter loop on bytecode execution, by reducing the number of message send/returns via binding some target methods at compilation, and by eliminating redundant class checking.

BrouHaHa- A portable Smalltalk interpreter

This paper presents the major design changes and optimization techniques used in the BrouHaHa interpreter, a portable implementation of the Smalltalk-80 virtual machine interpreter.

BrouHaHa - A Portable Smalltalk Interpreter

This paper presents the major design changes and optimization techniques used in the BrouHaHa interpreter, a portable implementation of the Smalltalk-80 virtual machine interpreter.

Babel - A Translator from Smalltalk into CLOS

Babel, a prototype translator and associated tools for developing stand-alone applications by translating Smalltalk into portable CLOS (Common Lisp Object System) and the performance of the translated code are assessed.

Smalltalk-80: The Language and Its Implementation

This book is the first detailed account of the Smalltalk-80 system and is divided into four major parts: an overview of the concepts and syntax of the programming language, a specification of the system's functionality, and an example of the design and implementation of a moderate-size application.

SPiCE: a system for translating Smalltalk programs into a C environment

  • Kazuki YasumatsuN. Doi
  • Computer Science
    Proceedings of 1994 IEEE International Conference on Computer Languages (ICCL'94)
  • 1994
SPiCE (Smalltalk-Programs-into-C Environment) is implemented, which is a system for translating Smalltalk into C, and its approach is to create the runtime replacement classes which implement the same functionality of the Smalltalk classes that are inherently part of the smalltalk execution model.

Hurricane: an optimizing compiler for Smalltalk

A recent attempt at providing a more efficient compilation system for the Smalltalk-80#8482; language than currently exists is discussed, and a type declaration and inference mechanism is developed in order to make the problem tractable.

TS: an optimizing compiler for smalltalk

TS (Typed Smalltalk) is a portable optimizing compiler that produces native machine code for a typed variant of Smalltalk, making Smalltalk programs much faster. This paper describes the structure of

Virtual memory on a narrow machine for an object-oriented language

The paper explains why the unusual design choices in LOOM were made, and provides an interesting example of the process of designing an integrated virtual memory and storage management system.