Implementation Patterns
by Kent Beck
List Price:
Our Price: $30.55
You Save: $14.44 (32%)
Availability: Usually ships in 1-2 business days
Buy Used: from $17.00 (click here)
Category: Book
See more book details and other editions
Book Summary Information
Author: Kent BeckEdition: Paperback
Audio: English (Unknown); English (Original Language); English (Published)
Published: 2007-11-02
ISBN: 0321413091
Number of pages: 176
Publisher: Addison-Wesley Professional
Book Reviews of Implementation Patterns
Book Review: Good book on how to communicate effectively with the code
Summary: 3 Stars
The book contains a number of low-level programming techniques for improving design of a program. Kent Beck is grand master of programming and a great communicator. If there is one thing you can learn from this book is to communicate design effectively with the code. The book is fairly concise and consists of ten chapters and 130 pages.
Due to his pioneering work in design patterns, Kent uses patterns to identify common programming techniques and similar to his extreme programming style for agile development he divides those techniques into values, principles and patterns. The values focus on high level goals such as communication, simplicity, flexibility. The principles focus on local consequences (minimize side-effect), DRY, keeping data/logic together, symmetry, decalartive (annotations), rate of change (Reuse/Release Equivalency Principle).
The chapter 5 describes different ways of organizing the code using classes, interfaces, versioned interface, abstract class, value object, etc. Kent shows importance of dependency inversion principle of coding to interfaces. He provides trade-offs between interfaces and abstract class such as change in implementation and change of the interface itself. One of the hardest thing in real world is progression of interfaces with new behavior and Kent describes versioned interface for it. Kent also encourages use of value or immutable objects to make the program side-effect free as in functional languages. He bemoans procedural interfaces due to temporal depdency they impose. Inheritance is also most difficult to get right, so Kent gives a lot of advice on that to make sure subclasses follow Liskov Substition Principle. Kent describes discourages use of conditional logic and encourags delegation technique based on polymorphism. He also shows pluggable selector briefly to implement plugin like behavior. Finally, he discourages of use of library classes with static methods and encourages use of instance methods.
The chapter 6 describes patterns for state such as access, variables, parameters, initializations, etc. Unlike functional languages that don't allow mutable state, imperative languages have to manage state that changes over time. Kent prefers indirect access to the state rather than direct especially when there is dependency between multiple pieces of data. Kent prefers keeping scope of variables local. This chapter also gives good advice on naming variables and parameters. Finally, this chapter describes techniques for eager and lazy initialization.
The chapter 7 describes patterns for control flow, methods and exceptions. In object oriented languages messages are fundamental mechanism for controlling workflow and communicating with the objects. Kent also describes technique for double dispatch (similar to visitor pattern) that provides polymorphic behavior but at the cost of additional coding and maintenance overhead. Other topics include providing guards, naming method and exception handling.
The chapter 8 describes how to divide logic into methods. The chapter describes composed method for calling other methods. It encourages use of symmetry and having same level of abstraction for called methods. Kent also shows use of Method object or Function object that mimics functional style of programming. This chapter also describes conversion methods, factory methods, getter/setter methods and advice of returning copy from the methods instead of internal references.
The chapter 9 describes collections such as arrays, lists, sets, map.
The final chapter describes how to evolve frameworks without breaking the applications. Kent borrows a lot of his experience from JUnit framework and Eclipse (his buddy Eric Gamma). One of interestic topic is how to use objects and the chapter provides three styles including instantiation, configuration and implmentation. Kent shows how implementation technique allow clients to implement a framework interface and extend behavior. Kent also describes trade-offs of extending interfaces and using specialized interfaces as used by AWT (LayoutManager2). The chapter also offers advice on use of internal classes by clients and how they can be instantiated using constructors, factories, etc.
This book shows a lot of techniques and patterns that most experienced programmers knowingly or unknowningly use on daily basis. Nevertheless, it helps to review these techniques and some trade-offs for them. Though, I wish the book gave a lot more examples and described antipatterns as I often found most of the topics a bit dull.
Summary of Implementation Patterns
?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.
Software Engineering Books
- Arts & Photography
- Biographies & Memoirs
- Business & Investing
- Children's Books
- Comics & Graphic Novels
- Computers & Internet
- Cooking, Food & Wine
- Entertainment
- Gay & Lesbian
- Health, Mind & Body
- History
- Home & Garden
- Horror
- Law
- Literature & Fiction
- Mystery & Thrillers
- Nonfiction
- Outdoors & Nature
- Parenting & Families
- Professional & Technical
- Reference
- Religion & Spirituality
- Romance
- Science
- Science Fiction & Fantasy
- Sports
- Teens
- Travel
Java Database Developmentby Martin Rinehart
Mcgraw-Hill Osborne Media; Published: 1997-11-10; Paperback; Book
Best price: $3.79
Price in other shops:
How to Be a Successful Online Studentby Sara Gilbert
McGraw-Hill; Published: 2000-11-21; Paperback; Book
Best price: $6.17
Price in other shops:
Sap R/ 3 Certification Exam Guide (All in One Certification)by Stewart S. Miller
Computing Mcgraw-Hill; Published: 1999-05-03; Paperback; Book
Best price: $29.00
Price in other shops:
Signals and Systems: Analysis Using Transform Methods and MATLAB. Michael J. Robertsby Michael J. Roberts
McGraw-Hill Higher Education; Published: 2003-09; Paperback; Book
Best price: $314.68
PgMP: Program Management Professional Exam Study Guideby Paul Sanghera
Sybex; Published: 2007-10-15; Paperback; Book
Best price: $32.01
Price in other shops:
Facts and Fallacies of Software Engineeringby Robert L. Glass
Addison-Wesley Professional; Published: 2002-11-07; Paperback; Book
Best price: $21.93
Price in other shops:
Extreme Programming in Practiceby James W. Newkirk, Robert C. Martin
Addison-Wesley Professional; Published: 2001-06-05; Paperback; Book
Best price: $0.99
Price in other shops:
SAP R/ 3 Plant Maintenance: Making it work for your businessby Britta Stengl, Reinhard Ematinger
Addison-Wesley Professional; Published: 2001-05-28; Hardcover; Book
Best price: $55.78
Price in other shops:
Patterns of Software: Tales from the Software Communityby Richard P. Gabriel
Oxford University Press, USA; Published: 1998-05-28; Paperback; Book
Best price: $64.55
Computer Systems: A Programmer's Perspectiveby Randal E. Bryant, David R. O'Hallaron
Prentice Hall; Published: 2002-08-23; Hardcover; Book
Best price: $36.99
Price in other shops:
Agile Software Development, Principles, Patterns, and Practicesby Robert C. Martin
Prentice Hall; Published: 2002-10-25; Hardcover; Book
Best price: $55.73
Price in other shops:
Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation (Addison-Wesley Signature Series (Fowler))by Jez Humble, David Farley
Addison-Wesley Professional; Published: 2010-08-06; Hardcover; Book
Best price: $31.27
Price in other shops:
Refactoring to Patternsby Joshua Kerievsky
Addison-Wesley Professional; Published: 2004-08-15; Hardcover; Book
Best price: $41.31
Price in other shops:
Growing Object-Oriented Software, Guided by Testsby Steve Freeman, Nat Pryce
Addison-Wesley Professional; Published: 2009-10-22; Paperback; Book
Best price: $31.76
Price in other shops:
Working Effectively with Legacy Codeby Michael Feathers
Prentice Hall; Published: 2004-10-02; Paperback; Book
Best price: $29.68
Price in other shops:
The Clean Coder: A Code of Conduct for Professional Programmers (Robert C. Martin Series)by Robert C. Martin
Prentice Hall; Published: 2011-05-23; Paperback; Book
Best price: $23.89
Price in other shops:
Refactoring: Improving the Design of Existing Codeby Martin Fowler, Kent Beck, John Brant, William Opdyke, Don Roberts
Addison-Wesley Professional; Published: 1999-07-08; Hardcover; Book
Best price: $25.00
Price in other shops:
Test Driven Development: By Exampleby Kent Beck
Addison-Wesley Professional; Published: 2002-11-18; Paperback; Book
Best price: $28.04
Price in other shops:
Patterns of Enterprise Application Architectureby Martin Fowler
Addison-Wesley Professional; Published: 2002-11-15; Hardcover; Book
Best price: $40.00
Price in other shops:
Clean Code: A Handbook of Agile Software Craftsmanshipby Robert C. Martin
Prentice Hall; Published: 2008-08-11; Paperback; Book
Best price: $32.89
Price in other shops: