Smalltalk and Object Orientation: an Introduction - Free

6. Smalltalk Building Blocks
6.1 Introduction
The aim of this chapter is to present an introduction to the Smalltalk Programming Language. The
scope of this chapter is to describe some of the features of the Smalltalk language. As such it is not
intended to be a comprehensive guide to the Smalltalk language. For a detailed description of the
Smalltalk language’s syntax and most commonly used constructs see, Appendix 1.
The remainder of the chapter is structured in the following manner: Section two introduces the basic
elements of the Smalltalk language. Section three discusses the concept of classes and instances in
Smalltalk and how they are defined. Section four presents methods and method definitions.
6.2 The basics of the language
Smalltalk is a completely object oriented language and as such has no other concept other than object.
The actual language is very, very small, however the Smalltalk system (as exemplified by VisualWorks)
is very big. All Smalltalk programmers make extensive use of the existing classes e ven when they are
writing relatively trivial code. For example, even when a programmer writes the following version of
the traditional “Hello World ” program they are reusing existing classes (rather than just using the
language):
| myName |
myName := 'John Hunt'.
(myName findString: 'Hunt' startingAt: 1)
ifTrue: [Transcript show: 'Hello ' , myName]
ifFalse: [Transcript show: 'Hello World'].
In this example, I have reused the String class to represent the string ‘John Hunt’ and to find a
substring in it using the message selector findString:startingAt:. Some of you may say that
there is nothing unusual in this and that in many languages string handling facilities are extensions to
the lang uage. However, in this case, the result of the test is an instance of either True or False
(subclasses of Boolean ) and that this message receives the message ifTrue:ifFalse:. What is
printed to the Transcript obje ct depends on which object actually receives the message. Thus,
ifTrue:ifFalse: is not part of the language but a method defined in a class. In most languages the
if-then-else construct would be an inherent part of the language - in Smalltalk it is not. Th is is because
everything is an object in Smalltalk, thus all language constructs are messages sent to objects. This
feature also illustrates the extent to which existing classes are reused - that is, you can’t help but reuse
existing code in Smalltalk because you do so by the very act of programming.
As well as possessing a completely object oriented programming paradigm, Smalltalk also possesses
an inheritance mechanism. It is this feature which separates Smalltalk from object based languages such
as Ada - they do not possess inheritance.
The availability of inheritance is very important in Smalltalk. For example, it promotes the reuse of
classes as well as enabling the explicit representation of abstract concepts (such as the cl ass Collection)
which can then be turned into concrete concepts (such as the class Set). It is also one of the primary
reasons why Smalltalk is so successful as a rapid application development tool - you inherit much of
what you want and only define the wa ys in which your application differs from what is already
available.
61