Brutal Refactoring: More Working Effectively with Legacy Code

Brutal Refactoring builds on Michael Feathers' earlier work about managing legacy code, providing methods for transforming complex and problematic codebases. The book outlines strategies for making aggressive changes to improve code structure while maintaining functionality and stability. The text presents a collection of refactoring patterns and techniques to help developers break dependencies, extract components, and untangle messy architectures. Through examples and case studies, Feathers demonstrates how to identify areas needing change and execute transformations with minimal risk. Each chapter addresses specific challenges in legacy code maintenance, from dealing with global state to managing test coverage during large-scale refactoring efforts. The book includes practical guidance on communicating refactoring needs to stakeholders and building team consensus around major structural changes. The work speaks to core tensions in software development between rapid delivery and sustainable architecture, suggesting that bold, strategic refactoring can bridge this divide. Its emphasis on systematic approaches to code improvement reflects broader principles about technical debt and software evolution.

There are not enough internet reviews to create a summary of this book. Instead, here is a summary of reviews of Michael Feathers's overall work: Software developers consistently rate "Working Effectively with Legacy Code" highly for its practical techniques for managing existing codebases. Readers cite the book's clear explanations of how to add tests to untested code and break dependencies. Readers appreciate: - Specific code examples and refactoring patterns - Solutions to common legacy code problems - Clear writing style focused on real-world situations - Techniques that work across programming languages Common criticisms: - Examples use older Java/C++ code that feels dated - Some concepts could be explained more concisely - Price is high for physical copies - Code samples can be hard to read in ebook format Ratings across platforms: Goodreads: 4.16/5 from 3,800+ ratings Amazon: 4.5/5 from 500+ reviews One developer noted: "This book gave me practical tools I used the next day at work." Another wrote: "Changed how I approach maintaining old systems, but wished for more modern examples."

Clean Code by Robert C. Martin This book provides systematic methods for transforming messy code into clean, maintainable code through practical examples and proven techniques.

Working Effectively with Legacy Code by Michael Feathers The book presents strategies and techniques for breaking dependencies, adding tests, and improving code structure in existing codebases.

Refactoring: Improving the Design of Existing Code by Martin Fowler The text catalogs common code smells and provides step-by-step refactoring patterns to transform problematic code into well-structured solutions.

The Art of Unit Testing by Roy Osherove This work demonstrates patterns for writing maintainable unit tests that support refactoring and code improvement efforts.

Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma The book presents a catalog of reusable design patterns that solve common software design problems and support code refactoring efforts.

🔧 Michael Feathers coined the term "legacy code," defining it as code without tests, which has become widely accepted in the software development community 📚 The book is a sequel to "Working Effectively with Legacy Code" (2004), which has been translated into six languages and is considered a classic in software engineering literature 💻 Feathers introduces the concept of "characterization tests" - tests written to describe existing code behavior rather than specify desired behavior 🔄 The techniques in the book were developed through the author's extensive consulting work with companies like Google, Microsoft, and Oracle 🎯 The "brutal" in the title refers to the book's emphasis on making decisive, sometimes dramatic changes to code structure, rather than incremental improvements that may preserve problematic patterns