Self: The Power of Simplicity David Ungar and Randall B. Smith
David Ungar Randall B. Smith CIS, Room 209 Xerox Palo Alto ResearchCenter Stanford University 3333 Coyote Hill Rd. Stanford, CA 94305 Palo Alto, CA 94304 (415) 725-3713 (415) 494-4947 [email protected] [email protected]
To thine own self be true. supportexploratory programming Me831, and there- -William Shakespeare fore includes runtime typing (i.e. no type declarations) and automatic storage reclamation. But Abstract unlike Smalltalk, Self includes neither classes nor variables. Instead, Self has adopted a prototype Self is a new object-oriented language for explor- metaphor for object creation EBor79, Bor81 Bor86, atory programming based on a small number of Lie86, LTP86]. Furthermore, while Smalltalk and simple and concrete ideas: prototypes, slots, and most other object-oriented languages support vari- behavior. Prototypes combine inheritance and instan- able access as well as message passing, Self objects tiation to provide a framework that is simpler and access their state information by sending messagesto more flexible than most object-oriented languages. L‘self,” the receiver of the current message. Slots unite variables and procedures into a single con- Naturally this results in many messages sent to struct. This permits the inheritance hierarchy to take “SeIf,” and the language is named in honor of these over the function of lexical scoping in conventional messages. One of strengths of object-oriented pro- languages. Finally, because Self does not distinguish gramming lies in the uniform access to different state from behavior, it narrows the gaps between kinds of stored and computed data, and the ideas in ordinary objects, procedures, and closures. Self”s Self result in even more uniformity, which results in simplicity and expressivenessoffer new insights into greater expressivepower. We believe that these object-oriented computation. ideas offer a new and useful view of object-oriented computation. Introduction Object-oriented programming languages are gaining Severalprincipals have guided the design of Self: acceptance,partly because they offer a useful perspec- tive for designing computer programs. However, Messages-at-the-bottom. Self features message they do not all offer exactly the same perspective; passing as the fundamental operation, providing there are many different ideas about the nature of access to stored state solely via messages. There are object-oriented computation. In this paper we pre- no variables, merely slots containing objects that sent Self, a programming language with a new return themselves. Since Self objects access state perspective on objects and messagepassing. Like the solely by sending messages,message passing is more Smalltalk-80* language [GoR83], Self is designed to fundamental to Self than to languageswith variables. *Smalltalk-gO is a trademark of ParcPlaceSystems. In this paper, the term “Smalltalk” will be used to refer to the Occam’s razor. Throughout the design, we have SmaUtalk-gO programming language. aimed for conceptual economy:
Permission to copy without fee all or part of this material is granted provided . As described above, Self’s design omits that the copies are not made or distributed for direct commerical advantage, classes and variables. Any object can per- the ACM copyright notice and the title of the publication and its date appear, form the role of an instance or serve as a and notice is given that copying is by permission of the Association for repository of sharedinformation. Computing Machinery. To copy otherwise, or to republish, requires a fee and/ or specific permission. l There is no distinction between accessing a 0 1987 ACM 0-89791-247-O/87/0010-0227 $1.50 variable and sendinga message.
October443,1987 OOPStA ‘87 Proceedings 227 class-based systems Self: no classes
inheritance relationships instance of inherits from I I subclass of I 1 creation metaphor 1 build according to plan 1 clone an object initialization executing a “plan” cloning an example on-f-a-kind need extra object for class no extra object needed infinite regress class of class of class of . . . none required
As in Smalhalk, the language kernel has no which may store either state or behavior. If an control structures. Instead, closures and object receives a messageand it has no matching slot, polymorphism support arbitrary control the search continues via its parent pointer. This is structures within the language. how Self implements inheritance. Inheritance in Self allows objects to share behavior, which in turn Unlike Smalltalk, Self objects, procedures, allows the programmer to alter the behavior of many and closures are all woven from the same objects with a single change. For instance as shown yarn by representing procedures and closures in Figure 1, a point* object would have slots for its as prototypes of activation records. This non-shared characteristics: x and y. Its parent would technique allows activation records to be be an object that held the behavior shared among all created the same way as other objects, by points: +, -, etc. cloning prototypes. In addition to sharing the same model of creation, procedures and closures also store their variables and main- Comparing Prototypes and Classes tain their environment information the same way as ordinary objects, as describedbelow. One of .Sers most interesting aspects is the way it combines inheritance, prototypes, and object creation, Concreteness. Our tastes have led us to a metaphor eliminating the need for classes. whose elements are as concrete as possible [Smi87]. So, in the matter of classes versus prototypes, we Simpler relationships. Prototypes can simplify the have chosen to try prototypes. This makes a basic dif- relationships between objects. To visualiz.e the way ference in the way that new objects are created. In a objects behave in a class-based language, one must class-based language an object would be created by grasp two relationships: the “is a” relationship, that instuntiuting a plan in its class. In a prototypebased indicates that an object is an instance of some class, language like Self, an object would be created by and the “kind of * relationship, that indicates that an cloning (copying) a prototype. In Self, any object object’s class is a subclass of some other object’s can be cloned. class. In a system with prototypes instead of classes such as Self, there is only one relationship, “inherits The remainder of the paper describes Self in more from”, that describes how objects share behavior and detail, and concludes with an example. We use State. This structural simplification makes it easier Smalltalk as our yardstick, as it is the most widely to understand the language and easier to formulate an known language in which everything is an object. inheritance hierarchy. Familiarity with Smalltalk will therefore be helpful to the reader. A working system will provide-the chance to discov- er whether class-like objects would be so useful that Prototypes: Blending Classesand programmers will create them without encourage- Instances ment from the language. The absence of the class-instance distinction may make it too hard to understand which objects exist solely to provide In Smalltalk, unlike C++, Simula, Loops, or ADA, shared information for other objects. Perhaps Self everything is an object and every object contains a pointer to its class, an object that describes its format and holds its behavior. (See Figure 1.) In * Throughout this paper we appeal to point objects in exam- ples. A Smalltalk pint represents a point in Self too, everything is an object. But, instead of a two-dimensional Cartesian coordinates. It contains two class pointer, a Self object contains named slots instance variables, an x anda y coordinate.
228 OOPSLA ‘87 Proceedings October 4-8,1987 Smalltalk instances and classes Self objects
print how to 1print 1 prir?!b;&ts ( * print objects A (class)
(name) Object (superclass) nil
(inst vars) I (methods) parent I x: t (class) ... Y: t (name) Point + (superclass) kFTJ I (inst vars) Iclass,x, Y 1 I i (methods) L-A-J
(class) parent parent \ w 3 X 3 X 7 (Y)j 5 Y 5 Y 9
Each Smalltalk point contains a class pointer, x Each Self point intrinsically describes its own for- and y coordinates. The class Point supplies both mat, but appeals to another object for any behavior format and behavior information for points. Addi- that is shared among points. In this example, the tional format and behavior information is points appeal to an object containing shared behavior inherited from Object via Point’s superclass link. for points. That object in turn appeals to another Each of the two classes in turn must appeal to (on top) for behavior that is shared by all objects. other classes (not shown) for their format and The “root” object fully describes its own format behavior. and behavior, so it has no parent.
L A Figure 1. A comparison of Smalltalk instances and classes with Self objects: At the bottom of each figure are two point objects that have been createdby a user program.
Odober 4-8,1937 OOPSIA ‘87 Proceedings 229 programmers will create entirely new organizational between computers and the real word, the ability to structures. In any case, Self’s flexibility poses a chal- make sweeping changes by changing shared behavior. lenge to the programming environment; it will have Once inheritance is introduced into the language, the to include navigational and descriptive aids. natural tendency is to make the prototype the same object that contains the behavior for that kind of Creation by copying. Creating new objects from object. For instance, the behavior of all points could prototypes is accomplished by a simple operation, be changed by changing the behavior of the prototypi- with a simple biological metaphor, copying, cal point. Unfortunately, such a system must supply cloning. Creating new objects from classes is accom- plished by instantiation, which includes the two ways to create objects: one to make an object that is the offspring of a prototype, and another to interpretation of format information in a class. (See cop,y an object that is not a prototype. The ultimate Figure 2.) Instantiation is similar to building a result is that prototypes would become special and house from a plan. Copying appeals to us as a sim- not prototypical at all. Self avoids these pitfalls by pler metaphor than instantiation. combining prototypes and inheritance. Examples of preexisting modules. Prototypes are Our solution is to put the shared behavior for a fami- more concrete than classes because they are exumples ly of objects in a separate object that is the parent of of objects rather than descriptions of format and ini- all of them, even the prototype. That way the proto- tialization. These examples may help users to reuse type is absolutely identical to every other member of modules by making them easier to understand. A the family. The object containing the shared behavior prototype-based systems allows the user to examine plays a role akin to a class, except that it contains no a typical representative rather than requiring him to formatting information; it merely holds some shared make senseout of its description. behavior. So to add some behavior to all points in Support for one-of-a-kind objects. Self provides Self, one would add that behavior to the parent of a framework that can easily include oneof-a-kind the Points. objects with their own behavior. Since each object has named slots, and slots can hold state or behavior, Blending state and behavior any object can have unique slots or behavior. (See Figure 3.) Class-based systems are designed for situa- In Self, there is no direct way to access a variable; tions where there are many objects with the same instead objects send messagesto access data residing behavior. There is no linguistic support for an object in named slots. So, to access its “x” value, a point to possess its own unique behavior, and it is awk- sends itself the “x” message. The messagefinds the ward to create a class that is guaranteed to have only “ X ” slot, and evaluates the object found therein. one instance. Self suffers from neither of these disad- Since the slot contains a number, the result of the vantages. Any object can be customized with its evaluation is just the number itself. In order to own behavior. A unique object can hold the unique change contents of the “x” slot to, say 17, instead of behavior, and a separate“instance” is not need& performing an assignment like “x+17,” the point Elimination of me®ress. No object in a must send itself the “x:” message with 17 as the class-based system can be self sufficienS another argument. The point object (or one of its ancestors) object (its class) is needed to express its structure must contain a slot named “x:” containing the assign- and behavior. This leads to a conceptually infinite ment primitive. Of course, all these messagessent to meta-regress: a point is an instance of class Point, “self” would make for verbose programs, so our syn- which is an instance of metaclass Point, which is an tax allows the “self? ’ to be elided. The result is instance of metametaclass Point, ad infinitum. On that accessing state via messagesin Self becomes as the other hand, in prototype-based systems an object easy to write as accessing variables directly in can include its own behavior; no other object is Smalltalk; “x” accessesthe slot by the same name, needed to breathe life into it. Prototypes eliminate and “x: 17” stores seventeenin the slot. meta regress. Accessing state via messagesmakes inheritance more The discussion of prototypes in this paper naturally powerful. Suppose we wish to create a new kind of applies to them as realized in Self. Prototype-based point, whose x coordinate is a random number instead systems without inheritance would have a problem: of a stored value. We copy the standard point, each object would include all of its own behav- remove the x: slot (so that x cannot be changed) and ior-just like the real world-and these systems replace the contents of the x slot with the code to would surrender one of the most pleasant differences generate a random number. (See Figure 4.) If instead
230 OOPSLA ‘87 Proceedings October 48,1987 Creating a Smalltalk Object Creating a Self Object
(class) (superclass) Fq+.. clone b how to clone objects (inst vars) I
(methods)
I (class) parent I (superclass) El+ x: t (inst vars) Y: t A (methods)
(class)
(name) (superdlass) (inst vars) (methods)
To create a new point in Smalltalk, the new To create a new point in Self, the clone messageis message is sent to the class Point. The new sent to the prototypical point. The clone method method-found in Point’s class’s superclass- copies its receiver. Because the protopoint slot uses information in its receiver (Point) to define residesin the root, any object can create a point. the size and format of the new object.
Figure 2. Object creation in Smalltalk and in Self.
October 4-8,1987 OOPSLA‘87 Proceedings 231 Smalltalk
(class) l l n
(name) Object (superclass) nil (inst vars) (none) (methods) . . . A (class) . . . (class) . . . (name) True (name) False (superclass) - (superclass) (inst vars) (none) (inst vars) (none) (methods) + ifTrue: trueBlock (methods) + ifFalse: falseBlock ifFalse: falseBlock BU trueBlock value falseBlock value (class) (class) - me false
self
true false parent parent ifTrue: iffalse: ifTrue: ifFalse: / I I I I
/
Figure 3. In Self, it is easier to defme unique objects than in a class-based system like SmalItalk. Consider the objects that represent the true and false boolean values. A system needs only one instance of each object, but in Smalltalk, there must be a class for each. In Self, since any object can contain behavior, it is straightforward to create specializedobjects for true and false.
232 OOPSLA ‘87 Proceedings October 441987 Computing a value instead of storing it Shared state
parent 1 nil parent nil I I ! I I print 1 print objects 1 I print print objects \ \ parent I I I parent I I + 1 add points 1 + add points I l
random
generator
Figure 4. Two examples of flexibility in Self. On the left is a point whose x coordinate is computed by a random number generator. Since all the code for point sends messagesto get the x value, the random x point can reuse all existing point code. On the right are two points that share the same x variable.
of modifying the x slot, we had replaced the x: slot variables, whose scopes roughly correspond to rungs with a “halt” method, we would obtain a breakpoint on the ladder of instantiation. on write. Thus, Self can express the idioms associat- ed with active variables and abmons. Accessing CIOSURS state via messagesalso makes it easier to share state. To create two points that share the same x coordi- The Scheme community has obtained excellent nate, the x and x: slots can be put in a separateobject results with closures (or lambda-expressions) as a that is the parents of each of the two points. (Also basis for control structures [Ste76, ASS841. Experi- seeFigure 4 .) ence with Smalltalk blocks supports this; closures In most object-oriented languages, accessing a vari- provide a powerful, yet easy-to-use metaphor for able is a different operation than sending a message. users to exploit and define their own control struc- This dilutes the message passing model of computa- tures. Furthermore this ability is crucial to any tion with assignment and access. As a result, language that supports user-defined abstract data messagepassing becomes less powerful. For instance, types. However, we believe that it is unwise to the inclusion of variables makes it harder for a design a language that makes separate provision for specialization (subclass) to replace a variable with a both objects and closures, because they are so similar computed result, becausethere may be code in a super- (both store’ behavior and state). In Self, objects, class that directly accesses the variable. Also, closures (blocks) and procedures (methods) have been class-based languages typically store the names and brought closer together by using slots and inheri- orders of instance variables in an object’s class (as tance to build closures and procedures: shown in Figure 1). This further limits the power Local variables. Closures and procedures require of inheritance; the specification within a class unnec- storage for local variables, and in Self, their slots essarily restricts an instance’s format. Finally, fulfill this function. In Smalltalk, invoking a variable access requires scoping rules, yet a further method results in the creation of an activation record complication. For instance Smalltalk has five kinds whose initial ‘contents is described by the method. of variables: local variables (temporaries), instance For example, the number of temporary variables variables, class variables, pool variables, and global listed in the method describes the number of fields
October4-8,1987 OOPSLA‘87 Proceedings 233 set aside in the activation record to hold variables. sive objects can be regarding merely as methods that This is similar to the way a class contains a struc- always return themselves. For example, consider the turd description used to instantiate its instances. number 17. In Smalltalk, the number 17 represents a But in Self, objects that play the role of subroutines particular (immutable) state. In Self, the number 17 and closures (methods and blocks) are protorypes of is just an object that returns itself and behaves a activation records; they are copied and invoked to run certain way with respect to arithmetic. The only the subroutine or block. So, local variables are allo- way to know an object is by its actions. cated by reserving slots for them in the prototype activation record. One advantage is that the proto- Computation viewed as refinement. In Smalltalk, type’s slots may be initialized to any value-the may the number 17 is a number with some particular even contain private methodsand closures (blocks). state, and the state information is used by the arith- metic primitives-addition for example. In Self, 17 Environment link. In general, a closure must con- can be viewed as a refinement of shared behavior for tain a link to its enclosing closure or scope. This numbers that responds to addition by returning 17 link is used to resolve references to variables not in more than its argument. Since in Self, an activation the closure itself. In Self, instead of having separate record’s parent gets set to the receiver of the mes- scope information, a closure’s parent link performs sage, method activation can be viewed as the creation this function. If a slot is not found in the current of a short-lived refinement of the receiver. Likewise scope, lookup proceeds to the next outer scope by fol- block, or closure activation can be viewed as the cre- lowing the parent link. ation of a refinement of the activation record for the Some interesting mechanisms are needed to make the enclosing context scope. parent links handle lexical scoping. First, the parent In our examples, we render the shared behavior link must get set to the appropriate object. This is object for points as an ordinary passive object. simple for an ordinary object; the parent link is set Another twist would be to build class-like objects to its prototype’s parent. For methods (procedures), out of methods. In Self, the shared behavior object the object created by the compiler serves as a proto- for points could be a method with code that simply type activation, and when invoked, gets cloned. The returned a clone of the prototypical point. This clone’s parent then gets set to the message’s receiv- method could then be installed in the “Point” slot er. In this fashion, the method’s scope gets of the root object. One object would then be serving embedded in the receiver%. For Self blocks, the par- two roles: its code would create new points, and its ent link must get set to the activation for the slots (locals) would hold the shared behavior for enclosing method. This can be done either when the points. At this writing, we do not believe that this method is activated and the activation record is creat- is the best way to construct a system, but the use of ed, or when the block is created. methods to hoId shared behavior for a group of Second, in order to allow the slots containing local objects is an example of the flexibility afforded by variables to be accessedin the same way as everything Self. else, the implicit “self” operand must take on an Parents viewed as shared parts. Finally, one can unusual meaning: start the message lookup with the view the parents of an object as shared parts of the current activation record, but set the receiver of the object. From this perspective, a Self point contains a messageto be the same as the current receiver. In a private part with x and y slots, a part shared with way, this is the opposite of the “super” construct in other points containing +, -, etc. slots, and a part SmalltaIk, which starts the lookup with the receiv- shared with all other objects containing behavior er’s superclass. (See Figure 5.) common to all objects. Viewing parents as shared parts broadens the applicability of inheritance. Speculation: Where is Self headed? Syntax In the designing of Self, we have been led to some rather strange recurring themes. We present them In this section we outline the syntax for a textual here for the reader to ponder. representation of Self objects. Where possible, we Behaviorism. In most object languages (Actors have followed Smalltalk syntax to avoid confusion. excepted), objects are passive; an object is what it is. We have added slot list syntax for creating objects In Self, an object is what it does. Since variable inline. In general, Self objects (including methods access is the same as message passing, ordinary pas- and blocks) are written enclosed in brackets, and
234 OOPSLA‘87 Proceedings October4-8,1987 include a list of slots and some code. Passive objects effect is identical to that of the left-arrow and blocks are enclosed in square brackets, and form, except that the variable is read-only. methods are enclosed in curly brackets. The code fol- lows Smalltalk syntax, except for the implicit self . A keyword (identifier with trailing colon) message destination. The slot list, though, departs followed by a left arrow (“O.“) defines an from Smalltalk. The first difference, is that the slot assignment slot. Such a slot can be used to list, if present, must be nestled in a pair of vertical change the value of a read-only slot else- bars. Next, each item in the slot list must be sepa- where. For example, points may be defined rated from the next by a period. (A trailing period to be immutable by omitting the assignment is optional.) Finally, there are several forms for slots from them, that is defining the proto- slots: typical point as “[ I x = nil. y = nil I I.” But a routine defined for points can change . A selector by itself denotes MO slots: a slot its receiver’s x or y if it includes x: or y: initialized to nil, and a slot named with a slots. trailing colon initialized to the assignment
primitive (denoted by “). -For example, the l Finally, one or more unary selectors (i.e. object identifiers) preceded by colons define one slot per identifier, bound to the correspon- [lx. II ding argument of the message. For example: ‘ ‘compareBlock = [ I :a :b I a c b]” defines a contains two slots: one called x containing block with two arguments,“a” and “b.” nil, and another one called x: containing -*. This has the same effect as declaring a The arguments for a method may also be Smalltalk variable. moved into the selector as in Smalltalk:
. A selector followed by a left arrow and an display: at: = ( expression also denotes two slots: a slot ini- 1:aForm :aPoint 1 tialized to the value of the expression, and a Bitblt destination: self; corresponding assignment slot. If the au aPoint; expression is a Self object with code, the source: aForm; object is treatedas a block. copybits ) For example, the method
( display: aForm at: aPoint = ( I tally *-0 I Bitblt destination: self; 10 timesRepeat:[tally: at: aPoint; tally + Random*]. source: aForm; “my copybits ) are equivalent. returns the sum of 10 random numbers. It contains a slot named “tally” initialized to zero, and a slot named “tally:” containing An Example the assignment primitive. The effect is simi- lar to an initialized variable. The following example shows one way to build a . A selector followed by an equals sign (=) data structure that holds a set of objects. The set is and an expression denotes only one slot, ini- implemented with a open-addressed hash table. A tialized to the value of the expression. The consequence of our notation is that the inheritance hierarchy usually corresponds to the lexical nesting *Randomis a slot in the root object containinga method to express (single) inheritance. Here the outermost that returns a random number. brackets denote the root object.
October4-8,1987 OOPSLA‘87 Proceedings 235 Activation in Self
shared behavior for all objects
. I parent \ + shared behavior for points - x: t Y:
parent a point X 3 arg nil prototype activation . 5 code @zl’ Y v Tclone x: x + arg x; y: y + arg y A
I I parent parent another point x 7 activation record arg Y 9 code
Figure 5. The figure above shows what happens when the point (3, 5) gets sent the plus messagewith argument (7, 9). Lookup for plus starts at (3, 5) and finds a matching slot in the object holding shared behavior for points. Since the contents of the slot is a method object, it is cloned, the clone’s argu- ment slot is set to the argument of the message,and its parent is set to the receiver. When the code for plus executes, the lookup for x will find the receiver’s x slot by following the inheritance chain from the current activation record. It will also find the contents of the args slot in the same way. It is this technique of having the lookup for the implicit self receiver start at the current activation, that allows local variables, instance variables and method lookup to be unified in Self.
236 OOPSiA ‘87 Proceedings October 4-8,1987 [I The global dictionary, or root object. nil = [ 1. An object with no slots. clone = (
Odoher 4-0,1987 OOPSlA ‘87 Proceedings 237 contents firstIndex Now searchfrom start to initial guess. to: hashIndex- 1 do: textBlock. grow indexFor: ohj ) If control falls through, then the receiver is full and the object is not in it, so enlarge the set. (Grow is not shown in this example.) 1I. End of SetTraits. AnEmptySet = (SetTraits emptyset clone ). Returns a new Set. il. End of Root Object.
Work in Progress
The design of Self remains unfinished in several vital are considering ways to incorporate encapsulation areas: multiple inheritance, private (encapsulated) into Self. slots, and activation details: Activation details are needed to tell a simple, con- Multiple inheritance would add more expressive- sistent story ahout methods and blocks. ness, permitting a better factorization of behavior. We are leaning towards an approach in which each status object could have multiple parents, and an enor- would occur if two slots of the same name were ever Craig Chambers, Elgin Lee, and Martin Rinard have found in the course of a lookup. Conflicts could he built a prototype environment for Self including a explicitly resolved by suppIying a new method that browser, inspector, debugger, and interpreter. This delegated the message. We also would limit the system is intended to help us gain a deeper understan- lookup of messages sent to “self’ to only those ding of the language and implementation challenges. paths including the sending method. That way the We have written and run small Self programs in this destination of a message sent to “self” would he environment. unaffected by siblings in the inheritance graph. The separation of format from behavior information Related Work and Acknowledgements in Self’s object model would help make multiple inheritance work. For example, many languages We would like to express our d&p appreciation to with multiple inheritance falter when confronted the past and present members of the System Concepts with inheriting two classes that contain an instance Laboratory at Xerox PARC for blazing the trail variable with the same name. Extra mechanism is with Sma.lltalk [GoR83]. The way Self accessesstate required to specify if the instances should contain via messagepassing owes much to conversations with only one instance variable that is shared by the two Peter Deutsch, and is reminiscent of an earlier unpub- parents, or if the instances should contain two lished language of his, called “0”. Some Smalltalk instance variables with the same name. An elegant programmers have already adopted this style of vari- solution exists in Self. If it is desired to merge the able accessing [Roc86]. Trellis/Owl, an instance variables, the prototype merely contains a independently designed object-oriented language slot with the appropriate name. If, on the other incorporating static typechecking and encapsulation hand, it is desired to keep them separate, the proto- includes syntactic sugar for. element accessand assign= type has neither slot, but instead can have two ment [SCB86]. However, the syntax resembles field parents that each have the slot. The lookup rules accessing and assignment. We stuck with mes- guarantee that the slots will be accessed by their sage-passing syntax in Self to emphasize behavioral appropriate parents. (See Figure 6.) connotations. Strobe was a frame-based language for Encapsulation is lacking in the current design; any AI that also mixed data and behavior in slots object can alter the state of any other object. This [Smi83]. Loops, an extension of InterLisp with could be fixed with some technique for achieving the objects, also included active variables [SBK86]. effect of private slots. Smalltalk protects variables We would like to thank Lieberman for calling our but not methods, so Self’s current lack of encapsula- attention to prototypes in D&86]. Exemplars is the tion may not be much worse that Smalltalk’s. We name given to prototypes in a project that added a
238 OOPSLA ‘87 Proceedings October d-a,1987 Multiple Inheritance in Self
Rectanqle #ared t ehavior parent width ? height ? bottom - top area ? width * height left: c , 1 right: 1 c I
a VLSIC I r&lrect parent I tree Darent I +
Figure 6. Sell? object model is so flexible that it can support multiple inheritance with only small changes. ln this example, a VLSI cell object has been created that inherits from both rectangles and trees. The problem for other languages is that, although both rectangles and trees have variables named left and right, they are used for different purposes and separate slots must be maintained. This can be implemented in Self by creating two extra parent objects, identified here as “rectangle part” and “treeNode part” which contain the slots specific to a given inheritance path. When the VLSI cell is sent the width message, the lookup will find the rectangle width method, which will in turn send the right message to self. A special multiIjle inheritance rule is that messagessent to self are looked up only on paths that contain the sender; thus the lookup will fiid only the right slot in the rectangle part-the right slot in the “treeNode part” poses no conflict. Self’s lack of constmints on an object’s formats and parents make this possible.
odober 4-8,1987 OOPSLA‘87 Proceedings 239 prototype-based object hierarchy to Smalltalk Lee have helped distill and refine the language. [LTP86]. Like our design for Self, objects are created Finally, we would like to thank all the readers and by cloning exemplars, and multiple representations reviewers for many helpful comments and criticisms, are permitted. Unlike Self in its present state, this especially Dave Robson, who helped separate the system also includes classes as an abstract type hierar- wheat from the chaff. chy, and two forms of multiple inheritance. One This work is partially supported by Xerox, and interesting contribution is the exemplar system’s sup- partially by the National Science Foundation Presi- port for or-inheritance. Self seems to be more dential Young Investigator Award DCK 8657631, unorthodox than exemplars in two respects: it elimi- NCR, Texas Instruments,and Apple Computer. nates variable accessing from the language, and it unifies objects and closures. Conclusions The Alternate Reality Kit [Smi86] is a direct-manipulation simulation environment based on Self offers a new paradigm for object-oriented lan- prototypes and active objects, and it has given us guages that combines both simplicity and much insight into the world of prototypes. Alan expressiveness. Its simplicity arises from realizing Boming’s experience with prototypebased environ- that classesand variables are not needed. Their elimi- ments, especially ThingLab [Bor79, Bor81, Bor861 nation banishes the metaclass regress, dispels the made him a wonderful sounding board when we were illusory distinction between instantiation and sub- struggling to grasp the implications of prototypes. classing, and allows for the blurring of the The DeltaTalk proposal [Boo861 included several differences between objects, procedures, and cl& ideas for merging Smalltalk methods and blocks, sures. Reducing the number of basic concepts in a which helped us to understand the problems in this language can make the language easier to explain, area. Actors [HeA87] system has active objects, but understand, and use. However there is a tension these are processes, unlike Self’s procedural model. between making the language simpler and making the Actors also rejects classes, replaces inheritance with organization of a system manifest. As the variety of delegation. constructs decreases, so does the variety of linguistic clues to a system’s structure. Oaklisp &aP86] is a version of Scheme with message Making Self simpler made it powerful. Self can passing at the bottom. However, Oaklisp is express idioms from traditional object-oriented lan- class-based, and maintains the inheritance hierarchy guages such as classes and instances, but can go separately from the lexical nesting; it does not seem beyond them to express oneof-a-kind objects, active to integrate lambdasand objects. Values, inline objects and classes, and overriding We would like to thank Daniel Weise and Mark instance variables. We believe that contemplation of Miller for listening patiently and tutoring us on Self provides insights into the nature of Scheme. Craig Chambers, Martin Rinard, and Elgin object-oriented computation.
240 OOPSLA‘87 Proceedings odober 441987 References
[ASS841 H. Abelson, G. J. Sussman and J. Suss- [RAM841 J. A. Rees, N. I. Adams and J. R. Mee- man, Structure and Interpretation of han, The T Manual (Fourth Edition), Computer Programs, MIT Press, 1984. Computer Science Dept., Yale Universi- ty, New Haven, CT, 1984. [Bor79] A. Borning, ‘ ‘ThingLab-A Constraint- Oriented Simulation Laboratory,” Ph.D. R. Rochat, “In Search of Good Smalltalk dissertation, Stanford University, March Programming Style,” Technical Report 1979. No. CR-86-19, Computer Research Labo- ratory, Tektronix Laboratories, [Bor81] A. H. Boming, “The Programming Lan- Beaverton, OR, 1986. guage Aspects of ThingLab, A Constraint- Oriented Simulation Laboratory,” ACM [SBK86] M. Stefik, D. Bobrow and K. Kahn, Transactions on Programming Languages “Integrating Access-Oriented Program- and Systems3,4 (October 1981), 353-387. ming into a Multiprogramming Environment,” IEEE Software Magazine [BoO86] A. Boming and T. O’Shea, “DeltaTalk: 3,1 (January 1986), 10-18. An Empirically and Aesthetically Moti- vated Simplification of the [SCB86] C. Schaffert, T. Cooper, B. Bullis, M. Smalhalk-80rM Language,” unpublished, Kilian and C. Wilpolt, “An Introduction 1986. to Trellis/Owl,*’ OOPSLA’86 Conference Proceedings, Portland, OR, 1986, 9-16. [Bor86] A. Boming, “Classes versus Prototypes Also published as a special issue of SIG- in Object-Oriented Languages,” Proceed- PLAN Notices, Vol. 21, No. 11, Nov. ings of the ACM / IEEE Fall Joint 86. Computer Conference, Dallas, TX, November, 1986.36-40. [She831 B. She& “Environments for Exploratory Programming,” Datamation, February, [GoR83] A. J. Goldberg and D. Robson, 1983. Smalltalk-80TM: The Language and Its Implementation, Addison-Wesley Pub- [Smi83] R. G. Smith, “Strobe: Support for Su-uc- lishing Company, Reading, MA, 1983. tured Object Knowledge Representation,” Proceedings of the 1983 International [HeA87] C. Hewitt and G. Agha, “ACTORS: A Joint Conference On Artificial InteIli- Conceptual Foundation For Concurrent gence, 1983,855-858. Object-Oriented Programming,” MIT AI Lab, January 21,1987. Unpublished draft. [Smi86] R. B. Smith, “The Alternate Reality Kit: An Animated Environment for Creating * W. R. LaLonde, D. A. Thomas and J. R. Interactive Simulations,” Proceedings of With, “An Exemplar Based Smalltalk,” 1986 IEEE Computer Society Workshop OOPSLA’86 Conference Proceedings, on Visual Languages, Dallas, TX, June, Portland, OR, 1986, 322-330. Also pub- 1986,99-106. lished as a special issue of SIGPLAN Notices Vol. 21, No. 11, Nov. 86. [Smi87] R. B. Smith, “Experiences with the Alternate Reality Kit: An Example of K. J. Lang and B. A. Pearlmutter, the Tension Between Literalism and Mag- “Oaklisp: An Object-Oriented Scheme ’ ” To appear in Proceedings of the with First Class Types,” OOPSLA’86 %I+GI’87 Conference, Toronto, Canada, Conference Proceedings, Portland, OR, April, 1987: 1986, 30-37. Also published as a special issue of SIGPLAN Notices Notices, Vol. [Ste76] G. L. Steele Jr., “Lambda, the Ultimate 21, No. 11, Nov. 86. Imperative,” AI Memo 353.1976. Lie.861 H. Lieberman, “Using Prototypical Objects to Implement Shared Behavior in Object-Oriented Systems,” OOPSLA’86 Conference Proceedings, Portland, OR, 1986, 214-223. Also published as a spe- cial issue of SIGPLAN Notices Notices, Vol. 21, No. 11, Nov. 86.
October4-a, 1987 OOPSLA‘87 Proceedings 241 Appendix: Formal Syntax
We herein include a preliminary formal syntax for binarySendPart= binarySelector unarysend , Self, developed by Craig Chambers from a grammar unarysend = primary II implicitself unarySendPartII written by the author for Smalltalk. Terminals are unarysend unarySendPart printed in boldface, commas separate productions, unarySendPart= IdentifierToken , and double vertical bars indicate alternation. primary = ( expression) II explicitself II object = blockobject II methodobject, explicitSuper II constant , implicitself = , blockobject = [ de&Part primitiveSpec body ] , explicitSelf = self, methodobject = { declsPartprimitiveSpec body } , explicitSuper = super, constant = object II scalarConstantII # arrayConstant, de&Part = II I decls optionalPeriod I, scalarConstant= NumberToken It ShingToken I I # de& = II decl II de&. decl , IdentifierToken II CharacterToken II nil II decl = argsDec1II slotDec1II assignDec1II initDec1 II true II false , constDec1II methodDec1, arrayConstant= (arrayElements) , arrayElement = IdentifierToken II NumberToken II argsDec1= argDec1II argsDec1argDec1, StringToken II CharacterToken II argDec1= : IdentifierToken , an-ayconstant , slotDec1= IdentifierToken, binarySelector = BinarySelectorToken II c II > II = , assignDec1= KeywordToken *’ , initDec1 = IdentifierToken ‘. constant, constDec1= IdentifierToken = constant, method&cl = slotName = object,
slotName = selectorsDec1II binarySelector II binaryPattern II keywordPattern, selectorsDec1= selectorDec1II selectorsDec1 selectorDee , selectorDec1= KeywordToken , binaryPattern = binarySelector IdentifierToken , keywordPattern = KeywordToken IdentifierToken II keywordPattern KeywordToken IdentifierToken ,
primitiveSpec = II c primitive: NumberToken >,
body = statementsoptionalPeriod optionalReturnStatement, optionalPeriod = II. , optionalRetumStatement= II expression, statements= II expression II statements. expression, expression= keywordsend II expressioncascadepart, cascadepart= ; sendPart,
sendPart= keywordSendPart II binarySendPartII unarySendPart, keywordsend = binarySend II implicitSelf keywordSendPart II binarysend keywordSendPart , keywordSendPart = KeywordToken binarySend II keywordSendPart KeywordToken binarysend, binarySend = unarySend II implicitSelf unarySendPart II binarySend binarySendPart ,
242 OOPSIA ‘87 Proceedings October q-8,1987