EUR 63,80
  • Tutti i prezzi includono l'IVA.
Disponibilità immediata.
Venduto e spedito da Amazon. Confezione regalo disponibile.
Working Effectively With ... è stato aggiunto al tuo carrello
Ne hai uno da vendere?
Passa al retro Passa al fronte
Ascolta Riproduzione in corso... In pausa   Stai ascoltando un campione dell'edizione audio udibile.
Maggiori informazioni
Visualizza tutte le 3 immagini

Working Effectively With Legacy Code (Inglese) Copertina flessibile – 30 nov 2004

4.0 su 5 stelle 2 recensioni clienti

Visualizza tutti i 3 formati e le edizioni Nascondi altri formati ed edizioni
Prezzo Amazon
Nuovo a partire da Usato da
Formato Kindle
"Ti preghiamo di riprovare"
Copertina flessibile
"Ti preghiamo di riprovare"
EUR 63,80
EUR 56,92 EUR 74,77
Nota: Questo articolo può essere consegnato in un punto di ritiro. Dettagli
Ritira il tuo ordine dove e quando preferisci.
  • Scegli tra gli oltre 8.500 punti di ritiro in Italia
  • I clienti Prime beneficiano di consegne illimitate presso i punti di ritiro senza costi aggiuntivi
Come inviare un ordine presso un punto di ritiro Amazon.
  1. Trova il tuo punto di ritiro preferito ed aggiungilo alla tua rubrica degli indirizzi
  2. Indica il punto di ritiro in cui vuoi ricevere il tuo ordine nella pagina di conferma d’ordine
Maggiori informazioni
click to open popover

Spesso comprati insieme

  • Working Effectively With Legacy Code
  • +
  • Clean Code: A Handbook of Agile Software Craftsmanship
Prezzo totale: EUR 92,07
Acquista tutti gli articoli selezionati

Descrizione prodotto

Dalla quarta di copertina

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.

© Copyright Pearson Education. All rights reserved.


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.

Non è necessario possedere un dispositivo Kindle. Scarica una delle app Kindle gratuite per iniziare a leggere i libri Kindle sul tuo smartphone, tablet e computer.

  • Apple
  • Android
  • Windows Phone

Per scaricare una app gratuita, inserisci il numero di cellulare.

Dettagli prodotto

  • Copertina flessibile: 434 pagine
  • Editore: Prentice Hall; 01 edizione (30 novembre 2004)
  • Collana: Robert C Martin
  • Lingua: Inglese
  • ISBN-10: 0131177052
  • ISBN-13: 978-0131177055
  • Peso di spedizione: 699 g
  • Media recensioni: 4.0 su 5 stelle  Visualizza tutte le recensioni (2 recensioni clienti)
  • Posizione nella classifica Bestseller di Amazon:
  • Visualizza indice completo
  • Garanzia e recesso: Se vuoi restituire un prodotto entro 30 giorni dal ricevimento perché hai cambiato idea, consulta la nostra pagina d'aiuto sul Diritto di Recesso. Se hai ricevuto un prodotto difettoso o danneggiato consulta la nostra pagina d'aiuto sulla Garanzia Legale. Per informazioni specifiche sugli acquisti effettuati su Marketplace consultaMaggiori informazioni la nostra pagina d'aiuto su Resi e rimborsi per articoli Marketplace.

    Se sei un venditore per questo prodotto, desideri suggerire aggiornamenti tramite il supporto venditore?

Quali altri articoli acquistano i clienti, dopo aver visualizzato questo articolo?

Recensioni clienti

4.0 su 5 stelle
5 stelle
4 stelle
3 stelle
2 stelle
1 stella
Consulta entrambe le recensioni cliente
Condividi la tua opinione con altri clienti

Principali recensioni dei clienti

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.
Commento 2 persone l'hanno trovato utile. Questa recensione ti è stata utile? No Invio feedback...
Grazie del feedback.
Spiacenti, non siamo stati in grado di registrare il voto. Provare di nuovo.
Segnala un abuso
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.
Commento Questa recensione ti è stata utile? No Invio feedback...
Grazie del feedback.
Spiacenti, non siamo stati in grado di registrare il voto. Provare di nuovo.
Segnala un abuso

Le recensioni clienti più utili su (beta) 4.5 su 5 stelle 107 recensioni
5 di 5 persone hanno trovato utile la seguente recensione
5.0 su 5 stelle Top 10 technical software engineering books of all time 13 dicembre 2015
Di Joshua McKinney - Pubblicato su
Formato: Formato Kindle Acquisto verificato
I don't write reviews all that often, but when I saw this book at 58 on a top 100 best software engineering books list (based somewhat on Amazon reviews), I had to add this review to push this a little higher. In my opinion, this is one of the top 10 technical software books of all time. It should be recommended reading for software graduates (and mandatory reading for those senior engineers that 'maintain' legacy code bases)
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.
3 di 3 persone hanno trovato utile la seguente recensione
5.0 su 5 stelle Practical, Realistic, and focuses on what can be done now 1 febbraio 2016
Di Clint Cooper Vrazel - Pubblicato su
Formato: Formato Kindle Acquisto verificato
The book is one of the rare books I've read that has an ideal vision for programming and design that also starts with a realistic view of the true day-to-day of a some developers: stumbling through old code written to changing demands and fix bugs, needing assurance that one's changes don't break existing functionality without laborious and time-consuming investigation and ad hoc testing.

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.
3 di 3 persone hanno trovato utile la seguente recensione
5.0 su 5 stelle We don't build software so much as grow it. Here's how to weed and prune. 8 maggio 2015
Di Lance Zant - Pubblicato su
Formato: Formato Kindle Acquisto verificato
A real eye-opener. I will be re-reading this one very soon. To start with, defining "legacy code" so concisely as, "code without tests" is brilliant. Of course there are many other characteristics, but they all turn out to be derivative from that focal point. From there, the general direction is obvious - what are the safest and fewest things we can do to bring the code under test, because once we have tests all our refactoring weapons come into play.

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.
6 di 7 persone hanno trovato utile la seguente recensione
4.0 su 5 stelle What exactly do YOU mean by Legacy Code? Ask yourself before buying this book! 27 aprile 2016
Di Amazon Customer - Pubblicato su
Formato: Copertina flessibile Acquisto verificato
A very good book, but whether it's useful to you or not, or how useful it is to you will largely depend on what kind of code you need to work with. If you have some code that lacks tests, that was once nicely designed but slowly deteriorated to a mess, then this book is for you! If it's code that was written by someone who lacked experience and/or knowledge, but still did their best, then this book is probably for you too. But if your code was a mess to begin with because nobody bothered to design it in the first place, then this book is of limited use.

Once I had to work with a program that consisted of one huge class. About 6000 lines of code, hundreds of variables. What kind of dependency breaking techniques would you use on a program that has no dependencies because it has no components? How would you deal with three almost identical tabs in the GUI, which don't correspond to instances of one class, but rather to subsets of fields named like "button1", "textField1" (first tab), "button2", "textField2" (second tab)? How would you go about refactoring code that uses fields to pass data from one method to another? How do you work with code that excessively abuses macros in C/C++, like "#define true false" or "#define begin {" / "#define end }"? And how on Earth would you work with a program that has three global variables named L, LL and LLL that are used for dozens of similar yet slightly different purposes throughout the codebase? This book has no answers. But then again, I suspects that nobody does.

This book is mainly about refactoring messy but refactorable code in the least risky way just to get enough test to be able to change more. It's an excellent book as far as this narrow topic goes, but don't expect it to be much more than that.
5.0 su 5 stelle One of the best software engineering books of all time! 22 giugno 2016
Di Keith P. - Pubblicato su
Formato: Copertina flessibile Acquisto verificato
This is one of the best books that I have ever read. Some of it seems really simple, but the way Feathers articulates it is pretty amazing. He takes fairly complex problems and shows ways to make legacy code testable. It is also a great guide about SOLID, OOP and many other things. If you understand SOLID principles, then you truly understand OOD. I have met many very high level architects software engineers that didn't understand SOLID. This book is the best guide ever written (that I have read) on how to apply the SOLID principles to real code.

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.

Ricerca articoli simili per categoria