Customer Reviews for

Refactoring: Improving the Design of Existing Code

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing all of 8 Customer Reviews
Page 1 of 1
  • Anonymous

    Posted October 26, 2009

    I Also Recommend:

    Essential reading for professional programmers

    Refactoring is the process of changing the internal structure of a program without changing its outward behavior. If you are writing a program that you only ever intend to run once, then you have no need to refactor. If, however, you plan on maintaining and adapting your program for years to come, then you will need to know how to change it safely without producing a sloppy, fragile, top-heavy mess. The point of this book is to produce clean, bug-free source code that is easy to adapt to the ever-changing requirements of the marketplace. So this book is as much about writing clean code as it is about refactoring. It identifies around seventy refactorings, explains when you would use each one, and provides some simple source code to illustrate each one.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted February 21, 2009

    Great book for anyone refactoring code

    The book is split into two sections, the process for refactoring code and the library of patterns. The topic is explained through the actual refactoring of sample code. It is an easy read and does a great job addressing the "wrong" approach to refactoring and a step by step process for doing it right. The website contains a more detailed and complex example of refactoring - the missing chapter.

    Fowler address the issues with the actual code but I would have liked some discussions on database migration issues. The code we needed to refactor was using ORM (Hibernate) and we shied away from a few classes since we wanted to avoid data migrations. Eventually we'll have to tackle the issue and we won't have a guidebook to help make better choices.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted November 12, 2002

    Refactoring: Improving the Design of Existing Code

    A little while back I was introduced to a word I had never heard before, Refactoring. I was told to get Martin Fowler's book and read it so I could gain a better understanding of what Refactoring was. Well folks, I would classify this book as a 'Hidden Treasure'. Although it is not a flashy or well known title, I believe its impact can be much deeper and long lasting than many of the mainstream, more popular technology books. The underlying theories that it teaches can be applied for years, even when languages change. There are only a couple of things I would change about this book, which I will mention below. Preface The Preface it brief enough, and gives the definition for the word Refactoring. This is a good thing because right form the start you get the true definition of Refactoring. In short, refactoring is the process of changing code to improve the internal structure, but not changing the external behavior. Chapter 1: Refactoring, a First Example In this chapter Mr. Fowler tries to start by showing a simple Refactoring example. The problem is that the chapter then goes on for 50+ pages. Mr. Fowler explains his reasons for doing this, but I think that a simple example should have been much simpler. Especially when it is in the first chapter of the book. It's not that this isn't a good chapter. I feel it's just too soon in the book. I would have put it at the end. Chapter 2: Principles of Refactoring This is an excellent chapter. The definition of Refactoring is discussed as well as the following questions: Why should you refactor? When should you refactor? What do I tell my manager? This last question may seem funny, but when you read this chapter you will understand why it is in there. This chapter also discusses common problems that occur during Refactoring, and Refactoring and performance. Chapter 3: Bad Smells in Code In this chapter things that cause code to 'smell' are discussed. When code 'smells' it could be an indicator that refactoring is needed. 22 different 'smells' are discussed. My favorites were Duplicated Code, Large Class, and Lazy Class. This is a chapter full of awesome hints. Chapter 4: Building Tests Building tests is an important part refactoring. Refactoring is done in small steps, and after every step you should test. In this chapter the discussion covers the processes and methodology of applying tests during refactoring. Chapter 5: Toward a Catalog of Refactorings This chapter is a quick setup for chapters 6 to 12. Mr. Fowler explains his method for cataloging the individual refactorings. What is pretty amazing is that he has taken a lot of time naming and detailing each refactoring. Chapter 6: Composing Methods One of my favorite chapters. Mr. Fowler opens by saying, "A large part of my refactoring is composing methods to package code properly." This chapter is all about that. 9 total refactorings are explained. My favorite ones are Inline Method and Extract Method. Chapter 7: Moving Features Between Objects Sometimes you need to move things from one object to another. This chapter discusses the art of moving features between objects. 8 total refactorings are discussed and detailed. My favorite from this chapter is Extract Class. Chapter 8: Organizing Data A very large chapter that discusses in meticulous detail 16 refactorings that will make it much easier to work with data. One thing that becomes very obvious in this chapter is that certain refactorings can go either way. What I mean is illustrated by these two: Change Value to Reference and Change Reference to Value. So some refactorings are not just one way deals. It just depends on the situation. Chapter 9: Simplifying Conditional Expressions This is a very useful chapter since conditional logic is a common occurrence in the programming world. Because conditional logic has a tendency to get very complex, this chapter has 8 refact

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted June 13, 2011

    No text was provided for this review.

  • Anonymous

    Posted October 31, 2008

    No text was provided for this review.

  • Anonymous

    Posted October 2, 2009

    No text was provided for this review.

  • Anonymous

    Posted January 3, 2011

    No text was provided for this review.

  • Anonymous

    Posted July 1, 2010

    No text was provided for this review.

Sort by: Showing all of 8 Customer Reviews
Page 1 of 1