Comment: Used Good condition book may have signs of cover wear and/or marks on corners and page edges. Inside pages may have highlighting, writing and underlining. All purchases eligible for Amazon customer service and a 30-day return policy.

Fulfilment by Amazon (FBA) is a service Amazon offers sellers that lets them store their products in Amazon's warehouses, and Amazon directly does the picking, packing, shipping and customer service on these items. Something Amazon hopes you'll especially enjoy: FBA items are eligible for and for Amazon Prime just as if they were Amazon items.

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.

{"currencyCode":"GBP","itemData":[{"priceBreaksMAP":null,"buyingPrice":26.31,"ASIN":"0201485672","isPreorder":0},{"priceBreaksMAP":null,"buyingPrice":24.79,"ASIN":"0132350882","isPreorder":0},{"priceBreaksMAP":null,"buyingPrice":21.07,"ASIN":"0735619670","isPreorder":0}],"shippingId":"0201485672::InmM1c3%2FN6XvUxd7B%2FGHtZ8RWslh9IBBGswRx4CB65L78RtJpM99PEFyy18Pa800%2BX%2FPpWc%2Bk%2BKmFdZAFOZwhs%2FwSDTbW40Q,0132350882::Qusxnqv1OIxAX20E1rZnrtO6pvedEMaMKOIWDoRC9b0LvLIwgd96iyn8O68ExsQtCW1dPgJ9Nt1eDinW%2F9kHp3%2BoPW1weyU2,0735619670::XJq2UE8g0%2B1olb4MQtk11Rd%2F3VMUuhXbCPGAmHOdjkdQpggvjQGinYe8xOBbo%2Bot1XVpIp%2BBJJfryvawKpT3p7hfTSKdM3a3","sprites":{"addToWishlist":["wl_one","wl_two","wl_three"],"addToCart":["s_addToCart","s_addBothToCart","s_add3ToCart"],"preorder":["s_preorderThis","s_preorderBoth","s_preorderAll3"]},"shippingDetails":{"xz":"same","xy":"availability","yz":"availability","xyz":"availability"},"tags":["x","y","z","w"],"strings":{"showDetails":"Show details","differentAvailabilityAll":"Some of these items are dispatched sooner than the others.","addToWishlist":["Add to Wish List","Add both to the Wish List","Add all three to the Wish List","Add all four to the Wish List"],"shippingError":"An error occurred, please try again","differentAvailability":"One of these items is dispatched sooner than the other.","preorder":["Pre-order this item","Pre-order both items","Pre-order all three items","Pre-order all four items"],"addToCart":["Add to Basket","Add both to Basket","Add all three to Basket","Add all four to the Basket"],"showDetailsDefault":"Show availability and delivery details","priceLabel":["Price:","Price For Both:","Price For All Three:","Price For All Four:"],"hideDetailsDefault":"Hide availability and delivery details","hideDetails":"Hide details"}}

Trade in Refactoring: Improving the Design of Existing Code (Object Technology Series) for an Amazon Gift Card of up to £8.90, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Learn more

More About the Authors

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

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.

Most Helpful Customer Reviews

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.Steve

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).

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.

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!

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.

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.

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.