The Design Patterns Smalltalk Companion / Edition 1 available in Paperback
- Pub. Date:
"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.
About the Author
Sherman Alpert has been designing and programming advanced technology applications in Smalltalk since 1987 at IBM's T. J. Watson Research Center.
Kyle Brown is currently an Executive Java Consultant with IBM WebSphere Services.
Bobby Woolf is coauthor of The Design Patterns Smalltalk Companion (Addison-Wesley, 1998), and author of articles in IBM DeveloperWorks, Java Developer's Journal, and elsewhere. He has been a tutorial presenter at OOPSLA, JavaEdge, and Smalltalk Solutions, among other conferences.
Read an Excerpt
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 Vlissidesthe 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.
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 FourErich, 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.
Table of Contents
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).
The conventional approach to avoiding duplication is the obviousdon't. Write a program once and use it over and over. Reuse has its successes, but as the scope of the code to reuse grows and the community within which it is to be reused grows, the probability of the goals of reuse being achieved drops. Eventually you end up with libraries that are more trouble to reuse than just writing the whole thing over from scratch.
Objects were supposed to save us from this widely experienced but little recognized "feature" of reuse. Inheritance and polymorphism provide two excellent ways of capturing variability, of letting code be the same but different. The scope in which object reuse works well may be larger and the communities may be larger (hmmm . . ., they may not), but eventually reuse runs out of gas as a strategy for improving productivity and quality and reducing cost and risk.
Patterns take the whole experience of programming déjà vu back to the drawing board. "All programmers writing accounting systems must solve problem X, and successful solutions converge on solution Y" is the kind of experience that gives rise to libraries of reusable software.
Here's the curious experienceÑif you get a group of experienced object designers sitting around drinking beer and talking about their systems, you get statements like the above. "Oh, I've implemented objects like that, except mine were for exotic options trading, not missle control." There is something about programming objects that leads over and over to the same problems, and over and over to the same solutions. Of course, same doesn't mean "the same code," it means, "if you squint your eyes and tilt your head just right you can see the similarity."
The Design Patterns book was the first powerful public statement of this orthogonal kind of déjà vu and what to do about it. It has been wildly successful. It has changed the way the object community programs, and introduced a new and more precise language for describing design.
The book you hold in your hands is a further exploration of what is universal about the 23 patterns in Design Patterns. Its purpose is to tease apart what of those patterns is an artifact of a language, and what is truly universal to object programming. As such, it makes a valuable contribution to the ongoing exploration of this new way of thinking about programs. If you are interested in the conversation, or even just the results of the conversation, you will enjoy it and learn from it.
The conversation is far from over. There are systems to describe, bars to sit in, and beer to drink. Come on in, pull up a comfy chair, and have a listen.