ou
Identifiez-vous pour activer la commande 1-Click.
ou
en essayant gratuitement Amazon Premium pendant 30 jours. Votre inscription aura lieu lors du passage de la commande. En savoir plus.
Plus de choix
Vous l'avez déjà ? Vendez votre exemplaire ici
Désolé, cet article n'est pas disponible en
Image non disponible pour la
couleur :
Image non disponible

 
Dites-le à l'éditeur :
J'aimerais lire ce livre sur Kindle !

Vous n'avez pas encore de Kindle ? Achetez-le ici ou téléchargez une application de lecture gratuite.

Working Effectively with Legacy Code [Anglais] [Broché]

Michael Feathers
4.7 étoiles sur 5  Voir tous les commentaires (3 commentaires client)
Prix : EUR 49,38 LIVRAISON GRATUITE En savoir plus.
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
Il ne reste plus que 3 exemplaire(s) en stock (d'autres exemplaires sont en cours d'acheminement).
Expédié et vendu par Amazon. Emballage cadeau disponible.
Voulez-vous le faire livrer le samedi 19 avril ? Choisissez la livraison en 1 jour ouvré sur votre bon de commande. En savoir plus.

Formats

Prix Amazon Neuf à partir de Occasion à partir de
Format Kindle EUR 16,58  
Broché EUR 49,38  

Description de l'ouvrage

22 septembre 2004

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.


Offres spéciales et liens associés


Produits fréquemment achetés ensemble

Working Effectively with Legacy Code + Refactoring: Improving the Design of Existing Code + Clean Code: A Handbook of Agile Software Craftsmanship
Acheter les articles sélectionnés ensemble


Descriptions du produit

Quatrième de couverture

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.

Biographie de l'auteur

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.


Détails sur le produit

  • Broché: 456 pages
  • Editeur : Prentice Hall; Édition : 1 (22 septembre 2004)
  • Langue : Anglais
  • ISBN-10: 0131177052
  • ISBN-13: 978-0131177055
  • Dimensions du produit: 23,1 x 17,5 x 2,5 cm
  • Moyenne des commentaires client : 4.7 étoiles sur 5  Voir tous les commentaires (3 commentaires client)
  • Classement des meilleures ventes d'Amazon: 13.756 en Livres anglais et étrangers (Voir les 100 premiers en Livres anglais et étrangers)
  • Table des matières complète
  •  Souhaitez-vous compléter ou améliorer les informations sur ce produit ? Ou faire modifier les images?


En savoir plus sur l'auteur

Découvrez des livres, informez-vous sur les écrivains, lisez des blogs d'auteurs et bien plus encore.

Dans ce livre (En savoir plus)
Parcourir les pages échantillon
Couverture | Copyright | Table des matières | Extrait | Index
Rechercher dans ce livre:

Quels sont les autres articles que les clients achètent après avoir regardé cet article?


Commentaires en ligne 

3 étoiles
0
2 étoiles
0
1 étoiles
0
4.7 étoiles sur 5
4.7 étoiles sur 5
Commentaires client les plus utiles
7 internautes sur 7 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Très utile pour apprendre à restructurer de 10 juillet 2008
Format:Broché
J'ai eu l'occasion de lire quelques articles ou livres sur le refactoring, mais quelque chose m'ennuyait dans les exemples donnés: le code à restructurer était soit de trop petite envergure, soit trop localisé, ou trop "idéal". Il s'agissait aussi de code relativement moderne, de projets assez jeunes.
Mais dans la pratique, il arrive qu'on doive maintenir, modifier et déboguer des projets datant de plusieurs années, à une époque où les pratiques de développement des programmeurs impliqués ou du département informatique étaient moins adaptées à la maintenance à long terme.
Ce type de code peut occasionner des prises de tête, et pour peu que le projet soit de taille importante, on en arrive vite à ne pas oser toucher certaines parties, à provoquer des bugs et effets de bords si on modifie sans vue d'ensemble suffisante du système, et surtout, d'après l'auteur... sans tests automatisés!
Voilà tout le problème, écrire des tests pour un code qui ne s'y prête pas, et qui devra donc être modifié dans le seul but d'être testé, pour pouvoir y apporter des modifications plus risquées, et enfin le restructurer pour augmenter son évolutivité.
Ce livre couvre cette problématique d'une belle manière, chaque chapitre étant consacré à un problème particulier (impossible de tester une classe, classe trop grande, où placer les tests utiles etc.), et en fin de livre de nombreuses techniques qui permettent de casser les dépendances entre classes, ce qui permet de les tester sans modifier le comportement de l'application.
Dommage que peu de livres aussi pratiques existent sur le sujet, et en français ils semblent malheureusement inexistants.
Avez-vous trouvé ce commentaire utile ?
1 internautes sur 1 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Où comment faire du neuf avec du vieux 21 décembre 2012
Format:Broché|Achat authentifié par Amazon
Le métier de développeur informatique consiste à maintenir d'anciens programmes et de temps en temps à en écrire de nouveaux flambant neufs. Et même dans la deuxième situation, il faut composer avec des dinosaures qui ne se laissent pas mourir.
Cet ouvrage est un recueil de bonnes pratiques qui améliorent beaucoup la qualité du travail autant que le confort du développement logiciel.
Si vous ne savez pas par quel bout traiter un bout de code écrit par d'autres, commencer par lire ce livre.
Il m'a été utile dès la première semaine où j'ai commencer à le lire, avis aux amateurs.
Avez-vous trouvé ce commentaire utile ?
Format:Broché|Achat authentifié par Amazon
Plein de bonne idées et de bon conseils. Avec des schémas uml, et du code en exemple.
Il vous permettra d'augmenter vos compétence en maintenance logiciel, et d'améliorer les programmes sur lesquels vous aurez à intervenir.
C'est un sujet sur lequel il y a peu d'ouvrages.
Bien sur il est en anglais, pas de version en français, mais en informatique l'anglais est obligatoire.
Il est bien organisé, facile à utiliser, efficace, on sent que les auteurs maitrise bien leur sujet.
Il est agréable en main.
C'est un bouquin que je recommanderais.
Avez-vous trouvé ce commentaire utile ?
Commentaires client les plus utiles sur Amazon.com (beta)
Amazon.com: 4.5 étoiles sur 5  64 commentaires
83 internautes sur 85 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 No more fairy-land 20 octobre 2004
Par Phlip - Publié sur Amazon.com
Format:Broché
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.
88 internautes sur 94 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 a wealth of practical information and solutions 13 octobre 2004
Par J.J. Langr - Publié sur Amazon.com
Format:Broché
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.
35 internautes sur 36 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 excellent reference and guide 11 novembre 2004
Par Jeanne Boyarsky - Publié sur Amazon.com
Format:Broché
"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.
74 internautes sur 85 ont trouvé ce commentaire utile 
2.0 étoiles sur 5 Not applicable for Large Legacy C applications 3 décembre 2009
Par David M. Boose - Publié sur Amazon.com
Format:Broché|Achat authentifié par Amazon
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.
23 internautes sur 26 ont trouvé ce commentaire utile 
4.0 étoiles sur 5 refactor and test 16 janvier 2005
Par W Boudville - Publié sur Amazon.com
Format:Broché
Feathers confronts a depressingly familiar problem encountered by many programmers. How to maintain a system of legacy code? Where often there has been no rigorous attempt to test it. Even in a manual fashion. He shows ways to build a test harness to automatically test the code. Even if this does not perform an exhaustive test, it may still be far in advance of what you already have (nothing?) to validate the code. He writes assuming that you might never have met a disciplined testing approach. So unit testing is carefully explained and he builds from there.

Simple, useful patterns like Decorator are described. The book is not meant as a comprehensive exposition of patterns. But hopefully, you can see the general idea of patterns and its utility. Large portions of the book are essentially about refactoring legacy code into these patterns, if possible. And also about testing your changes in a systematic way. If you do the former, you should also do the latter.

The examples are mostly in C++ and Java. But that's neither here nor there, if you program in other languages like C# or C. The ideas from the examples carry over well.
Ces commentaires ont-ils été utiles ?   Dites-le-nous
Rechercher des commentaires
Rechercher uniquement parmi les commentaires portant sur ce produit
ARRAY(0xaa55a438)

Discussions entre clients

Le forum concernant ce produit
Discussion Réponses Message le plus récent
Pas de discussions pour l'instant

Posez des questions, partagez votre opinion, gagnez en compréhension
Démarrer une nouvelle discussion
Thème:
Première publication:
Aller s'identifier
 

Rechercher parmi les discussions des clients
Rechercher dans toutes les discussions Amazon
   


Rechercher des articles similaires par rubrique


Commentaires

Souhaitez-vous compléter ou améliorer les informations sur ce produit ? Ou faire modifier les images?