Pub. Date:
The Design Patterns Smalltalk Companion / Edition 1

The Design Patterns Smalltalk Companion / Edition 1


Current price is , Original price is $39.95. You

Temporarily Out of Stock Online

Please check back later for updated availability.

Item is available through our marketplace sellers.

Product Details

ISBN-13: 9780201184624
Publisher: Addison-Wesley
Publication date: 02/24/1998
Series: Software Patterns Series
Edition description: New Edition
Pages: 464
Product dimensions: 7.20(w) x 8.90(h) x 1.00(d)

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 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.


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

Table of Contents



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.


Index. 0201184621T04062001


Foreword Programmers have long had the intuition that they were doing the same things over and over. Since the early seventies, and perhaps before, academic and professional software engineers have tried to find a way to take advantage of this sense of déjà vu to improve software development.

The conventional approach to avoiding duplication is the obvious—don'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.

Kent Beck

Customer Reviews

Most Helpful Customer Reviews

See All Customer Reviews