SELF: The power of simplicity

  title={SELF: The power of simplicity},
  author={David M. Ungar and Randall B. Smith},
  journal={LISP and Symbolic Computation},
SELF is an object-oriented language for exploratory programming based on a small number of simple and concrete ideas: prototypes, slots, and behavior. Prototypes combine inheritance and instantiation to provide a framework that is simpler and more flexible than most object-oriented languages. Slots unite variables and procedures into a single construct. This permits the inheritance hierarchy to take over the function of lexical scoping in conventional languages. Finally, because SELF does not… 

Object Inheritance Without Classes

This paper revisits the relationship between classes and objects and model various kinds of inheritance in the context of an object-oriented language whose objects are not defined by classes, and explains why class inheritance and initialisation cannot be easily modelled purely by delegation.

The Object-Oriented Paradigm

This chapter attempts to present the linguistic aspects which concern objects and their use, starting with a presentation of objects as a way to gain data abstraction in a way that is both flexible and extensible.

Prototalk: an Environment for Teaching, Understanding, Designing and Prototyping Object-Oriented Languages

Prototalk is a framework that provides a predefined set of language data structures and mechanisms that can be composed and extended to generate various prototype-based language interpreters and presents a classification of languages based on dierent mechanisms in an operational manner.

Prototype-based languages (panel): object lessons from class-free programming

An alternative to the class-based object-orient language model has emerged in recent years. In this protoype-based paradigm there are no classes in the traditional sense. In object-oriented

Parents are shared parts of objects: Inheritance and encapsulation in SELF

In SELF, a private slot may be accessed if the sending method is a shared part of the receiver, allowing privileged communication between related objects, and the classless SELF enjoys the benefits of class-based encapsulation.

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.

CLOS: integrating object-oriented and functional programming

This article explores the landscape in which the major object-oriented facilities exist, showing how the CLOS solution is effective within the two contexts.

Interaction-oriented programming

This dissertation describes the design and implementation of a general-purpose object-oriented (OO) programming language, Classages, which gives programmers refined control over modeling the interactions inside OO software, with inspirations drawn from human sociology.

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.

TAO: An Object-Orientation Kernel

An object-oriented programming language framework that deliberately separates mechanism from policy is proposed, and examples illustrating how conventional concepts of object- oriented programming can be implemented on top of these primitives are given.



Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems

Because any object can be used as a prototype, and any messages can be forwarded at any time, delegation is the more flexible and general of the two techniques.

Using prototypical objects to implement shared behavior in object-oriented systems

Because any object can be used as a prototype, and any messages can be forwarded at any time, delegation is the more flexible and general of the two techniques.

Lambda: The Ultimate Imperative

We demonstrate how to model the following common programming constructs in terms of an applicative order language similar to LISP: Simple Recursion, Iteration, Compound Statements and Expressions, GO

An exemplar based Smalltalk

It is shown that exemplar based systems are more powerful than class based systems and the notion of multiple representations to be provided without the need to introduce specialized classes for each representation.

Deltatalk: An Empirically and Aesthetically Motivated Simplification of the Smalltalk-80 Language

This paper presents the results of a series of empirical studies on learnability, and also some informal studies of large implementation projects, and suggests a number of changes to the Smalltalk-80 language and system.

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.

The Programming Language Aspects of ThingLab, a Constraint-Oriented Simulation Laboratory

The programming language aspects of a graphic simulation laboratory named ThingLab, which is an object-oriented system that employs inheritance and part-whole hierarchies to describe the structure of a simulation, are presented.

STROBE: Support for Structured Object Knowledge Representation

STROBE is a system that provides object-oriented programming support tools for INTERLISP that implements multiple resident knowledge bases, tangled generalization hierarchies, flexible inheritance of properties, procedural attachment, and event-sensitive procedure invocation.

An introduction to Trellis/Owl

This paper provides a brief introduction to the Trellis/Owl language and discusses the basic elements of the language, objects, and shows how these are specified and implemented using types, operations, and components.

Oaklisp: an object-oriented scheme with first class types

Oaklisp shows that a message based language can derive similar benefits from having first class types and Scheme demonstrated that lisp could be made simpler and more expressive by elevating functions to the level of first class objects.