Product Description
This book describes the design goals and language features of object-oriented languages without viewing them from the perspective of any particular language.Covers key object-oriented principles — date abstraction, inheritance, polymorphism, and dynamic binding in a language independent discussion that focuses on the purpose of each feature. ... Read more

Customer Reviews (14)

Buy this book.
This is a pretty nice piece of work of a bass player, educated at MIT and former instructor at the EECS Dept. of the University of Illinois at Chicago! I was one of the lucky ones who took the Object Oriented Conceptsand Programming class at UIC, when Caleb was teaching the class. This isyour definite reference, delivered from someone who really *knows* theconcepts covered in the book.

A long way from "Random Football"
A short thirty years ago, one of the best bass players on the planet was slightly distracted by all nite work in the computer lab in Champaign-Urbana... I can see that what was Jazz's loss, is an engineeringgain. It a long way from "Soft Machine", "RandomFootball", and basement study sessions, but it appears to have beenworth it. Congratulations, Cal!

A great book...sorry it had to end
With no doubt, this is the best book on object-oriented programming out there. The author addresses not only the theoretical concepts behind OO-programming, but he outlines how to do it using Smalltalk, one of the first OO-languages, and C++, certainly one of the most widely-used OO-languages. I do not know Smalltalk, and did not read the part on this language, so my comments will be limited to the sections on C++ and the general discussions on OO-programming.

The author gives an overview of the semantics or "meaning" of a program. He is very thorough in his treatment, and some of the areas that I found particularly well-written include his discussions of:Order of evaluation and side effects; conditional, controlled, and implicit iteration; the importance of strong typing in giving more reliable code; the run-time stack; passing by name, by value, by value-result,and by reference; declarations versus definitions; the difference between static and dynamic typing; static versus dynamic scoping; object lifetime and instantiation; static, automatic, and dynamic storage; data types; pointers; constrained types; encapsulation and information hiding; abstraction mechanisms; programming paradigms, including imperative, functional, logic, and object-oriented; =class semantics; the distinction between "pure" OO-languages such as Smalltalk, Eiffel, and Java, and hybrid OO-languages such as Object Pascal, Oberon, Delphi Pascal, Ada95, C++, and Objective C; the tradeoffs between execution time and dynamic binding in C++; the justification for using in-line functions rather than macros in C++; static, file, local function, and class scope in C++; static and dynamic storage allocation of objects in C++; the distinction between a class in C++, which must be an instance, and thus not "first-class" as in Smalltalk; friend declarations in C++ and how they depart from OO-philosophy; the example of the "Queue" class; the "this" pointer in C++; "smart" pointers in C++; and class templates in C++.

He does not include a discussion of object-oriented design methodologies (Booch, etc), but does give references for further reading. Excellent summaries are given at the end of each chapter along with exercises.It is definitely a book that serves well also as a reference, even though it was published in 1997, and some changes to the implementation of C++ have occurred since then.

A good attempt to capture OO language features
If you have found that after coding in C++, java, smalltalk or any other OO language that there are certain concepts that have remained ambiguous this books makes a good attempt to make clear distinctions between them.The information is there however it requires a good deal of work to extractit.It would benefit from further layering of concepts, improvedorganization and tighter cross referencing. As it stands it is a little toodense.

A Very Good Book.
This is an excellent book. It illustrates the OO concepts and the languagedesign using Smalltalk and C++ as examples. I have to say it is a very verygood book. C++ and Smalltalk go opposite direction in term of implementingthe language. If you like Bertrand Meyer's book on Eiffel (Object-OrientedSoftware Construction), you should love this book. I learn a lot from thisbook. I recommend this book. ... Read more

Product Description
This reference and text treats the Smalltalk programming system and the web of object-oriented ideas within and around it. Thus it is more than a guide to the language; it also examines Smalltalk in its technical and historical setting, and along the way addresses the questions that every Smalltalk developer sooner or later naturally wonders about. Assuming nothing more than general programming experience, it begins with what objects and classes are, and eventually progresses to subtle matters such as the distinction between types and classes. Going beyond typical programming language books, it also covers the most important design patterns and how to write them in Smalltalk. The thrust then is not merely programming in Smalltalk with objects, but thinking and designing effectively with objects.

This edition is a reprint of the original 1996 edition. Although the intervening years have brought the accustomed rapid changes in the computing industry, the principles presented here remain as relevant now as then.

"Three of my favorite topics are Smalltalk, objects, and design. Chamond Liu's book is the perfect blend of these topics. I heartily recommend this book to practitioners who don't want to read a dry treatment on design methodology or yet another programming book. You will be treated to elements of good design, a historical perspective, design patterns demystified and coded in Smalltalk, and just the right mix of Smalltalk programming and object concepts."—Rebecca Wirfs-Brock, author of Designing Object-Oriented Software

"Well-written and well-thought-out. . . . The chapter on design patterns especially is first-rate."—Doug Lea, author of Concurrent Programming in Java, and Object-Oriented System Development

"One of those rare books that rewards both beginners and experts with insights appropriate to their levels. In addition, the writing style—combining incisiveness and grace—makes it a real pleasure to read."—Dave Collins, author of Designing Object-Oriented User Interfaces

"Best book on Smalltalk I've seen!"—Sherman Alpert, author of The Design Patterns Smalltalk Companion

". . . approachable, literate, fun, accurate and different . . . the writing is of the highest calibre."—Ralph Johnson, author of Design Patterns: Elements of Reusable OO Software

"I am very impressed with it. . . . Unlike all of the other books, it covers all of the important issues relevant to effective understanding of the language under one cover."—Ed Klimas, author of Smalltalk with Style

"What I liked most about this book was the confidence with which Liu presents a wide range of topics: objects, architecture, gui, frameworks, design, patterns—all the right stuff. If a bright developer from some other branch of our discipline were to use his book as his only source of information, he would come off as savvy and well connected, even at a Smalltalk conference. And he would enjoy the experience too, since Liu never talks down to his readers."—Ward Cunningham, CRC Card inventor

"A very solid and entertaining book by an expert communicator . . .. Beginners and old hands alike will find useful ideas, entertaining writing and thought-provoking allusions to broader technical, literary and philosophical topics."—Martin Nally, chief architect of IBM Smalltalk and VisualAge

". . . the scope and level very interesting . . . a very useful collection of things which are spread around and hard to find . . ."—Tom Morgan, Manager of Technology Development, Brooklyn Union Gas

"A very well written book; a pleasure to read cover to cover. Good chapters on design patterns, metaclasses and garbage collection, etc. You can tell by the writing style that the author is also a teacher—conveys information gracefully and effectively. Highly recommended."—Paul Jasek, Chubb & Son, Inc.

Customer Reviews (16)

Veteran Smalltalk developer's idiosyncratic catalogue
---QUOTE---
This book is about Smalltalk and objects... By no means is this an advanced book, on either Smalltalk or objects. I have strived to stick to the matters that seasoned Smalltalk developers are fully aware of but consider too obvious to explain.
---END QUOTE---

The book is really interesting to read and touches many OOP-related concepts, concerning the nature of classes and objects, often such that remain in shadows. One problem is that it doesn't explore anything to depth. The other problem is that the book is not about anything in particular. Smalltalk ? Check. Objects ? Check. Design ? Check. So, what is it about ? Difficult to say.

Here is the cast in order of appearance:

1. Objects, classes and inheritance.
2. Smalltalk introduction.
3. Abstract classes.
4. Containers.
5. CRC cards.
6. Inheritance vs. aggregation.
7. Use cases and dynamic relationships.
8. MVC model.
9. Windows, Motif.
10. Designing UI.
11. Polymorphism.
12. Internals of OOP language's virtual machines, garbage collection.
13. Design patterns in OOP development.
14. Frameworks (one hearty example).
15. Metaclasses.
16. Why software development is still difficult.

See any plot ? I don't. And it's because it's not there.

---QUOTE---
This is not an orthodox book. Much of its structure derives from my experiences in sustaining the eagerness and momentum of typical Smalltalk beginners, making sure they learn some really important things.
...
The approach is not encyclopedic. ... You will not find a predictable or monotonous rhythm.
...
Many chapters are relatively independent and accessible without having to digest everything that comes before...
---END QUOTE---

The only hint to a plot that I found was the "hearty example" title. After reading the book I had this impression that the author essentially told his path to the object-oriented framework development. This is why the discussed design patterns accidentally were exactly the ones required for the discussed framework. This is why the object-related topics discussed were essential for explaining it. In other words, this is a book of one-man life philosophy, where veteran Smalltalk developer shares pieces of wisdom with the beginners.

For someone who is not a Smalltalk beginner taught by a veteran developer, this book is at best an insightful hint. If you are interested in object-oriented development, pick and read any chapter that you like, don't bother to read through. You will discover many interesting issues, rarely seen anywhere.

Elegant
If Chamond Liu's code writing is as good as his writing in this book...it must be elegant.

Not what I was looking for
I wanted a book I could pick up, read fast, and get a quick, passable knowledge of Smalltalk from. This was not the book, but perhaps it never meant to be.

It meant to be used by someone sitting down at a keyboard with a Smalltalk compiler in hand (i.e., not me). The book starts gently, with a few simple expressions to type at the interpreter's command line. Before it even gives the syntax for a Smalltalk function, though, it gives a comparison if the different syntaxes used for inheritance in seven languages, four obscure or obsolete (p.23). The next sections explain simple language elements, unfortunately in terms of GUI-based tools that the reader may not have at hand.

The next few sections wander back and forth between language features, OO design topics, a deeper look under the compiler covers than any beginner really needs, and a shallower look at the libraries than anyone could get by on. This last is especially frustrating in a "small" language, where so much of the capability is built up in the libraries. Instead, we just see a keyword here and there, with no attempt to bind them into a coherent whole. This organization could possibly have made sense if the book were a text for a semester course. If so, it's true to its breed: I generally find them to be poor self-study guides, especially for experienced programmers.

Perhaps this book is good for some purposes, just not for mine.

//wiredweird

Great book for beginners and no-longer-beginners alike
When I first looked into this book I thought "Oh well, this is just another book for Smalltalk and OOP beginners". Well I was wrong.

This book starts indeed from the fundamentals (objects and messages) and warns against certain pitfalls that beginners are prone to. It covers a few aspects of the class library, especially container classes as well as the MVC paradigm.

This book strongly focuses on design questions, i.e. "When to buy and when to inherit". It has a great chapter on "Specificaton inheritance" vs. "Implementation inheritance" and a chapter explaining the concept of design patterns as well as giving some example patterns for Smalltalk.

While a Smalltalk beginner might need more books to give a more complete introduction into the class library, this is a good book to expose beginners to the nuances of Smalltalk and OOP. The more advanced will appreciate the nuances in the design discussions especially in the 2nd half of the book.

In summary I can highly recommend this book for beginners and no-longer-beginners alike.

Like the title, this book is pure distilled information
"Smalltalk, Objects, and Design" is such a simple and unexciting title, and yet that's what this book is, in its entirety. This book will teach you about Smalltalk, it will teach you about objects (using Smalltalk as the medium, but you will learn much about Object Oriented programming that is applicable in any language), and it will teach you about good design principles.

It is written in clear, straightforward prose. In each chapter, the author presents a new idea, discusses the reason for that idea and its implementations (and often discusses several alternative solutions to a given problem that have been adopted historically or in other languages, as well), then gives some concrete examples, some exercises to reinforce the point, and then summarizes. I learned a lot of things in this book that I only vaguely understood before. How garbage collection works. How Smalltalk really accomplishes "everything is an object." What "weak references" are and how to use them. How the Model-View-Controller framework works. There are good discussions about inheritance and how to avoid overusing it, implementation of polymorphism, reifying methods, and so on. Good, meaty stuff especially for the beginning OO programmer.

This book talks about Smalltalk from a design perspective, so while there is an introduction to Smalltalk and a lot of examples to help you learn, it really isn't intended to teach the language. If you have no Smalltalk experience at all, the book will teach you enough to follow along, but you'll want another book to go further in the language. It is fairly implementation-neutral; the author uses IBM's VisualAge for his examples, but he provides tables and footnotes when it's necessary to point out the differences with other Smalltalk implementations such as VisualWorks, and as a VisualWorks user myself, nothing in this book threw me off.

Objects are explained in great detail, starting with the hierarchy (in Smalltalk), what classes really are, how inheritance really works, "buying" vs. "inheriting" (i.e., "has-a" vs. "is-a"), abstract classes, Containers, polymorphism, and many other crucial OO concepts. Again, it's focused on Smalltalk but if you do OO-programming in Java or C++ or some other language, there is a lot here that will be useful to learn (and the author even adds footnotes here and there commenting on how certain things are done in C++ or other languages).

The design chapters are good, though not as thorough, as software design is really a vast subject requiring many books in its own right. The author gives brief treatment of a lot of practices covered in much more detail in other books; for example, there is a chapter on design patterns, much of which is adapted from the famous "Gang of Four" book "Design Patterns" (Gamma, Helm, Johnson, and Vlissides). The author talks about CRC cards, UI design, software engineering practices, frameworks, and other topics that can't really be done justice in a chapter each.

If I were teaching a class in Object-Oriented Programming, I would use Smalltalk as the language to teach basic OO concepts, and I would use this book as the text. Even if I had to use Java as the teaching language, I would find a good Java-based book on OO-programming, and supplement it with this one.

The final chapter, "Why Developing Software is Still Hard," was the author's opportunity to digress, and is worthwhile for all new programmers to read. Basically, there is a lot of Object-Oriented Kool-Aid out there, and if you take this chapter to heart, you'll avoid drinking some of it. ... Read more

Product Description

Numerical methods naturally lend themselves to an object-oriented approach. Mathematics builds high- level ideas on top of previously described, simpler ones. Once a property is demonstrated for a given concept, it can be applied to any new concept sharing the same premise as the original one, similar to the ideas of reuse and inheritance in object-oriented (OO) methodology.

Few books on numerical methods teach developers much about designing and building good code. Good computing routines are problem-specific. Insight and understanding are what is needed, rather than just recipes and black box routines. Developers need the ability to construct new programs for different applications.

Object-Oriented Implementation of Numerical Methods reveals a complete OO design methodology in a clear and systematic way. Each method is presented in a consistent format, beginning with a short explanation and following with a description of the general OO architecture for the algorithm. Next, the code implementations are discussed and presented along with real-world examples that the author, an experienced software engineer, has used in a variety of commercial applications.

On the enclosed CD-ROM, you'll find files containing tested source code implementations of all the algorithms discussed in the book in both Java and Smalltalk. This includes repository files for VisualAge for Java and VisualAge for Smalltalk under ENVY.

* Reveals the design methodology behind the code, including design patterns where appropriate, rather than just presenting canned solutions.
* Implements all methods side by side in both Java and Smalltalk. This contrast can significantly enhance your understanding of the nature of OO programming languages.
* Provides a step-by-step pathway to new object-oriented techniques for programmers familiar with using procedural languages such as C or Fortran for numerical methods.
* Includes a chapter on data mining, a key application of numerical methods.Amazon.com Review
Didier Besset's Object-Oriented Implementation of Numerical Methods offers a wide-ranging set of objects for common numerical algorithms. Written for the math-literate Java and Smalltalk programmer, this volume demonstrates that both languages can be used to tackle common numerical calculations with ease.

This title bridges the gap between pure algorithms and object design. By tackling issues like class design, interfaces, and overcoming floating-point rounding errors in both Java and Smalltalk, the code can be used as-is or as a model for your own custom numerical classes.

The range of recipes, or sample numerical classes, all coded in both OOPLs, is rich. For anyone who's taken a few undergraduate math courses (like calculus, linear algebra, or statistics), plenty of the material will be familiar. After presenting some basic algorithm and mathematical principles, the book shows you the code that gets the job done (first in Smalltalk and then in Java). There's no room for demo code that shows how to use all this. The emphasis is on a good cross-section of common numerical calculations. The tour begins with calculus and moves through linear algebra, with plenty of material on matrices. Later sections on statistics cover familiar terms and calculations such as linear regression and calculations useful for establishing correlations between one or more independent variables. Sections on data mining examine the mathematical rules for finding patterns in large amounts of data. (There's also a nifty set of classes for implementing genetic algorithms.) Throughout, you get advice on choosing the right algorithm for the job. (There are class diagrams that map out how this class library is organized.)

Of course, it will help to know some of the underlying math to get the most out of this intelligent and wide-ranging book, but the writing is remarkably clear and the source code is a model of intelligibility, so even readers who are averse to equations will find Object-Oriented Implementation of Numerical Methods readable. In general, any competent Java or Smalltalk programmer will be able to tap into solid mathematical code by reading it, without having to reinvent the proverbial wheel. --Richard Dragan

Topics covered:

• Introduction to numerical methods and objects in Java and Smalltalk
• Numerical precision and rounding errors
• Comparing floating-point numbers
• Functions in Smalltalk and Java
• Evaluating polynomials
• The error, gamma, and beta functions
• Interpolation algorithms (Lagrange, Newton, Neville, Burlirsch-Stoer, and cubic spline interpolations)
• Choosing the right interpolation method
• Iterative algorithms
• Finding the zeroes of functions (the bisection method, Newton's method, roots of polynomials)
• Integration of functions (trapeze integration method and Simpson and Romberg integration algorithms)
• Open integrals
• Choosing the right integration method
• Infinite series
• Continued fractions
• Incomplete gamma and beta functions
• Algorithms for linear algebra
• Vectors and matrices
• Linear equations (backward substitution, Gaussian elimination, LUP decomposition)
• Matrix determinants and inversion
• Eigenvalues and eigenvectors of nonsymmetrical and symmetrical matrices
• Statistical moments
• Histograms
• Probability distributions (normal, gamma, and experimental distributions)
• The F-test
• The t-test
• The chi-squared test
• Least-fit square algorithms
• Optimization algorithms
• Extended Newton algorithms
• Hill-climbing algorithms
• Powell's algorithm
• Simplex algorithm
• The genetic algorithm
• Data mining
• Covariance
• Multidimensional probability distribution
• The Mahalanobis Distance
• Cluster analysis and variance

Customer Reviews (6)

Disappointing Introduction to the Implementation of Numerical Methods
As a mathematically oriented programmer I found no interesting ideas in this book. The content and treatment of the material is a bit too simplistic and, when viewed as an introduction, it looks unattractive.

Also, as a Smalltalk programmer, I was disappointed with the way algorithms are implemented. The author makes no attempt to take advantage of the wonderful expressiveness of the Smalltalk language. Classes and methods have been given awkward names; the source code is not elegant; basic objects such as matrices and polynomials are insufficiently modeled and treated as mere data structures; algorithms are not viewed as objects but as conventional procedures. Because of the flatness of the approach the resulting programming style is ugly when compared to Smalltalk standards. The eloquence and richness of pure object orientation is not achieved or suggested. SUnit tests, which would have fitted perfectly in all chapters, have been ignored everywhere.

Excellent book
The author is clearly very familiar with the theory and practice of numerical computations in OO languages. For me, the main contributions of the book are an expert formulation of some of the basic numerical techniques and concepts in OO terms (a subject rarely approached in the numerous existing books on OO technology), and examples that can be followed to implement other NM techniques and concepts.

The inclusion of very readable Smalltalk and Java source code is very useful.

For use in a course, I would like to see the material complemented by exercises.

Reconciling Numerical Methods and Object-Orientation
I really enjoyed this book because it shows that a high level language such as Smalltalk can efficiently model a complex domain like numerical methods. Besset presents a conceptual framework where the concepts are extended and reused, showing the power of OO programming. I also liked the structure of examples followed by a formal foundation, implementation, and implementation discussion.

Reconciling Numerical Methods and Object-Orientation
I really enjoyed this book because it shows that a high level language such as Smalltalk can efficiently model a complex domain like numerical methods. Besset presents a conceptual framework where the concepts are extended and reused, showing the power of OO programming. I also liked the structure of examples followed by a formal foundation, implementation, and implementation discussion.

Oh man, is this book neat!
Dr. Besset has written an uncommonly great book where he has given us important tools while teaching object-oriented analysis and design.Having both Smalltalk and Java code included is a gift.As a smalltalker, I greatly appreciate the inclusion of the Smalltalk code.The book is well organized, very readable and provides the basis for individuals to extend the classes provides as well as build applications with the included code.The code also provides solid examples of object-oriented programming style that will aid the newer programmers in developing effective use of both Java and Smalltalk. ... Read more

Product Description
When the classic book Design Patterns was first published in 1994, the landscape of object-oriented software engineering was forever changed. The 23 patterns contained in the seminal work vastly improved the discipline of object-oriented software design. That book, and the concepts it presented, allowed software professionals to solve specific design problems by reusing successful designs. Design Patterns was a gift to the world of software development, yet Smalltalk programmers could not take full advantage of the book's popular ideas because most of the original patterns were presented from a C++ perspective.In The Design Patterns Smalltalk Companion, the classic work has been tailored and enhanced to address the specific needs of the Smalltalk programmer. The catalog of simple and succinct solutions has been written in Smalltalk code, and the material is discussed from the perspective of the Smalltalk programmer. The full source code that supports the 23 patterns is also available via the Addison-Wesley Web site. Assembled and written in close conjunction with the authors of Design Patterns, this is the definitive patterns reference for those programming in Smalltalk. This book provides efficient solutions to your Smalltalk design problems, ultimately helping you become a better software designer. ... Read more

Customer Reviews (11)

The essential GOF companion
This isn't a Smalltalk translation of "Design Patterns." Instead, it's a companion to that book. You'll need to read the first one to get the most out of this one. If you have read the first one, you'll find this one is better written and really casts essential light on some of the GOF material. The Smalltalk aspects of this book are really a non-issue (except perhaps showing static-typers how many hoops you don't have to use in Smalltalk). This is required patterns reading.

Useful for Java Programmers too.
I bought this book because of the unresolved questions I had after spending so many hours exploring the GoF original book. I am an experience C, C++, and Objective C programmer, not a Smalltalk guru at all. And I found the GoF very confusing and intimidating. My current projects these days are written in Java (I miss Objective C). I looked for a book that would cover the pattern catalog in Java because I was really questioning the purpose of some of them in that language. Creating some mechanism to overcome the C++ language is somewhat understandable, but why bother with Java. Take the prototype pattern for example: "...It's (the prototype pattern) less important (to use it) in languages like Smalltalk or Objective C that provides what amounts to a prototype..." (page 121) Sure, ok, but what about Java? Can you give me an example on how it would benefit a language that doesn't really require it like Obj C, or even Smalltalk? Then the sample code refers to the maze example but not much material is given here. I bought several books with Java and Design Patterns in the title but was very disappointed with the beginner level these books approach this problem. The titles are seductive but the content is not that great. I don't need another ADOO (I've read Larman's book already. Get it if you are new to OO BTW.) So I ended up getting that book as a last resort. And you know what? It's great. I program in Java all day (and sometimes all night, sigh...) and this book spends more time on my desk than the GoF original one. So, if this comments remind you some of your experience, you should give this book a try. And this book lighted up another bulb in my brain: I ended up downloading Squeak and prototyping in Smalltalk some of my projects just for the fun of it, but that's a side effect I guess ;-)

Easier to understand than the original GoF
This book gives you a better understanding of the patterns than in its original version (the GoF one). I am not a SmallTalk programmer but a 9 years C++ one. At work I had to use the GoF book and never liked reading it. In contrast to this, the SmallTalk companion is easy to read and youcan understand the patterns within the first few lines of theirdescription. Take the Bridge pattern and compare their discussions in thetwo books. If you really like the Gof one then buy it. But according to me,it would be a big mistake buying the GoF in favour of the SmallTalkcompanion. Trust a C++ programmer :-)

More than a GOF Companion.
I found this an exellent book.The original design patterns book drew its examples from C++ applications.I could see a use for the patterns in C++, but I thought most of them would not have been necessary if the code hadbeen written in Smalltalk.

This book did an excellent job of showing howand where the patterns could be used in Smalltalk applications.Theauthors also extended and clarified many of the pattern so that they weresimplier to understand.The book is more than a companion to the GOF book;it is an enhancement of it.

More than a GOF Companion.
I found this an exellent book.The original design patterns book drew its examples from C++ applications.I could see a use for the patterns in C++, but I thought most of them would not have been necessary if the code hadbeen written in Smalltalk.

This book did an excellent job of showing howand where the patterns could be used in Smalltalk applications.Theauthors also extended and clarified many of the pattern so that they weresimplier to understand.The book is more than a companion to the GOF book;it is an enhancement of it. ... Read more

Product Description

This book presents a set of patterns that organizeall the informal experience successful Smalltalk programmers have learnedthe hard way. Understand these patterns, and you can write much moreeffective code. Understand the concept of Smalltalk patternsand why they work. Then learn patterns for working with methods, messages,state, collections, classes and formatting. Walk through a developmentexample utilizing patterns.Smalltalk programmers, projectmanagers, teachers and students -- both new and experienced.

Customer Reviews (19)

Jewel
This book and "TDD" from K. Beck are essential to anyone interested in being a prolific Smalltalk develper. This book is the next level to the vast number of introductory books on the subject.

Great for understanding why smalltalk code is written like it is
I have just recently started looking at smalltalk and like many people (being used to c++), when starting out in smalltalk, just going through the code didn't actually tell me much about anything, it's hard to find where anything is actually being done. After reading this book this task was significantly easier, the reason is simple, after going through this book one gets a much deeper understanding about why the code is split the way it is and gains a real insight into why this is a better approach than the usual C++ style with 100-200 lines of code methods. Kent Beck's writting makes the book a very nice read, must admit i was actually sorry when i finished it.

The Zen of OO
I wish more Java/C#/C++ programmers would read this (and maybe even learn Smalltalk) so that they can appreciate the weaknesses in those languages and possibly in their practices that they might not even realize today. I certainly did. While Robert Martin and others have offered up some of the canon of good design for contemporary developers, this little gem really reveals the "feel" of good OO.

Missable
I'm always looking for ways to make coding work better, at any level from nanosecond arithmetic operations to decade-long enterprise operations. I didn't find much of use here, but there were a few good points here (very few). Let me start with those.

The "Execute Around Method" pattern is good idea, applicable far beyond this Smalltalk context. The Beta language has "inner" inheritance, which makes the idea easy, but most other languages lack a good mechanism for undefined logic between matched operation pairs (open/close, setup/cleanup, etc.) "Enumeration" is another good one, enshrined as "Visitor" in the Gang of Four book.

Most of what's left is either trivial or Smalltalk-specific and face it, Smalltalk is mostly a cult language with nearly no commercial significance. The Smalltalk pretty-printing and variable-naming rules, fatuous at best, are just not applicable to most langages. Some of Beck's "practices" are language features (like 'super'). Other "practices", like the long chapter on Collections, seem to describe standard library classes and messages. Yet others (e.g. Type Suggesting Parameter Name) correct language defects - Smalltalk chose to give up the error detection capability offered by variable typing. Beck tries to sneak it back in with variable naming conventions sort of like Microsoft's old Hungarian naming. Some of his suggestions are just dangerous, like that one that says a constructor should "half-way construct an object in one place, then pass it off to another to finish construction. (p.23)" This distributes an object's setup responsibility across its client classes, leaves unusable and incomplete objects floating around, and causes subtle exposures in multithreaded systems - I'd rip out any code I saw built this way.

The good news is that no new trees died to make my copy of this book - I got it used, and it's returning to the used market. At least my conscience is clean on that account, no matter what I'm doing to the poor guy who buys this book next.

//wiredweird

Milestone for Your Programming Life
SBPP has changed me. Kent Beck has changed me.

SBPP shed a new light on my previous knowledge of "patterns" in computer programming. I was deep in the DP tar pit. SBPP saved me. SBPP changed almost all my thoughts on programming. It has changed what I value, and how I pursue it.

Kent Beck says that he is not a great programmer but just a pretty good programmer with great habits. Build great habits with this book. Read and reread this book every morn.

If you have studied DP, this book will open your eyes to the wider world of patterns. You will think about DPs quite differently after this book. You will be able to escape from the bad effects of DP abuse.

If DPs were nouns, verbs and adverbs/adjectives, SBPP are articles and auxiliary verbs. SBPP are used much more frequently than DPs. When you learn a language it is very important to learn more frequently used words first. It could be less efficient(or even dangerous) to learn "appreciate" before "thank (you)".

--JuneKim ... Read more

Customer Reviews (4)

Foundation work
Learning Smalltalk, and reading this book in particular, solidified my object oriented development foundation. This is a must read for any C++/Java/.NET/Objective C developer. Chances are slim you'll use Smalltalk commercially these days but the concepts laid out here remain true and are widely used across many modern languages some 30+ years after they were born. If you are looking to round out your experience, build perspective, and solidify concepts in your mind; add this to your library and read it. Quick read, easy to follow examples, well worth the money.

The Bible of Object Orientation
This book contains all the theory of object orientation you will ever need. It clear, brilliantly ordered, and besides this, it's refined and exquisite to read.There is a high chance you will have a great time reading it, even if you have spent years programming in other object oriented languages but Smalltalk.
I think it's also a "must" if you work with any object oriented language.
The fact that it's been written 20 years ago it's unimportant for me, because this book addresses mostly theoretical issues regarding Object Orientation.
So my humble advice is, if you want to really understand objects, know what a meta-class inherits from or what is a Behavior, and have fun on the way, read this book.
Some old friends of mine used to say: "it is the only computing science book there is" :)

One of the best book
"Smalltalk/80 - The Languaje" is not only a clasical book, it's a very modern book. Most of the content is incredible actual and very funny to read.

You can't say "I know Smalltalk" if you don't read it.

Out of date but classic
I suppose everyone who uses Smalltalk should have a copy of this book, even if it's just to sit on the shelf, though you will of course get more repect if you have the older out-of-print version (S.80- The language andits implementation).

There are two problems with the book for a Smalltalkuser of today:

1) The book was written a long time ago, and Smalltalkpioneered a lot of concepts in programming languages and IDEs, so veryoften the terms used for various things are not the terms we would usetoday; This makes for a confusing read at times.

2) The book is not veryhelpful from a practical point of view, if you are a new Smalltalkprogrammer struggling to get to grips with the class library because nearlyevery implementation these days has a plethora of non-standard extensionswhich obviously aren't covered, so what you are left with is a guide to thelanguage syntax, which of course famously fits on one page of A4, and abrief look at some of the standard collection classes.

Bottom line: Buythis book to help Goldberg and Robson, because we owe them, read it, thengo back to your implementation's help pages. ... Read more

Customer Reviews (1)

Just an amazing book
Of course all 3 ST published books are classics and all have 5 star ratings from me, this one in particular is GREAT for a newbie getting started with an ST-80 based system like Squeak, at least from a historical perspective.The book covers as its title implies the UI, so don't expect a language lesson here, get this book if you can find it and hold onto it, a huge piece of history and well written.Amazing stuff. ... Read more

Product Description
This unique book employs a dialog between two characters--one a normal human and the other an ObjectLand inhabitant--to help the reader understand the object-oriented paradigm and implement solutions using the object-oriented programming language Smalltalk/V. Contains a useful glossary of object-oriented and Smalltalk terms and abbreviations. 7 x 9. ... Read more

Product Description
A complete introduction to object-oriented programming using Smalltalk/V, the popular version of Smalltalk running on PC's and Apple Macintosh. ... Read more

Product Description
Smalltalk programmer Dan Shafer provides insight into design and coding techniques that are specific to the IBM Smalltalk environment. The book completely explains programming logic through examples, and demonstrates when and how to reuse code. Shafer's goal is to make each reader a more efficient and better Smalltalk programmer. ... Read more

Product Description
Produced in cooperation with IBM, provides encyclopedic coverage of the Smalltalk language. Includes numerous examples to guide readers through the concepts and methods of IBM Smalltalk. Paper. DLC: Smalltalk (Computer language program) ... Read more

Customer Reviews (2)

A good reference book
This book is great as a reference for the class library.I use this book when I'm trying to find just the right Collection or Stream method to use - it's much faster than browsing through all the code.

A good book for people who don't already know Smalltalk
This was my first experience with the Smalltalk language.It was recommended to me by someone who already programs with Smalltalk.I found that this book was very good the second time through.After reading thisbook the first time, a lot of the concepts seemed a little fuzzy.Afterreading it the second time, I then had a better grasp on the language andwas able to program most of the examples given in the book without too muchdifficulty.Knowing now the contents and organization of this book, it isnow one of MY recommended reference and learning books. ... Read more

Product Description
From a well-known developer of object-oriented systems in Smalltalk, this book provides an introduction to programming for the novice alongside complete coverage of the Smalltalk language. The coverage provides a complete introduction to the syntax of Smalltalk, including the Smalltalk libraries and the Smalltalk environment using Digitalk/V as the example environment. ... Read more

Customer Reviews (3)

A good introductory book to Smalltalk and objects
This is a good book for someone who has no OO knowledge/experience wanting to learn Smalltalk for several reasons:1) it avoids overloading the student with too much theory.It is particularly good at side-stepping ahigh-level description of objects in chapter one followed by designingobjects with classes as an exercise in chapter two.In fact, it takes theopposite approach of those Fasttrack books; the first five chapters gentlyintroduce the student to the Smalltalk environment and to objectinteractions.2) It sticks to the task at hand:teaching Smalltalk to theneophyte.It does this by avoiding the Language Comparison Holy War andthe My Style Is Better Than Yours Holy War.3) It takes its time with eachtopic, reinforcing each point with words, exercises and homeworks.

Thereare two points weighing against this book as it stands: 1) it's dated; it'sbased on an older version of Smalltalk/V and uses constructs avoided now(such as the message "become" to change a variable's state).2)For the person on the fast-track, it's slow.It spends a whole chapter onnumbers, and waits three more before discussing classes.

In summary, thisis a good book from which to learn Smalltalk and objects.I recommendusing Smalltalk Express, a descendant of Smalltalk/V freely available fromObjectShare, along with the book.

Excellent in the Basics
A good book for those wanting to get their "feet wet" in Smalltalk. Doesn't go over advanced topics. Overall, a good book.

Excellent!
The book is exceptionally well written and is ideal for Smalltalk beginners. It might also be suited for Smalltalk literates who want to see how CRC design and Smalltalk fit together (Chapter 8).

The book takes you step by step through problems and takes you to a real discovery because it is honest enough to admit that first attempts turn out to be insufficient in later stages.
It, therefore, spares you to wonder how an experienced designer gets everything right the first time, but teaches you to rethink what you have done after each step and how to systematically perform iterative development.

I wholeheartedly recommend the book, which is by the way an excellent fit to the freely available Smalltalk Express distribution (Smalltalk/V). ... Read more

Product Description
Bridging the gap between established software engineering principles and the real-world practice of programming, this book presents guidelines for programming in the Smalltalk language that will result in source code that is clear, easy to read, and easy to understand. Covers layout and structure, code formatting, reliability and portability, and tips. ... Read more

Customer Reviews (7)

great for improving your smalltalk programming style
This is a great book, it really is. The only potential for disappointment is if you think this book will teach you smalltalk -- it will not. This book is about good programming convensions in smalltalk -- it's about styleand consistency and clarity. All this may sound too trivial to merit abook, but consider the following:

You will not find many people thatprogram in smalltalk and you will not be able to see a lot of code. Thismeans that your coding style will take longer to develop *naturally*, onyour own. This is where Smalltalk With Style comes in: It's a small bookand makes simple and easy reading. When you're done with it, you'll put itaside and most likely never refer to it again. But it will change the wayyou write code in smalltalk, and your code will begin to look the waysmalltalk code should. The advantage of this book is that it packsinvaluable programming experience in a wonderful, but not-so-popularprogramming language into a very small book. Get it, read it, get over withit, and go on to write code like a natural smalltalker.

A definitive "Must Have"
This is one of two or three "must have" books that every person interested in or practicing Smalltalk needs to read and keep on a shelf near by. This book will teach you everything you need to know about writingclear and concise Smalltalk code. The author, Ed Klimas, is one of the mostwell known Smalltalk guru's around.

Good summary of 100 or so pitfalls and perils
This books, short and to the point of what to do and what not to do with SmallTalk.Simple, and concise, the book covers issues of style that actually can and do apply to anyone who is interested in creating andleaving quality code in place for others to learn from and prosper.Almosta book about Code Karma.

Essential for the practicing software professional
Smalltalk with Style is an absolute must for any software engineer'sbookshelf. Being practical and easy to navigate, the book directlyaddresses the day-to-day, "where the rubber hits the road" needs of ourdesigners and programmers. We have found its pearls of hard-sought wisdominvaluable to the success of our object-oriented development teams.

Belongs in every Smalltaker's took kit
This slim book does not waste any time in giving the essentials to goodSmalltalk programming practices. From how to name classes and format yourcode, to testing tips, you should be able to improve your classes afterreading through this book. The guidelines which follow each point are clearand relevant. (My alltime favorite is "Don't perform brain surgery onyourself"; it refers to modifying the Base System Classes.) This book,along with David Smith's "Smalltalk The Language" definitelybelongs next to every Smalltalker's PC. ... Read more

Product Description
This is an introduction for students who want to start constructing prototype applications in Smalltalk-80, but who don't want a detailed guide to the implementation. Requiring no previous exposure to Smalltalk-80 or object-oriented programming in general, the text offers a tutorial approach, with a large number of short chapters, each covering specific points. It mixes the language syntax, the class hierarchy and the user interface to maximize student interest and to stress relationships between them, and uses cross-referencing and indexing so that students can find what they are looking for. The book also provides a large number of illustrations of Smalltalk-80 operation, and contains extensive original exercises of various degrees of complexity at the end of most sections. ... Read more

Product Description
In this book, Smalltalk pioneer and guru, Kent Beck, weaves together a collection of his "landmark" articles from leading IT trade journals--The Smalltalk Report, JOOP, and Object Magazine. Written for Smalltalk programmers, this book is designed to help readers become more effective Smalltalk developers and object technology users. It is filled with insider tips, advanced techniques, and proven strategies on getting the most out of the Smalltalk language. Some specific topics covered are patterns, garbage collection, the use of CRC cards, and much more. ... Read more

Customer Reviews (2)

An excellent journey of Smalltalk philosophy
This book is quite distinct from Beck's other works in that it provides the reader an intellectual journey:through the reprinted articles, you can see the evolution of Kent's writing style, the beginnings of the"design patterns" movement, and the ever changing opinions aboutwhat to do / what not to do with Smalltalk.

There are many classic papersin this work, such as the original CRC-cards paper, and aptly-titled piecessuch as "Death to Case Statements!".The code examples are clearand easy to read, and I found the chronological ordering of the papers tobe appealing.

This book is not just for Smalltalkers - it's for anyonewith an interest in object orientation:patterns, idioms, and philosophy.

Too many typos
Kent Beck is a wonderful writer and has many good points to make in this book, but I can't recommend spending money on it unless the publisher produces a new edition correcting its hundreds of errors.Pages appear inthe wrong order, parts of paragraphs are randomly duplicated, code samplesare formatted incorrectly and nearly unreadable, and words appear in thewrong typeface making it difficult to distinguish identifiers from prose. Many of the articles appear to have been scanned in using OCR software andnot subsequently proofread, or possibly proofread by someone who didn'tunderstand the content.The lack of quality control is simplyappalling.

Better organization of the material would also have beenhelpful.The "Sorted Collection" is sorted by date only.Thismay be useful to those interested in tracing the recent history ofSmalltalk, but not to those wanting to learn most efficiently.

Much ofthe material in this book is better and more thoroughly presented in Beck'sother books.At best, this book can be seen as a haphazard introduction toBeck's ideas that will spur some programmers to learn more about Smalltalk,object-oriented design and Extreme Programming. ... Read more

Product Description
Helps you learn the essentials of Smalltalk programming. Teaches how to experiment using the workspace and the transcript, define classes that inherit variables and methods, design class and class hierarchies, use time-sorted collections in simulations and more. Paper. DLC: Smalltalk (Computer program language) ... Read more

Customer Reviews (9)

OK book
Good book, but not as good as Winston's other books.I didn't find it very useful as a learning aid for smalltalk, but think that it will be more of a help in going from novice smalltalker to intermediate/advanced smalltalker.

Practical approach to learning Smalltalk
As of 2005 I am a beginner in Smalltalk and I write my review from that perspective.

I like the approach the author uses where he splits the book in Sections and micro-sections. As the text proceeds, the attention of the reader is brought to topics previously introduced referring to them by their micro-section number. This allows easy comparing and contrasting related concepts introduced throughout the book. The net effect is that it is very easy to follow the explanations and never get lost as you can always browse very fast to the cross-referenced micro-sections.

This writing style gives the book a specific quality, whereby it does not need to be read from beginning to end, but rather can be opened at any page and you will make sense of the topic even if you have not picked the book in the last 6 months.

To me this is what a handy reference should be.

I do not give it 5 stars just because it is dated and it does not have as many pictures as I would have liked :-).

A Gentle Introduction to Smalltalk and OO Programming
This book is basically a Smalltalk primer, with a lot of OO-design principles embedded in the lessons. While useful to anyone who is new to Smalltalk, it is written with the assumption that the reader is not only completely new to Smalltalk, but also to Object-Oriented programming and possibly to programming in general. Thus, the lessons contain not only an introduction to Smalltalk syntax and grammar, but also to basic OO concepts like inheritance, aggregation, and data abstraction, as well as iterators, recursion, and other basic programming techniques. If you are an experienced programmer new to Smalltalk, some of the programming style advice may seem elementary, but you will still get a good introduction to the Smalltalk language. This would also be an excellent book for a basic Object-Oriented programming class. The author very deliberately tries to teach good OO style, and what is learned here will still be applicable if the reader goes on to work with Java or C++.

What prevented me from giving the book five stars was:

(1) It is a little bit dated. The book mostly uses Smalltalk Express or Cincom's VisualWorks in its examples. Both of these are still freely available, and there are only a few small changes in the current versions from what is described in the book. However, one does need to be aware that Smalltalk is not a dead language, it is still being actively developed, and this book is now over 6 years old.

(2) The style is a little different. The material is divided into logical task-oriented chapters that build on one another (How to Create Classes and Instances, How to Define Classes that Inherit Instance Variables and Methods, etc.), but each chapter is written as a series of numbered paragraphs as little "micro-lessons." I did not find it hard to follow, but it may not be to everyone's tastes.

Again, this is a primer for beginners, aimed at teaching Object Oriented programming style as much as Smalltalk. If you are an experienced programmer, especially with OO experience, looking to learn Smalltalk in a hurry, this may not be the most suitable book for you, as the language's keywords and idioms and syntax are introduced bit by bit throughout the book, and there is no concise reference guide.

Silly style; misleading content
I bought this book based on the reviews as was sorely dissapointed.

The writing style is of a programmer who never took an english class (it almost reads as if it were a program; every paragraph has its own number, and the organization is reminiscent of a C program).

The content fits the style. E.g., in an early example he shows how you can modify the Integer class to have calorie converter functions (his example application is a food calorie viewer). It seemed bizzare to me, so asked on comp.smalltalk and found out that this is an inappropriate use of the feature.

All in all, this is one of the poorest programming books I've ever seen.

Shayne Wissler

The best of it's kind!
This is an excellent book. Writien and organized in a style that is uncommonly clear and concise for an book of it's type. Winston explores the basic features of Smalltalk while continually implementing them in a workable application throughout the book. This is an extremely effective instruction technique. I recommend this book not only to Comp Sci students, but to professionals who want toadd Smalltalk to their skillset. ... Read more