PDF-Download Refactoring to Patterns, by Joshua Kerievsky
Aus dem Titel, werden wir sicherlich zeigen Ihnen auch das Thema zu definieren betreffen. Wenn Sie tatsächlich diese Art von Quelle erfordern, warum Sie es nicht jetzt nehmen? Diese Publikation wird nicht nur Sie das Wissen und auch Unterricht in Bezug auf das Thema, von den Worten, die genutzt werden, ist es neue angenehme Sache angeben. Diese Refactoring To Patterns, By Joshua Kerievsky fühlen Sie sich keine Angst wirklich mehr Zeit mit Lesen zu investieren.
Refactoring to Patterns, by Joshua Kerievsky
PDF-Download Refactoring to Patterns, by Joshua Kerievsky
Wenn Sie hier tatsächlich in der Lage gewesen sind, bedeutet dies, dass Sie in der Lage sind, auf die Bahn als auch eine Verbindung zu geben. Noch einmal, es gibt an, dass Internet eines der Mittel wird die Leichtigkeit Ihres Lebens machen können. Eines, das Sie gerade in dieser Sammlung tun kann, ist auch ein Teil Ihrer Initiative, um die Lebensqualität zu steigern. Ja, diese Website bietet nun das Refactoring To Patterns, By Joshua Kerievsky als eines der Materialien in dieser heutigen Zeit zu lesen.
Also the rate of an e-book Refactoring To Patterns, By Joshua Kerievsky is so budget-friendly; many individuals are truly thrifty to set aside their cash to purchase the books. The other reasons are that they feel bad and have no time at all to visit guide store to browse guide Refactoring To Patterns, By Joshua Kerievsky to check out. Well, this is modern-day period; numerous publications can be got easily. As this Refactoring To Patterns, By Joshua Kerievsky and also much more books, they could be entered quite quick means. You will certainly not require to go outside to obtain this publication Refactoring To Patterns, By Joshua Kerievsky
By visiting this page, you have actually done the best staring point. This is your begin to select guide Refactoring To Patterns, By Joshua Kerievsky that you really want. There are great deals of referred e-books to check out. When you want to obtain this Refactoring To Patterns, By Joshua Kerievsky as your book reading, you can click the link web page to download Refactoring To Patterns, By Joshua Kerievsky In few time, you have possessed your referred publications as your own.
Due to this publication Refactoring To Patterns, By Joshua Kerievsky is offered by on the internet, it will certainly ease you not to print it. you can get the soft documents of this Refactoring To Patterns, By Joshua Kerievsky to save money in your computer, kitchen appliance, and more gadgets. It relies on your willingness where as well as where you will certainly review Refactoring To Patterns, By Joshua Kerievsky One that you have to constantly keep in mind is that reviewing book Refactoring To Patterns, By Joshua Kerievsky will never finish. You will have going to read various other e-book after finishing an e-book, and also it's continuously.
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
0 komentar:
Posting Komentar