The Design Patterns Smalltalk Companion (Paperback)

~ Sherman Alpert (Author), Kyle Brown (Author), (Author)

Editorial Reviews

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.

From the Inside Flap

The Design Patterns Smalltalk Companion is intended to be a companion volume to Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides--the so-called Gang of Four. Their book has had an extraordinary impact on the field of object-oriented soft-ware design. Yet it has a decidedly C++ orientation. This works well for C++ developers, but it makes understanding and applying the Design Patterns mate-rial more difficult for others.

The Design Patterns Smalltalk Companion assumes readers are familiar with the material in Design Patterns, but want to understand the material better, especially from a Smalltalk development perspective. The Smalltalk Companion is designed to be read along with Design Patterns. We have tried hard not to repeat material that the Gang of Four already explained well. Rather, we clarify and add to the ideas that their book already expresses, doing so from the viewpoint of the Small-talk developer. We reference Design Patterns frequently; as you read our book, we expect you will too.

The Smalltalk Companion also assumes you have experience with object-oriented design and programming, preferably in Smalltalk. You should already be famil-iar with terms like "abstract class," "polymorphism," and "inheritance" and know what it's like to develop code in a Smalltalk interactive development envi-ronment. Although we address a broad audience, this book is nonetheless not an introduction to Smalltalk programming or object-oriented design. A Bit of History

A long time ago (it seems) in a galaxy far, far away (IBM's T. J. Watson Research Center), John Vlissides approached Sherman Alpert with the idea of writing a Smalltalk "sequel" to Design Patterns. At this point, Design Patterns was one of the hottest-selling computer science books on the market. They decided to send up a trial balloon: Sherman wrote up a few patterns and distributed them to the Gang of Four for review. Their feedback was positive: the balloon flew.

During the ensuing book contract process with Addison-Wesley, it became clear that more authors were needed to produce a polished Smalltalk Companion in the suggested time frame. Sherman approached Kyle Brown, a Smalltalker who had published extensively on design patterns, to see if he would like to join the effort. Kyle, in turn, made a similar offer to Bobby Woolf, his colleague at Knowledge Systems Corporation. Thus began the collaboration that has resulted in this book. At this time, Design Patterns is the best-selling computer science book ever. We hope you enjoy this book as much as readers apparently have the Gang of Four's. Acknowledgments

It takes a village to raise a child. Similarly, this book has been molded and influ-enced by a large community of colleagues, friends, and advisers. Much of what appears here is the direct result of their help and guidance, and we have many to thank.

First, big thanks to the Gang of Four--Erich, Richard, Ralph, and John, who have acted as reviewers, advisers, supporters, and mentors from the original idea through the entire book-writing process. Special thanks to John for providing us with the original Design Patterns figures, for his idraw graphical editor for our dia-grams, and for his thorough editing of our manuscript as Software Patterns series editor.

Huge thanks to the design patterns discussion group in the Computer Science Department of the University of Illinois at Urbana-Champaign (UIUC). This group, directed by Ralph Johnson, read and discussed all of our pattern sections and supplied extremely useful feedback. We could not have produced this book in its current form without their help. At various times, the following people have been part of the group: Jeff Barcalow, John Brant, Ian Chai, Annette Feng, Brian Foote, Yahya Mirza, Dragos-Anton Manolescu, Lewis Muir, Eiji Nabika, Ed Peters, Don Roberts, Joe Yoder, Kazuki Yoshida, and, of course, Ralph.

Thanks to other colleagues with whom we have discussed issues that are consid-ered in the Smalltalk Companion, and who commented on earlier drafts, offered advice, or suggested Smalltalk examples of design patterns in use. Also, prior to publication we placed drafts of several of our patterns on a public FTP site and invited comments. We thank all who spent time and energy providing helpful feedback. These folks include Kent Beck, Dave Collins, Lucio Dinoto, Richard A. Harmon, Philip Hartman, Dave Isaacs, Dick Lam, Chamond Liu, Richard J. Mac-Donald, Jasen Minton, James O'Connor, David N. Smith, Niall Ross, Robert Schwartz, Andrey Subbotin, Debbie Utley, and David Warren. (We hope we haven't inadvertently left anyone out, but if we have, thank you too!)

We thank the members of the Knowledge Systems Corporation (KSC) reading group for their comments and suggestions: Dana Anthony, Simon Archer, Ken Auer, Stuart Broad, Ilkay Celiker, Fonda Daniels, Amy Gause, Greg Hendley, Dave Houlbrooke, Scott Krutsch, Tran Le, and Vikas Malik. Thanks go to Larry Best of American Management Systems for graciously allow-ing us to include a portion of his OOPSLA'96 DesignFest problem in our case study.

We are grateful as well to Addison-Wesley's editorial and production teams, especially Marina Lang and Cate Rickard.

Sherman adds: Special thanks to the IBM Corporation and my manager, Peter Fairweather, for allowing me time and use of computational resources during the writing of the Smalltalk Companion. My ardent appreciation goes to John Vlissides for his support and encouragement. Thanks to the Smalltalkers with whom I've had the pleasure to collaborate at the T. J. Watson Research Center over the years. I've learned a great deal from you all: Rachel Bellamy, Dave Collins, Eric Gold, Mark Laff, Bob Mack, Petar Makara, John Richards, Mary Beth Rosson, Janice Singer, Kevin Singley, David N. Smith, and Christine Sweeney. Thanks also to Dick Lam who was a fount of C++ information. And most important, my grati-tude to my family, Amy and Jake, for putting up with me and supporting me while I hid away to write.

Kyle adds: I'd like to thank my wife, Ann, for putting up with my writing habit during an especially difficult time in our lives. You mean the world to me, dear, and I can't tell you how much I appreciate your support. Yorktown Heights, New York -- S.R.A.
Cary, North Carolina -- K.B., B.W.
December 1997 0201184621P04062001

See all Editorial Reviews

Product Details

• Paperback: 464 pages
• Publisher: Addison-Wesley Professional (February 20, 1998)
• Language: English
• ISBN-10: 0201184621
• ISBN-13: 978-0201184624
• Product Dimensions: 8.8 x 7.2 x 1.1 inches
• Shipping Weight: 1.4 pounds (View shipping rates and policies)
• Average Customer Review: 4.9 out of 5 stars  See all reviews (11 customer reviews)
• Amazon.com Sales Rank: #216,671 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

13 of 13 people found the following review helpful:

5.0 out of 5 stars Easier to understand than the original GoF, February 4, 2000

By	Nicolas Weidmann (Coinsins, Switzerland) - See all my reviews (REAL NAME)

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 you can understand the patterns within the first few lines of their description. Take the Bridge pattern and compare their discussions in the two 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 SmallTalk companion. Trust a C++ programmer :-)

5 of 5 people found the following review helpful:

4.0 out of 5 stars Useful for Java Programmers too., August 5, 2001

By	"ishikyo" (Menlo Park, CA USA) - See all my reviews

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 ;-)

5 of 5 people found the following review helpful:

5.0 out of 5 stars More than a GOF Companion., September 9, 1999

By A Customer

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 had been written in Smalltalk.

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