Kundenrezensionen


57 Rezensionen
5 Sterne:
 (47)
4 Sterne:
 (6)
3 Sterne:
 (3)
2 Sterne:    (0)
1 Sterne:
 (1)
 
 
 
 
 
Durchschnittliche Kundenbewertung
Sagen Sie Ihre Meinung zu diesem Artikel
Eigene Rezension erstellen
 
 

Die hilfreichste positive Rezension
Die hilfreichste kritische Rezension


12 von 12 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Standardwerk + Pflichtlektüre
Dieses Buch sollte bei jedem (angehenden) Software-Entwickler im Bücher-Regal stehen ! Bevor ich dieses Buch gelesen habe, wusste ich ehrlich gesagt nicht wirklich was ich alles unter dem großen Begriff "Refactoring" verstehen soll.
Es wäre auch falsch und naiv zu behaupten das ich nach diesem einen Buch die Kunst des Refactorings...
Veröffentlicht am 31. März 2006 von Klaus M.

versus
3 von 3 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Good addition
Matin surely presents a good strategy which is easily proved in the book. However I do not think it is a big enough issue to justify the whole book. He filled the content with many basics of object oriented and good programming practice. While many are not familiar with patterns and these techniques are not used as much as they should, I expect better material from...
Am 28. Oktober 1999 veröffentlicht


‹ Zurück | 1 2 36 | Weiter ›
Hilfreichste Bewertungen zuerst | Neueste Bewertungen zuerst

4 von 5 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Should be titled "Refactoring for Java Programmers", 13. Dezember 1999
As a C++ programmer I found many of the examples strongly geared to the specifics of the Java language (with which I have little familiarity). I was hoping for a more substantive generic OOP book. Many of the examples are OOP common sense and the book comes off as more of a beginners book for Java programming than one aimed at the audience of "Design Patterns" (an excellent book).
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


1 von 1 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Vital for every programmer, of great practical value., 8. Juni 2000
Von 
Dave O'Hearn (Boston, MA United States) - Alle meine Rezensionen ansehen
Unlike the AntiPatterns book, this one is valuable to every programmer, not just team leaders and academics. Refactoring is for everyone; I was doing it long before I knew what it was. Simply put, it is cleaning up the design before you add a new feature, so that the new feature will work with the design rather than fight it. The methods outlined in this book go beyond common sense, giving step-by-step guides to help refactoring be done safely and formally.
The text is also of great value to programemrs who learned the procedural style and still fealing it lingering in their object oriented designs. I have only owned it for two days and it has already contributed significantly to my knowledge of good object oriented design and implementation. It is one of the few books per year that I can afford to purchase and keep as a reference.
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


1 von 1 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen This book is changing the way I program., 30. Juni 1999
Von Ein Kunde
This is a terrific book that shows you how---with discipline and care, but without magic---you can improve the internals of existing programs. We've all come to believe over the years that software inevitably becomes more complex and brittle as it evolves and is maintained, but refactoring shows that it doesn't have to be that way. We're very lucky that the first book to cover refactoring in detail is such a gem.
The organization of this book is similar to that of "Design Patterns": introductory material that explains what refactoring is, how it works, and why it's important, followed by a catalog of refactorings that you can use in your programs. Fortunately, Fowler is a very entertaining writer, and "Refactoring" is much easier to read than "Design Patterns". Furthermore, many people, especially beginners, find it easier to see how to apply refactorings than patterns, and the book contains first-rate tips for identifying code that needs to be refactored.
If you write code, buy this book. Read it. Apply it. Your employers and your fellow programmers will thank you, and you will enjoy programming more.
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


6 von 8 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Ich vermisse das große Bild, 15. Oktober 2002
Von Amazon bestätigter Kauf(Was ist das?)
Wenn man dieses Buch durchgearbeitet hat, verändert sich automatisch die Art und Weise wie man programmiert und wie man geschriebenen Code bearbeitet. Man traut sich an den Code heran und bricht alte Strukturen auf um diese zu verbessern.
Man denkt sich nicht mehr: "Ach, dass sieht zwar schlecht aus aber es funktioniert. Irgendwie bekomme ich das neue Feature auch so da rein."
Nun geht man hin und verbessert Schritt für Schritt das Design bis es leicht wird das Neue einzubringen.
Auf jeden Fall eine geniale Möglichkeit seine Produktivität zu steigern.
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


14 von 19 Kunden fanden die folgende Rezension hilfreich
1.0 von 5 Sternen Good Information But Extremely Poor Delivery, 15. März 2000
This book contains some good information on how to improve yourexisting code without rewriting it entirely which is a nice departurefrom the norm of most of these UML-type books which advocate totally changing the way you design and build software. Not that the Unified method of designing and building is bad, its just that its hard to change the way this is done in an organization when you're not in charge of the organization. Mr. Fowler has put forth a mechanism for improving the design of existing code while adding functionality to it. And the information, once culled from the surrounding text, is extremely useful. It's not paradigm shift. And it's not a companion to Design Patterns - Fowler mentions the Design Patterns book throughout his text but this book is certainly not written for the same audience. Fowler never once gives an example where he converts bad code into good by utilizing a pattern from the Gang of Four's book. The book is useful for ANY object-oriented language even though he uses Java in his examples the principles map easily to C++ and SmallTalk. Almost all of the techniques are common sense and yet he spends the bulk of this book explaining in simple terms how to perform them. For each "refactoring" he capably provided a two or three sentence overview of the process, and a code fragment or class diagram exemplifying the technique. These summaries and figures are excellent. But his tone becomes condescending as he painfully explains the process of performing the code improvement. For instance, Extract Method, the first technique in the book, is succinctly described with: "[If] You have a code fragment that can be grouped together...[then] Turn the fragment into a method whose name explains the purpose of the method." Pretty simple and probably not quite enough to totally understand what he is talking about. But then he has a wonderful little code fragment that illustrates it perfectly. This requires about half of one page. But he spends four and a half more explaining how to perform this simple cut-and-paste. 270 Pages of this 418 page book are spent describing 72 techniques in this kind of excruciating detail. Eight very useful pages are spent describing the bad "smells" in your code that lead to these "refactactorings". Another 110 pages is spent telling you how to justify the work to your boss, encouraging you to do it whether or not your boss approves, advocating a "test-small-change-test" paired programming technique characteristic of Extreme Programming. The final 30 pages are written by the other contributors. Altogether, I think this book should be "refactored" into a 100 to 150 page soft-cover manual reminiscent of Scott Meyers' Effective C++ books. If you're looking for Design Patterns: Part 2 this isn't it! END
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


4.0 von 5 Sternen Bible(and only serious book) of Refactoring, 11. April 2014
It is surprising that there are not so many books available about the subject of refactoring, given that most of the software developers are working with some kind of code that was already developed by someone else often in a hurry or under time and budget constraints.

In this book, Martin Fowler gives very hands on, practical tips on how to change the code without changing the behavior of the existing software. It was really helpful to have this book handy when I had to refactor a complex legacy batch application into a more layered architecture for testing different layers in isolation.
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


5.0 von 5 Sternen Very useful book, especially for semi-beginners, 20. November 2013
Von Amazon bestätigter Kauf(Was ist das?)
A good guide for people with experience in programming but struggling with making the code clean and clear. Martin explains it in simple words and many examples which makes the book really valuable.
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


5.0 von 5 Sternen Awesome book!, 7. April 2013
Von Amazon bestätigter Kauf(Was ist das?)
All OK!

Item like as described
Very fast delivery time and without any problems.
Really good and worth to recommend!
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


5.0 von 5 Sternen Thematische Aufarbeitung & Referenz, 31. Juli 2009
Autoren & Coautoren geben einen motivierenden, leicht verständichen Einstieg in die Materie. Möglichkeiten, Ziele und Grenzen von "Refactoring" werden klar aufgezeigt und in nachvollziebarer Art und Weise diskutiert.

Ein Gutteil des Buches behandelt die einzelnen besprochenen Refactoring-Maßnahmen im Detail. Diesen "Katalog" kann man ohne weiteres als Ganzes im Stück lesen um einen groben Überblick zu bekommen.
Andererseits bieten zwei "Verzeichnisse" einen direkten Einstiegspunkt bei konkreten Anforderungen. Über eine einfache alphabetisch sortierte Liste findet man eine konkrete Maßnahme wenn man dazu eine Vorahnung hat. Die Liste von typischen "Code-smells" gibt alternativ einen möglichen Anhaltspunkt in weniger klaren Situationen.

"Refactoring" ist eines der besteren Fachbücher das mir in letzer Zeit untergekommen ist. -> strong buy!
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


5.0 von 5 Sternen Must-have for every Senior Java Developer, 19. Juni 2000
Von Ein Kunde
This book deals with a real-life software problem: maintenance of existing code. 90% of a developers work time are spent to maintenance programming and not to developing new designs and classes. This book guides how to take ownership of existing code which to my experience is a horror to most average-experienced software developers. The design patterns presented show what makes code a maintenance nightmare and how to rework such code. Thus it not only teaches hot to rescue existing code but also prevents oneself from writing code which is prone to be thrown away one day. Accompanied with "Java Idioms and Performance Guide" this book is the third one which I would recommend to a Java beginner after having read one entry Java book. Most experienced developers will have much "deja-vue" situations while reading; it's the same as with design patterns books. Before I read the book I sometimes blamed me for working on others persons code instead of using it "as-is" - now I know I'm not alone and some talented seniors do it the same way. In fact I saw many long-term projects die because of an increasing loss of architecture and constantly decreasing code quality. Refactoring could have rescued at least some of these.
Helfen Sie anderen Kunden bei der Suche nach den hilfreichsten Rezensionen 
War diese Rezension für Sie hilfreich? Ja Nein


‹ Zurück | 1 2 36 | Weiter ›
Hilfreichste Bewertungen zuerst | Neueste Bewertungen zuerst
ARRAY(0xa5a2bf9c)

Dieses Produkt

Nur in den Rezensionen zu diesem Produkt suchen