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

Refactoring: Improving the Design of Existing Code

(Addison-Wesley Object Technology Series)

4.23  ·  Rating details ·  6,068 ratings  ·  224 reviews
Fully Revised and Updated-Includes New Refactorings and Code Examples "Any fool can write code that a computer can understand. Good programmers write code that humans can understand."
--M. Fowler (1999) For more than twenty years, experienced programmers worldwide have relied on Martin Fowler's Refactoring to improve the design of existing code and to enhance software mai
Hardcover, Second edition, 448 pages
Published November 29th 2018 by Addison-Wesley Professional (first published January 1st 1999)
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, please sign up.
Popular Answered Questions
Ahmed Good book, but it contains some design patterns that they are kind of obsolete now. But overall is I recommend it for people who have never done…moreGood book, but it contains some design patterns that they are kind of obsolete now. But overall is I recommend it for people who have never done refactoring before.(less)
This book is not yet featured on Listopia. Add this book to your favorite list »

Community Reviews

Showing 1-30
4.23  · 
Rating details
 ·  6,068 ratings  ·  224 reviews

More filters
Sort order
Ivan Idris
Jan 22, 2012 rated it it was amazing  ·  review of another edition
Refactoring is the process of rewriting software, without changing the way it functions, in order to improve its readability, testability or maintanability. A book has been written on the subject by Martin Fowler. Some of the chapters were written by other people.

“Refactoring: Improving the Design of Existing Code” is focused on OO programming (lots of Java examples) and Agile practices. It is setup as a catalog of refactoring techniques. Each page dedicated to a refactoring is clearly marked, s
David Workman
While this book is more of a reference book than a book to read through a memorise (and I intend to use it as such in the future), this book is well worth having for software engineers looking to improve their practices. Even if you don't subscribe to Martin Fowler's 'lots of small methods and classes' style of programming (and I admit, it takes some getting used to), the techniques in this book are still useful and applicable to any software project.

The book consists mainly of a catalog of ref
Jan 31, 2012 rated it really liked it  ·  review of another edition
If you are interested in improving and maintaining the quality of your code this book should be on your reading list. It is not the kind of book you read once and forget about it. When you are doing refactoring it’s always recommended to come back and check the categories explained in it.

What I really enjoyed is that it confirmed some of the ideas I already had about software development. On the first hand you should have a robust test suite in order to be certain that refactoring didn’t change
Jesse Buss
Overall I was disappointed in this book. Modern tools and IDE's have removed nearly all of the pain points that are laid out in this book, which made reading annoying and tiresome. I skipped the "Mechanics" section of every single refactor because they are just not relevant in 2016. Your compiler and IDE will tell you every thing you need to know in nearly all cases.

That being said the content is good, albeit very basic. I would recommend this to someone who is just out of college or with littl
Ultra Violence
Feb 25, 2019 rated it really liked it  ·  review of another edition
До прочтения я писал плохой код; теперь я, слегка обновив приоритеты, пишу код чуть лучше. Это настолько радостное осознание собственного прогресса, что я готов простить книге и суховатый стиль, и отсутствие ответов на весьма кмк важные вопросы вроде приоритетов различных видов рефакторинга. Очень, очень хорошо.
Steliyan Stoyanov
Dec 04, 2016 rated it it was amazing  ·  review of another edition
Shelves: tech
This book is a must-read for every software developer. I would personally recommend it to my team members.

I totally agree with Martin and his vision that the changes should be incremental. I think everyone that tried a "complete rewrite" at some point failed or at least achieved unsatisfactory results. Maybe they didn't completed in time or didn't achieve the expected results.

The most important aspect that is emphasized in the book is that you should apply refactoring when you need to, not just
Mar 19, 2019 rated it it was amazing  ·  review of another edition
You hear something about refactoring and you want to see what it is ?
You want to make your code better but don't know how to do it ?

If your answer is yes, then this book is for you.
Martin Fowlers 'Refactoring' is in my opinion the best book about this subject.

Author describes many refactoring techniques and explain how and when to use them.
Each technique has it's own example write in javascript - code is very easy to understand
and you won't have any problems to apply it in your language of choic
Ehsan Gazar
Feb 07, 2019 rated it it was amazing  ·  review of another edition
This book is not just for refactoring, it's for understanding how professional are thinking about their code. You can use these methods even in writing the first line of your code.

This is one of the books that every developer should read to transform his knowledge to be in more readable and flexible code.
Steve Fenton
Jan 25, 2019 rated it it was amazing
What I like most about this book is that many of the refactorings are accompanied by an inverse equivalent. Like the GoF book on patterns, the idea behind the library is to commit the existence of patterns to memory, but refer back to the library when you want to apply one.
Rômulo Oliveira
Jan 10, 2019 rated it it was amazing
Um dos melhores livros de programação que se pode ter, atemporal. Ainda não havia lido e fiquei feliz de ver que já sabia e aplicava muito dos conceitos do livro, graças a ótimos colegas que trabalhei e me inspiram. Vai continuar fazendo parte do dia a dia, principalmente a versão web, muito fácil de consultar.

Saber refatorar bem (quando, como, porquê e para quê) separa os pequenos dos grandes, e esse livro é o guia definitivo para isso.
Aleksander Meterko
A solid book for a developer which contains a number of so-called "code smells", which should tell you that this specific piece of code needs to be refactored, along with techniques to achieve this result. Although these techniques seems outdated as modern IDEs are able to make most of these refactorings automatically for you (and these automation is described in Chapter 14) it is still good to know when to perform these refactorings.

This book may be read both as a reference guide (it has conven
Costin Manda
Feb 27, 2019 rated it really liked it  ·  review of another edition
Shelves: owned
It was long overdue for me to read a technical book and I've decided to go for a classic from 1999 about refactoring, written by software development icons as Martin Fowler and Kent Beck. As such, it is not a surprise that Refactoring: Improving the Design of Existing Code feels a little dated. However, not as much as I had expected. You see, the book is trying to familiarize the user with the idea of refactoring, something programmers of these days don't need. In 1999, though, that was a breakt ...more
Yevgeniy Brikman
Pros: presenting refactoring as a regular part of the development process is an important step forward. The example at the start of the book is a great demonstration if why this stuff matters. Nice to systematically catalog code smells.

Cons: the code smells section is great, but has no actual code examples. The chapters that go through the refactoring moves are better, but having each one isolated makes it boring to read. The big refactoring chapters are only UML diagrams, which are not good te
Apr 18, 2012 rated it really liked it  ·  review of another edition
I was having a great time reorganizing and hopefully improving some Java at work, and a coworker had mentioned this book. Good stuff. I didn't read through the whole reference section, but took a quick look at some. It seems like the IDE I was using (IntelliJ) had a bunch of refactorings (not sure what the overlap is with this catalog) available as keyboard shortcuts, basically. But it's still fun to read about. Unfortunately, I got this book approximately the same week I shifted off Java develo ...more
Mahmoud Tantawy
May 22, 2017 rated it it was amazing  ·  review of another edition
Good way to end a year!
A must-read reference for every developer, not only ones dealing with legacy code but ones starting new project to save the project on the long-run.

The book is well written, provides samples, examples, diagrams, steps to follow, side-notes, commentary, and basically everything you would need to fully understand a refactoring method.

While the book doesn't provide revolutionary solutions to perform refactoring (you shouldn't perform major refactoring in one step anyway), a l
May 19, 2015 rated it really liked it  ·  review of another edition
Shelves: programming
Finally finished this, long after the book club for it was over! This is a classic, which means there are both really good pieces of wisdom in here as well as concerns that don't need to be worried about so much anymore with more modern tools and text editors. The majority of the book is kind of a reference of refactoring "recipes" with checklists to go through to make sure you haven't missed something--time will tell if I end up using that reference portion. The descriptions and motivations for ...more
Mar 09, 2009 rated it it was amazing  ·  review of another edition
Shelves: work
The best programming book I've read in a long time.

There are a lot of design and analysis books but not a lot of programming books. I would gladly read anything from Fowler. It's so simple of a concept but it goes against a lot of 'common sense'. Essentially, don't over design. Don't spend too much time in design and analysis that you've been told to do based on the wrong assumptions of the waterfall model (which never worked).

Kent's book on Test-driven Development is a great companion to this
Ricardo Cavalcanti
This book represents one of the building blocks of good programming. Most of the examples are in java, and most of the techniques are already implemented by IDE such as IntelliJ. Still, the ideas can be applied in any programming language, with or without an IDE.
Fernanda Martins
Feb 02, 2016 rated it really liked it  ·  review of another edition
Very dense book. There's a lot of techniques about refactoring. It's a bit intense so I recommend not reading everything at once like I did.
Jean Tessier
Feb 13, 2019 rated it it was amazing
Shelves: software
An update to the 1999 classic Refactoring. I still have my autographed copy of the first edition. The original used code examples in Java. This new edition uses JavaScript instead.

I followed Fowler's advice to "read the first four chapters completely, then skip-read the catalog." It's the same approach I used when I read Gerard Meszaros' xUnit Test Patterns. The initial chapters make a case for refactoring and describe the general principles. The remainder of the book is a nice catalog of specif
Scott Pearson
Feb 09, 2019 rated it liked it  ·  review of another edition
Shelves: software
I picked up this book at the wrong time. The book was so successful that a second edition is due out on November 30, 2018 (less than two weeks from now).

On the other hand, I picked up this book at the right time. At work, my project is in the midst of a refactoring project. I am in the middle of changing PHP code from modular functions to object-orientation. The aim of this transition is to enhance the scalability of the project and ease the writing of documentation. I generally like to peer "be
Nathan Glenn
Apr 09, 2013 rated it it was amazing  ·  review of another edition
I'm giving this 5 stars sort of out of principle. As far as I'm concerned, I've already long ago absorbed the contents of this book just by being part of the greater developer community. There's lots of discussion about why you should refactor, how a good idea plus refactoring is better than full design up front, etc. There's a full catalog of refactorings that you can perform, with instructions on how to do them safely with a bare text editor(!). I think most of the refactorings are just built ...more
Andrés Quilodrán
Oct 15, 2017 rated it really liked it  ·  review of another edition
Shelves: programming
I loved this book. Martin does a great job at arguing why refactoring is so important to the software development process as a way to ensure you have the best design possible for your application, or at least aim to, at any given time. That's definitely one of the things that will stick with me the most after reading this book.

The refactoring catalog is presented in a very clear and concise way, going from the motivation to the mechanichs of each one, they're not hard to digest and easy to go ba
Jean-marie Prevost
Dec 19, 2013 rated it it was amazing  ·  review of another edition
Shelves: coding
Excellent book about the importance and advantages of refactoring. It's really made it clear for me how to not only see refactoring as a one-time act of tidying up, but rather as an ongoing process.

The examples provided with each refactoring are simple and short, but deliver all they need to in order to serve their purpose.

I found it especially interesting to see the inverse refactorings (e.g. break apart a class into 2, combine 2 classes into 1) and understand that most aspects of quality code
Asiful Nobel
Feb 08, 2019 rated it really liked it
This book by Martin Fowler is a classic which I decided to read after getting recommendation from multiple Senior Software Engineers. I must say that they were right that this is a must read for newly entering people in the field. Martin Fowler is very successful in passing the message that softwares are not meant to be designed once and coded. Then that codebase should only be refactored when bug fixes or new features need to be implemented. The author shows how to refactor a codebase to keep i ...more
Jonathan Kempf
May 07, 2019 rated it liked it
After having just "finished" this book, I can say I am unimpressed. As a library or reference for actual refactorings, it is useful, but fails in its effort to catalog them in any sort of referenceable way.

There are pure gold nuggets in there, of course. But this book could have used a refactor of its own to make it more readable and also, easier to bookmark as a reference when conducting some refactorings of your own.
Apr 29, 2019 rated it really liked it  ·  review of another edition
Shelves: coding
The book contains very great list of refactoring. I am really looking forward using them on real project. At the beginning it was difficult to read the book. Because it mentions all refactoring and bad smells at the beginning, so it did not know what they mean. Additionally it is cool that refactoring are written through links and it helps to look at the them while reading but it distracts and focus goes to other refactoring.
Jahongir Rahmonov
Apr 01, 2019 rated it really liked it  ·  review of another edition
Pretty good book that gives you insight into how professionals like Martin Fowler think. The author explains everything by going through each step that he would take:

First, I would do this. Then, I would do that because this would have caused that and etc.

I think this is more valuable than just plainly presenting information.

The only minus I see is the price. I feel it is too much. Still, worth reading of course.

Jan 28, 2018 rated it liked it  ·  review of another edition
Shelves: read-in-2018
Though it is a high rated book which is considered as a must-read classic as a software engineer, I think quite a few parts are outdated. This is a book written before object oriented programming totally got accepted in software industry, so lots of tips introduced can be considered as basics nowadays. Also, IDEs and libraries are much smarter when comparing to 20 years before, some refactoring techniques showed in this book should get refreshed now.
Johnny Graber
Oct 23, 2016 rated it it was amazing  ·  review of another edition
This book aged very well and all it covers is still relevant today. Refactoring code is a great way to preserve the value the code has while making it better at the same time. Fowlers catalogue of all the refactorings not only gives us names to define a common understanding, but a practical advice on how to do it. Definitively a must read for every software developer.
« previous 1 3 4 5 6 7 8 9 next »
topics  posts  views  last activity   
Goodreads Librari...: Second edition is listed as a separate book 2 229 Dec 19, 2018 10:43AM  

Readers also enjoyed

  • Refactoring to Patterns
  • Test Driven Development: By Example
  • Working Effectively with Legacy Code
  • Agile Software Development, Principles, Patterns, and Practices
  • Growing Object-Oriented Software, Guided by Tests
  • Rapid Development: Taming Wild Software Schedules
  • Design Patterns: Elements of Reusable Object-Oriented Software
  • xUnit Test Patterns: Refactoring Test Code
  • Domain-Driven Design: Tackling Complexity in the Heart of Software
  • Programming Ruby: The Pragmatic Programmers' Guide
  • Beautiful Code: Leading Programmers Explain How They Think
  • The Practice of Programming (Addison-Wesley Professional Computing Series)
  • Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions
  • The Art of Unit Testing: With Examples in .NET
  • The Pragmatic Programmer: From Journeyman to Master
  • Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development
  • Seven Languages in Seven Weeks
  • Programming Pearls
See similar books…

Goodreads is hiring!

If you like books and love to build cool products, we may be looking for you.
Learn more »
Martin Fowler (b. 1963) is a software engineer, Chief Scientist at ThoughtWorks, and an outspoken advocate for best practices in enterprise software design, particularly in regard to agile software development methodologies, including extreme programming.

Other books in the series

Addison-Wesley Object Technology Series (1 - 10 of 39 books)
  • Managing Software Requirements: A Use Case Approach (Addison-Wesley Object Technology Series)
  • ATL Internals: Working with ATL 8
  • Adopting the Rational Unified Process: Success with the RUP
  • Agility and Discipline Made Easy: Practices from OpenUP and RUP
  • Applying Use Case Driven Object Modeling with UML: An Annotated E-Commerce Example
  • The Art of Clearcase Deployment: The Secrets to Successful Implementation
  • The Art of Objects: Object-Oriented Design and Architecture
  • Aspect-Oriented Software Development with Use Cases
  • Building J2ee� Applications with the Rational Unified Process
  • Building Web Applications with UML
“I’m not a great programmer; I’m just a good programmer with great habits.” 12 likes
“Whenever I have to think to understand what the code is doing, I ask myself if I can refactor the code to make that understanding more immediately apparent.” 6 likes
More quotes…