author={David M. Ungar and Randall B. Smith},
  journal={Proceedings of the third ACM SIGPLAN conference on History of programming languages},
  • D. UngarRandall B. Smith
  • Published 9 June 2007
  • Computer Science
  • Proceedings of the third ACM SIGPLAN conference on History of programming languages
The years 1985 through 1995 saw the birth and development of the language Self, starting from its design by the authors at Xerox PARC, through first implementations by Ungar and his graduate students at Stanford University, and then with a larger team formed when the authors joined Sun Microsystems Laboratories in 1991. Self was designed to help programmers become more productive and creative by giving them a simple, pure, and powerful language, an implementation that combined ease of use with… 

Evolving User Interfaces From Within Self-supporting Programming Environments: Exploring the Project Concept of Squeak/Smalltalk to Bootstrap UIs

This paper describes plain Squeak without its user interface, considering object collaboration, code execution, and extension points in the virtual machine, and believes that self-supporting programming environments can benefit from multiple user interfaces to accommodate a variety of tasks.

The VIVIDE programming environment: connecting run-time information with programmers' system knowledge

This work proposes a new concept for programming environments, which allow programmers to work in a task-oriented way: Run-time information is collected automatically using tests; information is displayed consistently in self-contained editors arranged on a horizontal boundless tape.

Virtual Smalltalk Images: Model and Applications

Oz is presented, a virtual image solution that solves the edge cases of reflective architectures by adding a third participant, and thus, removing the selfmodification and self-observation constraints.

Eliminating distinctions of class: using prototypes to model virtual classes

It is proved that prototypes are type-safe but undecidable, and briefly outline a decidable semi-algorithm for dealing with them, which blur the distinction between compile-time and run-time.

A programming environment supporting a prototype-based introduction to OOP

This paper describes the features that a programming environment should have in order to help learning the object-oriented programming (OOP) paradigm and let students get the skills needed to build

Interleaving of Modification and Use in Data-driven Tool Development

A data-driven perspective on graphical tools is proposed that uses concise scripts as glue between data and views but also as means to express missing data transformations and view items and can inspire the creation of new trade-offs in modularity for both data-providing projects and interactive views.

Lively groups: shared behavior in a world of objects without classes or prototypes

This paper proposes Lively Groups, an extension to the object-centric development tools of Lively to work on multiple concrete objects, which scales the Lively Kernel’s explorative development approach from one to many objects, while preserving the maintainability of abstractions and the immediacy of concrete objects.

Data-driven tool construction in exploratory programming environments

An object-oriented, data-driven, declarative scripting language that reduces the amount of and governs the effects of glue code for view-model specifications, and a scalable UI-design language that promotes short feedback loops in an interactive, graphical environment such as Morphic known from Self or Squeak/Smalltalk systems are proposed.

Poker: visual instrumentation of reactive programs with programmable probes

The paper uses an application written in Stella to motivate the concepts provided by Poker, a visual instrumentation platform for reactive programs that features a canvas of so-called probes that can be dynamically wired into a running reactive program in order to instrument the running system.

An Implementation of a Knowledge-based Programming Language with Dynamic Grammar

An overview of the programming language “One”, designed to be an umbrella language that can be used to write computer programs in a more natural way and have them translated into code for any software development platform using appropriate knowledgebase, and its implementation.



Experiencing SELF Objects: An Object-Based Artificial Reality*

The goal is to make the user interface invisible, and thus make SELF objects and the SELF world real.

Programming as an Experience: The Inspiration for Self

The Self system attempts to integrate intellectual and nonintellectual aspects of programming to create an overall experience, and the language, interface, and implementation conspire so that die Self programmer lives and acts in a consistent and malleable world of objects.

The early history of Smalltalk

  • A. Kay
  • Computer Science
  • 1993
Smalltalk was the first complete realization of these new points of view as parented by its many predecessors in hardware, language and user interface design and became the exemplar of the new computing.

SELF: The power of simplicity

Because SELF does not distinguish state from behavior, it narrows the gaps between ordinary objects, procedures, and closures, and offers new insights into object-oriented computation.

Towards a Universal Implementation Substrate for Object-Oriented Languages

A Self-like system may form the basis of a universal substrate for implementation of object-oriented languages, and implementations of Smalltalk and Java by translation to Self were much easier to construct than by conventional means, and perform surprisingly well.

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.

An efficient implementation of SELF, a dynamically-typed object-oriented language based on prototypes

This work has developed and implemented techniques that double the performance of dynamically-typed object-oriented languages and dynamically compiles multiple versions of a source method, eachcustomized according to its receiver's map.

The Self-4.0 user interface: manifesting a system-wide vision of concreteness, uniformity, and flexibility

The semantics of the language, the efficiency and fidelity of its implementation, and the architecture of its user interface conspire to make the experience of constructing programs in Self immediate and tangible.

The design and implementation of the self compiler, an optimizing compiler for object-oriented programming languages

By applying a collection of implementation techniques that can improve the run-time performance of object-oriented languages, the performance of the SELF system is five times better than the fastest Smalltalk-80 system, better than that of an optimizing Scheme implementation, and close to half that of a optimizing C implementation.

Constructing a metacircular Virtual machine in an exploratory programming environment

This work is concurrently constructing two artifacts--a Self VM entirely in Self (the Klein VM), and a specialized development environment--with strict adherence to pure object-orientation, metacircularity, heavy code reuse, reactivity, and mirror-based reflection.