Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.

Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and .

Book Condition:Fast Shipping From Amazon! This book is in Very Good condition. Pages and cover are clean and crisp. Overall a Clean Copy with light amount of wear. 100% Guaranteed. Access codes and supplements are not guaranteed with used items.

Comment: Fast Shipping From Amazon! This book is in Very Good condition. Pages and cover are clean and crisp. Overall a Clean Copy with light amount of wear. 100% Guaranteed. Access codes and supplements are not guaranteed with used items.

Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.

This classic book is the definitive real-world style guide for better Smalltalk programming. This author presents a set of patterns that organize all the informal experience successful Smalltalk programmers have learned the hard way. When programmers understand these patterns, they can write much more effective code. The concept of Smalltalk patterns is introduced, and the book explains why they work. Next, the book introduces proven patterns for working with methods, messages, state, collections, classes and formatting. Finally, the book walks through a development example utilizing patterns. For programmers, project managers, teachers and students -- both new and experienced. This book presents a set of patterns that organize all the informal experience of successful Smalltalk programmers. This book will help you understand these patterns, and empower you to write more effective code.

Editorial Reviews

From the Publisher

The real-world style guide for better Smalltalk programming. This book presents a set of patterns that organize all the informal experience successful Smalltalk programmers have learned the hard way. When programmers understand these patterns, they can write much more effective code. The concept of Smalltalk patterns is introduced, and the book explains why they work. Next, the book introduces proven patterns for working with methods, messages, state, collections, classes and formatting. Finally, the book walks through a development example utilizing patterns. For Smalltalk programmers, project managers, teachers and students -- both new and experienced.

From the Back Cover

This book addresses a much neglected and supremely important area to successful software development: 'low level design.' Beck's collection of patterns benefit novice and experienced programmers alike, they are absolutely fundamental to good Smalltalk programming.

Top customer reviews

There was a problem filtering reviews right now. Please try again later.

this is one of the books that I reach for all the time. I use it to explain many concepts and I don't even write smalltalk. I have a hard copy and digital. I've also given a copy away as a gift. this is a must have when trying to build a common vernacular. It has improved communication of ideas for every team I've worked with.

I wish more Java/C#/C++ programmers would read this (and maybe even learn Smalltalk) so that they can appreciate the weaknesses in those languages and possibly in their practices that they might not even realize today. I certainly did. While Robert Martin and others have offered up some of the canon of good design for contemporary developers, this little gem really reveals the "feel" of good OO.

I'm always looking for ways to make coding work better, at any level from nanosecond arithmetic operations to decade-long enterprise operations. I didn't find much of use here, but there were a few good points here (very few). Let me start with those.

The "Execute Around Method" pattern is good idea, applicable far beyond this Smalltalk context. The Beta language has "inner" inheritance, which makes the idea easy, but most other languages lack a good mechanism for undefined logic between matched operation pairs (open/close, setup/cleanup, etc.) "Enumeration" is another good one, enshrined as "Visitor" in the Gang of Four book.

Most of what's left is either trivial or Smalltalk-specific and face it, Smalltalk is mostly a cult language with nearly no commercial significance. The Smalltalk pretty-printing and variable-naming rules, fatuous at best, are just not applicable to most langages. Some of Beck's "practices" are language features (like 'super'). Other "practices", like the long chapter on Collections, seem to describe standard library classes and messages. Yet others (e.g. Type Suggesting Parameter Name) correct language defects - Smalltalk chose to give up the error detection capability offered by variable typing. Beck tries to sneak it back in with variable naming conventions sort of like Microsoft's old Hungarian naming. Some of his suggestions are just dangerous, like that one that says a constructor should "half-way construct an object in one place, then pass it off to another to finish construction. (p.23)" This distributes an object's setup responsibility across its client classes, leaves unusable and incomplete objects floating around, and causes subtle exposures in multithreaded systems - I'd rip out any code I saw built this way.

The good news is that no new trees died to make my copy of this book - I got it used, and it's returning to the used market. At least my conscience is clean on that account, no matter what I'm doing to the poor guy who buys this book next.

I bought this book years ago from McGraw-Hill in NYC,...but I'd gladly pay double...for it today - don't be fooled by the fact that there are only 240 pages to this small, softcover book. The patterns are concise and the examples, priceless. Although I love Gamma's Design Patterns, if I were forced to be stuck on an island with one choice, it'd easily be Beck's BPP.I currently use C++ on UNIX in practice (wish there were more Smalltalk & Objective-C jobs out there), but I would still highly recommend this book for any OO-Practitioner: the lessons here can be applied to many different scenarios.Take this chance to observe the beauty of PURE OO - concise code with the semantic richness and clarity reminiscent of poetry... ...alas, if only code at work were so well crafted!This is a handbook of OO Programming. Patterns are broken into the following categories: Behavior, State, Collections, Classes, and Formatting. Each pattern is given a question/problem that the pattern answers/solves and references to other patterns are shown with page numbers.It's definitely one of those rare books that I return to over and over again... ...a classic.