Programming Books C Java PHP Python Learn more Browse Programming Books
Implementation Patterns (Addison-Wesley Signature Series and over one million other books are available for Amazon Kindle. Learn more
  • List Price: $49.99
  • Save: $16.47 (33%)
FREE Shipping on orders over $35.
Only 7 left in stock (more on the way).
Ships from and sold by
Gift-wrap available.
Add to Cart
FREE Shipping on orders over $35.
Used: Very Good | Details
Condition: Used: Very Good
Comment: Light user wear. Pages are clean and binding tight. May not contain supplements such as access codes, CDs, etc. Book is in Very Good Condition. Eligible for FREE Super Saving Shipping! Fast Amazon shipping plus a hassle free return policy mean your satisfaction is guaranteed! Tracking number provided with every order.
Access codes and supplements are not guaranteed with used items.
Add to Cart
Trade in your item
Get a $4.61
Gift Card.
Have one to sell? Sell on Amazon
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See all 2 images

Implementation Patterns Paperback – November 2, 2007

ISBN-13: 978-0321413093 ISBN-10: 0321413091 Edition: 1st

Buy New
Price: $33.52
32 New from $28.76 27 Used from $19.88
Amazon Price New from Used from
"Please retry"
"Please retry"
$28.76 $19.88


Frequently Bought Together

Implementation Patterns + Clean Code: A Handbook of Agile Software Craftsmanship
Price for both: $72.98

Buy the selected items together


Save up to 90% on Textbooks
Rent textbooks, buy textbooks, or get up to 80% back when you sell us your books. Shop Now

Product Details

  • Paperback: 176 pages
  • Publisher: Addison-Wesley Professional; 1 edition (November 2, 2007)
  • Language: English
  • ISBN-10: 0321413091
  • ISBN-13: 978-0321413093
  • Product Dimensions: 9.1 x 7.1 x 0.4 inches
  • Shipping Weight: 10.6 ounces (View shipping rates and policies)
  • Average Customer Review: 3.5 out of 5 stars  See all reviews (28 customer reviews)
  • Amazon Best Sellers Rank: #462,526 in Books (See Top 100 in Books)

Editorial Reviews

About the Author

Kent Beck, one of the software industry’s most creative and acclaimed leaders, consistently challenges software engineering dogma and promotes ideas like patterns, test-driven development, and Extreme Programming. Currently affiliated with Three Rivers Institute and Agitar Software, he is the author of many Addison-Wesley titles, including Test-Driven Development (2003) and, with Cynthia Andres, Extreme Programming Explained, Second Edition (2005).

Excerpt. © Reprinted by permission. All rights reserved.

This is a book about programming—specifically, about programming so other people can understand your code. There is no magic to writing code other people can read. It’s like all writing—know your audience, have a clear overall structure in mind, express the details so they contribute to the whole story. Java offers some good ways to communicate. The implementation patterns here are Java programming habits that result in readable code.

Another way to look at implementation patterns is as a way of thinking “What do I want to tell a reader about this code?” Programmers spend so much of their time in their own heads that trying to look at the world from someone else’s viewpoint is a big shift. Not just “What will the computer do with this code?” but “How can I communicate what I am thinking to people?” This shift in perspective is healthy and potentially profitable, since so much software development money is spent on understanding existing code.

There is an American game show called Jeopardy in which the host supplies answers and the contestants try to guess the questions. “A word describing being thrown through a window.” “What is ‘defenestration’?” “Correct.”

Coding is like Jeopardy. Java provides answers in the form of its basic constructs. Programmers usually have to figure out for themselves what the questions are, what problems are solved by each language construct. If the answer is “Declare a field as a Set.” the question might be “How can I tell other programmers that a collection contains no duplicates?” The implementation patterns provide a catalog of the common problems in programming and the features of Java that address those problems.

Scope management is as important in book writing as it is in software development. Here are some things this book is not. It is not a style guide because it contains too much explanation and leaves the final decisions up to the reader. It is not a design book because it is mostly concerned with smaller-scale decisions, the kind programmers make many times a day. It’s not a patterns book because the format of the patterns is idiosyncratic and ad hoc (literally “built for a particular purpose”). It’s not a language book because, while it covers many Java language features, it assumes readers already know Java.

Actually this book is built on a rather fragile premise: that good code matters. I have seen too much ugly code make too much money to believe that quality of code is either necessary or sufficient for commercial success or widespread use. However, I still believe that quality of code matters even if it doesn’t provide control over the future. Businesses that are able to develop and release with confidence, shift direction in response to opportunities and competition, and maintain positive morale through challenges and setbacks will tend to be more successful than businesses with shoddy, buggy code.

Even if there was no long-term economic impact from careful coding I would still choose to write the best code I could. A seventy-year lifespan contains just over two billion seconds. That’s not enough seconds to waste on work I’m not proud of. Coding well is satisfying, both the act itself and the knowledge that others will be able to understand, appreciate, use, and extend my work.

In the end, then, this is a book about responsibility. As a programmer you have been given time, talent, money, and opportunity. What will you do to make responsible use of these gifts? The pages that follow contain my answer to this question for me: code for others as well as myself and my buddy the CPU.

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

The authors casual writing style makes this easy to do.
David Klein
This short read confirmed what I mostly knew already (and a few things that I didn't!), but you can never go wrong reading anything from Kent Beck or Martin Fowler.
Amazon Customer
So i think this topic from this author would deserve a much better book.
Miklos Fazekas

Most Helpful Customer Reviews

81 of 84 people found the following review helpful By Riccardo Audano on February 18, 2008
Format: Paperback Verified Purchase
The right title should be something like... "Kent Beck on writing readable code". The word "pattern" is way out of context, and will induce you to expect to find something way more precise, detailed and technical than then general advice that this book has to offer. This text could be considered like a chance to have a chat with Kent Beck discussing his ideas on the importance of writing readable code, and on general guidelines for code clarity and expressiveness. I have seen a review complaining about using Java for the examples, but the truth is, you will see very little code in this book. I am also not very sure of the idea target reader for this work. An experienced programmer has already figured out this general advice by himself, but the level of abstraction and detail is too terse to be useful to a beginner. I believe that more material, more detail and a more tutorial-like style could have made this book a worthwhile read for a junior developer. As it is , I have to say it, but I have to rate it as a pretty useless book. I am a big fan of Kent Beck, I admire his programming style, his 'very good habits' and all his did with the XP movement. Together with Martin Fowler, and Allen Holub he's one of those guys who can really have a deep influence on the way you program and think about Object Oriented programming, but this time he' really been a bit self condescending. And the price.. come on..40 bucks for this? You should be ashamed...
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
45 of 49 people found the following review helpful By R. Williams VINE VOICE on November 25, 2007
Format: Paperback Verified Purchase
First off, this is a very thin tome. Which would make you expect a brisk pace, but instead, it's strangely just laconic. A lot of it is so elementary, it is kind of maddening. At one point, Kent tells us that if we need to fetch the time for a number of local variables, we ought use a local variable to 'freeze time.' The biggest problem here, however, is that when the book does turn to a topic that is worthy of some attention, the same paucity produces a feeling of futility: some of idioms, like collecting parameter, for instance, come up. No discussion of how it is a gateway to Visitor, nothing really interesting in fact, just a short little paragraph. Another section on parallel hierarchies ends with the author saying that he figured out how to solve his rather stilted example by introducing a CashFlow object. But he goes on without explaining it. Now, consider the fact that I believe books should ONLY take up topics like that one. This book is greatly confused about who it is for. The reality is this is probably best suited as a tome for people who have been doing basic programming but have not become really mature programmers. The problem is that it only does this in a way that I don't think will help those who have not crossed the bridge to do so. Ironically, I think the main use for this book will be to make people who are doing a lot of these things feel better about it.
3 Comments Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
11 of 11 people found the following review helpful By Jonathan Aquino on January 10, 2008
Format: Paperback Verified Purchase
Pros: Gave me a tiny bit more insight into how a programmer I admire (Beck) thinks. Also the hand-drawn diagrams were intuitivie and easy to grasp.

Cons: Not much material. Book could have been half of its already short length. You sort of got the sense Beck was running out of things to say - the chapter on Collections has graphs of the running times of various collections, and an Appendix is devoted to the code used to create the graphs.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
7 of 8 people found the following review helpful By Eric Jain on March 28, 2008
Format: Paperback
Well written and organized, with a lot of short code fragments to illustrate the main points. However I have agree with the reviewer who suggested that this book should have been titled "Kent Beck on writing readable code". I'd add to this that the book is quite Java specific. Fine with me, but this needs to be pointed out. The book would have been more interesting to me if it documented the different approaches in use (along with their advantages and drawbacks) e.g. for choosing between checked and unchecked exceptions. Instead we get a few general statements about what exceptions are, and some suggestions along the lines of "low-level exceptions should be wrapped with high-level exceptions". The level of detail is often not enough to be interesting for somewhat experienced developers, but the book may be too abstract for beginners. Given the compact size of the book you'll still get good value for your time from reading it. Just don't set your expectations too high -- or expect to get good value for your money...
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
4 of 4 people found the following review helpful By Miklos Fazekas on August 2, 2008
Format: Paperback
The book is about writing readeable/maintanable code. It's an interesting/important subject.

The first few (1-3) pharagraph is good , they clearly explain the values/principles of the topic.
Then the book tries to apply these pricnciples in a structured way - classes, state, behaviour, methods. This is ok, but there's too much repetition going on. And the examples are very small/specific, some more complex/longer examples would be much better.

Then there's 2 whole paragraph about the performance characteristics of various collections (map,hash,etc.), and the description of the framework used to benchmark them. I don't think it has to do anyhting with the topic of the book, and it was probably included to increase the number of pages (by 30 to 150).

Finally, there's also a chapter "Evlolving Frameworks" which is mostly about JUnit 3->4 improvements done by the author. It's an interesting chapter focusing mainly on compatibility issues related to framworks.

So i think this topic from this author would deserve a much better book.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Customer Images

Most Recent Customer Reviews


What Other Items Do Customers Buy After Viewing This Item?