Quantity:

More Buying Choices

41 used & new from �16.00

Have one to sell? Sell yours here

Working Effectively with Legacy Code (Robert C Martin)

See larger image

Share your own customer images

Publisher: learn how customers can search inside this book.

Working Effectively with Legacy Code (Robert C Martin) (Paperback)

by Michael Feathers (Author)

4.5 out of 5 stars See all reviews (4 customer reviews)

RRP:	�35.99
Price:	�17.98 & this item Delivered FREE in the UK with Super Saver Delivery. See details and conditions
You Save:	�18.01 (50%)
	o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o

In stock.
Dispatched from and sold by Amazon.co.uk. Gift-wrap available.

Want guaranteed delivery by Tuesday, November 10? Choose Express delivery at checkout. See Details

30 new from �16.99 11 used from �16.00

Frequently Bought Together

Customers Who Bought This Item Also Bought

Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin)

by Robert C. Martin

4.4 out of 5 stars (10) �13.99

Refactoring: Improving the Design of Existing Code (Object Technology Series)

by Martin Fowler

4.3 out of 5 stars (20) �22.77

Refactoring to Patterns (Addison-Wesley Signature)

by Joshua Kerievsky

4.7 out of 5 stars (6) �18.99

Test Driven Development (The Addison-Wesley Signature Series)

by Kent Beck

3.3 out of 5 stars (6) �11.49

xUnit Test Patterns: Refactoring Test Code (Addison Wesley Signature)

by Gerard Meszaros

3.5 out of 5 stars (2) �19.99

› Explore similar items

Product details

Paperback: 456 pages
Publisher: Prentice Hall (7 Oct 2004)
Language English
ISBN-10: 0131177052
ISBN-13: 978-0131177055
Product Dimensions: 23.4 x 17.5 x 3 cm

Average Customer Review: 4.5 out of 5 stars See all reviews (4 customer reviews)

Amazon.co.uk Sales Rank: 18,646 in Books (See Bestsellers in Books)

Popular in these categories:

#17 in	Books > Computing & Internet > Programming > Languages > C & C++
#20 in	Books > Computing & Internet > Software & Graphics > Software Design & Development
#20 in	Books > Computing & Internet > Computer Science > Software Design, Testing & Engineering

Would you like to update product info or give feedback on images?

See Complete Table of Contents

Customers Viewing This Page May Be Interested in These Sponsored Links

(What is this?)

C Code opens new browser window

www.Ask.com - Find the Best Results for C Code.

Product Description

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.

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.

See all Product Description

Tags Customers Associate with This Product

(What's this?)

Click on a tag to find related items, discussions, and people.

programming(1)

software development(1)

unit testing(1)

See all 4 tags...

What Do Customers Ultimately Buy After Viewing This Item?

	79% buy the item featured on this page: Working Effectively with Legacy Code (Robert C Martin) 4.5 out of 5 stars (4) �17.98
	12% buy Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin) 4.4 out of 5 stars (10) �13.99
	4% buy Domain-driven Design: Tackling Complexity in the Heart of Software 3.9 out of 5 stars (8) �18.99
	3% buy Refactoring: Improving the Design of Existing Code (Object Technology Series) 4.3 out of 5 stars (20) �22.77

Explore similar items

Customer Reviews

4 Reviews

5 star:		(2)
4 star:		(2)
3 star:		(0)
2 star:		(0)
1 star:		(0)

Average Customer Review

4.5 out of 5 stars (4 customer reviews)

Share your thoughts with other customers:

Create your own review

Most Helpful Customer Reviews

17 of 18 people found the following review helpful:

4.0 out of 5 stars practical and helpful advice on testing, 26 Feb 2006

By A Customer

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 Comment | Permalink | Was this review helpful to you? Yes No (Report this)

8 of 14 people found the following review helpful:

4.0 out of 5 stars A guide to retrofitting unit tests to existing code., 30 Dec 2005

By	"chriseyre2000" - See all my reviews

The books definiton of Legacy code is code not covered by unit tests.
This book covers adding unit tests to existing code.
It has a set of techniques for changing code so that it is more suitable to be covered by unit tests.

Comment Comment | Permalink | Was this review helpful to you? Yes No (Report this)

2 of 3 people found the following review helpful:

5.0 out of 5 stars A very useful book, 20 Sep 2008

By	Alan Lenton (London) - See all my reviews

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 Comment | Permalink | Was this review helpful to you? Yes No (Report this)

Share your thoughts with other customers: Create your own review

› See all 4 customer reviews...

Most Recent Customer Reviews

5.0 out of 5 stars 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

› See all 4 customer reviews...

.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; }