Facebook Twitter Pinterest
  • Alle Preisangaben inkl. MwSt.
Auf Lager.
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Menge:1
Working Effectively with ... ist in Ihrem Einkaufwagen hinzugefügt worden
Gebraucht: Sehr gut | Details
Verkauft von Warehouse Deals
Zustand: Gebraucht: Sehr gut
Kommentar: Gebrauchsspuren. Schrumpffolie fehlt, Aktivierungscodes für Online-Bonusinhalte können fehlen bzw. abgelaufen sein. Kleine Falte oder kleiner Knick auf der Vorderseite. Kleine Falte oder kleiner Knick auf der Rückseite. Kleine Falte oder kleiner Knick am Buchrücken. Kleine Falte oder kleiner Knick auf den Seiten. Amazon-Kundenservice und Rücknahmegarantie (bis zu 30 Tagen) bei jedem Kauf.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Hörprobe Wird gespielt... Angehalten   Sie hören eine Hörprobe des Audible Hörbuch-Downloads.
Mehr erfahren
Alle 3 Bilder anzeigen

Working Effectively with Legacy Code (Robert C. Martin ) (Englisch) Taschenbuch – 2013

4.6 von 5 Sternen 9 Kundenrezensionen

Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Preis
Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
Taschenbuch
"Bitte wiederholen"
EUR 46,95
EUR 32,83 EUR 26,60
74 neu ab EUR 32,83 10 gebraucht ab EUR 26,60
click to open popover

Wird oft zusammen gekauft

  • Working Effectively with Legacy Code (Robert C. Martin )
  • +
  • Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin)
  • +
  • Refactoring: Improving the Design of Existing Code (Object Technology Series)
Gesamtpreis: EUR 122,99
Die ausgewählten Artikel zusammen kaufen

Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.

  • Apple
  • Android
  • Windows Phone

Geben Sie Ihre Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.

Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.



Produktinformation

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 platformwith 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.
(c) Copyright Pearson Education. All rights reserved."

Alle Produktbeschreibungen

Kundenrezensionen

4.6 von 5 Sternen
Sagen Sie Ihre Meinung zu diesem Artikel

Top-Kundenrezensionen

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.
Kommentar 12 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden
Format: Taschenbuch Verifizierter Kauf
Man merkt, dass der Autor jahrelange Erfahrung hat mit der Beherrschung von "Legacy Code". Die Knackpunkte und das Vorgehen bei der Wartung/Erweiterung von legacy code sind konkret und kompakt dargestellt. Die Struktur des Buches orientiert sich zudem an den typischen Fragestellungen in diesem Kontext, z.B. wie man Änderungen an großen und/oder komplexen Methoden durchführt, ohne die bestehende Funktionalität zu zerstören. Oder wie man Unit-Tests in eng gekoppelten Komponenten einführt. Probleme, denen sich viele Entwickler gegenüber sehen, die an produktiven Anwendungen Änderungen oder Erweiterungen vornehmen sollen. Die einzelnen Kapitel des Buches sind an derartigen konkreten Fragen orientiert, was die Suche sehr erleichtert und das Lesen von vorne bis hinten überflüssig macht. Dieses Buch sollte an keinem Entwicklerarbeitsplatz fehlen!
Kommentar 6 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden
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.
Kommentar 11 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden
Format: Taschenbuch
This is a fascinating book. It really changed my outlook on unit testing. Previously, I had been under the impression that unit testing is something dogmatic. But the way the author approaches it is really eye-opening. For me, the most important part of the book is the philosophy how to go about testing legacy code. The technical part is also well-founded and all, but it was the philosophical aspect that really made me go "wow".
Kommentar 4 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden
Von Dooing am 6. Januar 2014
Format: Taschenbuch Verifizierter Kauf
Zunächst - ich bin ein großer Fan von Robert C. - Uncle Bob - Martin. Der Autor arbeitet für und mit Uncle Bob, ist selbst eine ähnlich große Legende, das Buch prinzipiell kein schlechtes Buch.
ABER:
Feathers Buch ist leider nicht so gut strukturiert und unterhaltsam, prägnant und korrekt geschrieben, wie ich das von seinem Mentor Uncle Bob gewohnt bin. Er schreibt, es sei kein Buch über Testing oder Test Driven Development. Auch sei die schlechte Code Qualität zu "entschuldigen", es wäre auch kein Buch über gute Codequalität. Design Patterns werden immer wieder kurz angerissen, aber, ihr ahnt es, es wird wieder auf die einschlägige Fachliteratur verwiesen. Das Buch soll nicht von vorne nach hinten, sondern im Querverweis Schema im Stile des Internets gelesen werden - dafür kaufe ich mir aber dann doch kein Buch? Zumindest mir persönlich sagen "lineare Bücher" mehr zu.
Die meisten Codebeispiele sind in Java gehalten, aber es gib auch einige Beispiele in C++, C und sogar ein Codebeispiel in Ruby. Auf mich wirkte das, als ob der Autor versucht, damit die Anzahl potentieller Leser und damit die Verkaufszahlen zu erhöhen. Die Codebeispiele gingen dabei oft auf jeweilige Besonderheiten der Sprache ein, und sind dadurch (was für mich relevant wäre) oft nicht auf Java übertragbar (weil z.B. aufgrund modernerer Syntax in Java gar nicht mehr nötig).
In dem Buch, das 2005 erschienen ist, wird in erster Linie gezeigt, wie man (ohne Mocking-Framworks) Legacy Code testbar machen kann, damit man dann im Anschluss (!) den Code optimieren kann – wobei dann aber größtenteils auf andere Bücher wie von Martin Fowler verwiesen wird.
Lesen Sie weiter... ›
Kommentar 15 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden