Refactoring: improving the design of existing code | Guide books

Refactoring: improving the design of existing codeJuly 1999

July 1999

Publisher:

Addison-Wesley Longman Publishing Co., Inc.
75 Arlington Street, Suite 300 Boston, MA
United States

ISBN:978-0-201-48567-7

Published:01 July 1999

Pages:

464

Available at Amazon

Bibliometrics

Abstract

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. 0201485672B04062001

Cited By

Index Terms

Refactoring: improving the design of existing code
1. Social and professional topics
  1. Professional topics
    1. Management of computing and information systems
      1. Software management
        Software maintenance
2. Software and its engineering
  1. Software creation and management
    1. Software post-development issues
      1. Software reverse engineering

Reviews

Reviewer: Ghita Mostefaoui

As most software developers know, software code has become more and more difficult to manage, and even to understand, as more features are added, bugs are fixed, and maintenance is done by different developers. In many development projects, the money spent to maintain and extend code is more important than the funds dedicated to its development. This is because most developers write code that produces the right output for a given input, without paying attention to clean design and presentation. Refactoring is about improving the internal structure of existing code without altering its external behavior. In practice, refactoring is a set of program transformations applied to a software system, in order to clean up code without introducing bugs. This book builds on the foundations laid by the pioneers of refactoring, Ward Cunningham and Kent Beck. Fowler presents a detailed discussion of refactoring techniques and provides a catalog of 72 proven refactorings, with step-by-step instructions for applying each. In chapter 1, the author presents an introductory example of refactoring. He performs a step-by-step improvement of a sample program by applying some of the techniques detailed in further chapters. In chapter 2, the author discusses cases that illustrate when refactoring existing code becomes a necessity. Chapter 3 contains a list of symptoms to identify badly written code, such as duplicated code, long methods, large classes, and data clumps. Chapter 4 demonstrates the use of JUnit, a testing framework built by Erich Gamma and Kent Beck to develop tests for code. Chapter 5 presents the format for refactoring patterns. As with design patterns, refactorings are carefully defined using a standard format. This format specifies a name; a short summary describing the situation in which this refactoring is useful; the motivation for why the refactoring should be done and circumstances in which it shouldn’t be done; the mechanics (a step-by-step description of how to carry out the refactoring); and finally, an example that illustrates how this refactoring works. Chapters 6 through 12 comprise an initial catalog of refactorings, categorized by their purpose. These categories include composing methods; moving features between objects; organizing data; simplifying conditional expressions; making method calls simpler; dealing with generalization; and big refactorings. Chapter 6 deals with the problem of long methods. Some refactorings are discussed that are used to package code properly. The core refactorings are Extract Method() and Inline Method(). Chapter 7 details the use of refactorings such as the Move Method(), Move Field(), and Extract Class(), used to redistribute responsibilities between objects. Chapter 8 discusses several refactorings that make working with data easier, and includes a set of illustrative examples. Chapter 9 presents the core refactorings used to simplify conditional expressions: Decompose Conditional, Consolidate Conditional Expression, and Replace Conditional with Polymorphism. Chapter 10 presents refactorings to make method calls simpler: Rename Method, Add Parameter, Remove Parameter, and Parameterize Method. Dealing with generalization is achieved by the mean of a set of refactorings. Chapter 11 contains the description of two of them. The Pull Up Field is applied when two subclasses have the same field. This refactoring is achieved by moving the field to the superclass. The Pull Up Method is applied when two methods have identical results on subclasses. This refactoring moves these methods to the superclass. Most of the research and practice of refactoring deals with smaller refactorings. Chapter 12 talks about big refactorings. The final chapters are written by guest authors. Chapter 13 is by William Opdyke, who presents a brief discussion about the early experience he gained during his refactoring research, and who addresses other refactoring-related issues, such as software reuse, product evolution, and platform selection. This chapter ends with a set of resources and references for refactoring. Manual refactoring is time consuming, and in most cases not very safe, since it can introduce bugs. Refactoring with an automated tool is thus very helpful. In chapter 14, Don Roberts and John Brant set up a list of technical requirements for a refactoring tool. In chapter 15, Kent Beck concludes the book by giving the reader guidelines for better use of refactoring. This book is a classic reference for refactoring. The reader will notice, however, that to learn the effective use of refactoring, it is not sufficient to read the whole book, or even to learn the catalog of the seventy-two refactorings; practitioners must gain experience from intensive practice. Online Computing Reviews Service

Access critical reviews of Computing literature here

Become a reviewer for Computing Reviews.

Comments

Please enable JavaScript to view thecomments powered by Disqus.

Recommendations

Interaction awareness for aspect refactoring
AOAsia '13: Proceedings of the 8th international workshop on Advanced modularization techniques

Aspect Refactoring includes two phases: aspect mining and aspect extraction. Aspect mining is used to identify crosscutting concerns from the OO program. Aspect extraction extracts the identified crosscutting concerns from the OO program and refactors ...
Role-based refactoring of crosscutting concerns
Sort-based refactoring of crosscutting concerns to aspects
LATE '08: Proceedings of the 2008 AOSD workshop on Linking aspect technology and evolution

Crosscutting concerns in object-oriented programming hinder evolution because of their symptoms: tangling and scattering. To benefit from the modularisation capabilities for crosscutting concerns provided by aspect-oriented programming (which prevent ...

Browse Books

Sections

Cited By

Index Terms

Reviews

Access critical reviews of Computing literature here

Interaction awareness for aspect refactoring

Role-based refactoring of crosscutting concerns

Sort-based refactoring of crosscutting concerns to aspects

Save to Binder

Sections

Cited By

Save to Binder

Index Terms

Reviews

Access critical reviews of Computing literature here

Recommendations

Interaction awareness for aspect refactoring

Role-based refactoring of crosscutting concerns

Sort-based refactoring of crosscutting concerns to aspects