Refactoring in Large Software Projects: Performing Complex Restructurings Successfully (Paperback)

~ (Author), Stephen Roock (Author) "Once, software developers believed it was possible to create the technical software design for a comprehensive system completely, correctly and free of contradictions right at..." (more)
Key Phrases: Martin Fowler, Black Box Refactoring, Change Compatibility (more...)

Editorial Reviews

Product Description

Large Refactorings looks at methods of establish design improvements as an important and independent activity during development of software, and will help to ensure that software continues to adapt, improve and remain easy to read and modify without altering its observable behaviour. It provides real-world experience from real refactored projects and shows how to refactor software to ensure that it is efficient, fresh and adaptable.

From the Back Cover

Breathe new life into old code! Learn how to refactor software to ensure that it is efficient, fresh and adaptable.

Refactoring is an aspect of eXtreme programming that enables software developers, designers and architects to breathe new life into old code. Authors Stefan Roock and Martin Lippert help you to keep your software projects alive and show you how to successfully adapt and improve complex restructurings.

Some Integrated Development Environments, such as Eclipse or IntelliJ, provide support for refactorings. However, this support does not tackle some of the planning or controlling, nor the long-term consequences, of large refactorings. This invaluable resource fills the gap and shows you how to improve the design of existing software code.

Whilst there have been a number of books on eXtreme Programming, few have looked in detail at individual practices. Stefan Roock and Martin Lippert take the idea a step further and extend the scope to applications that use libraries, frameworks and database structures.

Refactoring in Large Software Projects looks at methods of design improvements as an important and independent activity during development of software.

If you’re looking for a practical guide to performing complex restructurings, this is certainly the book for you.

See all Editorial Reviews

Product Details

• Paperback: 286 pages
• Publisher: Wiley; 1 edition (June 5, 2006)
• Language: English
• ISBN-10: 0470858923
• ISBN-13: 978-0470858929
• Product Dimensions: 9.1 x 7.4 x 0.6 inches
• Shipping Weight: 1.2 pounds (View shipping rates and policies)
• Average Customer Review: 4.0 out of 5 stars  See all reviews (2 customer reviews)
• Amazon.com Sales Rank: #1,068,290 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

1 of 1 people found the following review helpful:

4.0 out of 5 stars Refactoring in Large Software Projects, March 12, 2007

By	Maudrit Martinez (Miami, FL) - See all my reviews (REAL NAME)

Reviewed by Andres Anon

This book should be required reading for all developers and architects prior to attempting to refactor any application.

The material is presented very clearly. It touches on all aspects of refactoring form databases and published API's to single classes and methods. It emphasizes the importance of testing in refactoring and the use of emerging technologies (IDE's, plugin, and third party tools) to achieve this refactoring. It also concentrates on problems in applications which they refer to as smells. They identify the most common types of smells, how to locate them and refactor them in existing code and how to prevent them in future developments.

It provides a review of popular design principles and how to successfully refactor applications according to those principles. The examples are practical enough to understand but simple enough to follow without putting the book down. The book also reviews some of the most popular refactoring tools in the market PMD, JDepend, ClassCycle, Eclipse Metrics Plugin, RefactorIT, Dr. Freud, and SA4J.

Each chapter is organized differently. When covering the best practices for a large refactoring the author presents with a set of the most common problems and solutions. When covering how to refactor databases the author presents a very methodical approach. The constant throughout the reading is that every chapter presents a topic, provides experiences and recommendations as well as further reading that is available on any covered material.

I would definitely recommend that every java developer read this book sooner rather than later. It will provide you with a different perspective to guide you as you build your applications. After all, knowing what not to do is often as important as knowing what to do.

3 of 4 people found the following review helpful:

4.0 out of 5 stars Introduces refactoring at the architectural level..., June 27, 2006

By	Thomas Duff "Duffbert" (Portland, OR United States) - See all my reviews (TOP 50 REVIEWER)    (REAL NAME)

The concept of refactoring code shouldn't be a new idea to most software developers, but often it's done on a very limited basis. In those cases, it may be possible to allow the IDE to take care of much of the renaming and such. But what happens when you want to make a major refactoring change that spans the entire system? Resources and best practices are a little more rare in that case. Stefan Roock and Martin Lippert attempt to address that situation in their book Refactoring in Large Software Projects.

Contents: Introduction; Refactoring - An Overview; Architecture Smells; Large Refactorings; Refactoring of Relational Databases; API Refactorings; Tool-Based Detection and Avoidance of Architecture Smells; Conclusion; Glossary; Index

This book will be most helpful at the architecture level of a system; that is, when you determine that you've painted yourself into a design corner. It may be necessary to introduce a new feature that is somewhat similar to an existing one, but you can't just kill off the old feature due to unknown usage by others. Roock and Lippert show how it's possible to make these wholesale changes in a manner that allows for a graceful degradation of current functionality without sacrificing the new design. It's also helpful if you've solely focused on refactoring at the code level. The term "code smells" refer to situations where code develops a "stench" due to bad design or practices. This book takes that concept and stretches it out to the design level. Even if you're not in a situation where you need to redesign a system to remove some architectural smells, you'll learn what types of designs will introduce those "aromas" and how to avoid them. Much better not to make the mistake up front, than to have to refactor it out later.

Not an easy read, and you'll probably find some areas a bit more useful or applicable to where you're at. But if you're responsible for a system that is showing some age and getting harder to maintain, this might be a book that helps you turn the situation around.