Jay Fields - Refactoring. Ruby Edition

Upper Saddle River, NJ Boston Indianapolis San Francisco
New York Toronto Montreal London Munich Paris Madrid
Cape Town Sydney Tokyo Singapore Mexico City

Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and the publisher was aware of a trademark claim, the designations have been printed with initial capital letters or in all capitals.

The authors and publisher have taken care in the preparation of this book, but make no expressed or implied warranty of any kind and assume no responsibility for errors or omissions. No liability is assumed for incidental or consequential damages in connection with or arising out of the use of the information or programs contained herein.

The publisher offers excellent discounts on this book when ordered in quantity for bulk purchases or special sales, which may include electronic versions and/or custom covers and content particular to your business, training goals, marketing focus, and branding interests. For more information, please contact:

U.S. Corporate and Government Sales
(800) 382-3419

For sales outside the United States please contact:

International Sales

Visit us on the Web: informit.com/aw

Associate Publisher
Mark Taub
Acquisitions Editor
Greg Doench
Managing Editor
Kristy Hart
Project Editor
Andy Beaster
Copy Editor
Geneil Breeze
Indexer
Erika Millen
Proofreader
Jennifer Gallant
Technical Reviewers
Chad Fowler
Clinton Begin
Justin Gehtland
Publishing Coordinator
Michelle Housley
Cover Designer
Chuti Prasertsith
Compositor
Jake McFarland

Library of Congress Cataloging-in-Publication Data:
Fields, Jay, 1979
Refactoring / Jay Fields, Shane Harvie, and Martin Fowler. -- Ruby ed.
p. cm.
ISBN-13: 978-0-321-60350-0 (hardback : alk. paper)
ISBN-10: 0-321-60350-8 (hardback : alk. paper) 1. Software refactoring. 2. Ruby (Computer program
language) I. Harvie, Shane, 1980- II. Fowler, Martin, 1963- III. Title.
QA76.76.R42F54 2010
005.117--dc22
2009027577

Copyright 2010 Pearson Education, Inc.

All rights reserved. Printed in the United States of America. This publication is protected by copyright, and permission must be obtained from the publisher prior to any prohibited reproduction, storage in a retrieval system, or transmission in any form or by any means, electronic, mechanical, photocopying, recording, or likewise. For information regarding permissions, write to:

Pearson Education, Inc.
Rights and Contracts Department
501 Boylston Street, Suite 900
Boston, MA 02116
Fax (617) 671 3447

ISBN-13: 978-0-321-60350-0
ISBN-10: 0-321-60350-8

Text printed in the United States on recycled paper at RR Donnelley in Crawfordsville, Indiana.

First printing October 2009

To Dana, the love of my life, thank you for your endless patience and support

Jay Fields

To Jan, my sounding board for many a bad idea and questionable opinion, thank you for never judging

Shane Harvie

For Cindy

Martin Fowler

I remember what it was like to learn object-oriented (OO) programming; As I learned OO, I was left with a low-grade tensiona feeling that I was missing something. Some new concepts felt simple and familiar in a way that told you there was a depth underlying them waiting to be discovered. That can be an unsettling feeling.

I read the literature on design patterns with great interest but, disappointingly, derived little enlightenment. I talked to other developers, browsed the Web, read books, and perused source code but remained convinced that there was something important that wasnt coming through. I understood how the tools of object orientation worked, but I was unable to apply them in a way that felt right to me.

Then I picked up the first edition of this book.

Software is not created in one inspired moment. The usual focus on the artifacts of the development process obscures the fact that software development is in fact a process. More specifically, as Refactoring taught me, it is a series of small decisions and actions all made through the filter of a set of values and the desire to create something excellent.

Understanding that software development is a constant activity and not a static event helps us to remember that code can and should be organic. Good code is easy to change. Bad code can incrementally be made easier to change. Code thats easy to change is fun to work with. Code thats hard to change is stressful to work with. And the more changes you make, without refactoring it, the more stressful working with it becomes.

So becoming a software developer is less about what good code is than about how to make good code. Software doesnt just spring into being. Its created by humans, one keystroke at a time. Refactoring is the book from which I learned how to do that process well. It taught me how to sit down and write great code, one tiny piece at a time.

When I initially read Refactoring, I was on a small team whose responsibility was to help larger groups write better software. At meetings and code reviews, I would carry the hard-covered book around with me, wielding it as both a weapon and a shield. I was passionate about my job and (more strongly) the craft of software development, and Im sure that the developers we worked with often dreaded the sight of me and this book heading toward their cubicles. I didnt so much refer to the books contents in these meetings as just have it with me as a reminder of what it represented for me: Our work can be great if we always remember that it should be great and we take the simple steps to make it great.

Looking back on that time with the advantage of hindsight, I realize that the languages and tools we were using were working against us. The techniques in this book were born out of Smalltalk development. In a dynamic environment, refactoring flourishes. So its only fitting that they should be reborn here in Ruby. As a longtime Rubyist it is thrilling to see the book that made such a profound difference for me become available to developers who speak Ruby as their primary programming language.

Refactoring: Ruby Edition will serve as a guiding light for a new generation of Rubyists who will learn to create better, more flexible software and (I hope) to love the craft of software development as much as I have.

Chad Fowler
Co-Director, Ruby Central, Inc.
CTO, InfoEther, Inc.

Just over a decade ago I (Martin) worked on a project with Kent Beck. This project, called C3, became rather known as the project that marked the birth of extreme programming and helped fuel the visibility of what we now know as the agile software movement.

We learned a lot of things on that project, but one thing that particularly struck me was Kents methodical way of continually reworking and improving the design of the system. I had always been a fan of writing clear code, and felt it was worthwhile to spend time cleaning up problematic code to allow a team to develop features swiftly. Kent introduced me to a technique, used by a number of leading Smalltalkers, that did this far more effectively than I had done it before. Its a technique they called