Evergreen Scopri Toys Books Cloud Drive Photos CE Scopri Scopri Fire Shop Kindle Shop now Scopri Scopri Sport
Potrai iniziare a leggere Working Effectively with Legacy Code sul tuo Kindle tra meno di un minuto. Non possiedi un Kindle? Scopri Kindle Oppure inizia subito a leggere con un'applicazione di lettura Kindle gratuita.

Invia a Kindle o a un altro dispositivo


Prova gratis

Leggi gratuitamente l'inizio di questo eBook

Invia a Kindle o a un altro dispositivo

Ci dispiace. Questo articolo non è disponibile in
Immagine non disponibile per

Working Effectively with Legacy Code (Robert C. Martin Series) [Formato Kindle]

Michael Feathers
4.0 su 5 stelle  Visualizza tutte le recensioni (2 recensioni clienti)

Prezzo Copertina Ed. Cartacea: EUR 59,23
Prezzo Kindle: EUR 38,47 include IVA (dove applicabile) e il download wireless gratuito con Amazon Whispernet
Risparmi: EUR 20,76 (35%)

Applicazione di lettura per Kindle gratuita Grazie all'app Kindle GRATUITA per smartphone, tablet e computer, potrai leggere i libri Kindle, anche se non possiedi un dispositivo Kindle.

Per scaricare una app gratuita, inserisci l'indirizzo e-mail o il numero di cellulare.


Prezzo Amazon Nuovo a partire da Usato da
Formato Kindle EUR 38,47  
Copertina flessibile EUR 59,23  

Chi ha acquistato questo articolo ha acquistato anche

Pagina di Pagina iniziale
Questa funzione di acquisto consentirà di continuare a caricare gli articoli. Per accedere agli articoli non presenti su questo nastro trasportatore, utilizza il tasto di scelta rapida relativo alle intestazioni per accedere all'intestazione precedente o successiva.

Descrizione prodotto


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.

Dettagli prodotto

  • Formato: Formato Kindle
  • Dimensioni file: 4468 KB
  • Lunghezza stampa: 456
  • Utilizzo simultaneo di dispositivi: Fino a 5 dispositivi, per limite di editore
  • Editore: Prentice Hall; 1 edizione (22 settembre 2004)
  • Venduto da: Amazon Media EU S.à r.l.
  • Lingua: Inglese
  • ASIN: B005OYHF0A
  • Da testo a voce: Abilitato
  • X-Ray:
  • Word Wise: Non abilitato
  • Miglioramenti tipografici: Abilitato
  • Media recensioni: 4.0 su 5 stelle  Visualizza tutte le recensioni (2 recensioni clienti)
  • Posizione nella classifica Bestseller di Amazon: #117.612 a pagamento nel Kindle Store (Visualizza i Top 100 a pagamento nella categoria Kindle Store)

Recensioni clienti

5 stelle
3 stelle
2 stelle
1 stella
4.0 su 5 stelle
4.0 su 5 stelle
Le recensioni più utili
Formato:Copertina flessibile|Acquisto verificato
Forse il merito di questo testo e' quello di dar dei nomi a dei pattern da utilizzare per "attaccare" con un bel refactoring del codice legacy: e non e' poco.
Il fatto e' che se sviluppate da 15-20 anni e ve ne siete posti di domande su come modificare il codice esistente (e usate TDD), e' probabile che diventi un po' noioso perche' e' probabile conosciate gia' tutti i pattern indicati.
Questa recensione ti è stata utile?
Segnala un abuso
4.0 su 5 stelle Bella guida al codice "vecchio" 21 novembre 2013
Formato:Copertina flessibile
Un gran bel libro, da usare come guida e riferimento per gestire il codice obsoleto nell'ottica di modernizzarlo. Da far leggere a chi non vuole aggiornare il software.
Questa recensione ti è stata utile?
Segnala un abuso
Le recensioni clienti più utili su Amazon.com (beta)
Amazon.com: 4.6 su 5 stelle  92 recensioni
118 di 121 persone hanno trovato utile la seguente recensione
5.0 su 5 stelle No more fairy-land 20 ottobre 2004
Di Phlip - Pubblicato su Amazon.com
Formato:Copertina flessibile
The average book on Agile software development describes a fairyland of greenfield projects, with wall-to-wall tests that run after every few edits, and clean & simple source code.

The average software project, in our industry, was written under some aspect of code-and-fix, and without automated unit tests. And we can't just throw this code away; it represents a significant effort debugging and maintaining. It contains many latent requirements decisions. Just as Agile processes are incremental, Agile adoption must be incremental too. No more throwing away code just because it looked at us funny.

Mike begins his book with a very diplomatic definition of "Legacy". I'l skip ahead to the undiplomatic version: Legacy code is code without unit tests.

Before cleaning that code up, and before adding new features and removing bugs, such code must be de-legacified. It needs unit tests.

To add unit tests, you must change the code. To change the code, you need unit tests to show how safe your change was.

The core of the book is a cookbook of recipes to conduct various careful attacks. Each presents a particular problem, and a relatively safe way to migrate the code towards tests.

Code undergoing this migration will begin to experience the benefits of unit tests, and these benefits will incrementally make new tests easier to write. These efforts will make aspects of a legacy codebase easy to change.

It's an unfortunate commentary on the state of our programming industry how much we need this book.
99 di 106 persone hanno trovato utile la seguente recensione
5.0 su 5 stelle a wealth of practical information and solutions 13 ottobre 2004
Di J.J. Langr - Pubblicato su Amazon.com
Formato:Copertina flessibile
Martin Fowler's book on Refactoring showed us how to improve the design of our code. We learned to make changes safely, by taking small, rote steps, and by ensuring that we ran our tests after each small change. But what if we're working on the typical ugly system with no tests? In Working Effectively With Legacy Code, Michael Feathers tackles the problem that most of us end up dealing with.

Feathers does an excellent job of articulating the problems and scenarios, using clear examples from C, C++, Java, and C#. Many of the code examples look a lot like real examples I come across all the time--they don't appear to be fabricated.

Working Effectively With Legacy Code contains a catalog that provides a wealth of solutions. The catalog shows how to resolve concerns like, "I'm changing the same code all over the place" and "how do I safely change procedural code?"

The book is highly entertaining and comes across as a conversation with a really sharp, really patient guru developer. Often, it's a chore to slog through code-heavy books. But Feathers manages to keep my attention with interesting stories, loads of examples, and well-written text.

I think that Working Effectively With Legacy Code is an important book. The vast majority of existing code presents the classic catch-22: you can't change it safely because it doesn't have tests, and you can't write tests without changing it to easily support testing. It's not an easy problem, and most people will give you high-level ideas for solving it. Feathers is the first person to dig deep and present a wealth of knowledge and insight on the problem, all in one place. I'll be pulling this book from my shelf for years to come.
41 di 44 persone hanno trovato utile la seguente recensione
5.0 su 5 stelle excellent reference and guide 11 novembre 2004
Di Jeanne Boyarsky - Pubblicato su Amazon.com
Formato:Copertina flessibile
"Working Effectively with Legacy Code" is a very valuable resource. The author defines "legacy code" as "code without tests." It doesn't matter whether the code was written last week or ten years ago. There is more emphasis on old code that nobody understands, mainly because it is messier and harder to work with.

The examples in the book are mainly in C, C++ and Java, but there are a couple in C# and Ruby. While it is essential to know one of these languages, the author provides enough information to understand the others. When a technique only applies to a certain language, it is clearly indicated.

The author shows how different diagrams can help you learn how to understand code. In addition to UML, there are dependency and effect sketches. The author uses these to show how to think about understanding and refactoring. Other tools, such as refactoring browsers and mocks are explained.

Speaking of refactoring, there are "dependency breaking techniques" (aka refactorings) with step-by-step instructions (Martin Fowler style) throughout the book. There are also explanations of why patterns and design rules exist. Most importantly, there are lots and lots of cross-references and an excellent index.

Working with legacy code isn't fun, but this book helps make it as painless as possible. With the split emphasis between psychological/understanding/techniques and refactoring, this book is both a great read and an excellent reference.
100 di 114 persone hanno trovato utile la seguente recensione
2.0 su 5 stelle Not applicable for Large Legacy C applications 3 dicembre 2009
Di David M. Boose - Pubblicato su Amazon.com
Formato:Copertina flessibile|Acquisto verificato
I work at a decent sized telecommunications company. We have legacy code written in C that is over 1 million lines of code. Some of the code was written as far back as 1988. Needless to say, we didn't follow TDD and there are not a lot of unit tests. We have recently increase the number developers to add features to this code base and I was hoping that this book would help.

We've been doing a "techincal book club" for a while as part of continuous training. I've had about 20 engineers reading this book a few chapters a week and discussing them. Most of the reviews from the group have been negative. Hard to read, annoying editorial errors (duplicate text on following pages), and not really getting a lot out of it. The main problem is that our system is not using an object oriented language so a lot (most) of the techniques are not relevant.

At first I thought it was just me, but as I asked the other engineers, there was a lot of concensus, even from engineers that have worked on Java/C++ projects in the past.

I picked this book because of the following taglines on the back of the book:

* Techniques that can be used with any language or platform-with examples in Java, C++, C, and C#
* Coping with legacy systems that aren't object-oriented

There is one small section on non-object oriented code. It basically says that you should slowly migrate to an object oriented language.

Anyway - we've stopped reading the book. If you're code is already object oriented, this is probably a great book. If it's not, I wouldn't bother. Instead pick up a differnt book on how to migrate the code to an object oriented language.
16 di 17 persone hanno trovato utile la seguente recensione
5.0 su 5 stelle Pleasant to read and extremely practical. 27 luglio 2008
Di Andrew D. Conard - Pubblicato su Amazon.com
Formato:Copertina flessibile
I am an entry level software developer who has only been in the industry for a little over a year. While I was in college, I was always provided with very clean code bases to work with or analyze. I was in for a huge surprise when I entered the real world. The code I deal with every day at work is an extremely ugly mess. We have no automated tests. We are basically operating at CMMI level 0. There are no clear coding conventions of any kind. People just kind of band-aid things on top of other band-aids just to make the new changes work. We are basically in emergency mode every day because of all of the ugly side effects of global variables and functions. I was presented this book one day by my company news website. So I grabbed a copy and gave it a chance.

I was very satisfied with this book. I was expecting to start reading this and it would be like one of those GoF (Gang of Four) or Martin Fowler books that already assume that your code is already written fairly well in the first place. The reality is, like others have said here, is that most companies you will work for will just not have the prettiest code base in the world. The book's content is fabulous and I can see this being one of the key books on my desk every day. I absolutely love how pragmatic Michael Feathers is. I like how he continuously explains the concept that sometimes the code might look uglier or awkward in order to get it under test. I always thought the design pattern books were just a bit over the top. Michael is not like that. He provides examples you probably run into everyday and provides succinct steps for getting it under test.

The only gripe that I have with this book is the overwhelming amount of publishing errors throughout the book. Sometimes, a word is skipped in a sentence or the wrong word is obviously used. There was one point in the book I recall where it seemed like it was missing the ending of a sentence or something. I think if Michael ever wants another edition of this book then he ought to hire someone new that will catch all of these little glitches and correct them. They were a bit annoying at times. Also, like someone else said, it would've been nice to see some examples of really old code in COBOL or FORTRAN even.

Otherwise, it is easy to read this book and you'll get through it fairly quickly. There have been some technical books I have read where I just couldn't read it all the way through because of how utterly boring it was. Michael keeps you entertained with some rather interesting concepts and stories. I also like the way he formatted the book in general. I like how many of the chapters in the book are titled by some problem like "These API Calls Are Killing Me!" However, the last chapter called "Refactoring" was a bit vague and odd to me especially since all it discussed was his infamous "Extract Method" refactoring.

I really wish all of the developers on this team would read this book. They really need to. We need to stop this game of changing and guessing whether it worked. You just cannot do that with software unless it is very small. Any software engineer should have this book on their desk.
Ricerca recensioni cliente

Ricerca articoli simili per categoria