This is a review of the book “Smalltalk-80” by
The intention of this lightweight softcover booklet might have been to serve as a brief introduction and quick lookup reference for an application programmer who has prior experience with object-oriented programming languages, but is new to Smalltalk-80 and/or its language category. The reader can easily pick up the basic concepts and some of the idiosyncrasies that result from Smalltalk’s event-based mechanisms. On the other hand, there are not enough pages available to go into much detail regarding the system’s internals that directed the design of the programming environment. It should be noted that a certain amount of today’s continued interest in Smalltalk originates from its conceptual and technical implementation approach. While the book is too short to go into these topics, it still offers pointers to the system’s affordances for a reader who is not already familiar with the object-based programming paradigm.
In the book’s capacity of providing a reference, the base class hierarchy is presented in a rather decent manner. Some confusion might come from Smalltalk-specific terminology, especially if conflated with similar names and concepts of other programming languages, leaving to wonder to what extend these differ or are the same. Don’t expect help in the area of comparative language study.
After the general overview covering topics like the meta objects, meta classes and language syntax, about ⅓ of the pages are dedicated to describing utility classes including listing their messages → methods, accompanied by the keyword (= parameter) signatures and a short summary where useful or relevant. Interestingly, built-in classes for streams, processes and graphics received chapters as well. While the book neither attempts comprehensiveness nor completeness, graphics likely get addressed to expand on the particular strengths of a Smalltalk system its programmers can benefit from. Especially the graphics classes seem pertinent for Smalltalk having pioneered graphical user interface aspects and schemes. The various screenshots also manage to refresh the notion that the Smalltalk developer is not entirely working with program source code as text, but is expected to express and organize software in the from of objects communicating with each other, too aided by corresponding browser windows and contextualized menus.
Not a lot of example code can be found beyond the snippets that illustrate a certain point, and even the code of the example application at the end of the book is shown inside of screenshots, as it’s located in and tied to the message handling being accessed via the visual browser. Another oddity is the section on the Model-View-Controller model, which is a very reasonable suggestion to the application developer in the Smalltalk context, but a beginner might not easily grasp why, when and how to make good use of this arrangement versus instead ending up with just building any arbitrary custom GUI controls framework from scratch. The work is concluded by a short index that’s primarily compiled from class names, code construct names and main subject terms.
The print layout suffers quite a lot from the monospace typesetting, importantly lacking clear indication of what’s inline code. Class names are sometimes typeset in bold, but only occasionally so, based on their first mention in the text? This makes it rather difficult to read a paragraph, as names cited from source code appear next to and indistinguishable from any other regular English word. Also, indentation is often the only means by which the method reference is structured. For constraint of space not allowing for spacing, this messes with the word-wrap of the prose around it. A horizontal line is mostly reserved for making tables, and too it’s questionable if such would have been a good idea to use as a divider elsewhere, potentially scattered all over the place. Not a lot of visual icons were available. At least, a few typical symbols like the up-arrow ↑ (= return) are incorporated, but for the most part, inline code left-arrow ← (= assignment) is mocked as <-. As always, Smalltalk’s own special character set does not fully translate well over into ASCII. A few typos remain, the majority left hard to spot because of the layout’s uniformity. Their significance is low per both rarely being located in code and not being many in numbers to begin with.
More so than with other contemporary titles, it shows that this artifact was a product of its time. The assumption, expectation or hope seems to have been that the Smalltalk practice or the fixed Smalltalk-80 manifestation would become more commonplace, and an intro to such an object programming environment would be a meaningful resource for an application programmer. However, back then and similarly in our days, the audience is limited to those who have access to a Smalltalk implementation, regardless of whether it had been for lack of hardware, proprietary copyright reservation or is now for lack of ubiquitous support. Anyway, this book is an excellent contribution for gaining some insight into how programmers might develop applications in and for an object-based system, what Smalltalk-80 offers and what had been avoided and left out. These considerations only grow in importance with the increasing population of developers who have never encountered the object-based paradigm. Unfortunately, this book would render the study somewhat unpleasant because of its primitive typesetting, irrespective of the content, which otherwise is fine and adequate for the intended scope.
Copyright (C) 2025