Potrai iniziare a leggere Working Effectively with Legacy Code sul tuo Kindle tra meno di un minuto. Non possiedi un Kindle? Scopri Kindle.

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

Leggi gli eBook sul computer o altri dispositivi portatili con le Applicazioni di lettura Kindle gratuite.
Working Effectively with Legacy Code
 
Visualizza l'immagine in formato grande 
Condividi le tue immagini cliente

Working Effectively with Legacy Code [Formato Kindle]

Michael Feathers (Autore)
Prezzo edizione digitale: EUR 30,85 Cos'è?
Prezzo Copertina Ed. Cartacea: EUR 52,99
Prezzo Kindle: EUR 17,40 include IVA (dove applicabile) e il download wireless gratuito con Amazon Whispernet
Risparmi: EUR 35,59 (67%)

Formati

 Prezzo Amazon Nuovo a partire da Usato da
Formato Kindle EUR 17,40   -- --
Brossura EUR 20,47   -- --
Scopri come risparmiare fino all'80% su un titolo diverso ogni giorno
Iscriviti alla Newsletter dell'offerta lampo Kindle per ricevere direttamente nella tua casella di posta elettronica l'e-mail con l'offerta del giorno e non perdere nemmeno un titolo in promozione. Scopri di più

Chi ha acquistato questo articolo ha acquistato anche

Descrizione prodotto

Sinossi

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: 2610 KB
  • Lunghezza stampa: 456
  • Utilizzo simultaneo di dispositivi: Fino a 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: Non abilitato
  • Posizione nella classifica Bestseller di Amazon: #31.171 a pagamento nel Kindle Store (Visualizza i Top 100 a pagamento nella categoria Kindle Store)

Recensioni clienti

Non ci sono ancora recensioni di clienti su Amazon.it
5 stelle
4 stelle
3 stelle
2 stelle
1 stella
Le recensioni clienti più utili su Amazon.com (beta)
Amazon.com: 4.5 su 5 stelle  52 recensioni
58 di 59 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:Brossura
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.
82 di 88 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:Brossura
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.
33 di 34 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:Brossura
"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.

I più evidenziati

 (Cos'è?)
&quote;
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;
Evidenziato da 24 utenti Kindle
&quote;
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;
Evidenziato da 23 utenti Kindle
&quote;
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;
Evidenziato da 19 utenti Kindle

I clienti che hanno evidenziato questo articolo hanno evidenziato anche

Discussioni clienti

Forum su questo prodotto
Discussione Risposte Ultimo post
Nessuna discussione

Poni domande, condividi opinioni, raccogli informazioni
Inizia una nuova discussione
Argomento:
Primo post:
Dovrai effettuare l'accesso
 

   

Ricerca articoli simili per categoria


Al momento, è presente un problema nel caricamento di questo menu.

Ulteriori informazioni su Amazon Prime.

    Il tuo Carrello è vuoto.

    Naviga su Amazon.it e riempi il tuo carrello di libri, DVD, elettronica e molto altro ancora.

    Se già disponi di un account, accedi.

    Al momento non è possibile visualizzare un'anteprima del tuo carrello.

    Controlla la tua connessione Internet e vai al tuo carrello, oppure prova di nuovo.

    Vai al carrello (0 articoli)