Customer Reviews


96 Reviews
5 star:
 (72)
4 star:
 (12)
3 star:
 (7)
2 star:
 (4)
1 star:
 (1)
 
 
 
 
 
Average Customer Review
Share your thoughts with other customers
Create your own review
 
 

The most helpful favourable review
The most helpful critical review


4.0 out of 5 stars Must read book
Even after many years, it remains good ressource and a must have book for an IT professional.
I advise evry programmer to get it
Published 5 months ago by khorchani

versus
4 of 5 people found the following review helpful
1.0 out of 5 stars Good Information But Extremely Poor Delivery
This book contains some good information on how to improve yourexisting code without rewriting it entirely which is a nice departurefrom the norm of most of these UML-type books which advocate totally changing the way you design and build software. Not that the Unified method of designing and building is bad, its just that its hard to change the way this is done in an...
Published on March 15 2000 by Dissatisfied


‹ Previous | 1 210 | Next ›
Most Helpful First | Newest First

4 of 5 people found the following review helpful
1.0 out of 5 stars Good Information But Extremely Poor Delivery, March 15 2000
This review is from: Refactoring: Improving the Design of Existing Code (Hardcover)
This book contains some good information on how to improve yourexisting code without rewriting it entirely which is a nice departurefrom the norm of most of these UML-type books which advocate totally changing the way you design and build software. Not that the Unified method of designing and building is bad, its just that its hard to change the way this is done in an organization when you're not in charge of the organization. Mr. Fowler has put forth a mechanism for improving the design of existing code while adding functionality to it. And the information, once culled from the surrounding text, is extremely useful. It's not paradigm shift. And it's not a companion to Design Patterns - Fowler mentions the Design Patterns book throughout his text but this book is certainly not written for the same audience. Fowler never once gives an example where he converts bad code into good by utilizing a pattern from the Gang of Four's book. The book is useful for ANY object-oriented language even though he uses Java in his examples the principles map easily to C++ and SmallTalk. Almost all of the techniques are common sense and yet he spends the bulk of this book explaining in simple terms how to perform them. For each "refactoring" he capably provided a two or three sentence overview of the process, and a code fragment or class diagram exemplifying the technique. These summaries and figures are excellent. But his tone becomes condescending as he painfully explains the process of performing the code improvement. For instance, Extract Method, the first technique in the book, is succinctly described with: "[If] You have a code fragment that can be grouped together...[then] Turn the fragment into a method whose name explains the purpose of the method." Pretty simple and probably not quite enough to totally understand what he is talking about. But then he has a wonderful little code fragment that illustrates it perfectly. This requires about half of one page. But he spends four and a half more explaining how to perform this simple cut-and-paste. 270 Pages of this 418 page book are spent describing 72 techniques in this kind of excruciating detail. Eight very useful pages are spent describing the bad "smells" in your code that lead to these "refactactorings". Another 110 pages is spent telling you how to justify the work to your boss, encouraging you to do it whether or not your boss approves, advocating a "test-small-change-test" paired programming technique characteristic of Extreme Programming. The final 30 pages are written by the other contributors. Altogether, I think this book should be "refactored" into a 100 to 150 page soft-cover manual reminiscent of Scott Meyers' Effective C++ books. If you're looking for Design Patterns: Part 2 this isn't it! END
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


4.0 out of 5 stars Must read book, Feb. 6 2014
Verified Purchase(What's this?)
This review is from: Refactoring: Improving the Design of Existing Code (Hardcover)
Even after many years, it remains good ressource and a must have book for an IT professional.
I advise evry programmer to get it
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


4.0 out of 5 stars Recipes for improving code, May 5 2000
By 
Sean Kelly "Consultant" (Dallas, TX USA) - See all my reviews
(REAL NAME)   
This review is from: Refactoring: Improving the Design of Existing Code (Hardcover)
Like the Gang of Four's landmark book _Design Patterns_, Fowler and his cohorts have created another catalog-style book, this time on refactoring.
Refactoring refers to taking existing, working software, and changing it about to improve its design, so that future modifications and enhancements are easier to add. _Refactoring_ is primarily a catalog of 70 or so different kinds of improvements you can make to object-oriented software.
Each entry in the catalog describes an implementation problem, the solution, motivation for applying the solution, the mechanics of the refactoring, and examples. The book's examples are all in Java, but C++ programmers should be able to approach the refactorings with ease. Often, Fowler diagrams the refactorings in UML, so a little Unified Modeling Language experience will help, too.
While the catalog is nice, the kinds of refactorings are obvious is most cases. Even moderately experienced programmers won't need the step-by-step mechanics described. The real benefit, though, is that the mechanics of each refactoring help guarantee that you can pull off the refactoring without introducing new bugs or side effects. They encourage you to take smaller, verifiable steps, than the more gross refactorings that most developers would naturally take. You actually save time doing so.
How do you know your refactorings are safe? Unit testing is the answer that Fowler et al. provide. Java developers will find the introduction to the Junit Testing Framework the most valuable part of the book, more so than the catalog of refactorings itself.
There's more to the book than the catalog and Junit, of course. There's discussion of the history of refactoring, how to evaluate refactoring tools, and how to convince management that what appears to be an overhead activity is actually useful in the long run.
Unfortunately, these sections are all too brief. And there is no discussion of how refactoring fits in with various software development processes. For example, programmers using Extreme Programming (XP) would probably feel right at home with Fowler's recommendations of refactoring in duets and unit testing, but developers stuck with a Software Engineering Institute process like PSP categorize testing as failure time and something to be minimized if not avoided. Cleanroom developers are taught that unit testing inteferes with metrics for quality, and that verifications are what should be done. Should such developers redo verifications after each refactoring? There's no answer in this book.
An unusual chapter, called "Bad Smells in Code," gives overall motivation for the refactorings. These vague notions, such as "long methods" or "lazy classes" humorously provide a foundation for starting your own refactorings. I say "humorously" because (mostly) Beck's and Fowler's odd analogies (classes becoming too intimate and delving in each others' private parts) provoke a chuckle (as if a chapter about "bad smells" in code weren't enough).
Overall, I've enjoyed reading this book and referring to the catalog while putting my own unit tests and refactorings into practice. Fowler's writing style is smooth and fluid, and it's easy to digest the catalog in no time. The book's typesetting is crisp, the figures quite clean, and both the refactoring index and "smell" index are enormously useful.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


4 of 6 people found the following review helpful
2.0 out of 5 stars 50 page book expanded to over 400 pages, Dec 17 2000
By A Customer
This review is from: Refactoring: Improving the Design of Existing Code (Hardcover)
The subject matter is very pertinent, but the book could have been more to the point. Some of the pages have only four lines of code; I could not understand why so much of space was left blank. Many of the techniques taught are not new and should be part of development and refactoring. It would have been nice if the authors went through each other's manuscripts and REFACTORED the book, because the book is full of repetitive material.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


3 of 3 people found the following review helpful
4.0 out of 5 stars Competent And Influential, July 9 2004
By 
Vladimir Levin (Calgary, AB, Canada) - See all my reviews
(REAL NAME)   
This review is from: Refactoring: Improving the Design of Existing Code (Hardcover)
Fowler's refactoring has become a classic in the field of popular software engineering books. It's a good book that clearly explains the basic ideas of refactoring and develops a standard vocabulary for refactoring; the power of this vocabulary is demonstrated by the development tools like IntelliJ Idea and Eclipse that now incorporate its nomenclature directly to allow rapid automated refactoring. Refactoring together with Test-Driven development, both concepts developed largely by Kent Beck as part of his Extreme Programming methodology, are in my opinion the most powerful and innovative ideas in the last 10 years or so in software development. It is a fairly quick read for an experienced developer, and often admittedly presents concepts that any experienced develop would have discovered on his/her own. Nevertheless, all of the refacorings together in one book serve as an excellent reference and reminder. I think this book certainly belongs on the bookshelf of any developer wishing to improve his or her craft.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


1 of 1 people found the following review helpful
5.0 out of 5 stars Great book for the professional, May 22 2004
This review is from: Refactoring: Improving the Design of Existing Code (Hardcover)
I got this book at the recommendation of another book (Ken Henderson's Guru's Guide to Stored Procedures) and was simply blown away by it. I have been preaching the lessons this book tries to teach for years. Now I finally have a text I can point people to to say "Hey, this code is really broken even though it still runs. We need to fix it!" Thank you, thank you, thank you for such a wonderful book.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


1 of 1 people found the following review helpful
3.0 out of 5 stars Good addition, Oct. 28 1999
By A Customer
This review is from: Refactoring: Improving the Design of Existing Code (Hardcover)
Matin surely presents a good strategy which is easily proved in the book. However I do not think it is a big enough issue to justify the whole book. He filled the content with many basics of object oriented and good programming practice. While many are not familiar with patterns and these techniques are not used as much as they should, I expect better material from Martin.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


2 of 3 people found the following review helpful
2.0 out of 5 stars Shallow, verbose, and too ambitious, Feb. 10 2003
This review is from: Refactoring: Improving the Design of Existing Code (Hardcover)
The book attempts to match the Gang of Four book in both format and effect. Unfortunately, it fails. The author spends so many pages explaining trivial refactorings such as renaming a method or introducing a constant. Any software developer with moderate experience would now how and why to perform such tasks without any need for such a book. The book doesn't cover more complex or exotic refactorings that are of greater value to the experienced developer, and it doesn't touch upon the impact that refactoring might introduce into existing code and how to manage and minimize that impact.
However, it does contain some useful tips on correcting some classic design mistakes using refactoring, which might prove valuable to the novice. Thus, the two-star rating.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


2 of 3 people found the following review helpful
3.0 out of 5 stars A beginner book, April 7 2002
By 
Takuya Murata (Winona, Minnesota United States) - See all my reviews
This review is from: Refactoring: Improving the Design of Existing Code (Hardcover)
First of all, this book is good to understand the meaning of refactoring and its techniques. If you are a beginner programmer, the book is quite helpful to know how to do refactoring, and why and when to do it.
However, the problem is the book is a "book". Many programmers may feel familiar with stories and techniques in the book. The techniques in the book, though, are not exceptional, unfortunately. For example, the book explains how to make a temporary variable or how to eliminate it for a couple of pages! This kind of thing is a common work for programmers. Many don't have to learn that.
One of problems of refactoring for experienced programmers is that refactoring means not add features but "change" existing code. Although giving benefits, refactoring gives some problem. For example, when working as team, it is hard to even change the name of method because the change often causes conflict among sourcecode. The book doesn't give any solution of this problem.
In conclusion, I don't recommend this book for experienced programmers.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


2 of 3 people found the following review helpful
2.0 out of 5 stars Make sure it is relevant before you purchase., Feb. 26 2001
By 
Jane Avriette (Arlington, Virginia USA) - See all my reviews
This review is from: Refactoring: Improving the Design of Existing Code (Hardcover)
I am a perl programmer. I also write C and I do a lot of UNIX shell programming as well. The ideas contained in this book are helpful, but largely irrelevant and poorly applied to code you may be writing -- unless you are writing in Java.
As an academic text, it is nice to have on the shelf for when I want to go and really tear into something on a theoretical and scholarly level.
But for day-to-day programming, there are much better texts.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


‹ Previous | 1 210 | Next ›
Most Helpful First | Newest First

This product

Refactoring: Improving the Design of Existing Code
Refactoring: Improving the Design of Existing Code by Don Roberts (Hardcover - June 28 1999)
CDN$ 67.99 CDN$ 42.83
Usually ships in 3 to 5 weeks
Add to cart Add to wishlist
Only search this product's reviews