Refactoring: Improving the Design of Existing Code and over 2 million other books are available for Amazon Kindle . Learn more

Sign in to turn on 1-Click ordering.
Trade in Yours
For a £11.25 Gift Card
Trade in
More Buying Choices
Have one to sell? Sell yours here
Sorry, this item is not available in
Image not available for
Image not available

Start reading Refactoring on your Kindle in under a minute.

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Refactoring: Improving the Design of Existing Code (Object Technology Series) [Hardcover]

Martin Fowler , Kent Beck , John Brant , William Opdyke , Don Roberts
4.6 out of 5 stars  See all reviews (37 customer reviews)
RRP: £41.99
Price: £33.59 & FREE Delivery in the UK. Details
You Save: £8.40 (20%)
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
In stock.
Dispatched from and sold by Amazon. Gift-wrap available.
Want it Sunday, 2 Nov.? Choose Express delivery at checkout. Details


Amazon Price New from Used from
Kindle Edition £31.07  
Hardcover £33.59  
Paperback --  
Trade In this Item for up to £11.25
Trade in Refactoring: Improving the Design of Existing Code (Object Technology Series) for an Amazon Gift Card of up to £11.25, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Learn more

Book Description

28 Jun 1999 0201485672 978-0201485677 1

Refactoring is about improving the design of existing code. It is the process of changing a software system in such a way that it does not alter the external behavior of the code, yet improves its internal structure. With refactoring you can even take a bad design and rework it into a good one. This book offers a thorough discussion of the principles of refactoring, including where to spot opportunities for refactoring, and how to set up the required tests. There is also a catalog of more than 40 proven refactorings with details as to when and why to use the refactoring, step by step instructions for implementing it, and an example illustrating how it works The book is written using Java as its principle language, but the ideas are applicable to any OO language.

Frequently Bought Together

Refactoring: Improving the Design of Existing Code (Object Technology Series) + Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin) + Design patterns : elements of reusable object-oriented software
Price For All Three: £90.37

Buy the selected items together

Product details

  • Hardcover: 464 pages
  • Publisher: Addison Wesley; 1 edition (28 Jun 1999)
  • Language: English
  • ISBN-10: 0201485672
  • ISBN-13: 978-0201485677
  • Product Dimensions: 19.6 x 3 x 24.2 cm
  • Average Customer Review: 4.6 out of 5 stars  See all reviews (37 customer reviews)
  • Amazon Bestsellers Rank: 10,331 in Books (See Top 100 in Books)
  • See Complete Table of Contents

More About the Authors

Discover books, learn about writers, and more.

Product Description

Amazon Review

Your class library works, but could it be better? Refactoring: Improving the Design of Existing Code shows how refactoring can make object-oriented code simpler and easier to maintain. Today, refactoring requires considerable design know-how, but once tools become available, all programmers should be able to improve their code using refactoring techniques.

Besides an introduction to what refactoring is, this handbook provides a catalogue of dozens of tips for improving code. The best thing about Refactoring is its remarkably clear presentation, along with excellent nuts-and-bolts advice, from object expert Martin Fowler. The author is also an authority on software patterns and UML, and this experience helps make this a better book, one that should be immediately accessible to any intermediate or advanced object-oriented developer. (Just like patterns, each refactoring tip is presented with a simple name, a "motivation," and examples using Java and UML.)

Early chapters stress the importance of testing in successful refactoring. (When you improve code, you have to test to verify that it still works.) After the discussion on how to detect the "smells" of bad code, readers get to the heart of the book, its catalogue of more than 70 "refactorings"--tips for better and simpler class design. Each tip is illustrated with "before" and "after" code, along with an explanation. Later chapters provide a quick look at refactoring research.

Like software patterns, refactoring may be an idea whose time has come. This groundbreaking title will surely help bring refactoring to the programming mainstream. With its clear advice on a hot new topic, Refactoring is sure to be essential reading for anyone who writes or maintains object- oriented software. --Richard Dragan

Topics Covered: Refactoring, improving software code, redesign, design tips, patterns, unit testing, refactoring research and tools.

From the Back Cover

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, software system professionals are discovering just how difficult it is to work with these inherited, "non-optimal" applications. For several years, expert-level object programmers have employed a growing collection of techniques to improve the structural integrity and performance of such existing software programs. Referred to as "refactoring," these practices have remained in the domain of experts because no attempt has been made to transcribe the lore into a form that all developers could use. . .until now. In Refactoring: Improving the Design of Existing Code, renowned object technology mentor Martin Fowler breaks new ground, demystifying these master practices and demonstrating how software practitioners can realize the significant benefits of this new process.


With proper training a skilled system designer can take a bad design and rework it into well-designed, robust code. In this book, Martin Fowler shows you where opportunities for refactoring typically can be found, and how to go about reworking a bad design into a good one. Each refactoring step is simple--seemingly too simple to be worth doing. Refactoring may involve moving a field from one class to another, or pulling some code out of a method to turn it into its own method, or even pushing some code up or down a hierarchy. While these individual steps may seem elementary, the cumulative effect of such small changes can radically improve the design. Refactoring is a proven way to prevent software decay.


In addition to discussing the various techniques of refactoring, the author provides a detailed catalog of more than seventy proven refactorings with helpful pointers that teach you when to apply them; step-by-step instructions for applying each refactoring; and an example illustrating how the refactoring works. The illustrative examples are written in Java, but the ideas are applicable to any object-oriented programming language.

Inside This Book (Learn More)
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index
Search inside this book:

What Other Items Do Customers Buy After Viewing This Item?

Customer Reviews

Most Helpful Customer Reviews
7 of 7 people found the following review helpful
5.0 out of 5 stars This book is improving the standard of coding 12 Oct 2001
By A Customer
Like the GoF book, this book makes new ground by describing each refactoring in baby-step format and *naming* each of the refactorings. It has also led to more refactoring tools (which I hope will become a mandatory IDE requirement). So, instead of having to refactor your code manually, you can simply goto the menu and select "Extract Method", "Replace Temp with Query" etc. I highly recommend people check out the new IntelliJ IDEA (called Pandora). As Kent Beck notes, a refactoring tool completely changes the way you think about coding.
10 thumbs up for this book and the effect it will have on the industry.
Comment | 
Was this review helpful to you?
36 of 39 people found the following review helpful
5.0 out of 5 stars Stop those annoying grubby code build-ups 15 Aug 2002
Format:Hardcover|Verified Purchase
I'm probably not alone in finding that, upon opening up source code (even my own), I have an uncontrollable urge to remove duplication, simplify, reduce and generally "improve" things before I can start to see how changes can be made. Then I read this book and discovered that I was refactoring.
Even better, I started to understand that there were a set of well-designed methods to apply, some of which I'd informally discovered for myself (so I wasn't alone after all) and many more that I hadn't thought of. It doesn't hurt that the book is well, and often entertainingly written.
Although some of the content is explicitly targeted at code built in full-blown object-oriented languages (the language used throughout is Java), it doesn't prove to be a hindrance to VB programmers like myself.
This book may fall slightly behind "Code Complete" in my list. Which would only make it the second best development book I've ever read (but it's the first one I felt like posting a review on).
Comment | 
Was this review helpful to you?
20 of 22 people found the following review helpful
This book is simply great !! It's definately the most useful book I've read since "Design Patterns".

It has an easily read and also sometimes quite amusing text, UML diagrams when necessary, and of course, VERY GOOD CONTENT !!! In short Refactoring is about turning badly designed and written code into well designed and written code, without breaking the program. If you liked read "Design Patterns" (Gamma et al.) you love this one as well. It's structured in much the same way.

The content covers

* WHY + WHEN to refactor
* HOW + WHAT to refactor
* A very good chapter on unit testing with JUnit (Open Source, by Eric Gamma (Design Patterns) and Kent Beck (Extreme Programming) )
* A thorough catalogue of different refactorings you can do to improve the design and readability of your code.
Was this review helpful to you?
3 of 3 people found the following review helpful
5.0 out of 5 stars Who cares if you "knew this already" ?!! 8 Dec 2009
Great ideas in software are often met with the "if you've been around as long as me, then you know this stuff already" line. WHO CARES?!! Often in fields involving know-how, the most "obvious" things (techniques, principles) *need* to be revisited, re-stated (out loud, as it were), just to plant our feet back on the ground, to reacquaint us with the foundations. I approached this book with scepticism but after reading a chapter and skimming through the rest, I was already re-enthused on a software project I had become disillusioned with. The results are an order of magnitude better: lean, clear, crisp, efficient. It'll make you proud to show your code to others!
Comment | 
Was this review helpful to you?
2 of 2 people found the following review helpful
By A Customer
Martin Fowler gets better and better. His writing is clear, well structured and amusing. Lets face that alone is enough to put him at the top end of the computer book market.
It is the subject matter that really impresses. Refactoring is the process of restructuring your software in a controlled, safe manner. It is the key to avoiding software entropy and the exponential cost-of-change curve. Most of all it re-empowers developers without handing a carte blanche to the cowboy coders.
Fowler presents the key principles of refactoring in a series of pattern like chapters of techniques; with examples and suggestions for their applicability. This is both a great exposition of the theory of refactoring along with practical, "how-to", examples.
I expect to see this on quality "must have on the bookshelf" lists from now on.
Comment | 
Was this review helpful to you?
14 of 16 people found the following review helpful
5.0 out of 5 stars Required Reading 29 Jun 2006
By C. Jack
Format:Hardcover|Verified Purchase
I'd advise people to ignore the negative reviews for the following reasons:

1) People now talk about specific refactorings so, like design patterns, you need to know the names.

2) It was never supposed to teach you good design. If you want to learn that there are good books out there (including by Craig Larman and Robert C. Martin).

3) Some of it is basic but you can ignore that stuff if you want to, and when your doing some of the more complicated refactorings they could well be useful.

4) As Martin Fowler points out you don't need to read it cover to cover, in fact he advises you use it as a reference.

What this does teach you is how to iteratively improve bad code, something every developer needs to be able to do. In any case its valuable to read about the code smells, the reasons for needing to do specific refactorings and to read the examples.

Also if you want more advanced concepts I'd recommend "Agile Software Development" by Robert C. Martin and "Refactoring to Patterns" by Joshua Kerievsky which both build on this work.
Was this review helpful to you?
1 of 1 people found the following review helpful
5.0 out of 5 stars It's always obvious in retrospect 13 Dec 2008
When I first read this book it described a whole lot of practices that I'd been following for years, I just hadn't call it refactoring. I'd find some piece of code that didn't feel right and then I'd tinker with it to improve it. I'd rename variables and methods and rearrange stuff and so on until I felt it was right. I just didn't have a vocabulary to describe what I was doing.
As with other classics the situations and methods that are described here are now considered obvious and simple by many, but that wasn't always the case. This book defined the terms that are now in common use, the code smells, the refactorings, even the word itself. It has provided modern software development with a knowledge and understanding that code isn't developed perfect the first time around, that it is ok to improve it and that it can be done in a safe and controlled manner.
Every developer should read this book at least once. Personally it is one the books that I always keep with me when working.
Comment | 
Was this review helpful to you?
Would you like to see more reviews about this item?
Were these reviews helpful?   Let us know
Most Recent Customer Reviews
5.0 out of 5 stars Five Stars
Exactly what I expected.
Published 3 months ago by Y. Heslop
5.0 out of 5 stars Still makes sense in 2014
I find it amazing that this book was written more than 10 years ago and it still makes sense.. a lot. I read it a while back and I keep coming back to it. Read more
Published 5 months ago by Amazon Customer
5.0 out of 5 stars Excellent book which you will keep going back to read again.
When buying this book I wasn't sure if it would be worth buying since most of the patterns are explained online, but after reading most of the book more than once I would recommend... Read more
Published 7 months ago by Mr G.
4.0 out of 5 stars It's slightly dated in a few respects, but still, required reading.
A widely regarded classic in the industry, and you can see why.

The first section presents a large refactoring exercise applied to a little movie rental application,... Read more
Published 9 months ago by C. O'Neil
5.0 out of 5 stars If your code has turned into a monster, this book is the light at the...
This is one of my all time favourite books.

It has helped me out on numerous occasions.

If your code has turned into a monster, this book is the light at the... Read more
Published 11 months ago by John Walker
5.0 out of 5 stars Awesome !
It is a great and very helpful technical read. The product of a brilliant mind - clean, practical, straight to the point.
Published 14 months ago by Teodor Parvanov
5.0 out of 5 stars Exceptional book
This style of the book is conversational, easy to read, lucid almost like being mentored by a great man. Read more
Published 15 months ago by cjase2012
4.0 out of 5 stars Book5, Kindle 3. Kindle layout is poor, text too big
The book is a classic: essential reading for any software developer. Unfortunately, the Kindle edition devalues it slightly:
- text cannot be reduced in size enough. Read more
Published 17 months ago by ratuk
5.0 out of 5 stars Excelent and Informative
This is an excellent source of information and written in such a way that it is easily reference able without being programming language specific.
Published 18 months ago by DarkGeek
5.0 out of 5 stars Its a classic
If you have any experience with programming this book may not be a big revolution. However, iterating over the step-wise approach to changing code is educating and having the... Read more
Published 19 months ago by Olav Cleemann
Search Customer Reviews
Only search this product's reviews

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
First post:
Prompts for sign-in

Search Customer Discussions
Search all Amazon discussions

Look for similar items by category