- Paperback: 456 pages
- Publisher: Prentice Hall; 1 edition (October 2, 2004)
- Language: English
- ISBN-10: 0131177052
- ISBN-13: 978-0131177055
- Product Dimensions: 7 x 1.2 x 9.2 inches
- Shipping Weight: 1.5 pounds (View shipping rates and policies)
- Average Customer Review: 4.5 out of 5 stars See all reviews (110 customer reviews)
- Amazon Best Sellers Rank: #16,304 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Working Effectively with Legacy Code 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
Frequently bought together
Customers who bought this item also bought
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 platformwith 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.
Browse award-winning titles. See more
If you are a seller for this product, would you like to suggest updates through seller support?
Top Customer Reviews
Feathers covers the topics of why, and how to deal with code that is difficult to change with a variety of useful patterns. Most useful of these is the legacy code change algorithm:
1. identify the change points
2. find test points
3. break dependencies
4. write tests
5. make changes and refactor
This book will make you a better developer.
Now, the only downside of this book is that the examples covering several different languages can sometimes obscure the teaching of the narrative. Perhaps in a future edition it would be nice to see a single language (or a couple) and have extra resources available in the electronic versions or websites to cover other languages. To me, this did not represent something worth dropping this from a 5 star review. I gave my physical copy away long ago and repurchased a second copy on the kindle.
Michael Feathers does a great job of modelling his mindset, choices, and techniques through short example case studies. Nothing is presented as dogma, and many cases are followed to see the effects of different techniques to solve the same problem.
Many of the techniques to get code into a testable form are just best practice or are similar to a Design Pattern, but a key strength of this book is making getting from here to there within reach. Clients and superiors want code that works, and the testing and incremental approach that Michael advocates provides the net for safely and confidently making the transition to less tightly-coupled, more modular, understandable, and verified code from the time-tested battle-worn code many of us call home.
Even better, Michael's approach destroys the "design vs just maintenance" dichotomy, as it satisfies that little voice to start making improvements we've been putting off when we get our code in testable form.
I hope my department picks this up, and that we all start leaving the code a little better than we found it.
The only flaw in this book is: It doesn't go far enough. I've now been working for 1+yr with a 20+yr old C++ code base (that's still responsible for over $1B revenue a year, runs on over 1500 servers, handles well over 100000 requests/min in total). I read this book in the first couple of weeks and thought "yeah, ok, but things can't possibly be that bad".
Well, now I know better. They're worse.
This book can help you _a lot_ with the technical aspects of working with legacy code - but some things (esp. long-standing company processes) just can't be fixed by mortal man. So you need a good attitude (including a good sense of humor) as well. Working with good colleagues also helps. But definitely read this book and use its lessons in practice.
Some of Michael's techniques are old friends that I never thought to use in this way. Others were things I didn't realize I knew at all, and others were totally new to me. What they all had in common was that they offer a wealth of approaches to incrementally improve a tough situation, both to accomplish the immediate task and to prepare for further improvements later. This pay-as-you go alternative is both more effective and less risky than either of the extremes of doing nothing or large-scale replacement.
Another strength of the book is that Mr. Feathers provides examples in several languages, mostly Java and C++, but also Ruby and some others. This variety is very helpful for deepening our understanding of both the problems and the solutions.
Most Recent Customer Reviews
the signatories of the Agile manifesto (Robert Martin, Martin Fowler
or Kent Beck, to name a few)...Read more
minus one star since there are a lot of places that the words / paragraph just missing.Read more