Book Review: Implementation Patterns
I finally finished “Implementation Patterns” by Kent Beck and I have to be honest. I am a little disappointed. Let me preface this by saying my review of this book is not a reflection of my view of Kent Beck. Kent Beck is a programming hero. He pioneered the adoption of Test Driven Development, invented Extreme Programming and was one of the creators of JUnit. With that said, I will be honest about the book.
This book is about the low level construction of software and algorithms. Implementation Patterns looks at the patterns which are applied to programming when creating even the simplest of designs.
The book covers patterns relating to classes, state, behavior, methods and collections.
- Excellent introduction on implementation patterns
- Good reference for knowing how to call the thing you know is right, but can't explain.
- Section on collections is very good for understanding trade-offs between collection types.
- Doesn't read much like a book. It is a bunch of little pieces on each topic, but they don't really tie together smoothly.
- Some of the patterns I disagree with, especially the ones involving using inheritance over a different solution. (I am not a fan of concrete inheritance.)
- The book feels like it was not fun to write, like it was a labor of filling up pages.
- The treatment of collections perhaps belongs in a different book. The appendix which talks about performance measurement definitely does. A large amount of the book are these two topics.
- The framework section seemed a little strange in this book and it didn't really have enough information to be useful.
What I learned:
There is always something still to learn, and I did learn one very important concept from this book. Kent talks about Values and Principles in the 3rd chapter of the book. This concept has been something that I haven't been able to put into words, but I have known it is there. Kent very clearly describes the differences between values of programming and principles, and how principles are built on top of values. Often, I have a hard time in my mind accepting the need for making trade-offs between one or more principles. He very clearly addresses this issue, leading back to the values for ultimately making the decision.
I learned many names for things I was doing, but without knowing what to call them.
I also learned quite a bit about Java collections which I did not know before. I found out some good considerations when writing code to determine performance, which I would probably have not considered until reading this book.