Programming Books C Java PHP Python Learn more Browse Programming Books
Buy New
$32.92
Qty:1
  • List Price: $39.95
  • Save: $7.03 (18%)
FREE Shipping on orders over $35.
Only 5 left in stock (more on the way).
Ships from and sold by Amazon.com.
Gift-wrap available.
The Design Patterns Small... has been added to your Cart
Trade in your item
Get a $2.00
Gift Card.
Have one to sell? Sell on Amazon
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

The Design Patterns Smalltalk Companion Paperback – February 20, 1998

ISBN-13: 978-0201184624 ISBN-10: 0201184621 Edition: 1st

Buy New
Price: $32.92
25 New from $28.93 35 Used from $19.54
Amazon Price New from Used from
Paperback
"Please retry"
$32.92
$28.93 $19.54
Amazon%20Web%20Services

$32.92 FREE Shipping on orders over $35. Only 5 left in stock (more on the way). Ships from and sold by Amazon.com. Gift-wrap available.

Frequently Bought Together

The Design Patterns Smalltalk Companion + Smalltalk, Objects, and Design
Price for both: $54.48

Buy the selected items together
  • Smalltalk, Objects, and Design $21.56

NO_CONTENT_IN_FEATURE

Shop the New Digital Design Bookstore
Check out the Digital Design Bookstore, a new hub for photographers, art directors, illustrators, web developers, and other creative individuals to find highly rated and highly relevant career resources. Shop books on web development and graphic design, or check out blog posts by authors and thought-leaders in the design industry. Shop now

Product Details

  • Paperback: 464 pages
  • Publisher: Addison-Wesley Professional; 1 edition (February 20, 1998)
  • Language: English
  • ISBN-10: 0201184621
  • ISBN-13: 978-0201184624
  • Product Dimensions: 9 x 7.3 x 1 inches
  • Shipping Weight: 1.6 pounds (View shipping rates and policies)
  • Average Customer Review: 4.9 out of 5 stars  See all reviews (13 customer reviews)
  • Amazon Best Sellers Rank: #1,453,458 in Books (See Top 100 in Books)

Editorial Reviews

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

From the Back Cover

"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


More About the Authors

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

4.9 out of 5 stars
5 star
12
4 star
1
3 star
0
2 star
0
1 star
0
See all 13 customer reviews
Share your thoughts with other customers

Most Helpful Customer Reviews

18 of 18 people found the following review helpful By Nicolas Weidmann on February 4, 2000
Format: Paperback
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 :-)
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
9 of 9 people found the following review helpful By KR on August 5, 2001
Format: Paperback
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 ;-)
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
7 of 7 people found the following review helpful By A Customer on September 9, 1999
Format: Paperback
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.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
4 of 4 people found the following review helpful By A Customer on March 9, 1998
Format: Paperback
I've read the original Design Patterns several times and always felt like I was missing something. I don't know C++, and honestly don't want to learn it. Patterns are supposed to simplify coding; how could they when they seem so complex? I now understand that Patterns ARE simple; it's C++ that's complex (compared to Smalltalk). This book is much more than a rehash of the old text. It clearly explains the Patterns, showing TRUE Smalltalk implementations with all the variations you could want. Great care is taken in explaining how Smalltalk features change the implementation and usefulness of the Patterns. Now I get what everyone has been raving about.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
2 of 2 people found the following review helpful By A Customer on August 25, 1998
Format: Paperback
I bought this book because a person in my study group is asmalltalker and had it. I am primarily a Java programmer, but when Iread a pattern in this book, I flipped!
I found that the discussion of the problems that the patterns are designed to solve are really helpful, as well as a discussion as to how the pattern actually works to resolve the problem.
The code examples were not so useful to me, but after all, I don't know Smalltalk. Even the C++ programmers I work with read discussions from this book.
In all a very useful tool to help understand the 23 GoF patterns.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
2 of 2 people found the following review helpful By Mark Wilden on April 18, 2004
Format: Paperback Verified Purchase
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.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
4 of 5 people found the following review helpful By A Customer on July 11, 1999
Format: Paperback
This book presents in an excellent way the GoF patterns from a Smalltalk perspective. By showing how the design pattern intent is resolved with a Smalltalk perspective, it provides more than just an implementation of the patterns in Smalltalk. It offers complete new views on the problems that the GoF pattern where solving. A must for every Smalltalk programmer that is not accointed with C++.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

What Other Items Do Customers Buy After Viewing This Item?