Self Handbook Documentation Release for Self 2017.1 Russell Allen (Ed.) May 05, 2017 CONTENTS 1 Introduction 3 1.1 History..................................................3 1.2 System Overview.............................................3 2 Getting Started 5 2.1 Downloading Prebuilt VM and snapshot.................................5 2.2 Running on OS X............................................5 2.3 Running on Linux............................................5 2.4 Building your own system........................................5 3 Language Reference 7 3.1 Objects..................................................7 3.2 Slot descriptors.............................................. 11 3.3 Expressions................................................ 16 3.4 Lexical elements............................................. 22 4 The Self World 27 4.1 World Organization........................................... 27 4.2 The Roots of Behavior.......................................... 28 4.3 Blocks, Booleans, and Control Structures................................ 29 4.4 Numbers and Time............................................ 31 4.5 Collections................................................ 32 4.6 Pairs................................................... 35 4.7 Mirrors.................................................. 36 4.8 Messages................................................. 36 4.9 Processes and the Prompt........................................ 37 4.10 Foreign Objects............................................. 37 4.11 I/O and Unix............................................... 38 4.12 Other Objects............................................... 39 4.13 How to build the world.......................................... 39 4.14 How to use the low-level interrupt facilities............................... 41 4.15 Using the textual debugger........................................ 42 4.16 Logging.................................................. 42 5 A Guide to Programming Style 45 5.1 Behaviorism versus Reflection...................................... 45 5.2 Objects Have Many Roles........................................ 46 5.3 Naming and Printing........................................... 47 5.4 How to Return Multiple Values..................................... 48 5.5 Substituting Values for Blocks...................................... 49 i 5.6 nil Considered Naughty........................................ 49 5.7 Hash and =................................................ 49 5.8 Equality, Identity, and Indistinguishability................................ 50 6 How to Program in Self 51 6.1 Introduction............................................... 51 6.2 Browsing Concepts............................................ 51 6.3 Hacking Objects............................................. 68 6.4 The Transporter............................................. 71 7 Morphic: The Self User Interface Framework 77 7.1 Overview................................................. 77 7.2 Composite Morphs............................................ 78 7.3 Morph Traits and Prototypes....................................... 79 7.4 Saving a Composite Morph....................................... 90 7.5 Handling User Input........................................... 90 7.6 Drag and Drop.............................................. 92 7.7 Automatic Layout............................................ 92 7.8 Animation................................................ 94 7.9 Other Issues............................................... 96 7.10 Morph Responsibilities.......................................... 99 7.11 Some Useful Morphs........................................... 99 7.12 The Graphical Environment....................................... 100 8 Virtual Machine Reference 103 8.1 Building a VM.............................................. 103 8.2 Startup options.............................................. 104 8.3 System-triggered messages....................................... 104 8.4 Run-time message lookup errors..................................... 104 8.5 Low-level error messages........................................ 106 8.6 An example................................................ 106 8.7 Lookup errors.............................................. 107 8.8 Programmer defined errors........................................ 107 8.9 Primitive errors.............................................. 107 8.10 Nonrecoverable process errors...................................... 108 8.11 Fatal errors................................................ 108 8.12 The initial Self world........................................... 109 8.13 Option Primitives............................................. 113 8.14 Interfacing with other languages..................................... 114 9 References 131 10 Appendices 133 10.1 Glossary................................................. 133 10.2 Lexical overview............................................. 135 10.3 Syntax overview............................................. 136 10.4 Built-in types............................................... 136 10.5 Useful Selectors............................................. 136 10.6 Every Menu Item in the Programming Environment.......................... 144 10.7 The system monitor........................................... 146 10.8 Primitives................................................. 149 11 Extras 151 11.1 The Original Self UI........................................... 151 ii Self Handbook Documentation, Release for Self 2017.1 Release for Self 2017.1 Date May 05, 2017 Edited by Russell Allen. Authors (in alphabetical order): Ole Agesen, Lars Bak, Craig Chambers, Bay-Wei Chang, Urs Hölzle, John Maloney, Tobias Pape, Randall B. Smith, David Ungar and Mario Wolczko. Thanks to Ganesh R for his transcription services. CONTENTS 1 Self Handbook Documentation, Release for Self 2017.1 2 CONTENTS CHAPTER ONE INTRODUCTION Self is a prototype-based dynamic object-oriented programming language, environment, and virtual machine centered around the principles of simplicity, uniformity, concreteness, and liveness. Self includes a programming language, a collection of objects defined in the Self language, and a programming environment built in Self for writing Self programs. The language and environment attempt to present objects to the programmer and user in as direct and physical a way as possible. The system uses the prototype-based style of object construction. Self is available for Solaris, Linux and natively on MacOS X under a BSD-like licence; we would be very interested in anyone prepared to make a Windows port. 1.1 History The first version of the Self language was designed in 1986 by David Ungar and Randall B. Smith at Xerox PARC. A series of Self implementations and a graphical programming environment were built at Stanford University by Craig Chambers, Urs Hölzle, Ole Agesen, Elgin Lee, Bay-Wei Chang, and David Ungar. The project continued at Sun MIcrosystems Laboratories, where it benefited from the efforts of Randall B. Smith, Mario Wolczko, John Maloney, and Lars Bak. Smith and Ungar jointly led it there. Work on the project officially ceased in 1995 Release 4.0 contained an entirely new user interface and programming environment designed for “serious” program- ming, enabling the programmer to create and modify objects entirely within the environment, and then save the object into files for distribution purposes. The metaphor used to present an object to the user is that of an outliner, allowing the user to view varying levels of detail. Also included in the environment is a graphical debugger, and tools for navigation through the system. Release 4.4 was the first release for Linux x86. 1.2 System Overview This section contains an overview of the system and its implementation; it can be skipped if you wish to get started as quickly as possible. Although Self runs as a single UNIX1 process, or a single Macintosh application, it really has two parts: the virtual machine (VM) and the Self world, the collection of Self objects that are the Self prototypes and programs: The VM executes Self programs specified by objects in the Self world and provides a set of primitives (which are methods written in C++) that can be invoked by Self methods to carry out basic operations like integer arithmetic, object copying, and I/O. The Self world distributed with the VM is a collection of Self objects implementing various 1 UNIX is a trademark of AT&T Bell Laboratories. 3 Self Handbook Documentation, Release for Self 2017.1 Fig. 1.1: The Self system traits and prototypes like cloning traits and dictionaries. These objects can be used (or changed) to implement your own programs. Fig. 1.2: How Self programs are compiled. Self programs are translated to machine code in a two-stage process (see Fig. 1.2). Code typed in at the prompt, through the user interface, or read in from a file is parsed into Self objects. Some of these objects are data objects; others are methods. Methods have their own behavior which they represent with bytecodes. The bytecodes are the instructions for a very simple virtual processor that understands instructions like “push receiver” or “send the ‘x’ message.” In fact, Self bytecodes correspond much more closely to source code than, say, Smalltalk-80 bytecodes. (See [CUL89] for a list of the Self byte codes.) The raison d’être of the virtual machine is to pretend that these bytecodes are directly executed by the computer; the programmer can explore the Self world down to the bytecode level,