- 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 (108 customer reviews)
- Amazon Best Sellers Rank: #18,033 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.
Prepare for your professional certification with study guides and exam prep tools from Wiley. See more
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.
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.
If you are wondering how can I make this app testable that is riddled with static methods and procedural code, then this is the book for you. If you are coming out of college and get stuck with some legacy code, this is the book for you.
This is easily in my top 5 software engineering books of all time. I feel like I could re-read it every couple of years. All software engineers should own this book.
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