Goodreads helps you keep track of books you want to read.
Start by marking “Refactoring to Patterns” as Want to Read:
Refactoring to Patterns
Enlarge cover
Rate this book
Clear rating
Open Preview

Refactoring to Patterns

(Martin Fowler Signature Book)

4.05  ·  Rating details ·  1,397 ratings  ·  44 reviews
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 pat ...more
Hardcover, 400 pages
Published August 15th 2004 by Addison-Wesley Professional (first published 2004)
More Details... Edit Details

Friend Reviews

To see what your friends thought of this book, please sign up.

Reader Q&A

To ask other readers questions about Refactoring to Patterns, please sign up.

Be the first to ask a question about Refactoring to Patterns

Community Reviews

Showing 1-30
Average rating 4.05  · 
Rating details
 ·  1,397 ratings  ·  44 reviews

More filters
Sort order
Start your review of Refactoring to Patterns
Rod Hilton
Oct 30, 2008 rated it liked it
Shelves: programming
Refactoring to Patterns essentially attempts to merge together two types of books: books on code design (such as the GoF Patterns book, Head First Design Patterns, Patterns of Enterprise Application Architecture, etc) and books on engineering principles (such as the eXtreme Programming series and, most of all, Fowler's Refactoring).

In this, it succeeds. Refactoring to Patterns really makes explicit the relationship between agile programming practices and OO design. It draws a connection precisel
Frederik Sørensen
Dec 22, 2013 rated it it was amazing
Shelves: software
Without context advises from pattern books like Design Patterns: Elements of Reusable Object-Oriented Software can be difficult to apply. This is where Joshua's book shine. He walks through many different patterns, shows how messy code could look and explains how to refactor the code into patterns.

Most importantly he also gives many advises to when not to apply the refactorings. I particularly likes the boxes with pros and cons for each refactoring.

The book heavily references Design Patterns: El
Mark Nenadov
Jan 11, 2019 rated it really liked it
A solid resource for software developers. Essentially, it provides a detailed and prolonged practical look at the broader context that is often missing in typical design pattern/GoF type books. There is a lot of real code and explanation here. And the code displayed generally isn't some sort of pared down or contrived example. My only beef is that I found some aspects of the layout to be rather tedious, and while initially the format seems attractive and effective, by the end it seems too busy a ...more
Jan 16, 2018 rated it really liked it
Really useful reference material. You need to be comfortable with design patterns in order to fully appreciate the message of this book. The mechanics for each type of refactoring is refreshing as we're often introduced to design patterns or refactoring from a singular example. This book bridges the gap between an existing solution to one that uses design patterns. ...more
Josh Hamacher
Aug 10, 2012 rated it liked it
Shelves: programming
Like several other reviewers, this book left me scratching my head slightly and wondering what its aim really was. I was hoping the focus would be more on analysis of legacy code, with advice on discovering and teasing out potential patterns. Instead, this is almost entirely a "how-to" book.

The vast majority of its 350 pages are taken up with 27 refactorings. Each refactoring includes a "how to" section and then an (often lengthy) step-by-step example. Yet, if you're familiar with design pattern
Ronald Rajagukguk
Oct 16, 2013 rated it really liked it
Personally I expect more the book, nevertheless it gave me quite an impression. The book gave a lot of code example but unfortunately some of them is unclear, which need me to stare at the code several minutes till I understand the author intention. Good book a software engineer who want to know design pattern deeper, but i don't recommend this book for beginner. ...more
Melita Mihaljevic
Jan 13, 2012 rated it really liked it
Great and useful book. Highly recommended.
Marko Kunic
Aug 31, 2018 rated it it was amazing
This should for sure be your first book about patterns. I really enjoyed the approach in this book, it is very well explained. Joshua Kerievsky first shows the problem and then refactors the code step by step into a pattern. Why did I enjoy the approach? Because giving you a pattern catalog and just going over patterns isn’t enough. You need to understand when to use patterns and not to use it prematurely, maybe you won’t even need it. When you see the “bad” code and you take steps to refactor i ...more
Jordi Espasa Cusachs
The book drives you into the world of patterns in a very didactic way. Easy to read, engages you to use the patterns and also, very important, when not to use it. Full of stories and real examples, it shows you the decision process to when to use a pettern or another, or not use it at all. Not using patterns is an enemy, overengineering is an enemy as well.
Dec 27, 2016 rated it really liked it
Shelves: software
Refactoring is my favorite topic in Software Quality. This book has only made me an even a bigger Merciless Refactorer. I like the way Joshua put the focus on learning the problem and not the solution.
Kaloyan Roussev
Oct 12, 2018 rated it it was amazing
Shelves: programming
The more interesting version of "Design patterns" by GoF and a lightweight substitute of one third of "Agile software development - Patterns practices principles".
The natural continuation of Fowler's "Refactoring"
Madhur Ahuja
Nov 05, 2017 rated it it was amazing
Shelves: tech
Another book to be read again and again, after "Refactoring: Improving the Design of Existing Code" ...more
Jun 14, 2018 rated it really liked it
Shelves: software
Kerievsky provides a succinct set of patterns with non-trivial examples for each. All developers should have this for reference.
Dec 12, 2018 rated it it was amazing
Very interesting book, but in order to get the most benefits from it, you have to read the Refactoring book by Martin Fowler first. and preferred to read the Design Patterns book by the Gang of Four.
Paolo Bizzarri
Jun 25, 2019 rated it it was amazing
Excellent book on refactoring and patterns. Very good examples. Always a pleasure to reread.
Federico Fregosi
Jan 16, 2020 rated it liked it
Very oo
Mar 29, 2020 rated it really liked it
Bit dated, but still solid patterns to follow
Nov 26, 2012 rated it really liked it
This book is an excellent combination of Design Patterns and Refactoring. It's perfect if you're looking to improve your understanding of design patterns and/or refactoring, but it really shines if your goal is to understand how they both work together. Rather than thinking of design patterns as things you cook into your program, which is what usually leads to "design pattern abuse," this book recommends you start with a simple design first, and evolve to design patterns if you start noticing "c ...more
Blair Conrad
Apr 09, 2008 rated it it was amazing
A very good book, balancing the need to present useful refactorings against the risk of alienating readers with too-complicated refactorings. The constant references to Martin Fowler’s work were justified, and if you really want to get the most out of this book, you should have Refactoring and Design Patterns with you.
I didn’t, though, and still found it very interesting. By the end, the “mechanism” section of each refactoring was a little tough slogging, but the examples were very followable. A
Ash Mishra
Aug 06, 2011 marked it as to-read
The subject material in this book is what separates those who think they understand the purpose and utilization of patterns, from those who realize that patterns are essential not to just the design of an application, but more importantly to its extensibility and forward maintenance. Too often as software engineers, we have seen two camps of developers: those who are new to the field and unaware of good design, and the latter are those armed and dangerous with knowledge of patterns, but use them ...more
Apple84 Wylie
Aug 04, 2008 rated it liked it
Recommended to Apple84 by: developers involved in large projects or legacy code
In regard to design patterns, lines can be strongly drawn between developers. Some argue it is the only way to code while others believe the practice is sterile and inhibits creativity. I think patterns are useful in some situations and a hinderance in others; for me, their utility factors on a large number of variables, including project type, resources, language, and number of developers involved in the project. It helps to understand and research the technology if only to eschew or discount t ...more
Dec 14, 2016 rated it really liked it
If you read Refactoring, then this book will be the next step. While Martin Fowler explains in Refactoring the mechanics of the trade, Joshua Kerievsky explains how you can use the small building blocks to make significant refactorings towards patterns. Especially helpful when you need to solve problems that fall within a useful pattern and you don’t want to reinvent the wheel. The book is even better when you are at a pattern that someone forced upon your application but doesn’t solve the probl ...more
Wilson Jimenez
This book is presented as the connection between Design Patterns [GoF] and Refactoring [Fowler]. Overall content is good and thoroughly explained. I was expecting it to have a structure like: refactoring ABC from Fowler can be matched with patterns X, Y, Z from GoF. However, it feels more like a paraphrased version of Fowler's Refactoring book, which makes it feel repetitive.

And even if my expectations would've been met, I now realise you wouldn't need a book to describe this relation between pa
Gleb Sevruk
Oct 11, 2013 rated it really liked it
Shelves: read-dev
This book is quite dated and can be misleading. However just skimming through was helpful to understand all of existing patterns.

Some patterns are dead and considered as anti-patterns:

If you haven't read Dependency Injection in .NET by Mark Seemann, and thinking about next book I highly recommend to close this page, and go and read right now - that book is also all about patterns and OOP.

Sep 12, 2013 rated it liked it
If you already have applied yourself proper TDD and refactoring, don't buy this. Almost everything in this book is totally intuitive if you know about design patterns. You don't even have to be an expert to know every single pattern driven refactoring in this book.

If you don't, I guess it is a great introduction to refactoring and design pattern, probably even better than Martin Fowler's book. Often, design pattern books are boring and unusable, but not this one.
Apr 20, 2011 rated it really liked it
Very good explanations of each refactoring process that the author undertakes along with code snippets, thought process, steps involved, testing the changes, etc. As a developer you'd want to get into that habit of always refactoring your code to a cleaner / better version. ...more
Uldis Sturms
Jul 03, 2014 rated it it was amazing
Loved the way refactorings were presented - steps to follow to keep the code compiling and passing tests as much as possible while refactoring - very detailed, felt like pair programming w/ author. Also good reasoning.
José Pereira
Sep 02, 2014 rated it really liked it
Very interesting way to present design patterns, through real problems that needed to be refactored.
There is also a reference to common problems, such as conditional complexity and duplicated code, and the refactorings that could be applied.
Franck Chauvel
Sep 03, 2014 rated it really liked it
To my opinion, the important part in this book is to illustrate how to move safely from or to design patterns, in a disciplined manner without breaking everything, but taking baby steps. Beyond the mere refactoring steps, it provides insight about when to use and when not to use patterns.
Jan 05, 2015 rated it really liked it
I liked the attention given to context and forces for the patterns.
I read Emergent Design by Bain before this which may have taken some of the wind out of the sails, but still thought this one was great in it's own right.
« previous 1 next »
There are no discussion topics on this book yet. Be the first to start one »

Readers also enjoyed

  • Refactoring: Improving the Design of Existing Code
  • Test-Driven Development: By Example
  • Domain-Driven Design: Tackling Complexity in the Heart of Software
  • Design Patterns: Elements of Reusable Object-Oriented Software
  • Clean Architecture
  • Clean Code: A Handbook of Agile Software Craftsmanship
  • The Clean Coder: A Code of Conduct for Professional Programmers
  • Designing Data-Intensive Applications
  • Growing Object-Oriented Software, Guided by Tests
  • Code Complete
  • Head First Design Patterns
  • Working Effectively with Legacy Code
  • Release It!: Design and Deploy Production-Ready Software (Pragmatic Programmers)
  • Accelerate: Building and Scaling High-Performing Technology Organizations
  • The Pragmatic Programmer: From Journeyman to Master
  • Building Microservices: Designing Fine-Grained Systems
  • The Mythical Man-Month: Essays on Software Engineering
  • Peopleware: Productive Projects and Teams
See similar books…

Goodreads is hiring!

If you like books and love to build cool products, we may be looking for you.
Learn more »

Other books in the series

Martin Fowler Signature Book (1 - 10 of 11 books)
  • xUnit Test Patterns: Refactoring Test Code
  • Refactoring HTML: Improving the Design of Existing Web Applications
  • Beyond Software Architecture: Creating and Sustaining Winning Solutions
  • Refactoring Databases: Evolutionary Database Design
  • Continuous Delivery: Reliable Software Releases Through Build, Test, and Deployment Automation
  • Domain-Specific Languages
  • Patterns of Enterprise Application Architecture
  • Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions
  • Continuous Integration: Improving Software Quality and Reducing Risk
  • Service Design Patterns: Fundamental Design Solutions for SOAP/WSDL and RESTful Web Services

News & Interviews

Need another excuse to treat yourself to a new book this week? We've got you covered with the buzziest new releases of the day. To create our...
25 likes · 5 comments