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

4.2 of 5 stars 4.20  ·  rating details  ·  3,080 ratings  ·  122 reviews
As the application of object technology--particularly the Java programming language--has become commonplace, a new problem has emerged to confront the software development community. Significant numbers of poorly designed programs have been created by less-experienced developers, resulting in applications that are inefficient and hard to maintain and extend. Increasingly, ...more
Hardcover, 464 pages
Published July 8th 1999 by Addison-Wesley Professional (first published June 28th 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.

Be the first to ask a question about Refactoring

The Pragmatic Programmer by Andrew HuntThe  C Programming Language by Brian W. KernighanDesign Patterns by Erich GammaStructure and Interpretation of Computer Programs by Harold AbelsonCode Complete by Steve McConnell
Essential Programming Books
6th out of 111 books — 248 voters
The Pragmatic Programmer by Andrew HuntClean Code by Robert C. MartinCode Complete by Steve McConnellRefactoring by Martin FowlerWorking Effectively with Legacy Code by Michael C. Feathers
Software Craftsmanship
4th out of 19 books — 60 voters

More lists with this book...

Community Reviews

(showing 1-30 of 3,000)
filter  |  sort: default (?)  |  rating details
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
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
Ivan Idris
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
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
Andreas Kaufmann
The book teaches the following:
* Recognize badly written code (smells).
* How to improve it and make better (refactoring).

Even the software written by good programmes becomes large and complex with the time and will need refactoring. The best time to do refactoring is at the begining of the project (I assume the project here is the task to add some big non-trivial functionality to already complex software product). Benefits of doing this:
* The relevant code will become simpler and it will be easi
Mar 09, 2009 Daniel rated it 5 of 5 stars
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
Nice book, I'm glad I finally managed to read it. I'm already familiar with the discipline of refactoring and testing, I also had read the first chapter a few years ago but it was interesting to go through the whole book.

Despite the code examples being a bit outdated, this book is still relevant because it's about fundamentals to software engineering that developers end up learning mostly from experience. I specially liked the advice from Kent Beck at the end of the book.

Of course lots of things
Miguel Ángel
Además de un 'Must Read' es un libro al que hay que volver cada cierto tiempo.

Los consejos y puntos claves están escondidos entre la colección de refactors que va explicando.

De vez en cuando también incluye alguna perla de humor inglés.

Algunos Refactors pueden parecer muy simples, pero son necesarios ya que va apoyándose en los simples para ir construyendo los más grandes.

También hay mucha insistencia en las mecánicas y su importancia, en principio puedes pasar de forma superficial, pero el l
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
Alfredo Chavez
It doesn't matter if your IDE has refactoring capabilities built-in. You deserve yourself reading this one so you can refactor your code more effectively, but even more important: why and when you should (or shouldn't) refactor.

I'd practiced Object-Oriented programming for 10 years before reading this book, only to find out that I didn't understand it even a little bit. This book was a real eye-opener.

And while you're reading through it, you'll also learn about good OOD too!

Instant classic!
Vedran Novoselac
Although written in 1999, it's still as fresh as it was back then. In so many cases I found it to be a positive confirmation of what I was doing unaware it has it's item in this book, but the book does it so much better, with precise mechanics and certain outcome. Sticking to the step-by-step approach, things are less likely to go wrong.

Here are some highlights from the book:
* Introduce Null Object - now widely known, somewhat non-intuitive, but invaluable, especially if you wish to reduce cyclo
Pros: The opening chapters give a great introduction to refactoring. The middle chapters are worth their weight in gold as a reference to object-oriented refactorings. Explains why refactoring is a necessity for us.

Cons: The final 3 chapters by other authors weren't very useful to me, exluding Beck's chapter, but don't necessarily detract from the book because I suspect others will find them relevant.

Summary: One of those "must have" books for all "classical" developers (procedural and object-or
Sylvain Prat
C'est un livre très instructif montrant comment réagencer du code existant en vue de l'améliorer (lisibilité, maintenabilité, testabilité, préparation à l'ajout de fonctionnalités). C'est en quelque sorte un livre de recettes, mais de ce fait il est assez difficile/fastidieux à lire, surtout de bout en bout.

Une chose qui m'a un peu agacé à la lecture du bouquin : les exemples sont introduits après le mode d'emploi, ce qui fait que l'on a du mal à comprendre ce que veux dire l'auteur avant d'avo
This book is the foundation of those sets of techniques, methodologies and practices which came later, but I've already known before finishing this book. Very inspiring for me professional-wise. There is also a historical element in reading it, that is to see the conception of an innovative idea in the academic work until it became adapted in the industry.

Reading the techniques like Extract Method, etc, I usually just scan quickly the steps prescribed, because now it takes only a few keys in the
Zbyszek Sokolowski
This is classic book, just a little outdated nowadays but mainly due too fact that examples uses Java 2.0. On the other hand I found it very useful. It describes many refactoring methods from very basic to more even architectural ones. Learning how to refactor code, has another big advantage it teaches you how to write good code at first try. Moreover because forecasting which features will be added in future some project mistakes are often unavoidable, refactoring gives you a tool how to deal w ...more
Frederik Sørensen
The book does a very good job at explaining how to make refactorings and provides a very detailed reference section. Each refactoring is shown in detailed small steps so it is easily reproduced in you own system. The authors make an effort to relay that refactoring is an ongoing process and are best made by taking babysteps, not by freezing a project for months while refactoring. They make refactoring a part of the daily routine.

The examples are made in Java but is easily applied to any OO lang
A fantastic catalog of refactoring patterns. To read this book is to read code, lots of it. That's both good and bad; good because you can't learn code without actually coding; bad because it's very hard to provide good examples of code that marries well with the reader's experiences. Show a simple example, the richness of the lesson is lost. Show a complex example, the reader gets lost in the example and misses the lesson.

The first priority of code is to make it work. But how often do we stop
Evan Leybourn
Nearly 15 years old, you would think this book (in fact this idea) would be well enough understood to be redundant. Sadly this book remains as relevant today as when I first read it all those years ago. Put simply; if you are a software developer, you /must/ understand this book
Stancalău Cristian
The topics are very well structured but it is not a book for reading as it is for reference when getting stuck on some refactoring issues. However, I would recommend going through it once just to get familiarized with the terms and techniques.
Yang Zhang
I am using python extensively in scientific research. I used to think that I was a good programmer. But after a lot failures and struggling, I realized that I am far from a good programmer and in order to become one, you have to read and learn.

This book is definitely a must-read book for intermediates to be propelled into the next level.

It talks about bad senses in the design of object-oriented programs and gives clues to identify problems and suggestions on how to improve them.

After reading thi
Vladimir Rybalko
Every programmer can develop code that a computer understands, but only units write understandable code to others. It's really brilliant words. Refactoring is a very important process. Very pity that much developers don't understand it. Especially insulting when these people are your managers. In this case, you have only one way, don't speak about refactoring as author advised.
Testing is refactoring's friend. It is another very useful advise. Nice to know that more and more developers spend more
Carl-Erik Kopseng
Not a book to read cover to cover, but very useful when you are wondering how to achieve something. Might have been groundbreaking in its day, but when reading it a lot of the tips/how-to's seemed not to have passed the test of time. Not because they are not correct, but because a lot of them are now integrated into the tools (IDEs) we use every day. Might make more sense if you are hardcore a Vi/Emacs user without refactoring support.

A lot of the harder refactorings are not in any IDE, and then
Rodrigo Navarro
An obligatory to any software developer. Fantastic examples, and, even being a catalog book (which I am not really a big fan) I enjoyed this one a lot!
Juliusz Gonera
Book lists refactoring recipes for:
+ composing methods
+ moving features
+ organizing data
+ simplifying conditional expressions
+ making method calls simpler
+ dealing with generalization

The recipes are very simple/basic, if you have experience in programming you will find most of them familiar. The value of the book is in systematizing the methods of refactoring, explaining the motivation behind them, giving examples of things to look out for in your code.

It will not revolutionize the way you appr
I found it a great help writting well constructed OOP code. Quality design and construction of OOP code are a couple of those intangibles which are hard to discern merely by reading things like keep your code loosely coupled etc.

Besides the obvious benefits of great refactorings for poorly written code, I found it more valuable in that it has given me a much better sense of what well constructed clean code looks like by illustrating what not to do.

BTW, after a couple of weeks with this book, my
This book presents some basic designs for refactoring your software towards better readability and thus easier modifications. I can not give it 5 stars for 2 reasons only
1) it is a bit old
2) most of the things discussed here are better conveyed in the "Code Complete. Second Edition" which I believe to be far superior to this book both in terms of being up to date and simplicity of the language (which makes latter more understandable)

But anyway - this is a really good read for someone who wants t
Peter Onneby
Some good refactorings in this book, for sure
The thing that made this book amazing in my eyes is the demystification factor.

As the author himself admits, software consultants often say they adhere to some vague notion of "software aesthetics", which frankly doesn't help at all when one wants to reach the next level of good programming.

However, in this book the author gives a detailed (but not bloated!) list of very concrete techniques to make Java projects easier to maintain and evolve.

One of the "absolutely must read" books when you get p
Jorge Roldán
This book is the natural continuation to "Design Patterns". After all design patterns are targets to refactoring, so, once you know where you want to get reach, you need to learn the process to do it safely.

This books shows you that and, for me, it has been an inpiration to solve many problems in the design of my programs that I didn´t realize I had and could be wiped out.

I have found specially interesting the chapter about simplifying conditional logic. Following Martin's advices I´m getting mu
« previous 1 3 4 5 6 7 8 9 99 100 next »
There are no discussion topics on this book yet. Be the first to start one »
  • Working Effectively with Legacy Code
  • Refactoring to Patterns
  • Test Driven Development: By Example
  • Design Patterns: Elements of Reusable Object-Oriented Software
  • Domain-Driven Design: Tackling Complexity in the Heart of Software
  • Agile Software Development, Principles, Patterns, and Practices
  • Growing Object-Oriented Software, Guided by Tests
  • The Pragmatic Programmer: From Journeyman to Master
  • Code Complete
  • Programming Pearls
  • Head First Design Patterns
  • Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions
  • The Practice of Programming
  • Effective Java Programming Language Guide
  • Seven Languages in Seven Weeks
  • Release It!: Design and Deploy Production-Ready Software (Pragmatic Programmers)
  • Xunit Test Patterns: Refactoring Test Code
  • Structure and Interpretation of Computer Programs (MIT Electrical Engineering and Computer Science)

Goodreads is hiring!

If you like books and love to build cool products, we may be looking for you.
Learn more »
Patterns of Enterprise Application Architecture UML Distilled: A Brief Guide to the Standard Object Modeling Language Domain-Specific Languages Analysis Patterns: Reusable Object Models UML Distilled: Applying the Standard Object Modeling Language

Share This Book

“Moving state and behavior between classes is the very essence of refactoring. As the system develops, you find the need for new classes and the need to shuffle responsibilities around. A design decision that is reasonable and correct one week can become incorrect in another. That is not a problem; the only problem is not to do something about it.” 0 likes
“In almost all cases, I’m opposed to setting aside time for refactoring. In my view refactoring is not an activity you set aside time to do. Refactoring is something you do all the time in little bursts.” 0 likes
More quotes…