Implementation Patterns

by Kent Beck

Programmers make hundreds of decisions a day. Occasionally they make large-scale decisions like those covered by Design Patterns. Far more frequently they make small-scale decisions--choosing names, organizing code logically, dividing programs into coherent parts. The cumulative effect of these hour-by-hour, minute-by-minute decisions is as significant as the effect of the design decisions in making code clear, flexible, and robust. This book is a...

• Format: Paperback
• Language: English
• ISBN: 0321413091
• ISBN13: 9780321413093
• Release Date: October 2007
• Publisher: Addison-Wesley Professional
• Length: 157 Pages
• Weight: 0.80 lbs.
• Dimensions: 0.5" x 7.1" x 9.2"

Customer Reviews

This time Beck talks about patterns "in the small"

I typically enjoy reading pattern's books and this is going to be one of my all-time favorites. This time Beck talks about patterns "in the small", not the traditional kind of architectural patterns we are used to know. This book it's about those small decisions we make every time we write even a small piece of code. Somebody could think the word "patterns" is misused here, but I tend to disagree and, in the end, I don't even care that much. What really matters to me is that I found valuable advice inside this book and I really enjoyed reading it. In the past Beck's books were always worth reading for me, this one benefit from a more fluid and pleasant writing style too.

The focus is on communication not wizard tricks

The reviews I've seen so far are bi-modal. Readers who were looking to communicate more effectively through their code found the book helpful. Readers who were looking for expert coding techniques were disappointed.

Another Excellent book by Kent Beck

Kent Beck is like the Jonathan Livingston Seagull of programmers. When I read his writings or hear him speak, I can't help but think that he's been to some higher plane of programming and has come back to help the rest of us. Implementation Patterns is his latest attempt to get the rest of us to think about more than what we are doing right here right now and to think about more than just ourselves. While some may not appreciate the author's philosophical approach to software development, I find it refreshing and challenging. He encourages us to look at our work as a contribution to society and not as just something we have to do to get a paycheck. He challenges us to think about others, those who will have to read and extend our code, and not just about ourselves. These principles are valuable in any occupation but are often overlooked in the technology fields. Before I go too far and give the wrong impression, Implementation Patterns is not a philosophy book. It is a book about code, specifically Java code (one of it's strong points) with many useful ideas for writing better code. However, there is a philosophy behind these ideas and I believe that the philosophy is at least as valuable as the ideas themselves. Now, on to the book. The first two chapters, Introduction and Patterns, together serve as an introduction of just what the author has in mind when he refers to an "implementation pattern". This is especially helpful if you are familiar with the Gang of Four's Design Patterns book. This book does not follow the same format for describing implementation patterns as you might be used to with design patterns. Some patterns are described as code samples while others use the author's high tech modeling system. The third chapter, A Theory of Programming, is my favorite. Here the author explains the ideas behind the patterns in the rest of the book. Here he talks about the values and principles that lead to the patterns. The values are Communication, Simplicity and Flexibility. The principles are Local Consequences, Minimize Repetition, Logic and Data Together, Symmetry, Declarative Expression and Rate of Change. The author describes the relationship between these elements, values, principles and patterns as follows: "The patterns describe what to do. The values provide motivation. The principles help translate motive into action." Chapter four describes the motivation behind developing and using these implementation patterns. The basic premise is that change is costly and that attempts to reduce or eliminate change are futile, so why don't work at making change less costly by writing code that is more communicative, simpler and more flexible. The actual implementation patterns are described in chapters five through nine. Each chapter covers a certain group of patterns: Class, State, Behavior, Methods and Collections. These chapters can be read in any order but the patterns within a chapter do seem to build on eac

Great guide for clearer, more maintainable code

This book is a wonderful, concise book on writing code that others can understand. I love Beck's premise in his intro: "Actually, this book is based on a rather fragile premise: that good code matters. I have seen too much ugly code make too much money..." A pretty amazing blurb, but Beck goes on throughout the book to prove why you should care about good code and how you can do a better job of writing non-ugly code that others can more easily grok out. The book's chapters run a short gamut of great topics from programming theory to frameworks. One of the more intestesting bits I found was his discussion on symmetry, the idea that methods and classes should be well balanced. Methods such as "Add()" should be balanced by "Remove()", and that ideas in sections of code should be expressed in the same style, i.e. void process() { input(); count++; output(); } where input() and output() are intentions while count++ is an implementation. Esoteric, but the flow is much cleaner and clearer when you read the snippet below instead. void process() { input(); tally(); output(); } I like the discussion in this book is on good naming styles, something I'm passionate about -- and am still not happy with my own practices in that area. There's also great text on state, behavior, and different ways to look at methods. This book's an easy read. Beck's writing style is absolutely approachable, and the book's quite short at 155 or so pages. Beck's book helps me to better consider how to rephrase my code so its intent is clearer and it's more maintainable by myself and others on my teams. Highly recommended.

how to write readable, maintainable code.

"Implementation Patterns" is a great book to make better Java developers. The focus is to make us think about writing more readable and maintainable code. Kent Beck accomplishes this by going thru WHY we write things a certain way. The audience is Java developers who know the basics of the language. If you have more experience, you will understand points on a deeper level. If you are newer to Java, you will form good habits. There were just too many things I liked about this book, so here's a list: - clear, concise and short snippets - simple, bare-bones diagrams - discussion on caveats and tradeoffs - over 100 pages of patterns - over 75 patterns - about concepts and OO; not a style guide - focus on values like communication and simplicity - section on cross cutting principles like minimizing repetition - short sections (Kent says some chapters long, but 30 patterns in 30 pages has great subdivision) - how JUnit 4 design decisions follow theses patterns - Kent even got in a dig about Sun never removing deprecated code - bibliography with a blurb from Kent on each title - pattern index on inside back cover in addition to traditional index The book can be read straight thru or used as a reference. It's short, light and easy enough that it can be read on an airplane. (and in this case, it was.) It's also organized enough to go back and read about the pattern relevant at the time.