Glossary of terms



abstract class: A class that is designed to provide common behaviour for its subclasses but is not designed to have instances of itself. See the Abstract Class pattern.

accessor method: A method which gets or sets the value of an instance variable. See the Accessor Method pattern.

answer: To return a value. Conventionally, the verb answer is used in Smalltalk rather than return.

application framework: A template used for building applications. An application framework is, essentially, an abstract implementation of a set of patterns. rules, with high-level classes such as Model and View. These provide a framework within which applications may be built by re-using common components. Model-View-Presenter is the most commonly used Dolphin application framework.


bereavement: A weakling's loss of a weak reference to another object, occurring when that object is not reachable along a path of strong references from a root object.

binary selector: A special (usually arithmetic) selector which is composed of one or more symbolic characters, and which is used in infix form between receiver and argument, but which is distinguished from a unary keyword selector by not posessing a terminating with a colon (:). e.g. + and <=.

block: A self-contained series of Smalltalk expressions, enclosed by square brackets, which is formed into an object at run-time which encapsulates the execution scope accessible at the pointer when it was created, and which can be subsequently evaluated, repeatedly if necessary.

byte object: An object whose instance variables are integers in the range 0..255 (i.e. 8-bit bytes). A byte object's instance variables are accessed by index and cannot be named. Byte object cannot contain pointer variables, named or indexed. e.g. ByteArray.


canvas: An object representing an area upon which drawing operations may be performed.

cascaded message: An expression where multiple messages are sent to the same receiver. Messages are separated by semicolons and are sent, in order, to the last receiver before the first semicolon.

change log: A text file, named <image stem>.CHG, that resides in the Dolphin directory and contains all additions and modifications that have been made to the image, and the text of any expressions evaluated. This file can be used to recover previous work after a failure. The file is in chunk format.

chunk format: The Smalltalk source file format in which code and expression are stored in small sections, separated by exclamation marks. File in operations understand the chunk file format.

class instance variable: Literally an instance variables of a class (as opposed to its instances). The defining class and each of its subclasses each have their own slot for the instance variable. Only the class methods of the class can directly reference the data. Assigning to the variable in one class does not change it for the other related classes. Contrast with class variable.

class variable: A variable that is shared by its defining class and that class' subclasses. The instance and class methods of these classes can directly reference the variable. Contrast with class instance variable.

collection: A data structure which can contain other objects, and which provides differents ways to access those objects, depending on its particular behaviour.

corpse: The instance of the singleton class DeadObject used by the memory manager to replace replaces expired weak references when collecting garbage.

critical section: A code sequence which only a single process is permitted to enter at any one time. Critical sections protect data structures from corruption/misinterpretation in a situation where multiple processes may wish to access them.


dependency: A mechanism which allows an observer object to register an interest in all aspects of another object.

dictionary: An unordered collection whose elements are accessed by an explicitly assigned external key. See also pool dictionary.

dirty read: A read access occurring to an incompletely updated object (i.e. one in an invalid state). This error can occur where multiple processes share data, and one process writes to an attribute that another is reading.


equality: Two object in Smalltalk are equal if they of the same species and have equivalent contents. Contrast with identity.

event: A mechanism that allows an observer object to register an interest in a specific aspect of another object.


file in: The action of loading classes, methods, and evaluable expressions from a chunk format file.

finalization: Performing final operations just before an object expires, typically releasing external resources. See the Finalization pattern.


global variable: A variable with global scope, stored in the Smalltalk system dictionary. See the Global Variable pattern.


identity: The globally unique 'name' of an object. Every Smalltalk object has an individual identity which distinguishes it from any other object, i.e. two object have the same identity iff they are one and the same object. The identity of an object is not a user-accessible attribute. Contrast with equality.

image: The current persistant state of the Dolphin object.

indexable object: An object whose instance variables are accessible by sequenced integer keys (i.e. indices) rather than by name. Indexable pointer objects can also contain named instance variables.

instance variable: Private data that belongs to an object and is hidden from direct access by all other objects. Instance variables can only by accessed by the methods of the defining class and its subclasses. See the Instance Variables pattern.


keyword selector: A message name formed from one or more parts all terminated with a colon (:) delimiting the positions of the expected arguments.


lazy initialisation: The action of initialising something, usually a variable, when it is first accessed, rather than during a specific initialisation process when an object is created. See the Lazy Initialization pattern.

literal: An object with a text representation from which a duplicate can be constructed by the compiler. A literal can be a number, a character string, a single character, a symbol, or an array. Literals are either immutable, or should be treated as such.


message: A communication from one object (the sender) to another (the receiver) requesting it perform a named action as specified by the selector, parameterised with a specified set of arguments. The result of the method execution (an object in itself) is answered (returned) to the sender.

metaclass: The class specification of a class object; the complete description of a class's attributes, behaviour and implementation. Every class has a metaclass, of which it is the sole instance.

method: The implementation for a particular message in a class.

monadic valuable: An object which implements the ANSI <monadicValuable> protocol, for example a one argument block. Monadic valuables are evaluated by sending them the #value: message with one argument.

mourning: The state of a weakling when it has suffered bereavements following a garbage collection, and before it has been able to complete repairs to the damage.

mourning weakling A weakling which is a member of a class which is marked as requiring bereavement notifications.

mutual exclusion: The process of ensuring that an operation may not be interrupted. Mutual exclusion is handled in Dolphin Smalltalk using the Mutex class.


nil: The Smalltalk object that means "no value", and the distinguished instance of the UndefinedObject class.. All pointer variables are initialized to nil. nil is somewhat similar to C's null with the important distinction that it is distinct from zero (0).

niladic valuable: An object which implements the ANSI <niladicValuable> protocol, for example a zero argument block. Niladic valuables are evaluated by sending them the #value message.


observer: An object whose state depends on another object. Observers are designed to 'know' how to update themselves when they receive notification of a change from another object (the subject). See dependency and event for mechanisms which can be used to implement this ability. See the Observer pattern.


pointer: A reference to an object. Variables in Dolphin are either pointers or bytes.

pointer object: An object whose instance variables are references to other objects (cf. byte object).

polymorphism: The ability of different object to respond to the same message in specific ways: Objects can have very different implementations of the same message. In Smalltalk polymorphic behaviour in responce to messages is independent of inheritance.

pool dictionary: A dictionary whose keys define variables that can be shared by multiple classes. The methods of a class can access the variables in a pool dictionary by name if the class declares the pool dictionary as part of its scope.

process: An independent unit of execution running within the image. Also the class of Smalltalk object representing such. Smalltalk processes are more similar in concept to threads than traditional processes. Dolphin permits (and indeed requires) multiple independent processes to be running at the same time.

prompter: A dialogue box containing a single editable text field intended for soliciting a single value from the user.

protocol: An informal group of messages which, together, describe a coherent set of behaviour implementing some logical concept. Protocols are the nearest thing to 'types' in Smalltalk.



selector: The name for a particular action or message.

singleton: A class that can only have one instance of itself instantiated. See the Singleton package.

SmalltalkSystem: A Model which represents the development system classes.

species: The generic class of an object. This is normally the same as the class of an object, otherwise it is a class which describes the generic group of classes to which a particular class belongs. Note that this does not necessarily have to be class from the same branch of the hierarchy.

stream: An object which provides sequential read and/or write access to the contents of a collection of file.

symbol: A globally unique string. Symbol is the class of constant object which has a single instance to represent each possible value. Symbols are displayed with a # prefix. For example, #textSymbol will always be the same, identical object from wherever it is referenced, but 'textSymbol' may have any number of separate Strings representing it.


temporary variable: A variable whose scope is limited to the method or block in which it is defined. See the Temporary Variables package.

thunk: A small piece of machine code which bridges the boundary between one calling convention and another. Used to permit libraries written in languages other than Smalltalk to call into Dolphin.

Transcript: A general-purpose workspace window where system messages are displayed and Smalltalk expressions may be evaluated.


unary message: A message that has no arguments. #size is a common example of a unary message.


Virtual Machine: The executable program that contains the Dolphin interpreter which brings the Dolphin image to life.


weak reference: A pointer reference to an object which is ignored by the Garbage Collector when traversing the graph of object references. A weak reference has only a tenuous grasp on the object it references, and the object will slip from its grip if no other object has a stronger hold. See the Weak Collections pattern.

weakling: An object whose indexable instance variables are weak references. See the Weakling pattern.


yourself: A message which answers the receiver. This is most useful at the end of a sequence of cascaded messages