Start reading Working Effectively with Legacy Code on your Kindle in under a minute. Don't have a Kindle? Get your Kindle here.

Try it free

Read books on your computer or other mobile devices with our FREE Kindle Reading Apps.

Share your own customer images

Working Effectively with Legacy Code [Kindle Edition]

Michael Feathers (Author)

4.2 out of 5 stars See all reviews (10 customer reviews) |

Digital List Price:	�24.71 What's this?
Print List Price:	�40.99
Kindle Price:	�18.47 includes VAT* & free wireless delivery via *Amazon Whispernet*
You Save:	�22.52 (55%)
Unlike print books, digital books are subject to VAT.

Length: 456 pages
Don't have a Kindle? Get your Kindle here.

	Amazon Price	New from	Used from
Kindle Edition	�18.47	--	--
Paperback	�34.84	--	--
Show # more paperbacks
Show fewer paperbacks

Customers Who Bought This Item Also Bought

Growing Object-Oriented Software, Guided by Tests by Steve Freeman
4.9 out of 5 stars (16)

�19.42
Design Patterns: Elements of Reusable Object-Orien... by Erich Gamma
4.6 out of 5 stars (51)

�19.98
The Clean Coder: A Code of Conduct for Profes... by Robert C. Martin
4.0 out of 5 stars (8)

�17.25
Kanban by David J. Anderson
4.6 out of 5 stars (7)

�12.83
Clean Code: A Handbook of Agile Software Craf... by Robert C. Martin
4.2 out of 5 stars (28)

�20.22
Domain-Driven Design: Tackling Complexity in the He... by Eric Evans
4.0 out of 5 stars (12)

�22.24

Product Description

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.

From the Back Cover

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

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.

See all Product Description

Product details

Format: Kindle Edition
File Size: 2132 KB
Print Length: 456 pages
Publisher: Prentice Hall; 1 edition (22 Sep 2004)
Sold by: Amazon Media EU S.� r.l.
Language English
ASIN: B005OYHF0A
Text-to-Speech: Enabled

Average Customer Review: 4.2 out of 5 stars See all reviews (10 customer reviews)

Amazon Bestsellers Rank: #104,849 Paid in Kindle Store (See Top 100 Paid in Kindle Store)

Would you like to give feedback on images?

More About the Author

Discover books, learn about writers, and more.

› Visit Amazon's Michael C. Feathers Page

What Other Items Do Customers Buy After Viewing This Item?

Growing Object-Oriented Software, Guided by Tests by Steve Freeman Kindle Edition
4.9 out of 5 stars (16)

�19.42

› Explore similar items

Tag this product

(What's this?)

Think of a tag as a keyword or label you consider is strongly related to this product.
Tags will help all customers organise and find favourite items.

Customer Reviews

2 star

4.2 out of 5 stars

Write a customer review

Most Helpful Customer Reviews

23 of 24 people found the following review helpful

practical and helpful advice on testing 26 Feb 2006

By A Customer

Format:Paperback

This book focuses on how best to treat existing, large and probably poorly designed code, when needing to add features. This is most likely to happen when you have big old code that needs maintaining, but a lot of the advice is directly applicable to open source projects that lack tests and documentation. Therefore this can be considered as a valuable addition to the literature on testing and refactoring.

The advocated approach is rooted in writing unit tests and refactoring. Each chapter is themed around a problem (e.g. "Dependencies on Libraries is Killing Me", "I Don't Understand the Code Well Enough to Change It"), and then a series of techniques are suggested. At the back of the book are a series of refactorings, specifically for dealing with large classes, with some platform specific approaches, such as C++ forbidding the use of virtual functions that resolve to subclasses in constructors.

The code is mainly in Java, with a large number of examples in C++, and a handful in C and C#. You can probably get by with just knowing Java.

To get the most out of this book, I would suggest having read Martin Fowler's Refactoring first. It would also help to be familiar with the JUnit Java testing framework, which is used for the testing examples throughout. If you don't already know JUnit, you can pick up enough knowledge from the many articles on the web, and you certainly don't need to have read a book on Test Driven Development.

A reasonable measure of the quality of a book such as this is if it changes the way you code. It did so for me, and I recommend this as another high quality book in the Robert C. Martin series.

Comment |

Was this review helpful to you?

Yes

6 of 7 people found the following review helpful

Excellent! 4 Dec 2009

By Anders Juul Larsen

Format:Paperback

I attended Feathers' speach at JAOO this year and was highly motivated to work with legacy code - I really wanted to try out all the presented techniques! I wished for the next contract to be a legacy project, and lo and behold, wishes do come true.

Given that, I was highly motivated when my copy arrived in the mail and ate it in three healthy bites - not leaving too much time to sleep when you have a wife and two small kids that you want to see too!

MF starts by stating that 'good code is code under test'.

The highligt is to some extend the 20-something page introduction. MF manages to set the arena for working with legacy code and pass on the enthusiasm of getting a job done on difficult terms. I mean, if you can be a success with green field projects, thats fine, but how well do you cope with legacy code?

Following that is a rather lengthy catalog of ways to get code under test. Much of the time you'd nod and say, yes, I've seen mess like this before - so that is how I could have dealt with it!

Having had the time to try to work by the principles, I'd summarize that the book has given me a professional lift. Many a time, I'd have to bypass the good advice due to pressure to produce short-term results, but over-all I'd say that more and more of the 'tricks' gets used and with good results.

Highly reccommended!
Anders, M.Comp.Sc., Contractor, Denmark

Comment |

Was this review helpful to you?

Yes

8 of 10 people found the following review helpful

A very useful book 20 Sep 2008

By Alan Lenton

Format:Paperback|Amazon Verified Purchase

The biggest single problem I had when I moved from working for myself as a programmer back to the mainstream was dealing with other people's code. For nearly twenty years I only had to deal with my own code. Suddenly I had to understand and change other people's code. It was quite a culture shock, and one of the most difficult things I've done.

I wish I'd found Michael's book earlier, it would have helped ease the transition. Of course, not everyone else's code is legacy code, but even if you are not handling true 'legacy' code, this book will help you deal with the problems you face.

The book is in three parts. The first is a discussion of how you go about changing software that is badly structured and has complex interactions and side effects. Where do you start, and how do you make sure that you don't break things further down the convoluted chain of dependencies. The answer to the latter, of course, is testing, testing, testing, and the author makes a good enough case to persuade even the most sloth like to get into the testing mode.

The second part of the book is organised almost like an FAQ with chapters devoted to common problems like 'I don't understand the code well enough to change it'. This one crops up all too often, and is an excellent example of how the author doesn't avoid difficult questions. The final part of the book is a useful catalog of mostly pattern based techniques that can be used to break dependencies.

The book is well written and features clear examples that are written in either C++, Java, C and C#, and the problems caused by the different features, or lack of them, available to the different languages are discussed and work arounds suggested. I enjoyed reading this book.

Highly recommended!

Comment |

Was this review helpful to you?

Yes

› See all 10 customer reviews on Amazon.co.uk

Write a customer review

Would you like to see more reviews about this item?

› Go to Amazon.com to see all 42 reviews

Were these reviews helpful? Let us know

Most Recent Customer Reviews

Good but limited

It is essentially another refactoring book. It largely assumes you will work with code written fairly recently in a modern language and to which you can apply automated unit... Read more

Published 12 months ago by D. Murphy

This isn't "legacy" code!

The author claims that "legacy" code is composed of C++, Java, and C# code bases. Well...maybe if you were born only twenty years ago that might seem like legacy code. Read more

Published 15 months ago by Michael E. Piazza

Legacy Code

This was bought as a present for a friend who was very impressed with it and found it really interesting and useful.

Published 17 months ago by Christine Davis

Extremely useful!

This is definitely one of those books that I will continuously refer to when faced with the task of maintaining legacy software. It has a permanent place on my reference shelf! Read more

Published on 21 April 2010 by David JM Emmett

Standard Text

I have a few (5 or so) programming books that I hold in very high regards. This is one of them. I intend to keep this one close to hand. Read more

Published on 20 Feb 2010 by O. Arnold

Excellent book

Got the book after attending one of the authors presentations. Excellent advice on how to apply TDD to existing code. Read more

Published on 21 May 2006 by Mr. S. P. Bracken

A guide to retrofitting unit tests to existing code.

The books definiton of Legacy code is code not covered by unit tests.
This book covers adding unit tests to existing code. Read more

Published on 30 Dec 2005 by "chriseyre2000"

Popular Highlights

(What's this?)

A test is not a unit test if: 1. It talks to a database. 2. It communicates across a network. 3. It touches the file system. 4. You have to do special things to your environment (such as editing configuration files) to run it. &quote;

Highlighted by 24 Kindle users

When you have to make a change in a legacy code base, here is an algorithm you can use. 1. Identify change points. 2. Find test points. 3. Break dependencies. 4. Write tests. 5. Make changes and refactor. &quote;

Highlighted by 23 Kindle users

Dependency is one of the most critical problems in software development. Much legacy code work involves breaking dependencies so that change can be easier. &quote;

Highlighted by 19 Kindle users

.jsOffDisplayBlock { display: block; } .jsOffDisplayInline { display: inline; } .jsOffVisibility { visibility: visible; } .jsOnDisplayBlock { display: none; } .jsOnDisplayNoneBlock { display: block; } .jsOnDisplayNoneInline { display: inline; } .jsOnDisplayInline { display: none; } .jsOnVisibility { visibility: hidden; } .jqOnDisplayBlock { display: none; } .jqOnDisplayInline { display: none; } .jqOnVisibility { visibility: hidden; } .jqOnDisplayNoneBlock { display: block; } .jqOnDisplayNoneInline { display: inline; }