Skip to content
Scan a barcode
Scan
Paperback Implementation Patterns Book

ISBN: 0321413091

ISBN13: 9780321413093

Implementation Patterns

(Part of the A Kent Beck Signature Book Series and The Addison-Wesley Signature Series Series)

Select Format

Select Condition ThriftBooks Help Icon

Recommended

Format: Paperback

Condition: Very Good

$10.89
Save $39.10!
List Price $49.99
Almost Gone, Only 1 Left!

Book Overview

"Kent is a master at creating code that communicates well, is easy to understand, and is a pleasure to read. Every chapter of this book contains excellent explanations and insights into the smaller but important decisions we continuously have to make when creating quality code and classes."

-Erich Gamma, IBM Distinguished Engineer

"Many teams have a master developer who makes a rapid stream of good decisions all day long. Their code is easy to understand, quick to modify, and feels safe and comfortable to work with. If you ask how they thought to write something the way they did, they always have a good reason. This book will help you become the master developer on your team. The breadth and depth of topics will engage veteran programmers, who will pick up new tricks and improve on old habits, while the clarity makes it accessible to even novice developers."

-Russ Rufer, Silicon Valley Patterns Group

"Many people don't realize how readable code can be and how valuable that readability is. Kent has taught me so much, I'm glad this book gives everyone the chance to learn from him."

-Martin Fowler, chief scientist, ThoughtWorks

"Code should be worth reading, not just by the compiler, but by humans. Kent Beck distilled his experience into a cohesive collection of implementation patterns. These nuggets of advice will make your code truly worth reading."

-Gregor Hohpe, author of Enterprise Integration Patterns

"In this book Kent Beck shows how writing clear and readable code follows from the application of simple principles. Implementation Patterns will help developers write intention revealing code that is both easy to understand and flexible towards future extensions. A must read for developers who are serious about their code."

-Sven Gorts

"Implementation Patterns bridges the gap between design and coding. Beck introduces a new way of thinking about programming by basing his discussion on values and principles."

-Diomidis Spinellis, author of Code Reading and Code Quality

Software Expert Kent Beck Presents a Catalog of Patterns Infinitely Useful for Everyday Programming

Great code doesn't just function: it clearly and consistently communicates your intentions, allowing other programmers to understand your code, rely on it, and modify it with confidence. But great code doesn't just happen. It is the outcome of hundreds of small but critical decisions programmers make every single day. Now, legendary software innovator Kent Beck-known worldwide for creating Extreme Programming and pioneering software patterns and test-driven development-focuses on these critical decisions, unearthing powerful "implementation patterns" for writing programs that are simpler, clearer, better organized, and more cost effective.

Beck collects 77 patterns for handling everyday programming tasks and writing more readable code. This new collection of patterns addresses many aspects of development, including class, state, behavior, method, collections, frameworks, and more. He uses diagrams, stories, examples, and essays to engage the reader as he illuminates the patterns. You'll find proven solutions for handling everything from naming variables to checking exceptions.

This book covers

The value of communicating through code and the philosophy behind patterns How and when to create classes, and how classes encode logic Best practices for storing and retrieving state Behavior: patterns for representing logic, including alternative paths Writing, naming, and decomposing methods Choosing and using collections Implementation pattern variations for use in building frameworks

Implementation Patterns will help programmers at all experience levels, especially those who have benefited from software patterns or agile methods. It will also be an indispensable resource for development teams seeking to work together more efficiently and build more maintainable software. No other programming book will touch your day-to-day work more often.

Customer Reviews

5 ratings

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.
Copyright © 2025 Thriftbooks.com Terms of Use | Privacy Policy | Do Not Sell/Share My Personal Information | Cookie Policy | Cookie Preferences | Accessibility Statement
ThriftBooks ® and the ThriftBooks ® logo are registered trademarks of Thrift Books Global, LLC
GoDaddy Verified and Secured