Advertisements
Posted by: jsonmez | March 1, 2010

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.

Good:

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

Bad:

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

Advertisements

Responses

  1. Thank you for the review!

    • Your welcome. Glad you found it useful.


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Categories

%d bloggers like this: