Refactoring to Patterns (The Addison-Wesley Signature Series) / Edition 1

Hardcover (Print)
Buy Used
Buy Used from BN.com
$42.32
(Save 37%)
Item is in good condition but packaging may have signs of shelf wear/aging or torn packaging.
Condition: Used – Good details
Used and New from Other Sellers
Used and New from Other Sellers
from $35.97
Usually ships in 1-2 business days
(Save 47%)
Other sellers (Hardcover)
  • All (19) from $35.97   
  • New (10) from $40.19   
  • Used (9) from $35.97   

Overview

In 1994, Design Patterns changed the landscape of object-oriented development by introducing classic solutions to recurring design problems. In 1999, Refactoring revolutionized design by introducing an effective process for improving code. With the highly anticipated Refactoring to Patterns , Joshua Kerievsky has changed our approach to design by forever uniting patterns with the evolutionary process of refactoring.

This book introduces the theory and practice of pattern-directed refactorings: sequences of low-level refactorings that allow designers to safely move designs to, towards, or away from pattern implementations. Using code from real-world projects, Kerievsky documents the thinking and steps underlying over two dozen pattern-based design transformations. Along the way he offers insights into pattern differences and how to implement patterns in the simplest possible ways.

Coverage includes:

  • A catalog of twenty-seven pattern-directed refactorings, featuring real-world code examples
  • Descriptions of twelve design smells that indicate the need for this book’s refactorings
  • General information and new insights about patterns and refactoring
  • Detailed implementation mechanics: how low-level refactorings are combined to implement high-level patterns
  • Multiple ways to implement the same pattern—and when to use each
  • Practical ways to get started even if you have little experience with patterns or refactoring

Refactoring to Patterns reflects three years of refinement and the insights of more than sixty software engineering thought leaders in the global patterns, refactoring, and agile development communities. Whether you’re focused on legacy or “greenfield” development, this book will make you a better software designer by helping you learn how to make important design changes safely and effectively.

Read More Show Less

Editorial Reviews

From Barnes & Noble
The Barnes & Noble Review
Everyone loves design patterns. But there’s a catch. Most software isn’t new. What good are patterns when someone’s already “mis”-designed your system? Plenty, actually. Joshua Kerievsky will show you how to use “pattern-directed refactorings” to substantially improve existing software. Along the way, you’ll also learn to refactor toward patterns in your new software and achieve the elegance and robustness you’ve always aimed for.

Kerievsky systematically helps you identify code that can benefit from refactoring and offers an extensive catalog of potential refactorings for creation, simplification, generalization, protection, and accumulation. For each, you’ll find thoughtful explanations (with UML “sketches”); “why/when-to-use” guidance; step-by-step mechanics; and a detailed example.

Kerievsky was a technical reviewer on both The Gang of Four’s Design Patterns and Martin Fowler’s Refactoring. Like those, this book could wind up a classic. Bill Camarda

Bill Camarda is a consultant, writer, and web/multimedia content developer. His 15 books include Special Edition Using Word 2003 and Upgrading & Fixing Networks for Dummies, Second Edition.

Read More Show Less

Product Details

  • ISBN-13: 9780321213358
  • Publisher: Addison-Wesley
  • Publication date: 8/6/2004
  • Series: Addison-Wesley Signature Series
  • Edition description: New Edition
  • Edition number: 1
  • Pages: 367
  • Sales rank: 922,388
  • Product dimensions: 7.00 (w) x 9.30 (h) x 1.00 (d)

Meet the Author

Joshua Kerievsky is the founder of Industrial Logic (http://industriallogic.com), a company specializing in Extreme Programming. Since 1988, Joshua has been a professional software developer, coach, and instructor for clients such as Bankers Trust, MTV, MBNA, Ansys, MDS Sciex, Nielsen Media Research, and Sun Microsystems. He speaks regularly at conferences, has written numerous articles, and contributed chapters to Extreme Programming Explored (Addison-Wesley, 2001) and Extreme Programming Perspectives (Addison-Wesley, 2002). Joshua lives with his wife and daughters in Berkeley, California.

Read More Show Less

Read an Excerpt

What Is This Book About?

This book is about the marriage of refactoring—the process of improving the design of existing code—with patterns, the classic solutions to recurring design problems. Refactoring to Patterns suggests that using patterns to improve an existing design is better than using patterns early in a new design. This is true whether code is years old or minutes old. We improve designs with patterns by applying sequences of low-level design transformations, known as refactorings.

What Are the Goals of This Book?

This book was written to help you:

  • Understand how to combine refactoring and patterns
  • Improve the design of existing code with pattern-directed refactorings
  • Identify areas of code in need of pattern-directed refactorings
  • Learn why using patterns to improve existing code is better than using patterns early in a new design

To achieve these goals, this book includes the following features:

  • A catalog of 27 refactorings
  • Examples based on real-world code, not the toy stuff
  • Pattern descriptions, including real-world pattern examples
  • A collection of smells (i.e., problems) that indicate the need for pattern-directed refactorings
  • Examples of different ways to implement the same pattern
  • Advice for when to refactor to, towards, or away from patterns

To help individuals or groups learn the 27 refactorings in the book, you’ll find a suggested study sequence on the inside back cover of the book.

Who Should Read This Book?

This book is for object-oriented programmers engaged in or interested in improving the design of existing code. Many of these programmers use patterns and/or practice refactoring but have never implemented patterns by refactoring; others know little about refactoring and patterns and would like to learn more.

This book is useful for both greenfield development, in which you are writing a new system or feature from scratch, and legacy development, in which you are mostly maintaining a legacy system.

What Background Do You Need?

This book assumes you are familiar with design concepts like tight coupling and loose coupling as well as object-oriented concepts like inheritance, polymorphism, encapsulation, composition, interfaces, abstract and concrete classes, abstract and static methods, and so forth.

I use Java examples in this book. I find that Java tends to be easy for most object-oriented programmers to read. I’ve gone out of my way to not use fancy Java features, so whether you code in C++, C#, Visual Basic .NET, Python, Ruby, Smalltalk, or some other object-oriented language, you ought to be able to understand the Java code in this book.

This book is closely tied to Martin Fowler’s classic book Refactoring F. It contains references to low-level refactorings, such as:

  • Extract Method
  • Extract Interface
  • Extract Superclass
  • Extract Subclass
  • Pull Up Method
  • Move Method
  • Rename Method

Refactoring also contains references to more sophisticated refactorings, such as:

  • Replace Inheritance with Delegation
  • Replace Conditional with Polymorphism
  • Replace Type Code with Subclasses

To understand the pattern-directed refactorings in this book, you don’t need to know every refactoring listed above. Instead, you can follow the example code that illustrates how the listed refactorings are implemented. However, if you want to get the most out of this book, I do recommend that you have Refactoring close by your side. It’s an invaluable refactoring resource, as well as a useful aid for understanding this book.

The patterns I write about come from the classic book Design Patterns DP, as well as from authors such as Kent Beck, Bobby Woolf, and myself. These are patterns that my colleagues and I have refactored to, towards, or away from on real-world projects. By learning the art of pattern-directed refactorings, you’ll understand how to refactor to, towards, or away from patterns not mentioned in this book.

You don’t need expert knowledge of these patterns to read this book, though some knowledge of patterns is useful. To help you understand the patterns I’ve written about, this book includes brief pattern summaries, UML sketches of patterns, and many example implementations of patterns. To get a more detailed understanding of the patterns, I recommend that you study this book in conjunction with the patterns literature I reference.

This book uses UML 2.0 diagrams. If you don’t know UML very well, you’re in good company. I know the basics. While writing this book, I kept the third edition of Fowler’s UML Distilled Fowler, UD close by my side and referred to it often.

How to Use This Book

To get a high-level understanding of the refactorings in this book, you can begin by studying each refactoring’s summary (see Format of the Refactorings, 47), as well as its Benefits and Liabilities box, which appears at the end of each refactoring’s Motivation section.

To get a deeper understanding of the refactorings, you’ll want to study every part of a refactoring, with the exception of the Mechanics section. The Mechanics section is special. It’s intended to help you implement a refactoring by suggesting what low-level refactorings to follow. To understand a refactoring in this book, you don’t have to read the Mechanics section. You’re more likely to use the Mechanics section as a reference when you’re actually refactoring.

The coding smells described in this book and in Refactoring F provide a useful way to identify a design problem and find associated refactorings to help fix the problem. You can also scan the alphabetized listing of refactorings (on the inside covers of this book and Refactoring ) to find a refactoring that can help improve a design.

This book documents the refactorings that take a design either to, towards, or away from a pattern. To help you figure out what direction to go in, you’ll find a section on this subject (called Refactoring to, towards, and away from Patterns, 29) as well as a table (listed on the inside front cover) that shows each pattern name and the refactorings you can apply to take a design to, towards, or away from the pattern.

The History of This Book

I began writing this book sometime in 1999. At the time, there were several forces driving me to write about patterns, refactoring, and extreme programming (XP) Beck, XP. First, I was surprised that patterns had not been mentioned in the XP literature. This led me to write a paper called “Patterns & XP” Kerievsky, PXP in which I publicly discussed the subject and offered some suggestions on how to integrate these two great contributions to our field.

Second, I knew that Martin Fowler had included only a few refactorings to patterns in Refactoring F, and he clearly stated that he hoped someone would write more. That seemed like a worthwhile goal.

Finally, I noticed that people in The Design Patterns Workshop, a class that my colleagues and I teach, needed more help in figuring out when to actually apply a pattern to a design. It’s one thing to learn what a pattern is and an altogether different thing to really understand when and how to apply the pattern. I thought that these students needed to study real-world examples of cases where applying a pattern to a design makes sense, and thus I began compiling a catalog of such examples.

As soon as I began writing this book, I followed Bruce Eckel’s lead and placed my rather rough contents on the Web to obtain feedback. The Web is indeed a beautiful thing. Many folks responded with suggestions, encouragement, and appreciation.

As my writings and ideas matured, I began presenting the subject of Refactoring to Patterns in conference tutorials and during Industrial Logic’s intensive patterns and refactoring workshops. This led to more suggestions for improvement and many ideas on what programmers needed to understand this subject.

Gradually I came to see that patterns are best viewed in the light of refactoring and that they are destinations best reached by applying sequences of lowlevel refactorings.

When my writings began to resemble a book, rather than a long paper, I was fortunate enough to have many experienced practitioners review my work and offer suggestions for improvement. You can read more about these folks in the Acknowledgments section.

Standing on the Shoulders of Giants

In the summer of 1995, I walked into a bookstore, encountered the book Design Patterns DP for the first time, and fell in love with patterns. I wish to thank the authors, Erich Gamma, Richard Helm (whom I still haven’t met), Ralph Johnson, and John Vlissides for writing such an excellent piece of literature. The wisdom you shared in your book has helped me become a much better software designer.

Somewhere around 1996, before he became famous, I met Martin Fowler at a patterns conference. It was to be the beginning of a long friendship. I doubt whether I would have written this book if Martin (and his colleagues, Kent Beck, William Opdyke, John Brant, and Don Roberts) had not written the classic book Refactoring F. Like Design Patterns, Refactoring utterly changed the way I approach software design.

My writings in this book could only have happened because of the hard work of the authors of Design Patterns and Refactoring. I can’t thank you all enough for your great books.

Read More Show Less

Table of Contents

Foreword by Ralph Johnson.

Foreword by Martin Fowler.

Preface.

What Is This Book About?

What Are the Goals of This Book?

Who Should Read This Book?

What Background Do You Need?

How to Use This Book.

The History of This Book.

Standing on the Shoulders of Giants.

Acknowledgments.

1. Why I Wrote This Book.

Over-Engineering.

The Patterns Panacea.

Under-Engineering.

Test-Driven Development and Continuous Refactoring.

Refactoring and Patterns.

Evolutionary Design.

2. Refactoring.

What Is Refactoring?

What Motivates Us to Refactor?

Many Eyes.

Human-Readable Code.

Keeping It Clean.

Small Steps.

Design Debt.

Evolving a New Architecture.

Composite and Test-Driven Refactorings.

The Benefits of Composite Refactorings.

Refactoring Tools.

3. Patterns.

What Is a Pattern?

Patterns Happy.

There Are Many Ways to Implement a Pattern.

Refactoring to, towards, and away from Patterns.

Do Patterns Make Code More Complex?

Pattern Knowledge.

Up-Front Design with Patterns.

4. Code Smells.

Duplicated Code.

Long Method.

Conditional Complexity.

Primitive Obsession.

Indecent Exposure.

Solution Sprawl.

Alternative Classes with Different Interfaces.

Lazy Class.

Large Class.

Switch Statements.

Combinatorial Explosion.

Oddball Solution.

5. A Catalog of Refactorings to Patterns.

Format of the Refactorings.

Projects Referenced in This Catalog.

A Starting Point.

A Study Sequence.

6. Creation.

Replace Constructors with Creation Methods.

Move Creation Knowledge to Factory.

Encapsulate Classes with Factory.

Introduce Polymorphic Creation with Factory Method.

Encapsulate Composite with Builder.

Inline Singleton.

7. Simplification.

Compose Method.

Replace Conditional Logic with Strategy.

Move Embellishment to Decorator.

Replace State-Altering Conditionals with State 166

Replace Implicit Tree with Composite.

Replace Conditional Dispatcher with Command.

8. Generalization.

Form Template Method.

Extract Composite.

Replace One/Many Distinctions with Composite.

Replace Hard-Coded Notifications with Observer.

Unify Interfaces with Adapter.

Extract Adapter.

Replace Implicit Language with Interpreter.

9. Protection.

Replace Type Code with Class.

Limit Instantiation with Singleton.

10. Accumulation.

Move Accumulation to Collecting Parameter.

Move Accumulation to Visitor.

11. Utilities.

Chain Constructors.

Unify Interfaces.

Extract Parameter.

Afterword by John Brant and Don Roberts.

References.

Index.

Read More Show Less

Preface

What Is This Book About?

This book is about the marriage of refactoring—the process of improving the design of existing code—with patterns, the classic solutions to recurring design problems. Refactoring to Patterns suggests that using patterns to improve an existing design is better than using patterns early in a new design. This is true whether code is years old or minutes old. We improve designs with patterns by applying sequences of low-level design transformations, known as refactorings.

What Are the Goals of This Book?

This book was written to help you:

  • Understand how to combine refactoring and patterns
  • Improve the design of existing code with pattern-directed refactorings
  • Identify areas of code in need of pattern-directed refactorings
  • Learn why using patterns to improve existing code is better than using patterns early in a new design

To achieve these goals, this book includes the following features:

  • A catalog of 27 refactorings
  • Examples based on real-world code, not the toy stuff
  • Pattern descriptions, including real-world pattern examples
  • A collection of smells (i.e., problems) that indicate the need for pattern-directed refactorings
  • Examples of different ways to implement the same pattern
  • Advice for when to refactor to, towards, or away from patterns

To help individuals or groups learn the 27 refactorings in the book, you’ll find a suggested study sequence on the inside back cover of the book.

Who Should Read This Book?

This book is for object-oriented programmers engaged in or interested in improving the design of existing code. Many of these programmers use patterns and/or practice refactoring but have never implemented patterns by refactoring; others know little about refactoring and patterns and would like to learn more.

This book is useful for both greenfield development, in which you are writing a new system or feature from scratch, and legacy development, in which you are mostly maintaining a legacy system.

What Background Do You Need?

This book assumes you are familiar with design concepts like tight coupling and loose coupling as well as object-oriented concepts like inheritance, polymorphism, encapsulation, composition, interfaces, abstract and concrete classes, abstract and static methods, and so forth.

I use Java examples in this book. I find that Java tends to be easy for most object-oriented programmers to read. I’ve gone out of my way to not use fancy Java features, so whether you code in C++, C#, Visual Basic .NET, Python, Ruby, Smalltalk, or some other object-oriented language, you ought to be able to understand the Java code in this book.

This book is closely tied to Martin Fowler’s classic book Refactoring F. It contains references to low-level refactorings, such as:

  • Extract Method
  • Extract Interface
  • Extract Superclass
  • Extract Subclass
  • Pull Up Method
  • Move Method
  • Rename Method

Refactoring also contains references to more sophisticated refactorings, such as:

  • Replace Inheritance with Delegation
  • Replace Conditional with Polymorphism
  • Replace Type Code with Subclasses

To understand the pattern-directed refactorings in this book, you don’t need to know every refactoring listed above. Instead, you can follow the example code that illustrates how the listed refactorings are implemented. However, if you want to get the most out of this book, I do recommend that you have Refactoring close by your side. It’s an invaluable refactoring resource, as well as a useful aid for understanding this book.

The patterns I write about come from the classic book Design Patterns DP, as well as from authors such as Kent Beck, Bobby Woolf, and myself. These are patterns that my colleagues and I have refactored to, towards, or away from on real-world projects. By learning the art of pattern-directed refactorings, you’ll understand how to refactor to, towards, or away from patterns not mentioned in this book.

You don’t need expert knowledge of these patterns to read this book, though some knowledge of patterns is useful. To help you understand the patterns I’ve written about, this book includes brief pattern summaries, UML sketches of patterns, and many example implementations of patterns. To get a more detailed understanding of the patterns, I recommend that you study this book in conjunction with the patterns literature I reference.

This book uses UML 2.0 diagrams. If you don’t know UML very well, you’re in good company. I know the basics. While writing this book, I kept the third edition of Fowler’s UML Distilled Fowler, UD close by my side and referred to it often.

How to Use This Book

To get a high-level understanding of the refactorings in this book, you can begin by studying each refactoring’s summary (see Format of the Refactorings, 47), as well as its Benefits and Liabilities box, which appears at the end of each refactoring’s Motivation section.

To get a deeper understanding of the refactorings, you’ll want to study every part of a refactoring, with the exception of the Mechanics section. The Mechanics section is special. It’s intended to help you implement a refactoring by suggesting what low-level refactorings to follow. To understand a refactoring in this book, you don’t have to read the Mechanics section. You’re more likely to use the Mechanics section as a reference when you’re actually refactoring.

The coding smells described in this book and in Refactoring F provide a useful way to identify a design problem and find associated refactorings to help fix the problem. You can also scan the alphabetized listing of refactorings (on the inside covers of this book and Refactoring ) to find a refactoring that can help improve a design.

This book documents the refactorings that take a design either to, towards, or away from a pattern. To help you figure out what direction to go in, you’ll find a section on this subject (called Refactoring to, towards, and away from Patterns, 29) as well as a table (listed on the inside front cover) that shows each pattern name and the refactorings you can apply to take a design to, towards, or away from the pattern.

The History of This Book

I began writing this book sometime in 1999. At the time, there were several forces driving me to write about patterns, refactoring, and extreme programming (XP) Beck, XP. First, I was surprised that patterns had not been mentioned in the XP literature. This led me to write a paper called “Patterns & XP” Kerievsky, PXP in which I publicly discussed the subject and offered some suggestions on how to integrate these two great contributions to our field.

Second, I knew that Martin Fowler had included only a few refactorings to patterns in Refactoring F, and he clearly stated that he hoped someone would write more. That seemed like a worthwhile goal.

Finally, I noticed that people in The Design Patterns Workshop, a class that my colleagues and I teach, needed more help in figuring out when to actually apply a pattern to a design. It’s one thing to learn what a pattern is and an altogether different thing to really understand when and how to apply the pattern. I thought that these students needed to study real-world examples of cases where applying a pattern to a design makes sense, and thus I began compiling a catalog of such examples.

As soon as I began writing this book, I followed Bruce Eckel’s lead and placed my rather rough contents on the Web to obtain feedback. The Web is indeed a beautiful thing. Many folks responded with suggestions, encouragement, and appreciation.

As my writings and ideas matured, I began presenting the subject of Refactoring to Patterns in conference tutorials and during Industrial Logic’s intensive patterns and refactoring workshops. This led to more suggestions for improvement and many ideas on what programmers needed to understand this subject.

Gradually I came to see that patterns are best viewed in the light of refactoring and that they are destinations best reached by applying sequences of lowlevel refactorings.

When my writings began to resemble a book, rather than a long paper, I was fortunate enough to have many experienced practitioners review my work and offer suggestions for improvement. You can read more about these folks in the Acknowledgments section.

Standing on the Shoulders of Giants

In the summer of 1995, I walked into a bookstore, encountered the book Design Patterns DP for the first time, and fell in love with patterns. I wish to thank the authors, Erich Gamma, Richard Helm (whom I still haven’t met), Ralph Johnson, and John Vlissides for writing such an excellent piece of literature. The wisdom you shared in your book has helped me become a much better software designer.

Somewhere around 1996, before he became famous, I met Martin Fowler at a patterns conference. It was to be the beginning of a long friendship. I doubt whether I would have written this book if Martin (and his colleagues, Kent Beck, William Opdyke, John Brant, and Don Roberts) had not written the classic book Refactoring F. Like Design Patterns, Refactoring utterly changed the way I approach software design.

My writings in this book could only have happened because of the hard work of the authors of Design Patterns and Refactoring. I can’t thank you all enough for your great books.

Read More Show Less

Customer Reviews

Average Rating 4
( 5 )
Rating Distribution

5 Star

(3)

4 Star

(1)

3 Star

(0)

2 Star

(0)

1 Star

(1)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing all of 5 Customer Reviews
  • Anonymous

    Posted June 8, 2006

    Really important topic, disappointing treatment of it

    There seems to be a common misconception that Refactoring and Patterns are disconnected things. I had high hopes that this would be the book that cleared this misconception and tied them together. But I found the examples to be contrived, and often not deserving of the patterns that were applied. The step-by-step examples were hard to follow as they constantly gave tiny snippets of code that were missing proper context. As important as I think this topic and message is, I can't imagine this book convincing anyone who wasn't already convinced. At best, this might make a passable supplement to someone learning patterns for the first time from another source. On the bright side, some of the stories in the early chapters were entertaining, but not enough to recommend this derivative work.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted October 21, 2004

    nice sequel to Fowler's Refactoring

    This is a recent book in Martin Fowler's series of computing texts. The series begins with his classic Refactoring text. Now Kerievsky takes us into a sequel. Because you can imagine this as a suitable extension of the previous book. Where now the author has us look for patterns during the refactoring process. The style of the book closely follows Fowler's book. And, like that book, the code examples are in Java. But what if you program in C++ or C#? If you are experienced enough, you should be able to apply many of these ideas in your language. The examples are meant to give flesh to general patterns. And the patterns should be able to be implemented in any object oriented language. Actually, if you have already been looking for patterns, or designing to them, then much of this book may be no surprise. Because one virtue of the book is that it binds together a set of commonly encountered refactorings. But even in this case, a few hours reading may be profitable for you, if it just exposes you to a few hitherto unfamiliar patterns.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted September 19, 2004

    Wonderful! Brings patterns into coding, not just designing

    Based on its title alone I had high expectations for this book. It didn¿t disappoint. The book takes two of the most important advances of the past decade (patterns and refactoring) and puts them together into a whole that is definitely more than the sum of its parts. I¿ve read many good patterns books and have been applying patterns to how I think and talk about software since the original ¿Design Patterns¿ book in 1995. However, something was always missing. Through my consulting work, whenever I introduced patterns to a new team they would take quickly to the idea and patterns would become part of how they thought¿but only when designing, not when coding. Since we spent more time coding than designing, patterns played less of a role than they could have. This book does an excellent job of bringing patterns into coding, rather than relegating them just to design discussions. As the author points out, ¿patterns are best viewed in the light of refactoring and that they are destinations best reached by applying sequences of low-level refactorings.¿ This book has earned a permanent place on my bookshelf. That is, when it¿s not open beside me as I program. Very highly recommended!

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted April 18, 2014

    No text was provided for this review.

  • Anonymous

    Posted March 2, 2014

    No text was provided for this review.

Sort by: Showing all of 5 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)