Practical Smalltalk. Using Smalltalk/V
This is a well-written book about the ``hands-on use of a Smalltalk dialect, Smalltalk/V 286. The reader has to have some experience with Smalltalk (no tutorial on the language is given, but a useful short overview is provided). The emphasis is on producing real applications, and throughout the book the authors advice the reader about those properties of the language and the environment that they consider to be not sufficiently emphasized in the Smalltalk/V manuals. Although the book is about the Smalltalk/V implementation on an IBM PC. This reviewer was able to work - almost literally - with the examples and advice on his Macintosh where the implementation of Smalltalk/V is slightly different. The presentation is informal and usually based on examples. The authors do not delve into the intricacies of the highly non-trivial class library (e.g., concepts like metaclass are not mentioned). Their approach is very pragmatic, so that Smalltalk is used ``just as a very useful tool for building applications, with a very strong emphasis on the user interface. Some (fragments) of these applications may well be successfully reused by the reader. The authors state that ``the model-pane-dispatcher (MPD) triad is central to Smalltalk/V programming; although the statement is questionable, the presentation is centered around this triad. As the authors note in the Preface, they do not each object programming concepts and methodology: the reader is supposed to ``understand key OOP ideas, at least minimally, as a prerequisite. The authors do, however, overview the Smalltalk environment and provide a general guidance and useful pragmatic advice for creating applications. Inheritance and uninstantiated classes are discussed in a clean manner (the one page about the latter perfectly explains their purpose). However, the - not less important - explicit and conscious use of information hiding characteristics of Smalltalk is not stressed throughout. Sometimes the authors seem to present a rather hacking approach to creating applications (e.g., in the first application the class Screen Dispatcher is changed with only a gut feeling that this is correct; the same is true for the last application and the newly created class Entry Text Pane; at times, the authors overemphasize experimenting with the internals of the class library). Quite a few program fragments seem to appear out of the magic hat, and some constructs are used before they are defined. The authors' overemphasis on user interface issues (used for most of the projects and examples) leads to often lengthy and painstaking Smalltalk code. As a result, the power of Smalltalk is blurred, and certain explanations are somewhat shallow. First, the majority of Smalltalk users will want to use it for ``getting the job done rather than for enhancing the user interface (and the job is often not a graphing or a form application). Second, it seems that user interface applications (and the existing non-trivial MPD class library) in Smalltalk may be reasonably understood, appreciated, and changed only after some maturity is achieved in more conventional applications. The code for the latter is usually easier to understand. (This is exactly the approach taken in \textit{J. P. Wilf LaLonde} [Inside Smalltalk (Vols. 1-2). Prentice-Hall (1990)] which deals with user interface applications only in its Volume 2. Additionally, it provides more advice on the use of abstraction, including information hiding for methods in subclasses.) Note also that reuse of user interface classes is quite complicated and may violate information hiding: e.g., in Chapter 7 method code is often copied from a superclass to its subclass and modified there without a complete understanding of its work. If there is a need to find out which method does what (e.g., to override a certain functionality), the authors recommend (in Chapter 11 and elsewhere) to look into the methods' code. Although this recommendation works, it also violates information hiding, and therefore appropriate caveats are needed. This is especially important for the prospective reader of this book who is supposed to be not very experienced in object information management. There exists no reference list, and there are almost no references in the text - an important shortcoming for a reader who decides to obtain a deeper understanding of the concepts used in the book. There exist some misprints in the program texts.
This page was built for publication: Practical Smalltalk. Using Smalltalk/V
Report a bug (only for logged in users!)Click here to report a bug for this page (MaRDI item Q3997656)