Self is a general-purpose, high-level, object-oriented programming language based on the concept of prototypes. Self began as a dialect of Smalltalk, being dynamically typed and using just-in-time compilation (JIT) with the prototype-based approach to objects: it was first used as an experimental test system for language design in the 1980s and 1990s. In 2006, Self was still being developed as part of the Klein project, which was a Self virtual machine written fully in Self. The latest version, 2024.1 was released in August 2024. Several just-in-time compilation techniques were pioneered and improved in Self research as they were required to allow a very high-level object-oriented language to perform at up to half the speed of optimized C. Much of the development of Self took place at Sun Microsystems, and the techniques they developed were later deployed for Java's HotSpot virtual machine. At one point a version of Smalltalk was implemented in Self. Because it was able to use the JIT, this also gave extremely good performance.
History Self was designed mostly by David Ungar and Randall Smith in 1986 while working at Xerox PARC. Their objective was to advance the state of the art in object-oriented programming language research, once Smalltalk-80 was released by the labs and began to be taken seriously by the industry. They moved to Stanford University and continued work on the language, building the first working Self compiler in 1987. Then, focus changed to working to build a full system for Self, in contrast to only the language. The first public release was in 1990, and the next year the team moved to Sun Microsystems where they continued work on the language. Several new releases followed until falling largely dormant in 1995 with version 4.0. In 2006, version 4.3 was released, for Mac OS X and Solaris. in 2010, a new release, version 4.4, was developed by a group comprising some of the original team and independent programmers, for Mac OS X and Linux, as are all later versions. In January 2014, a follow-up, 4.5 was released, and three years later, version 2017.1 was released in May 2017. The Morphic user interface construction environment was originally developed by Randy Smith and John Maloney for the Self programming language. Morphic has been ported to other notable programming languages including Squeak, JavaScript, Python, and Objective-C. Self also inspired a number of languages based on its concepts. Most notable, perhaps, were NewtonScript for the Apple Newton and JavaScript used in all modern browsers. Other examples include Io, Lisaac and Agora. The IBM Tivoli Framework's distributed object system, developed in 1990, was, at the lowest level, a prototype-based object system inspired by Self.
Prototype-based programming languages
Traditional class-based OO languages are based on a deep-rooted duality:
Classes define the basic qualities and behaviours of objects. Object instances are particular manifestations of a class. For example, suppose objects of the Vehicle class have a name and the ability to perform various actions, such as drive to work and deliver construction materials. Bob's car is a particular object (instance) of the class Vehicle, with the name "Bob's car". In theory, one can then send a message to Bob's car, telling it to deliver construction materials. This example shows one of the problems with this approach: Bob's car, which happens to be a sports car, is not able to carry and deliver construction materials (in any meaningful sense), but this is a capability that Vehicles are modelled to have. A more useful model arises from the use of subclassing to create specializations of Vehicle; for example Sports Car and Flatbed Truck. Only objects of the class Flatbed Truck need to provide a mechanism to deliver construction materials; sports cars, which are ill-suited to that sort of work, need only drive fast. However, this deeper model requires more insight during design, insight that may only come to light as problems arise. This issue is one of the motivating factors behind prototypes. Unless one can predict with certainty what qualities a set of objects and classes will have in the distant future, one cannot design a class hierarchy properly. All too often the program would eventually need added behaviours, and sections of the system would need to be re-designed (or refactored) to break out the objects in a different way. Experience with early OO languages like Smalltalk showed that this sort of issue came up again and again. Systems would tend to grow to a point and then become very rigid, as the basic classes deep below the programmer's code grew to be simply wrong. Without some way to easily change the original class, serious problems could arise. Dynamic languages such as Smalltalk allowed for this sort of change via well-known methods in the classes; by changing the class, the objects based on it would change their behaviour. However, such changes had to be done very carefully, as other objects based on the same class might be expecting this wrong behavior: wrong is often dependent on the context. (This is one form of the fragile base class problem.) Further, in languages like C++, where subclasses can be compiled separately from superclasses, a change to a superclass can actually break precompiled subclass methods. (This is another form of the fragile base class problem, and also one form of the fragile binary interface problem.) In Self, and other prototype-based languages, the duality between classes and object instances is eliminated. Instead of having an instance of an object that is based on some class, in Self, one makes a copy of an existing object, and changes it. So Bob's car would be created by making a copy of an existing Vehicle object, and then adding the drive fast method, modelling the fact that it happens to be a Porsche 911. Basic objects that are used primarily to make copies are known as prototypes. This technique is claimed to greatly simplify dynamism. If an existing object (or set of objects) proves to be an inadequate model, a programmer may simply create a modified object with the correct behavior, and use that instead. Code which uses the existing objects is not changed.
Description Self objects are a collection of slots. Slots are accessor methods that return values, and placing a colon after the name of a slot sets the value. For example, for a slot called "name",
returns the value in name, and
… excerpt ends here. Continue reading the full article.
