Glossary
This glossary defines the main VisualWorks and Smalltalk terms that are used
in the documentation. Within a definition, terms that appear in italic type are also defined in this glossary. accessing method
accessor action widget
application application framework
The VisualWorks application framework includes the ApplicationModel
class and its subclasses, the UIBuilder
class, policy classes for various platform "look-and-feels," and classes for the various widgets and value models. application model argument aspect adaptor aspect path assignment binary message block expression Boolean objects browser builder A builder holds onto the user-interface objects it creates. Consequently, an application can send messages to a builder to obtain programmatic access to a given widget or to the window itself. Builders are instances of the
class UIBuilder, which is part of the VisualWorks application framework. canvas Canvas Tool cascaded messages category Change List changes file class Every class is itself a kind of object and therefore has its own data (class variables) and operations (class methods). One of the primary operations of a class is to create the objects that are its instances. class hierarchy class method class variable component controller data widget Definer dependency mechanism domain domain model expression file in File List file out global variable graphical image graphical user interface In VisualWorks, a graphical user interface includes not only the windows and widgets themselves, but also various supporting object
s that are supplied by the application framework. In addition, a graphical user interface includes the code that implements the widgets' application-specific behavior--the functionality that enables them to interact with domain models. A VisualWorks graphical user interface is normally implemented using one or more application models and interface specifications. Hierarchy Browser image Image Editor inheritance inheritance hierarchy Inspector install instance Every object in the Smalltalk system is an instance of a class. All instances of a given class are identical in form and behavior, although they generally hold different data in their instance variables. instance method instance variable interface interface specification keyboard focus keyword keyword message Launcher lazy initialization look policy mask Menu Editor message message category message expression message protocol message selector method A method is executed when a message matching its message pattern is sent to an instance of the class in which the method is found. A method determines the value of a message expression, either by explicitly specifying the object to be returned or by allowing a default value to be returned. also instance method and class method. method lookup modal dialog box model mouse pointer mutator MVC architecture object object engine open paint Palette pointer properties Properties Tool protocol receiver resource Resource Finder resource method return The object that is returned by a receiver is determined by the method that is invoked by a message. The method may specify the returned object explicitly through an expression containing the return operator
(^); otherwise, the default value returned is usually the receiver itself. selector Settings Tool shared variable Smalltalk snapshot sources file standard image static variable subclass subject subject channel superclass symbol System Browser system classes System Transcript tab chain temporary variable text cursor UI object unary message user interface user-interface object value When discussing value models, "value" usually refers to the object that is returned by sending the
message value to a value model. value holder value model A data widget
normally depends on a value model to store or retrieve the data they collect or display. Value models are created from the VisualWorks
application framework
. The term refers to a subclass of the class
ValueModel, or to an instance of such a subclass. also aspect adaptor and value holder. variable view (2) A display region of a Smalltalk browser. For example, in a System Browser, the
category view displays a list of categories in the system, whereas the code view displays textual lines of code. visual component VisualWorks main window VisualWorks Smalltalk language In Smalltalk, every entity is an object, and all processing is carried out as messages sent among the objects. Because the VisualWorks implementation of the language also provides a large set of predefined objects, the language is considered part of the VisualWorks Smalltalk system. VisualWorks Smalltalk system widget window working image Workspace
A
method that is either an accessor or a mutator; a way of referring to operations whose purpose is to either get or set the value of a variable.
An accessing method that gets, or returns, the value of a
variable. also mutator.
A widget that enables a user to invoke an application's action. Action widgets include action buttons and menu items. Action widgets are designed to ask an application model to carry out their actions.
A complete program that enables users to define, process, store, and/or retrieve data in various ways. Applications help to automate various aspects of operation in some domain. Typical applications include word-processing systems, spreadsheets, calculators, and payroll systems.
A set of classes that provide a core structure from which to build a complete application.
A model in a Smalltalk program that provides application-specific information and services. At a minimum, an application model provides the code required to support the mechanics of the graphical user interface. For example, an application model establishes the connections between widgets and domain models, and it defines the interactions between widgets.
An object that specifies additional information for an operation. Arguments are specified as expressions in binary messages or keyword messages.
A kind of value model that accesses a value held in another object, called its subject. An aspect adaptor responds to
value and value:
messages by sending appropriate accessor and mutator messages to its subject. An aspect adaptor is an instance of the class
AspectAdaptor, which is a subclass of
ValueModel.
A way of filling in a data widget's aspect
property to cause the builder to create an aspect adaptor for the widget. An aspect path contains multiple elements, in which the first element (the head) refers to a subject channel for the aspect adaptor, and subsequent elements specify accessor names.
An expression that makes a change to a
variable's value--for example
quantity := 19.
A message
that has one argument and whose selector is made up of one or two special characters
. For example, in the
message expression
3+4, the binary message is +4, where
+ is the selector and 4 is the argument.
A description of a deferred sequence of actions. Block expressions consist of one or more expressions enclosed in square brackets.
The Smalltalk objects
true and false, which serve as the answers to yes-no questions and which respond to messages that request logical operations and conditional control structures (if-then-else operations).
A window that displays portions of the Smalltalk class library for viewing or editing. A browser displays its information in multiple views.
An object that builds an operating window from an interface specification. A builder is created by
an application model
when the application needs to open a window. The builder, in turn, creates and assembles appropriate user-interface objects
according to the contents of the interface specification and a specified look policy.
A special work area in which you paint the contents and layout of a window (or part of a window) for an application. You also affect the appearance of a canvas by setting
properties. A canvas is the graphical form of an interface specification.
The VisualWorks tool for fine-tuning a canvas's appearance and for invoking additional canvas-preparation tools. A Canvas Tool is automatically opened when you open a canvas.
Multiple messages sent to one object in a single message expression. A cascaded message expression consists of one description of the receiver followed by several messages separated by semicolons. For example:
OrderedCollection new add: 1; add: 2; add: 3
results in three add:
messages being sent to the result of OrderedCollection new.
A group of classes. Every class in the system belongs to exactly one category. Classes are grouped into categories purely for organizational purposes; all classes in all categories are globally available. also protocol.
The VisualWorks tool that displays the changes stored in a changes file. To open a Change List, choose
Changes ?
Open Change List from the VisualWorks main window.
A file that lists all the changes made to the VisualWorks Smalltalk system in your
image(1)
. The changes file is located in the same directory as the corresponding image file and has the file extension
.cha. You view your changes file using the Change List.
A description of a group of similar objects. A class serves as a "template" for defining the data and operations for these objects, which are its instances. A class defines:
The structure formed by the inheritance relationships among classes. The hierarchy of classes is rooted in the class
Object, which defines the state and behavior common to all objects in the system. Class
Object does not inherit from any other class.
A method that defines a particular operation that is carried out by a
class, such as creating an instance of itself. Class methods are invoked by sending message
s to a class rather than to one of its instances.
A variable that is shared by a
class and all its instance
s. Class variables maintain information that is the same for all instances.
widget.
An object in a Smalltalk program that enables the user to interact with information displayed by a view. Together, view-controller pairs form user-interface objects such as widget
s. A controller manages a widget's response to mouse or keyboard input. also MVC architecture.
A widget that displays some aspect of an application's data and/or collects it from the user. Data widgets include input fields, lists, datasets, and so on. Data widgets are designed to use value models to manage their access to the data they present.
The VisualWorks tool for generating Smalltalk code that supports widgets. The code is generated in an application model. You invoke the Definer from a Canvas Tool
A widely used technique for coordinating the activities of different objects in an application, whereby one object, usually an instance of a subclass of
Model, maintains a list of objects that depend on it for information and notifies these objects whenever the relevant information changes. also model.
The area of endeavor that an application helps to automate--for example, employee payroll, billing, inventory control, accounting, and so on.
A model in a Smalltalk program that defines data and operations that are relevant to the application's domain. For example, an accounting application might include domain models such as Customer, Account, and so on. Domain models are generally kept free of user-interface code, so that they can be reused with other interfaces.
A sequence of characters that describes an object, which is the value of the expression. also message expression and block expression.
To load one or more files from a disk into the current VisualWorks
image(1)
. When Smalltalk files are filed in, any class and method definitions they contain are compiled into the image.
The VisualWorks tool for interacting with your operating system's file-management facilities. You use a File List to locate and select files in your file system and then read them into your
image(1). To open a File List, choose
Tools ? File List in the VisualWorks main window.
To store the source code for one or more classes or methods in a disk file that is separate from the VisualWorks
image(1) file. When you file out Smalltalk code, the system appends the
.st extension to the filename. Filing out is a common means of backing up your work, preserving intermediate versions, or transferring code to another image (by "filing in").
A variable whose value can be accessed by all objects in the system.
A bitmapped illustration. You create graphical images
using the Image Editor. You can use graphical images in a variety of ways--for example, as labels for action buttons. also mask.
A user interface that consists of a collection of windows containing visual controls, or widgets.
A kind of browser that displays the superclasses and subclasses of a particular class. To open a Hierarchy Browser, you choose
Browse ? Class Named... in the VisualWorks main window and then specify the class.
(1) A file that stores the entire state of an individual VisualWorks Smalltalk system, including all the current objects, all the information on the screen, and any pending instructions to the system. A VisualWorks image preserves objects between VisualWorks sessions. When you start VisualWorks, the object engine reads the image file and restores the system to its previous state.
(2) graphical image.
The VisualWorks tool for creating and modifying graphical images, with pixel-level control.
A mechanism whereby classes can make use of the methods and variables defined in all classes above them on their branch of the class hierarchy.
class hierarchy.
The VisualWorks tool for examining the values of the variables in an object. To open an Inspector, you choose
inspect from an <Operate> menu.
To save a resource (such as a painted canvas) in an application model. Installing a resource creates a resource method, which makes the resource available to the running application.
An individual object described by a class. An instance:
A method that describes how a particular operation is carried out by every instance of a class. also class method.
A variable that stores data for an instance
of a class. Collectively, an object's instance variables describe the object's data structure. Instances of the same class have the same number of instance variables with the same names; these instance variables generally store different values for different instances of the class. also class variable.
graphical user interface.
A symbolic description of a window (or part of a window) that is created when you install a painted canvas in an application model
. An interface specification contains a description of the widgets you painted in the canvas, including the properties you set for them. When the application runs, the interface specification serves as the builder's blueprint for constructing an operational window.
The state of a
widget that enables it to receive input from the keyboard. You can move the keyboard focus among widgets by clicking them or by pressing the <Tab> key.
An identifier with a trailing colon, such as ifTrue:
. Keywords are used in keyword messages.
A message with one or more arguments whose selector is made up of one or more keywords. For example, in the following message expression:
aRunArray copyFrom: startIndex to: stopIndex
the selector is copyFrom:to: (consisting of keywords
copyFrom: and to:) and the arguments are startIndex
and stopIndex.
VisualWorks main window.
A technique for initializing an instance variable. Initialization code is put in an accessor
so that the variable is initialized the first time it is accessed. This technique is used in code generated by the Definer.
The platform-specific "look-and-feel" of an application's interface, which determines the appearance and behavior of buttons, scroll bars, and so on. You set the look policy by selecting it in the Settings Tool.
A monochrome graphical image.
VisualWorks tool for creating and editing menus. You open the Menu Editor from a Canvas Tool.
A request for an object to carry out one of its operations. A message consists of a selector and possibly one or more arguments. also binary message, keyword message, and unary message.
protocol.
A description of a message
to a receiver. When a message expression is evaluated, the receiver carries out the operation requested by the message and returns an object to the sender; this object is the value of the message expression. The value is determined by the method that the message invokes. That method is found in the class of the receiver.
The list of messages to which an object can respond.
selector.
A description of how to perform one of an object's operations, containing a sequence of Smalltalk expressions that is evaluated when the method is executed. Methods are analogous to procedures or functions in other programming languages.
The mechanism used to determine which method to execute when a message is sent to an object.
A dialog box that must be accepted, canceled, or closed before the user can invoke any other application actions.
An object in a Smalltalk program that is concerned with defining and processing data. The data in a model is usually presented to users via user-interface objects. A typical VisualWorks application contains a number of different kinds of models, including domain models, application models, and value models. also MVC architecture.
pointer.
An accessing method that sets a new value for a variable. also accessor.
The classic Smalltalk programming architecture, consisting of decomposing an application (or a portion of an application) into models (M),
views (V), and controllers (C).
A software unit that contains storage for a collection of related data plus operations for manipulating that data. Fundamental kinds of objects are classes and instances of classes.
The executable program that runs the VisualWorks Smalltalk system on your platform; it essentially "sets in motion" the system objects in an image.
To start an application by sending an
open message to create an instance of an application model. The term "open" also means causing a window to display.
To specify the layout and contents of a window (or part of a window) by selecting widgets from a Palette and positioning them appropriately on a canvas. You can also affect the appearance of a canvas by setting properties.
The VisualWorks tool that supplies the widgets you can paint on a canvas. By default, a Palette is opened automatically when you open a canvas.
A graphic, usually in the shape of an arrow, that you move on the screen using a pointing device, such as a mouse, trackball, or joystick. You use a pointer to interact with widgets in VisualWorks windows.
Attributes of widgets and windows that define a variety of visual characteristics, such as font, color, borders, and so on. For widgets that display data, properties also indicate the nature of the data to be displayed and how that data is to be referenced by the application.
The VisualWorks tool for setting the various properties for individual widgets. Properties are displayed in a notebook containing pages of related properties. You open a Properties Tool from a Canvas Tool.
A group of methods in a class definition. Every method in a class belongs to exactly one protocol. Methods are grouped into protocols for organizational purposes only. Also called
message category.
The object to which a message is sent in a message expression. The receiver is described by an expression. It is up to the receiver to decide how to respond to the message.
An object or description needed by the builder to assemble a particular window for a running application. Resources include interface specifications (canvases), menu bars, graphical images, and database queries. An application's resources are normally stored in separate resource methods in an application model.
The VisualWorks tool for locating
classes that contain resources. You can use a Resource Finder to start
applications or to open individual resources for editing. To open a Resource Finder, choose
Browse ? Resources in the VisualWorks main window.
A method (usually a class method) in an application model
that returns a
resource.
Resource methods are normally invoked by the builder when an application opens a window.
To communicate information back to the sender of a message. Whenever a message expression is evaluated, the receiver of the message responds by returning an object, which becomes the value of the message expression. Returning a value indicates that the receiver's response to the message is complete.
The name of a method; the portion of a message that determines which of the receiver's methods will be invoked.
The VisualWorks tool for customizing various global parameters of an
image(1)
, such as the default size, look, and behavior for VisualWorks tools. To open the Settings Tool, choose
File ? Settings in the VisualWorks main window.
A variable whose value is accessible by several objects.
VisualWorks Smalltalk language.
A saved image(1)
file. "Taking a snapshot" of an image refers to saving that image periodically.
A file that contains the source text of the compiled Smalltalk objects in an image
(1). Every image consults a sources file to display class and method definitions.
The image
(1) that is delivered with the VisualWorks product. The first time you start VisualWorks, you use the standard image; thereafter, you normally do your work in your own working image.
shared variable.
A class that inherits variables and methods from some other class (its superclass). A subclass is lower in the class hierarchy than its superclass. A subclass is generally a specialization of its superclass--its
instances
have the same kind of data and behavior as instances of the superclass, plus some of their own. A subclass may also override any of its inherited behavior by redefining inherited methods.
An object that holds onto information to be accessed by an aspect adaptor. Every aspect adaptor is created either with a subject or a subject channel.
A value model that holds onto a subject for an aspect adaptor. Subject channels provide a convenient mechanism for changing a subject that is shared by multiple aspect adaptors.
The class from which
variables
and methods
are inherited. A superclass is higher in the class hierarchy than its
subclasses.
A string that is guaranteed to be unique in the system. All class and method names are symbols. A symbol is expressed literally by prefixing it with the character
# (for example, #balance).
The principal VisualWorks tool for creating and viewing class and method definitions. To open a System Browser, choose
Browse ? All Classes in the VisualWorks main window.
The set of classes
that come with the VisualWorks Smalltalk system. The system classes provide the standard functionality of a programming language (arithmethic, data structures, control structures, and input/output facilities) and development environment (editor, compiler, debugger, window system, and so on).
The display area for informational messages generated by VisualWorks or your code. By default, the System Transcript is in the area below the tool bar of the VisualWorks main window. To close or reopen a System Transcript, choose
Tools ? System Transcript from the VisualWorks main window.
A sequence of widgets
(in a single window) whose properties are set so that the application user can move keyboard focus among them using the <Tab> key.
A variable
that provides temporary storage for a value referenced in one or more expression
s, usually in a method definition. A temporary variable is declared between vertical bars--for example
| aCheck |.
A small triangular graphic that shows where typed input will be inserted. A text cursor appears at the base of a line of text, between two characters.
user-interface object.
A message without
arguments
. In a message expression such as
0 asValue, the unary message is asValue.
The means by which a user can control the behavior of an application; the software that handles input and output. also graphical user interface.
An object in a Smalltalk program that is concerned with presenting information and enabling users to interact with it. User-interface objects include
windows and widgets
. Each user-interface object is a complex object containing a
view coupled with a controller
and associated supporting objects.
The object that is described by an expression. The value of a variable name is the object that is referenced by the variable. The value of a message expression is the object
returned by the invoked method.
A kind of value model
that holds onto its value in an instance variable. A value holder is an instance of the
class ValueHolder, which is a subclass of
ValueModel. also aspect adaptor.
An object that contains or refers to some other object (its value) and:
A storage place within an object for a reference to another object. A variable's name is an
expression that describes the referenced object. VisualWorks has several kinds of variables (see class variable,
shared variable, instance variable,
and temporary variable), which differ in terms of how widely they are available (their scope) and how long they persist.
(1) An object in a Smalltalk program that displays text or graphics representing information in a model. A view is tightly coupled with a controller; together, view-controller pairs form user-interface object such as widgets. also MVC architecture.
widget.
The window that serves as the starting point for your work. It is frequently called the Launcher. It contains a menu bar and a tool bar for invoking VisualWorks tools and operations, and the System Transcript.
The general-purpose, object-oriented computer programming language that is provided by VisualWorks, and a dialect of Smalltalk. The applications you build with VisualWorks are implemented in the VisualWorks Smalltalk language, as is VisualWorks itself.
The collection of interacting
objects implemented in the VisualWorks Smalltalk language. Some of these objects provide functions that make up the VisualWorks software development system: the compiler, debugger, browsers, and so on. Other objects in the system exist so that you can incorporate them into your own applications, as, for example, when you use
classes in the VisualWorks application framework. You extend this system whenever you create new objects.
A control that appears in an application's graphical user interface, such as an action button, an input field, or a scrollable list. Widgets enable the application user to view information, enter information, or invoke operations.
A display area on the screen that is part of an application's graphical user interface. A window presents the user with information and controls for invoking operations. You create a window for an application by painting a canvas and installing it in an application model.
A copy of the standard image in which a user does his or her own work.
A window in which you can enter text and/or evaluate fragments of Smalltalk code. To open a Workspace, choose
Tools ? Workspace in the VisualWorks main window.
