Buy new:
-40% $39.20
FREE delivery Tuesday, August 27
Ships from: Goodvibes Books
Sold by: Goodvibes Books
$39.20 with 40 percent savings
List Price: $64.99

The List Price is the suggested retail price of a new product as provided by a manufacturer, supplier, or seller. Except for books, Amazon will display a List Price if the product was purchased by customers on Amazon or offered by other retailers at or above the List Price in at least the past 90 days. List prices may not necessarily reflect the product's prevailing market price.
Learn more
FREE delivery Tuesday, August 27. Details
Or fastest delivery August 21 - 23. Details
Only 5 left in stock - order soon.
$$39.20 () Includes selected options. Includes initial monthly payment and selected options. Details
Price
Subtotal
$$39.20
Subtotal
Initial payment breakdown
Shipping cost, delivery date, and order total (including tax) shown at checkout.
Ships from
Goodvibes Books
Ships from
Goodvibes Books
Returns
30-day refund/replacement
30-day refund/replacement
This item can be returned in its original condition for a full refund or replacement within 30 days of receipt. You may receive a partial or no refund on used, damaged or materially different returns.
Returns
30-day refund/replacement
This item can be returned in its original condition for a full refund or replacement within 30 days of receipt. You may receive a partial or no refund on used, damaged or materially different returns.
Payment
Secure transaction
Your transaction is secure
We work hard to protect your security and privacy. Our payment security system encrypts your information during transmission. We don’t share your credit card details with third-party sellers, and we don’t sell your information to others. Learn more
Payment
Secure transaction
We work hard to protect your security and privacy. Our payment security system encrypts your information during transmission. We don’t share your credit card details with third-party sellers, and we don’t sell your information to others. Learn more
$29.85
Get Fast, Free Shipping with Amazon Prime FREE Returns
Average used book may have worn corners/Used condition Ships direct from Amazon! Average used book may have worn corners/Used condition Ships direct from Amazon! See less
FREE delivery Wednesday, August 21 on orders shipped by Amazon over $35
Only 1 left in stock - order soon.
$$39.20 () Includes selected options. Includes initial monthly payment and selected options. Details
Price
Subtotal
$$39.20
Subtotal
Initial payment breakdown
Shipping cost, delivery date, and order total (including tax) shown at checkout.
Access codes and supplements are not guaranteed with used items.
Kindle app logo image

Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.

Read instantly on your browser with Kindle for Web.

Using your mobile phone camera - scan the code below and download the Kindle app.

QR code to download the Kindle App

Follow the author

Something went wrong. Please try your request again later.

Working Effectively with Legacy Code 1st Edition

4.5 4.5 out of 5 stars 667 ratings

{"desktop_buybox_group_1":[{"displayPrice":"$39.20","priceAmount":39.20,"currencySymbol":"$","integerValue":"39","decimalSeparator":".","fractionalValue":"20","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"9H4um%2BErjcPQU5nCqb5KoBjQL8SIj3rdqEB7%2F%2BUm383t8OnAOrjvcZS5HDEMxmBTn%2FW1prIxR7dOxyJsXDE9HzQAzZDloSyPF9IED7KzT4JxYECfTC3ewpXsg57s09yDhwUFCiJ%2BcrtGNxpiqyRH0oLVwmCnOBYbXQpB28%2BYu2yFSCY41PHfSA%3D%3D","locale":"en-US","buyingOptionType":"NEW","aapiBuyingOptionIndex":0}, {"displayPrice":"$29.85","priceAmount":29.85,"currencySymbol":"$","integerValue":"29","decimalSeparator":".","fractionalValue":"85","symbolPosition":"left","hasSpace":false,"showFractionalPartIfEmpty":true,"offerListingId":"9H4um%2BErjcPQU5nCqb5KoBjQL8SIj3rdaIrnAFTL1IoIG9%2BOf8uNTeLy6fl9sm5C6y7ggZBWhB7EkS7YNsaECg2C9vbH5yLIxmrbyYrhp3Pl2eoekybYgoH9E9al4Fepsq7WB%2Bj0eL%2Bc%2FH%2Ftokb8utSNbtp0l3G4D9SYC4%2B23CsMn0iDvjW%2BBRd%2F%2FoFKg6YV","locale":"en-US","buyingOptionType":"USED","aapiBuyingOptionIndex":1}]}

Purchase options and add-ons

This book provides programmers with the ability to cost effectively handlecommon legacy code problems without having to go through the hugelyexpensive task of rewriting all existing code. It describes a series of practicalstrategies that developers can employ to bring their existing softwareapplications under control. The author provides useful guidance about how touse these strategies when refactoring or making functional changes to codebases. One of the book's key points is that it teaches developers to write teststhat can be used to make sure they are not unintentionally changing theapplication as they optimize it. Examples are provided in Java, C++, and Csharp,and the book assumes that the reader has some knowledge of UMLnotation. Strategies using UML and code in C++ and Java primarily whilelanguage independent advice will be delivered in side bars and appendices forlanguage specific users.


Amazon First Reads | Editors' picks at exclusive prices

Frequently bought together

This item: Working Effectively with Legacy Code
$43.09
Get it as soon as Tuesday, Aug 20
In Stock
Ships from and sold by Amazon.com.
+
$49.57
Get it as soon as Tuesday, Aug 20
In Stock
Ships from and sold by Amazon.com.
+
$46.99
Get it as soon as Tuesday, Aug 20
In Stock
Ships from and sold by Amazon.com.
Total price:
To see our price, add these items to your cart.
Details
Added to Cart
spCSRF_Treatment
Choose items to buy together.

From the brand


From the Publisher

Programmer holding Working with Legacy Code and a lap top

Must-Read for Every Programmer and Developer

This classic, endorsed by Robert "Uncle Bob" Martin (author of Clean Code), is on many must-read lists for programmers and developers including lists featured on Guru99, DZone, Built In, Dev Community (dev.to), and more.

"The book is important, as almost every developer at some point in career, has to work with a legacy system and it still represents the most challenging problems for many companies. The book goes deep into understanding the general process of a software change like adding features, fixing bugs, optimizing performances, etc."

—Milan Milanovic, DZone, November 2021

Editorial Reviews

From the Back Cover

Get more out of your legacy systems: more performance, functionality, reliability, and manageability

Is your code easy to change? Can you get nearly instantaneous feedback when you do change it? Do you understand it? If the answer to any of these questions is no, you have legacy code, and it is draining time and money away from your development efforts.

In this book, Michael Feathers offers start-to-finish strategies for working more effectively with large, untested legacy code bases. This book draws on material Michael created for his renowned Object Mentor seminars: techniques Michael has used in mentoring to help hundreds of developers, technical managers, and testers bring their legacy systems under control.

The topics covered include

  • Understanding the mechanics of software change: adding features, fixing bugs, improving design, optimizing performance
  • Getting legacy code into a test harness
  • Writing tests that protect you against introducing new problems
  • Techniques that can be used with any language or platform―with examples in Java, C++, C, and C#
  • Accurately identifying where code changes need to be made
  • Coping with legacy systems that aren't object-oriented
  • Handling applications that don't seem to have any structure

This book also includes a catalog of twenty-four dependency-breaking techniques that help you work with program elements in isolation and make safer changes.


© Copyright Pearson Education. All rights reserved.

About the Author

MICHAEL C. FEATHERS works for Object Mentor, Inc., one of the world's top providers of mentoring, skill development, knowledge transfer, and leadership services in software development. He currently provides worldwide training and mentoring in Test-Driven Development (TDD), Refactoring, OO Design, Java, C#, C++, and Extreme Programming (XP). Michael is the original author of CppUnit, a C++ port of the JUnit testing framework, and FitCpp, a C++ port of the FIT integrated-testing framework. A member of ACM and IEEE, he has chaired CodeFest at three OOPSLA conferences.


© Copyright Pearson Education. All rights reserved.

Product details

  • Publisher ‏ : ‎ Pearson; 1st edition (September 22, 2004)
  • Language ‏ : ‎ English
  • Paperback ‏ : ‎ 464 pages
  • ISBN-10 ‏ : ‎ 0131177052
  • ISBN-13 ‏ : ‎ 978-0131177055
  • Item Weight ‏ : ‎ 1.65 pounds
  • Dimensions ‏ : ‎ 7 x 1.2 x 9.25 inches
  • Customer Reviews:
    4.5 4.5 out of 5 stars 667 ratings

About the author

Follow authors to get new release updates, plus improved recommendations.
Michael C. Feathers
Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

Discover more of the author’s books, see similar authors, read author blogs and more

Customer reviews

4.5 out of 5 stars
667 global ratings

Customers say

Customers find the book's technical accuracy to be practical and timeless. They also appreciate the tests and say it's a great book for making code better incrementally. Opinions are mixed on readability, with some finding it clear and easy to read, while others find it hard to read and overly technical. Readers also disagree on the code, with others finding it well designed and awesome, while still others say the way ideas are organized is crazy.

AI-generated from the text of customer reviews

51 customers mention "Technical accuracy"51 positive0 negative

Customers find the book offers a practical approach to making code base better incrementally. They say it provides excellent examples and easily described techniques for dependency breaking. Readers also mention that it provides a map to slowly add tests. They appreciate the author's modeling of mindset, choices, and techniques. Overall, they say the book helps them work with legacy code and instill a type of culture.

"...your perceptions about testing on their head, Feathers also provides good advice on how to create loosely coupled code, how to identify and..." Read more

"...Why is that useful? First, it is an effective way of documenting what a system actually does, particularly if --- as with most legacy code --- there..." Read more

"Refactorings in last chapter are heart of book. Much timeless advice here. The primary concept is that code without automated tests is legacy code...." Read more

"This was one of those famous, timeless books (like Code Complete) that I had heard many people talk about, and I finally read it...." Read more

20 customers mention "Readability"13 positive7 negative

Customers have mixed opinions about the readability of the book. Some find it clear and easy to read, while others find it hard to read and dull. They also say the book is not expert-level material and is overly technical.

"...Feathers' style is easy to read. As you would expect there is lots of example code here, and it is folded naturally into the explanatory text...." Read more

"...It is quite readable and accessible, and doesn't overwhelm. I found a lot of valuable techniques in here that I have not found anywhere else...." Read more

"...The book, for all its wisdom within, is not particularly engaging to read and the examples are just. plain. awful...." Read more

"...Some of it seems really simple, but the way Feathers articulates it is pretty amazing...." Read more

6 customers mention "Code"4 positive2 negative

Customers have mixed opinions about the code in the book. Some find it well designed and awesome, while others say the way ideas are organized is crazy.

"...of the techniques in this book immediately and found that coding was higher quality and more enjoyable...." Read more

"...But, the way ideas are organized is completely crazy.For..." Read more

"One of the best books about design, testing, pragmatism, and overall programming. I wish I had come across it sooner...." Read more

"Really shows you how to get from nasty code to well designed and awesome code...." Read more

Copy missing portions of text
1 out of 5 stars
Copy missing portions of text
The book is good so far, but don't get it here. Apparently this is an "Abridged" version, but I wouldn't even call it that. I've compared this physical copy with a PDF version and parts of sentences and sections are missing in a way that doesn't even make sense. Sentences at the bottom of a page are cut off without an ending, and an entirely new section starts on the next page. On one two page spread (shown in photos), a chart is duplicated, pushing the content down, and the rest of the content that is supposed to be on that page is just omitted entirely. The attached photos are of three pages from my physical copy with the issues I described, and the same three pages from a free PDF version of the book.
Thank you for your feedback
Sorry, there was an error
Sorry we couldn't load the review

Top reviews from the United States

Reviewed in the United States on May 21, 2014
Whether taking on TDD, breaking dependencies or trying to maintain code that's lacking testing this book is a must read.

Is your code a tangled mess? Are you tired of seeing telescoping methods and methods that are 100s of lines long? Want to clean up code you didn't write and get it under test but everyone's too afraid of breaking things? Does it take you forever to write unit tests? Is it painstaking and laborious? Do you write mainly integration tests because unit testing is too hard? Do you wonder how people can write lots of unit tests, let alone unit test every method? Do you want to kick your object oriented coding skills up a notch? Then this book is for you. It can teach you how to overcome all of those obstacles and so much more.

For me the first roughly 100 pages of the book were a revelation. If you don't understand how to do TDD the problem probably isn't testing, it's probably the code you're trying to test or your perceptions about what it is that you are actually supposed to be testing. Michael Feathers does a great job identifying the mistakes and traps that so many developers experience when trying write and test good code and provides recipes for overcoming them. He adds clarity to what a unit test is and what it's supposed to do and in the process takes a deep dive into what good object oriented code looks like through the eyes of TDD. The book can completely change your perception about what is and is not possible.

In addition to turning your perceptions about testing on their head, Feathers also provides good advice on how to create loosely coupled code, how to identify and eliminate dependencies in existing code as well as strategies for reorganizing poorly structured code into better objects. This book has clearly changed the way I code and the way I think about testing for the better. It's not just about testing it's also about turning procedural code into object oriented code and bringing your object oriented thinking to the next level.

I can't say enough great things about this book. It's dearer to me than any other book in my programming collection including books about object oriented code from Bloch, Beck, Fowler and others. It wasn't until I read Working Effectively with Legacy Code that things really came together for me in the object oriented world. I got the concepts individually but failed to recognize how it all comes together. What's so great about encapsulation / getters and setter? Why is it so important to have classes and methods that do just one thing? What's so important about breaking dependencies between classes? How small is a small method? How can I ever hope to achieve open/closed? How is TDD even possible? Your mileage may vary, but if you're like me this book will change your life for the better.
24 people found this helpful
Report
Reviewed in the United States on January 4, 2005
The vast majority of software texts are about greenfield development: creating a new application from nothing at all. But the vast majority of software work involves existing code: adding features, finding bugs, or refactoring code that someone else wrote. This book is a supurb first step in fixing that imbalance.

This is not a theoretical work. For example, Feathers does not present a grand ontology of legacy systems. Not is this book heavy on methodology. Instead Feathers describes techniques --- lots of techniques, roughly 50 --- for working with legacy code.

The techniques are organized by the problems they address. For example, one chapter is entitled "My Application Is All API Calls" and then presents two techniques for working with existing code that is full of calls to APIs.

Feathers comes from the XP school, and he adopts that school's premise that you can safely change code if (and only if) there are sufficient tests in place to tell you when your new change has introduced a bug. Many of the techniques in this book are about different ways of putting legacy code into test harnesses, and doing that safely without introducing bugs along the way.

He also introduces new concepts, or at least concepts I had never seen before. For example, a "characterization test" is a test that characterizes the actual behavior of the code, not what the code is supposed to do, but what it actually does. Why is that useful? First, it is an effective way of documenting what a system actually does, particularly if --- as with most legacy code --- there is no other documentation. And it can tell you when you have changed that existing behavior.

Feathers' style is easy to read. As you would expect there is lots of example code here, and it is folded naturally into the explanatory text. My only gripe with the book is with the examples: they are largely in Java, C++, or C. I would have liked some examples in older legacy-only languages, like COBOL.

But overall, this book is simply supurb, a tour de force of an important topic that has received little coverage before.
27 people found this helpful
Report
Reviewed in the United States on June 11, 2024
Refactorings in last chapter are heart of book. Much timeless advice here. The primary concept is that code without automated tests is legacy code. The book explains how to get code to be testable.

Top reviews from other countries

Translate all reviews to English
daniele
5.0 out of 5 stars amazing
Reviewed in Spain on May 12, 2024
great book
Siddharth Kothari
5.0 out of 5 stars Very helpful book
Reviewed in India on July 31, 2023
Amazing book. Must read after clean code books from uncle bob.
María d.
5.0 out of 5 stars Great!!!
Reviewed in Mexico on November 23, 2020
Llegó en excelentes condiciones. Y muy rápido también 😁
liouba2505
5.0 out of 5 stars Le cadeau original pour un geek anglophone
Reviewed in France on January 9, 2022
J'avoue, je n'aurais jamais eu l'idée d'offrir ce livre s'il ne m'avait pas été demandé. C'est une véritable bible pour les encodeurs a priori. Un beau pavé de 400 pages en anglais, il y a de quoi occuper quelque temps !
Reviewer
1.0 out of 5 stars This book is a reprinting of very low quality - beware!
Reviewed in Australia on January 12, 2024
The book arrived with "Printed in the United States of America" in the front, and "Manufactured by Amazon.com.au in Sydney" at the back. On my copy, the cover is misprinted, and the contents of the book include printing and typesetting issues which are not present in the genuine article, such as page titles being half cut off. This book is not a genuine copy of the book, it is a locally printed book which is of severely less quality than the genuine book.