This is a book to be experienced, not to be cold-bloodedly reviewed. Lalonde assumes that readers have immediate access to a copy of Smalltalk to discover programming for themselves. The book acts as a guide and educator in this strange environment--strange because no programming background is assumed (indeed, the first chapter covers such issues as mouse movements and window control).

Educationalists tell us that the ways of learning are progressive differentiation and abstraction. Progressive differentiation means refining a concept by discovering subsets of the general idea; it is typical of a reference manual. Abstraction takes two steps. First we associate similar concepts, then we discard the differences between the concepts to form a more abstract concept.

Lalonde uses both progressive differentiation and abstraction. One theme is the progressive differentiation of the computer unit into parts. In common with the first chapter of many programming textbooks, Lalonde starts by introducing the computer, describing its major hardware components. Of course, the description has to be different from that in structured programming textbooks in order to support the development of object-oriented programming. Thus the individual parts are described as objects. (The description is still incomplete in that Lalonde does not note that the parts are linked together by a message bus.) The machine description finishes with a description of windows as an introduction to the Smalltalk environment.

Chapters 2, 4, and 9 are further refinements of the concepts involved in the language. Chapter 2 more precisely defines windows, messages, receivers, and selectors. Chapter 4 uses a description of a browser to more completely define classes and methods. Chapter 9 gives a quick summary of the Smalltalk library.

Most of the book, however, uses exploratory learning by looking at case studies. These case studies are not exemplars of a principle enunciated earlier in the chapter; rather, they are teaching about problem solving the object-oriented way. The student is expected to explore the case studies to learn the principles involved. To really evaluate this book, you need to do the case studies yourself.

To guide the student, each chapter has an introductory section on “What You Will Learn” and concluding sections entitled “What You Did and Did Not Learn,” “Important Facts,” and “Helpful Hints,” as well as the more usual sections called “Summary,” “Keywords,” and “Exercises.”

The section on “What You Did and Did Not Learn” reviews the concepts covered by the chapter to strengthen the student’s correct understanding of ideas found by exploration. As such, it is an integral part of the teaching and is distinct from the chapter summary. The section called “Important Facts” does include facts but also often reinforces low-level concepts. From chapter 5 onward, the low-level concepts associated with programming are collected into their own section, called “Helpful Hints.”

Exploration starts in chapter 2, where the student is encouraged to examine classes and messages using inspectors, so that these concepts can be developed from experience. Exploration continues in case studies in chapters 3, 5, 6, 7, 8, and 10. Chapter 3 is an introductory case. Developing the solution to the problem leads to the need to learn about browsers, the topic of chapter 4. Chapter 5 covers methods, classes, and debuggers; chapter 6 covers hierarchies of classes; and chapter 7 covers program development using object containers such as dictionaries. Chapter 8 examines evolutionary software development and design.

Two of the concepts developed in these chapters are hierarchy and inheritance. In chapter 3, the simple idea of “levels” is touched on in an exploration of local and global variables. Many examples in chapter 5 provide the support for the more abstract concept of a class hierarchy covered in chapter 6. Chapter 7 uses progressive differentiation from the class “collection” to teach about various classes. Without drawing attention to this goal, the two case studies in this chapter introduce the concepts of a collection as an aggregation of entities and a collection as an abstraction. The case study in chapter 8 builds on this so that finally Lalonde can discuss the differences between an is-a hierarchy (generalization) and a part-of hierarchy (aggregation). Throughout the book, many concepts are covered in this spiral manner.

Chapter 9 is a quick guide to various classes in the Smalltalk library, while chapter 10 skims the use of windows in classes. Both could benefit from expansion.

The book includes a three-page appendix giving the syntax of a subset of Smalltalk and an 18-page glossary. The index appears to be adequate.

It is difficult to compare this book with others on the market, as it is one of the few to try teaching object-oriented programming to neophytes. Further, it uses discovery techniques rather than the more usual didactic teaching. Textbooks using discovery techniques are often similar to good laboratory handbooks. As in many such laboratory handbooks, this work contains no references for further reading. This omission is a liability if no provision is made for the student to be introduced to more theoretical issues once the basic introduction to programming is effected.

Discovery techniques tend to take longer and cover less material, though the material covered is usually better understood. If you like discovery techniques, you will find that Lalonde provides a good framework for the reader to develop the abstraction of object-oriented programming. It is now the prescribed text for the introductory object-oriented programming class that I teach to first-year undergraduates.