Smalltalk Best Practice Patterns

by Kent Beck

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.

Genres: Programming, Technology, Software, Computer Science, Nonfiction, Technical, Coding

224 pages, Paperback

First published January 1, 1996

Reviews

[Walerian Sobczak · Rating 5 out of 5]

Obligatory read for every programmer - it provides fundamental patterns of object-oriented design, with very relevant examples, and accurate explanations. You don't need earlier experience with Smalltalk to understand code snippets from the book.

[Marcin · Rating 5 out of 5]

Another timeless classic and a great introduction to OO design in any language. SmallTalk is easy enough to read and understand. Fascinating to see how many original ideas from this book have surfaced many times over in Kent's later works.

[Ash Moran · Rating 5 out of 5]

The best introductory OOP book I've read. Lucid insights into low-level object design decisions that transcend language.

[Jano Suchal · Rating 3 out of 5]

Review (in slovak) http://j.mp/101bciH

[Kerrick · Rating 5 out of 5]

I’ve never written a line of Smalltalk. I get paid to write JavaScript and TypeScript, and I also write Ruby for fun. Even though I’ll never use Smalltalk, I wish I’d read this book within my first month of starting to program.

This book is written incredibly accessibly. As soon as you’ve read a single ‘how to program’ book that covers an OO language, this should be your next book. It doesn’t matter if that language isn’t Smalltalk—heck, it probably isn’t.

This book covers so many good habits and patterns that are universal to OOP (and even some that apply to procedural and FP) that it’s worth it. Everything Beck said about naming, class design, method decomposition, and the way to think about problems applies in any modern language. Even the parts that feel specific to Smalltalk, like the chapter on Collection methods, are great. Odds are your language or standard library include a version of these methods, and you can learn tips about applying them here.

But even though I’ve been a professional developer since 2008, I learned something from this book. Double dispatch, Default Method, RunArray, and using stacks and queues for tree traversal will all level up my programming. Plus, it’s nice to have a name, situation, and solution to reference for things I’ve always explained from my gut when doing code reviews, pair programming, and mentorship.

[Michal · Rating 5 out of 5]

This is is a great book. It is true that Smalltalk makes it harder to parse for somebody not familiar with the language and I would have a better time reading it if it used something moe familiar, but that is not a reason to rate it lower.

There are couple patterns that are clearly very smalltalk specific that you can skip over.

[Ling Wang · Rating 4 out of 5]

This 1997 book is still relevant in 2020. Not much has changed from Smalltalk to Objective-C with respect to the things talked about in the book. Even as Objective-C is being replaced with Swift, many patterns are general enough to cross languages, so modern iOS/Mac developers can still benefit from the book.

[Paulo · Rating 5 out of 5]

Still relevant for developers (a must read)

Was not the easiest read, also because I never programmed in smalltalk. But this book is full of very insightful tips to organize your code. It really made me think :)

[Philip Lambok · Rating 3 out of 5]

Interesting book, but somehow it is difficult to read the code because I never write Smalltalk before. Btw I found an interesting tool to help: https://github.com/ruben/smalltalk-be....
If you didn't know Smalltalk like me but familiar to ruby, maybe that tool can help you too.

[Dave · Rating 5 out of 5]

An outstanding book of practical advice for writing readable, maintainable programs. My fear is that many will pass over this book because they think it doesn’t apply to them.

[Dan Croak · Rating 5 out of 5]

Top 10 favorite software book. Short and simple.

[Sorin · Rating 3 out of 5]

I quited this book, because I didn’t enjoyed reading it. Make your own decision.

[Costin Manda · Rating 3 out of 5]

I have started with a book recommended by many sites about software architecture and design as a must read: Smalltalk Best Practice Patterns by Kent Beck. It is well written and I can see why it attracted a lot of people, even if there aren't so many Smalltalk programmers out there: it is written for use! That means that the book has less than 200 pages, but each of the specific patterns there are laden with references to others in the book, some even in the next chapters. That's because the book itself is structured to be kept nearby and consulted whenever a new project is started or in progress, not something that you read and forget in a bookshelf, gathering dust.

However, the patterns presented are sometimes useless for a C# programmer, some being already integrated in language and some being not applicable. The fact that Smalltalk works with Messages further complicates things. I did eventually open a link to #-Smalltalk, but who will ever have time for it?

I have decided that rather than reading this book and forgetting or not getting many of the things inside, it would be more efficient searching for a similar book that is more C# oriented.

So, bottom line: great approach, both literary and technical, but a little hard to use for one such as me.

[Piers · Rating 5 out of 5]

Hands down the best book I know on the nitty gritty of writing object oriented code. I learned so much from this about how to take advantage of dynamic languages like Perl and Ruby as well as Smalltalk.

It's also one of the very few decent patterns books in the computing literature. A genuine pattern language rather than a ragbag of patterns with no real coherence. Up there with Alexander's "A Pattern Language"

[Marc Johnson · Rating 5 out of 5]

Very well written, with insights and anecdotes relevant to programming and software development in general, not only Smalltalk.

Lack of familiarity with Smalltalk likely meant I missed parts of, or misinterpreted some patterns. Generated thoughts on how different languages might have different considerations. And how neat and ahead of it’s time Smalltalk was.

Extending the example at the end is the only feedback I have for improvement.

[Alpha · Rating 4 out of 5]

4.5/5 - Not many people use Smalltalk, but this is a pretty great read for Ruby and Objective-C, as both languages inherit much of Smalltalk's base concepts. A lot of the patterns are obvious (some in general, some in hindsight), but it's nice to have them actually explained and put down into words.

[Thomas · Rating 4 out of 5]

This book is a good look into where some of the names and constructs in Objective-C and Ruby come from.

Some of the patterns and recommendations are strictly a result of the idiosyncrasies of Smalltalk and working within the average Smalltalk browser.

Oddly most enlightening for me were the code formatting recommendations which assumed using line wrapping in a browser.

[Brandon Bayer · Rating 4 out of 5]

I read this because it's one of DHH's top five programming books. Overall, it's full of truly great patterns (how to name a method, how to name a variable, etc), but the Smalltalk examples were a real challenge to wade through because this was my first exposure to Smalltalk. I'd definitely rate it 5 stars if the examples were in ruby or a similar "modern" language.

[Wangyiran · Rating 3 out of 5]

i want to look the reference about the question and the method first
the language is out of date,i have to try learn the smalltalk,but after i read smalltalk introduce,i still not understand the book code well,so i give up read it.

[Kamil Chmielewski · Rating 1 out of 5]

This is a programming book written in 1997. It has a few ideas that are sound, but those ideas have been 'coined/named' and explained with better details since then. If you are looking to up your level as a programmer I recommend Clean Code or Refactoring over this book.

[Michael · Rating 4 out of 5]

Beck's book explains patterns for gaining fluency in language expression while the GoF book attempts gain features for underpowered languages.

[Barry]

DHH recommended: http://37signals.com/svn/posts/3375-t...

[Charles Wood · Rating 5 out of 5]

If you're looking for a guidebook on how to write Smalltalk, this isn't your book. If you want a TERRIFIC guidebook on writing good Object Oriented code, then you have to check this book out.

[Nick · Rating 4 out of 5]

A highly practical book on Object Oriented patterns, despite being perhaps the most hipster of all programming books ("Oh, I'm reading about this language, you've probably never heard of it!").

[Joel · Rating 5 out of 5]

Pretty useful.

[Enrico · Rating 5 out of 5]

Instructive, as usual from Kent!