Smalltalk and Object Orientation: an Introduction - Free

6.2.1 Some terminology
We will now recap some of the terminology introduced in Part 1 of this book, however we will explain
this terminology with reference to Smalltalk.
In Smalltalk programs are run or actions are performed by passing messages to and from objects. A
message is a request for some procedure (referred to in Smalltalk terms as a method) to be performed by
the object receiving the message (referred to as the receiver of the message). The object which sent the
message in the first place is referred to as the sender. Just as procedure calls can contain parameters , so
can messages. In addition, just as in some functional languages, all method executions result in a
response being returned to the sender.
Smalltalk is not a strongly typed language. That is, you do not specify that a variable will take a
certain type of data structure. Nor does the compiler attempt to check what types a var iable possesses.
However, it is not true to say that Smalltalk is not typed. Each object is an instance of a class. These
classes give an object a type (as defined by the class). It is possible to send a message to an object to
determine the type of its cl ass. Smalltalk is thus a dynamically typed language. This is a feature of
Smalltalk which promotes its abilities as a rapid application development tool. It also enables the
polymorphic facilities available to be utilized appropriately.
6.2.2 The Smalltalk message passing mechanism
The Smalltalk message passing mechanism is somewhat like a procedure call in a conventional
language. That is:
• The point of control is moved to the receiver; the object sending the message is suspended until a
response is received.
• However, the receiver of a message is not determined when the code is created (at compile time)
it is identified when the message is sent (at run time).
This dynamic (or late) binding mechanism is the feature which gives Sma lltalk its polymorphic
capabilities (see Chapter 1 for a discussion of polymorphism).
Another difference between the message passing mechanism of Smalltalk and the procedure call
mechanisms of other languages, is that much of what one would consider the ba sics of the language are
implemented using message passing (for example the equivalent of control and iterations structures).
This means that not only is message passing fundamental to the language, it is also a critically important
feature of the performance of the language.
6.2.3 Smalltalk statements
In the remainder of this chapter you will encounter a number of pieces of Smalltalk. It is therefore
useful to introduce you to one of the features of the Smalltalk language; the statement terminator. In
Smalltalk this is the full stop (or period). For example:
Transcript show: 'Hello World'.
Thus the majority of statements will terminate with a ‘ .’. There are a few situations in which it is not
necessary to terminate a statement with a full stop. However, in these situations it is often a good idea to
do so. In this and following chapters, we shall adopt the convention of always terminating a statement
with a full stop (period).
6.3 Classes
A class is the basic building block in Smalltalk. Classes act as templates which are used to construct
instances. This means that programmers can specify the structure of an object (i.e. what instance
variables etc. it will possess) and the function of an object (i.e. what methods it will have) separately
from t he objects themselves. This is important, as it would be extremely time -consuming (as well as
inefficient) for the programmer to have to define each object individually. Instead, they define a class
and create instances of that class.
62