Download Refactoring to Patterns, by Joshua Kerievsky
Das Nachdenken über das Buch Refactoring To Patterns, By Joshua Kerievsky zur Bewertung ist ebenfalls erforderlich. Sie können das Buch wählen auf den bevorzugten Arten basieren , die Sie mögen. Es wird Sie beinhaltet verschiedene andere Publikationen Refactoring To Patterns, By Joshua Kerievsky Es kann über die Anforderung zusätzlich gerne lesen , dass Sie das Buch zu überprüfen , verpflichtet. Da diese Refactoring To Patterns, By Joshua Kerievsky, könnten Sie es als Ihre Lesung Veröffentlichung lokalisieren, auch Ihr bevorzugtes Lesebuch. Also, suchen Sie Ihre bevorzugte Veröffentlichung hier und auch den Link erhalten , um Führungs Soft - Datei herunterladen.
Refactoring to Patterns, by Joshua Kerievsky
Download Refactoring to Patterns, by Joshua Kerievsky
Nach ein paar Momente erwarten, schließlich können wir Refactoring To Patterns, By Joshua Kerievsky auf dieser Website präsentieren. Dies ist unter den Büchern, die in erster Linie am meisten gewartet und auch erwünscht. mehrmals zu investieren für dieses Buch zu warten, wird sicherlich Problem nicht sein. Sie werden auch richtig zu bestätigen suchen, wie viele Menschen über dieses Buch sprechen. Nach der Gründung kann dieses Buch in mehreren Quellen entdeckt werden.
Das Vorhandensein dieses neuen Buches für Sie eine brandneue Ressource sein. Diese Veröffentlichung ist eigentlich ideal für Ihre einsame Zeit in der Freizeit zu begleiten. Es wird sicherlich nicht so angenehm sein, wenn keine Aktivitäten in Ihrer Freizeit hat. Vor dem Fernseher kann bringen. So, dass Verfahren, Refactoring To Patterns, By Joshua Kerievsky Check-out können Sie brandneue geben Aufgabe so gut wie Sie neue Lektion bringen. Wenn Sie das Gefühl so angemessen mit diesem Buch wirklich, warum Sie es nicht zur Zeit nehmen?
Da die verschiedene andere Publikation wird sicherlich geben, neben der neuen Lehre wird es zusätzlich den Eindruck, als auch Inspirationen zu diesem Thema im Zusammenhang verbessern. Wir sind wirklich sicher, dass Ihre Wahl zu wählen als Analyse Veröffentlichung sicherlich nicht falsch sein. Sie denkt, dass die Existenz der Führer wird dieses Erdballs literarischen Sammlungen verbessern. Wenn viele Menschen für dieses Thema für das Buch Analyse zu suchen, wird es sein, das ein Ende, die Sie machen neue Inspirationen beeinflussen.
lesen. Warum? Noch einmal, das ist so angemessen mit dem Thema, das Sie wirklich jetzt benötigen. Es wird zusätzlich Ihre Auswahl des Tages, den Moment zu füllen, indem sie diese Publikation zu lesen. Auch ist es eine Art von Soft-Datentypen, Refactoring To Patterns, By Joshua Kerievsky Inhalt nicht mit dem Druck aus dem Buch verschiedenen sein.
Synopsis
In 1994, Design Patterns changed the landscape of object-oriented development by introducing classic solutions to recurring design problems. In 1999, Refactoring revolutionized design by introducing an effective process for improving code. With the highly anticipated Refactoring to Patterns, Joshua Kerievsky has changed our approach to design by forever uniting patterns with the evolutionary process of refactoring. This book introduces the theory and practice of pattern-directed refactorings: sequences of low-level refactorings that allow designers to safely move designs to, towards, or away from pattern implementations. Using code from real-world projects, Kerievsky documents the thinking and steps underlying over two dozen pattern-based design transformations. Along the way he offers insights into pattern differences and how to implement patterns in the simplest possible ways.Coverage includes: *A catalog of twenty-seven pattern-directed refactorings, featuring real-world code examples *Descriptions of twelve design smells that indicate the need for this book's refactorings *General information and new insights about patterns and refactoring *Detailed implementation mechanics: how low-level refactorings are combined to implement high-level patterns *Multiple ways to implement the same pattern--and when to use each *Practical ways to get started even if you have little experience with patterns or refactoring Refactoring to Patterns reflects three years of refinement and the insights of more than sixty software engineering thought leaders in the global patterns, refactoring, and agile development communities.Whether you're focused on legacy or "greenfield" development, this book will make you a better software designer by helping you learn how to make important design changes safely and effectively.
Buchrückseite
In 1994, "Design Patterns" changed the landscape of object-oriented development by introducing classic solutions to recurring design problems. In 1999, "Refactoring" revolutionized design by introducing an effective process for improving code. With the highly anticipated "Refactoring to Patterns," Joshua Kerievsky has changed our approach to design by forever uniting patterns with the evolutionary process of refactoring.This book introduces the theory and practice of pattern-directed refactorings: sequences of low-level refactorings that allow designers to safely move designs to, towards, or away from pattern implementations. Using code from real-world projects, Kerievsky documents the thinking and steps underlying over two dozen pattern-based design transformations. Along the way he offers insights into pattern differences and how to implement patterns in the simplest possible ways.Coverage includes: A catalog of twenty-seven pattern-directed refactorings, featuring real-world code examplesDescriptions of twelve design smells that indicate the need for this book's refactoringsGeneral information and new insights about patterns and refactoringDetailed implementation mechanics: how low-level refactorings are combined to implement high-level patternsMultiple ways to implement the same pattern--and when to use eachPractical ways to get started even if you have little experience with patterns or refactoring"Refactoring to Patterns" reflects three years of refinement and the insights of more than sixty software engineering thought leaders in the global patterns, refactoring, and agile development communities. Whether you're focused on legacy or "greenfield" development, this book will make you a better software designer by helping you learn how to make important design changes safely and effectively.
Alle Produktbeschreibungen
Produktinformation
Gebundene Ausgabe: 400 Seiten
Verlag: Addison Wesley; Auflage: 01 (5. August 2004)
Sprache: Englisch
ISBN-10: 0321213351
ISBN-13: 978-0321213358
Größe und/oder Gewicht:
17,8 x 2,5 x 23,6 cm
Durchschnittliche Kundenbewertung:
4.1 von 5 Sternen
8 Kundenrezensionen
Amazon Bestseller-Rang:
Nr. 20.180 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)
Ich persönlich sehe das Buch als Fortsetzung bzw. Ergänzung zu "Refactoring: Improving the Design of Existing Code" von Martin Fowler. Es wird initial auch des Öfteren auf Fowlers Buch verwiesen - die vorgestellten Patterns unterscheiden sich allerdings größtenteils (bzw. ergänzen aus meiner Sicht jene von Fowler).Was mir gar nicht am Buch gefällt sind diese unsinnigen Beispiele. Es wird sehr oft ein HTML Parser exemplarisch "refactored" - aber ich musste die Beispiele - aufgrund der etwas schwierigeren Domäne - mehrmals lesen. Es fehlt mir teilweise der Bezug bzw. der Kontext des gezeigten Code Ausschnitts und ich konnte mir dann schwer drunter etwas vorstellen.
This is the first time that I have thought the refactorings as a way of transforming the software to more complex forms.I always thought the patters as design patterns that one applies up front to a software. However this book fits the patterns very nicely to the context of software evolution. I found this book very valuable. It made me to apply patterns much more frequently in my projects.
Dieses Buch habe ich mir auf der Java One 2005 besorgt und mit viel Spaß gelesen.Ich kannte sowohl das Standardwerk zu Design-Patterns von Gamma et al und auchden Refactoring-Klassiker von Martin Fowler.Das Buch von Joshua Kerievsky verknüpft beide Standardwerke, verbindet als Refactoringsmit den Ideen der Entwurfsmuster. Außerdem werden einige Ideen zu gutem Softwareentwurfvermittelt.Ein sinnvolles Buch für den engagierten Softwareentwickler.
This book is a must-read directly after the classical Design Patterns (Gamma et al.) and Refactoring (Fowler). Joshua bridges the gap between these two practices by introducing how to get from code which lacks clear design towards clearly structured and designed classes. It builds upon the Refactorings from Fowler and goes beyond them and shows how to get back to working flexible software if you have coded yourself into a mess. For any developer out I consider this to be a standard piece of literature.
Wer, wie ich, ein Fan schlechter Übersetzungen ist, wird mit dem vorliegenden Werk seine wahre Freude haben (Vorsicht Sarkasmus !).Das fängt an mit den obligatorischen Zwangseindeutschungen englischer Fachbegriffe, geht weiter mit Inkonsistenzen in der Anwendung (Diagramme sind häufig gleichzeitig englisch und deutsch beschriftet) bis hin zu schlicht falschen (das Java Interface Serializable wird z.B. sinnentleert in Serialisierbar übersetzt) bzw. unverständlichen Übersetzungen.Mein persönlicher Favorit ist diesbzgl. folgender Satz:"Es handelt sich um Patterns (Design Patterns von Gamma, Anm. R.), mit denen, in Richtung auf oder ohne die meine Kollegen und ich echte Projekte überarbeitet haben." Ach so !Es ist daher überhaupt nicht verwunderlich, daß Niemand für die geleistete Arbeit mit seinem Namen einstehen wollte, die Übersetzung erfolgte nämlich recht anonym durch G&U.Jetzt zum Buch. Insgesamt würde ich den Inhalt als wirklich brauchbar einschätzen, erst recht in Ergänzung zu Gammas "Design Patterns"; allerdings kocht Kerievsky auch nur mit Wasser.So wirkt das Bsp. zum Refactoring "Kompositum durch Erbauer kapseln" doch recht gekünstelt. Nach der Anwendung hat er gerade mal ein paar Zeilen Code eingespart, dafür aber deutlich an Verständlichkeit eingebüßt, weil die neuen Funktionen Vieles implizit erledigen, was mir nicht ohne Weiteres akzeptabel erscheint. Auch die Aufteilung der Funktionalität des BUILDER-Patternelements Director auf Client und Builder, deutet für mein Empfinden eindeutig auf einen Fall von Overengineering hin, da anscheinend ganze Patternbestandteile obsolet sind. Doch gerade diese Art des Patterngebrauchs sollte durch Anwendung nachträglicher Refactorings eigentlich vermieden werden.Ein ähnliches Problem gibt es auch bei "Singleton inline stellen". Nachdem uns der Autor mitteilt, daß viele Singletons überflüssig sind, auch wenn sie anfangs sinnvoll erscheinen, wie z.B. beim State-Pattern oder der Factory, setzt er dem Leser nachfolgend ein derart triviales Bsp. vor, wo, glaube ich, Niemand auch nur im Entferntesten annehmen würde, hier wäre dieses Pattern jemals angebracht gewesen. Wer ordnet bitte sehr ein Attribut einer Klasse A einer Klasse B zu, nur um dann später global auf dieses zugreifen zu müssen ? Das fällt wohl eher in die Kategorie "elementare Designfehler" als in den Bereich möglicher Designverbesserungen.Auch das Beispiel des etwas eigenartig benannten Refactorings "Typenschlüssel durch Klasse ersetzen" hat mich nicht überzeugt. Im Grunde genommen geht es um die Ersetzung von Wertkonstanten durch Referenzkonstanten (und die damit einhergehenden typsichere Eingrenzung des möglichen Wertebereichs). Warum er das ausgerechnet an (final static) String-Konstanten demonstriert, bei denen es sich ja schon um Referenzkonstanten handelt, erschließt sich mir nicht unbedingt. Im Ergebnis erfolgt nur die Substitution des vorher (wie ich finde, fälschlicherweise) benutzten Wertevergleichs (String.equals(...)) durch einen Wertevergleich mit Referenzvergleichsemantik (Aufruf von "==" in Object.equals(..)) und der Leser stellt sich die berechtigte Frage, worin hier eigentlich die Verbesserung liegt, man hätte doch gleich einen Referenzvergleich durchführen können - eine Frage, deren Beantwortung uns der Autor leider schuldig bleibt. In meinen Augen gibt es für dieses Refactoring nur 2 sinnvolle Anwendungen: 1. wenn man verhindern will, daß Attributwerte einer Referenzkonstanten nachträglich verändert werden. Dann macht es Sinn, eine Wrapper-Klasse zu schreiben, die den Zugriff entsprechend steuert, und 2. wenn man den Sonderstatus der Konstanten durch Einführung eines speziellen Konstantentypen hervorheben möchte; ansonsten benutzt man gleich beliebige Objekte + Referenzvergleich und nicht den Umweg über "equals(...)". Beides wird von Kerievsky im Abschnitt "Motivation" jedoch nicht erwähnt.Aber ok, die meisten Refactorings haben sicher ihre Daseinsberechtigung, auch wenn die Beispiele nicht immer gelungen erscheinen.Ich bin mir aber nicht sicher, ob Kerievskys haarkleine Aufschlüsselung der Vorgehensweise beim Refactoring (also Schritt für Schritt als Pseudo-Algorithmus) wirklich die beste Alternative darstellt, um den Sachverhalt zu erklären. Das Ganze ist nicht universell einsetzbar (muß für jeden Anwendungsfall umgemünzt werden) und enthält letztendlich viele unbrauchbare Zwischenschritte, die den Leser nur unnötig verwirren (mußte öfter grübeln, obwohl mir der Ablauf generell klar war). Ein klar strukturiertes VORHER/NACHHER hätte hier eindeutig mehr gebracht, zumal Jeder selbst die Anzahl der dazu erforderlichen Umwandlungsschritte nach seinen Vorlieben festlegt.Sauer aufgestoßen sind mir auch die oft fehlerhaften UML-Diagramme und da meine ich nicht die Darstellung komplizierter Sachverhalte, in denen sich vielleicht ein kleiner Fehler eingeschlichen hat; nein, ganz Rudimentäres wie z.B. Zustände in Zustandsdiagrammen oder Objekte in Sequenzdiagrammen werden schlichtweg falsch visualisiert. Wie das passieren kann, obwohl angeblich sogar Martin Fowler (Autor eines UML-Buches) gegengelesen haben soll, ist für mich nicht nachvollziehbar. Ich will aber nicht unfair sein und räume ein, daß das evtl. das Übersetzungsteam zu verantworten hat.Fazit: Kauft das englische Original und nutzt es vor allem als Denkanreiz, weniger als Anleitung.Übersetzung: 2 SterneBuchinhalt: 3.5 Sternemacht insgesamt: 3 Sterne.
Refactoring von Code mittels Entwurfsmustern.Dreh- und Angelpunkt des Buches ist eine Übersichtsliste mit Code Smells (z.B. duplizierter Code) und dazu passenden Refactorings (z.B. Template Method bilden).Hervorragend als Ergänzung zu "Refactoring" von Martin Fowler.
Wer Bücher von Fowler, Uncle Bob etc gewöhnt ist, wird sich schwer tun mit dem Sprachfluss dieses Buches. Außerdem muss man tatsächlich das "Refactoring"-Buch zur Hand haben, da ständig Querverweise erfolgen. Auf mich wirkt das Buch sehr umständlich, ständig wird auf später erklärte Themen verwiesen, und jedes Pattern 3 mal erklärt, meist ohne wirklichen Mehrwert. Die "real world examples" sind auch alles andere als interessant und nicht wirklich besser als rein theoretische Beispiele.Bei so vielen Verweisen auf Refactoring, hat der Autor jedoch eine ganz andere, eigene Philosophie.Alles in allem, leichter verständlich als das original Patternbuch von Gamma etc. aber dennoch nicht einfach lesbar. Im Prinzip macht das Buch, was der Titel verspricht, es zeigt die nötigen Refactoringschritte hin zu einem Pattern, lässt aber an manchen Stellen, trotz der Mehrfachwiderholung, die nötige Tiefe missen.
Refactoring to Patterns, by Joshua Kerievsky PDF
Refactoring to Patterns, by Joshua Kerievsky EPub
Refactoring to Patterns, by Joshua Kerievsky Doc
Refactoring to Patterns, by Joshua Kerievsky iBooks
Refactoring to Patterns, by Joshua Kerievsky rtf
Refactoring to Patterns, by Joshua Kerievsky Mobipocket
Refactoring to Patterns, by Joshua Kerievsky Kindle
COMMENTS