Register your product to gain access to bonus material or receive a coupon.
Design Patterns Smalltalk Companion, The
- By Sherman Alpert, Kyle Brown, Bobby Woolf
- Published Feb 10, 1998 by Addison-Wesley Professional.
Book
- Sorry, this book is no longer in print.
Description
- Copyright 1998
- Dimensions: 7-1/4" x 9"
- Pages: 464
- Edition: 1st
- Book
- ISBN-10: 0-201-18462-1
- ISBN-13: 978-0-201-18462-4
"This is a GREAT book, very readable and also dense with content, one that even experienced Smalltalkers like myself will benefit from."
- Dave Collins, author of Designing Object-Oriented User Interfaces"This book adds value to the Gang of Four Design Patterns book. . . . The authors have found a good way to blend the Smalltalk discussions with the GoF pattern descriptions."
- Erich Gamma, coauthor of Design Patterns: Elements of Reusable Object-Oriented Software
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.
0201184621B04062001
Sample Content
Table of Contents
Foreword.
Preface.
1. Introduction.
2. Aha!
3. Creational Patterns.
Abstract Factory (DP 87).
Builder (DP 97).
Factory Method (DP 107).
Prototype (DP 117).
Singleton (DP 127).
4. Structural Patterns.
Adapter (DP 139).
Bridge (DP 151).
Composite (DP 163).
Decorator (DP 175).
Facade (DP 185).
Flyweight (DP 195).
Proxy (DP 207).
5. Behavioral Patterns.
Chain of Responsibility (DP 223).
Command (DP 233).
Interpreter (DP 243).
Iterator (DP 257).
Mediator (DP 273).
Memento (DP 283).
Observer (DP 293).
State (DP 305).
Strategy (DP 315).
Template Method (DP 325).
Visitor (DP 331).
6. Conclusion.
References.
Index. 0201184621T04062001
Preface
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
Updates
Errata
p. 2 and References, author name is spelled incorrectly:
currently reads: "Duego and Benson (1996)"
should be: "Deugo ..."
p. 10, 4th line from top, citation is incorrect:
currently reads: "Kent Beck's Smalltalk Best Practice Patterns[1997b] ..."
should be: "Kent Beck's Smalltalk Best Practice Patterns[1997] ..."
p. 112, bottom of page (last 2 lines):
currently reads: "...it obtains them using the following application-supplied message"
should be: "...it obtains them using the application-supplied
message, as follows"
p. 122, figure:
RefinedAbstractionA and RefinedAbstractionB
should be italicized (they're
abstract classes).
p. 123, figure:
EsBucketSet and EsHashSet
should be italicized.
p. 297, figure, upper left box:
currently reads: "Originato"
should be: "Originator"
p. 350, figure at bottom of page, lower left box:
currently reads: "mortgag"
should be: "mortgage"