|
||||||||||||||||||||
|
||||||||||||||||||||
|
||||||||||||||||||||
Working Effectively with Legacy Code
und über 1 Million weitere Bücher verfügbar für Amazon Kindle .
Erfahren Sie mehr
| ||||||||||||||||||
 Gutschein erhalten
Tauschen Sie jetzt Working Effectively with Legacy Code (Robert C. Martin) gegen einen Amazon-Gutschein in Höhe von EUR 14,85 ein - einlösbar für Tausende von Artikeln bei Amazon.de. Entdecken Sie mehr eintauschbare Bücher im Bücher Trade-In Shop. Bitte beachten Sie die Teilnahmebedingungen.
 Jetzt für Amazon Student anmelden und um 20% erhöhten Eintauschwert sichern. |
Wird oft zusammen gekauft
Produktinformation
Möchten Sie die Produktinformationen aktualisieren oder Feedback zu den Produktabbildungen geben?
Ist der Verkauf dieses Produkts für Sie nicht akzeptabel? |
Mehr über den Autor
Entdecken Sie Bücher, lesen Sie über Autoren und mehr
› Besuchen Sie die Seite von Michael C. Feathers auf Amazon
› Besuchen Sie die Seite von Michael C. Feathers auf Amazon
Produktbeschreibungen
Synopsis
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.
Buchrückseite
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.
Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?
In diesem Buch
(Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis
Tags, die Kunden mit diesem Produkt verbinden(Was ist das?)Klicken Sie zum Suchen verwandter Artikel, Diskussionen oder Personen auf ein Tag.
|
Kundenrezensionen
Die hilfreichsten Kundenrezensionen
11 von 11 Kunden fanden die folgende Rezension hilfreich
Format:Taschenbuch
Michael Feathers does a great job of introducing into the problems with legacy, untested code. He describes how to get difficult to test classes under test and have them refactored in order to improve your flexibility. The introduced practices are worthwhile to read, but sometimes you need to apply them to make sense of them.
Personally I liked the dependency breaking techniques and the seam theory in the book most. While reading through it, it got a bit hard to just read the book and don't practice anything related to the content. Make sure when buying and reading this book to plan in MUCH time to try things out.
Personally I liked the dependency breaking techniques and the seam theory in the book most. While reading through it, it got a bit hard to just read the book and don't practice anything related to the content. Make sure when buying and reading this book to plan in MUCH time to try things out.
7 von 7 Kunden fanden die folgende Rezension hilfreich
Format:Taschenbuch
The methods to tackle legacy code, to start putting code under tests by breaking dependencies, aren't new or exciting; most experienced developers probably know how subclassing and simple refactorings can gradually bring pieces of spaghetti code into a test harness. (I would recommend that junior developers first read up on the basics, like "Refactoring" by Martin Fowler, and any good introduction to object-oriented design principles.)
Nonetheless, Michael Feather's discussion of changes to the worst and most hopeless legacy implementations provides useful material, accompanied by much example code. Its main focus is on mainstream OO-languages like Java, but also covers specialties for C++, procedural code, and scripting languages.
This book has the potential to become a classic, like the "Refactoring" book. In my opinion, it falls slightly short of it due to poor editing. (I have the 10th printing from May-2009.) Mostly, it's just sloppy mistakes like mismatches of class names in the code and accompanying description, or wrong highlighting of changes in a refactoring step, which is just a bit irritating when following along. But I also mentally stumbled over sidebars that have little connection to the surrounding text. Some techniques are shown in excruciating detail, while others gloss over very interesting areas with just a short page.
Michael did a great job with this book, I just wished for some more polish. I wholeheartedly recommend it to anyone that has to deal with inherited or existing code (thus, virtually every programmer); even the experienced developer will take something away from it.
Nonetheless, Michael Feather's discussion of changes to the worst and most hopeless legacy implementations provides useful material, accompanied by much example code. Its main focus is on mainstream OO-languages like Java, but also covers specialties for C++, procedural code, and scripting languages.
This book has the potential to become a classic, like the "Refactoring" book. In my opinion, it falls slightly short of it due to poor editing. (I have the 10th printing from May-2009.) Mostly, it's just sloppy mistakes like mismatches of class names in the code and accompanying description, or wrong highlighting of changes in a refactoring step, which is just a bit irritating when following along. But I also mentally stumbled over sidebars that have little connection to the surrounding text. Some techniques are shown in excruciating detail, while others gloss over very interesting areas with just a short page.
Michael did a great job with this book, I just wished for some more polish. I wholeheartedly recommend it to anyone that has to deal with inherited or existing code (thus, virtually every programmer); even the experienced developer will take something away from it.
Format:Taschenbuch
Legacy code with long history and from many authors without development documentation has been the custom case in my work. I haven't practiced unit testing till yet. This book give advices how to extract more understandable parts from big classes or methods step by step.
Dilemma between "clean code" and necessity of including some concessions during testing has been mentioned. I would like to have discussion about introducing new parameters in extracted methods versus new member variables. (One of advices from the book "Clean Code" by Robert C. Martin)
Dilemma between "clean code" and necessity of including some concessions during testing has been mentioned. I would like to have discussion about introducing new parameters in extracted methods versus new member variables. (One of advices from the book "Clean Code" by Robert C. Martin)
Möchten Sie weitere Rezensionen zu diesem Artikel anzeigen?
Waren diese Rezensionen hilfreich?
Wir wollen von Ihnen hören.
Kunden diskutieren
|
Das Forum zu diesem Produkt
Fragen stellen, Meinungen austauschen, Einblicke gewinnen Aktive Diskussionen in ähnlichen Foren
Kundendiskussionen durchsuchen
|
Ähnliche Foren
|
||||||||||||||||||||||||||||||||||
Lieblingslisten
|
|
Ähnliche Artikel finden
Anhand des Sachgebietes nach ähnlichen Produkten suchen:
Ihr Kommentar
Möchten Sie die Produktinformationen aktualisieren oder Feedback zu den Produktabbildungen geben?
|
