find Hier klicken Jetzt informieren PR CR0917 Cloud Drive Photos Alles für die Schule Learn More TDZ HI_PROJECT Mehr dazu Hier Klicken Shop Kindle PrimeMusic AmazonMusicUnlimited Fußball longss17

Kundenrezensionen

4,7 von 5 Sternen
59
4,7 von 5 Sternen
Format: Gebundene Ausgabe|Ändern
Preis:53,99 €+ Kostenfreie Lieferung mit Amazon Prime


Derzeit tritt ein Problem beim Filtern der Rezensionen auf. Bitte versuchen Sie es später noch einmal.

am 30. Juni 1999
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.
0Kommentar| Eine Person fand diese Informationen hilfreich. War diese Rezension für Sie hilfreich?JaNeinMissbrauch melden
am 8. Juni 2000
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.
0Kommentar| Eine Person fand diese Informationen hilfreich. War diese Rezension für Sie hilfreich?JaNeinMissbrauch melden
am 22. Juli 1999
First one small complaint about this book: It introduces the notion of "bad smells in code" which are nothing but "Anti-patterns". Why introduce another new term? The notion of "Antipatterns" was introduced by another book with that title. That book too handled some of the issues of "Refactoring" although at different level and hence should have atleast been mentioned in the bibilography.
Interesting thing is that the "Catalog of Refactoring" in this book is in inverse format of the "Catalog of Anti-Patterns". That is not a bad thing though.
Many thanks to all these authors (like the GoF and Fowler-Beck-gang) who giving the OO programming world a higher level vocabulary, by giving names and cataloging simple types of changes that you make to your code to rejuvenate it. That is a very important contribution towards documenting valuable programming folklore.
The book is pretty focused. The authors talk of little Refactoring. And don't digress into suggesting ways to handle Architectural or Infrastructural Refactorings (like say moving from Monoliths to N-Tiers). That makes it a fun yet valuable read.
--------------------------------------
This are my own views not my employers
0Kommentar|War diese Rezension für Sie hilfreich?JaNeinMissbrauch melden
am 19. Juni 2000
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.
0Kommentar|War diese Rezension für Sie hilfreich?JaNeinMissbrauch melden
am 20. Februar 2000
The majority of books describing the development process deal with the design phase. Clearly, this is important, but the latest information is that eighty percent of development time is now spent in the area known as software maintenance. Information concerning how to perform this vital function correctly has been conspicuously deficient. After the publication of this book, that oversight is substantially corrected.
Refactoring is defined as the modification of pre-existing code to improve the performance, and does not directly involve the modification of code to add additional functionality. That aside, improving the efficiency of the code is a valuable goal that is now more attainable.
Given a system that does work, making changes to improve performance is often not a high priority. In the high speed world of software development, making a change that adds only percentage points of improvement in one area does not raise eyebrows, it tends to create frowns. However, like so many other things, this is a very short-sighted view. In my mind, the most significant lesson of the Y2K event is that code tends to live a long time, despite dramatic changes in the hardware. Those simple changes that we do now may not save much time per execution, but iterate that over decades and the return on investment is quite high.
The most significant advantage of the improvements described in this book is that almost all of them can be implemented fairly quickly and can be verified locally, without global recompiles and exhaustive retesting. Therefore, the management decisions that need to be made to carry them out entail much less risk. It is also much easier to allocate resources if it is known with a high degree of certainty that the modification will be completed in a matter of hours rather than days or weeks. This is also consistent with the body of evidence that is overwhelming in favor of a software development cycle with small iterations that can be quickly completed.
No one single refactoring operation listed here will change your application from a tortoise to a hare. However, each one will add a bit more bounce to her step, and if you perform enough of them, you will have either a very fast tortoise or a slow hare. This is a book that should be required reading in all sections that perform software maintenance. If I were in a position of maintaining software, I would create a checklist of refactorings and simply step through that list looking for places to make the changes. There is no doubt that this is one of the best books of the year.
0Kommentar|War diese Rezension für Sie hilfreich?JaNeinMissbrauch melden
am 28. Februar 2000
This is a book that will change the way you view code - as you are writing it and when you are maintaining it.
While the examples are written in Java (and a couple of the refactorings seem to be Java-isms) this is a book that should change the way you look at your code - no matter what language you use.
If you look at any code at all - if you are author, maintain or review code in any language - you should get this book, read it, and leave it on your desk.
Like many fundamentally good ideas, refactoring seems so simple that one wonders why we didn't think of it before. Fact is, refactoring has been happening for years (decades) but Fowler is one of the first to make this process accessible.
If you are a very experienced developer, this book will help you put some of your own practice into words, to explain it to other developers on your team. You will probably learn a few new wrinkles as well.
If you are a less experienced developer, this book can help you to become better at your craft. You'll find out some of the "tricks of the trade" used by the best developers (those who produce the most reliable, most maintainable code).
0Kommentar|War diese Rezension für Sie hilfreich?JaNeinMissbrauch melden
am 20. Juli 1999
It's a rare book that causes the reader to say: "This changes *everything*." The Design Patterns book is one such, Refactoring is another.
The introductory chapters establish a clear theoretical and practical basis for the catalog of refactorings that make up the larger part of the text. Many of the examples are trivial, but then, many of the refactorings occur in simple situations. The more complex refactorings are usually accompanied by detailed example code. The mechanics section in each refactoring is an outstanding tool, and I expect to use it quite frequently.
I have followed the 'extreme programming' (XP) movement for some time, and I'm an ardent fan, as is, so I gather, Fowler himself. But don't be fooled by this: the book is not just for the XP crowd. All programmers who use Java (or have used more than one other oo language), will find this book a huge resource. I have a library that I recommend to journey-folk who aspire to mastery. Refactoring is certainly the newest addition. I think this book will be an instant classic.
I cannot say enough. Why not buy it now?
0Kommentar|War diese Rezension für Sie hilfreich?JaNeinMissbrauch melden
am 17. Mai 2000
The basic thesis of this book is that, for various reasons, real programs are poorly designed. They get that way for a variety of reasons. Initially well designed, extending the program may lead to software decay. Huge methods may result from unanticipated complexity. Refactoring, according to Fowler, is a function preserving transformation of a program. The transformations are reversible, so the intention is to improve the program in some way.
Fowler suggests refactoring a program to simplify the addition of new functionality. The program should also be refactored to make it easier for human readers to understand at the same time.
He also insists that each step is small and preserves functionality, and on frequent unit testing with a comprehensive test suite.
Half of the book consists of a catalogue of refactorings. He gives each refactoring a memorable name, such as "Replace Type Code with Subclasses". He illustrates the design transformation with a pair of UML class diagrams, and has a standard set of sections: Motivation, Mechanics and Example.
The Motivation is a prose section that describes and justifies the refactoring, showing the relationship to other refactorings.
The Mechanics is a sequence of steps needed to carry out the refactoring, shown as a list of bullet points He expands on some points.
The Example is where the value of this book lies. Fowler takes a fragment of Java code, and takes us step by step through the refactoring. The code is small enough that he can show it all each step of the way without overwhelming us, but is large enough to be realistic.
The code is clear enough for non-Java programmers to follow. He explains his code well enough for the book to function as a Java tutorial where the meaning of the code is not obvious. One or two of the refactorings are specific to the Java object model, and do not apply to other languages. Other languages would benefit from similar treatment, but there are very few language-specific refactorings.
The book is very much of the Design Patterns movement, with frequent references to patterns. The aim of a factoring may be to achieve a particular pattern, or it may take advantage of a particular pattern. The book can be used as a tutorial on Design Patterns.
I have a small number of complaints. Fowler advocates the use of refactoring while studying code for a code review. One needs to be very sensitive to the feelings of the programmer here, especially if he or she is a novice. The reviewer should read the code with refactoring in mind, and possible refactorings recommended, but it is for the programmer to make the changes.
Reading this book has inspired me to refactor some of my own code. My mistakes underlined the need to take small steps, and to test frequently. I spent a day building a useful Delphi testing framework from the description Fowler gives of the JUnit testing framework. The one category of code that does not seem to lend itself to this approach is some highly coupled parsing code. While I can extract small blocks of code, they remain tightly coupled with each other, and it is hard to give them meaningful names. The answer here may be to use the top down approach of recursive descent, rather than the bottom up approach of refactoring. Perhaps recursive descent can guide refactoring. Refactoring is largely a local approach. One can almost say a pinhole approach. Sometimes a global view is needed.
In summary, I would say that this very good book would be of use to Java programmers who have some understanding and much bafflement. It is very good for us older dogs who have become a little jaded and need some new ideas and motivation.
0Kommentar| 4 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich?JaNeinMissbrauch melden
am 17. März 2000
Learn how to improve your code using 73 refactorings. Sixty seven percent (49/73) of the refactorings are specific to object-oriented languages such as Java, C++, and Smalltalk. Refactoring promotes a healthy approach to maintenance programming. "When you find you have to add a feature to a program, and the program's code is not structured in a convenient way to add the feature, first refactor the program to make it easy to add the feature, then add the feature." Fowler's systematic approach and insistence on regression tests insures that each refactoring will not break any existing code. The constant application of appropriate refactoring results in reliable and clear source code. Some refactorings are opposite pairs such as "Add parameter", "Remove parameter" and "Replace Delegation with Inheritance", "Replace Inheritance with Delegation". A refactoring may have significant downsides, for example "Preserve Whole Object" increases coupling and "Replace Temp with Query" decreases performance.
0Kommentar|War diese Rezension für Sie hilfreich?JaNeinMissbrauch melden
am 1. November 1999
I just finished reading this book (and I am going to read it again and again.) Martin, you are the man! Your style is so amazing. But mostly, this is a book I am going to recommend to my co-workers, my friends, my family and anyone who wants to write good code. It's never too late to start. This book is just unbelievably great. There are so many examples. I program in Java and C++ and it was a time when I was at lost with my own code, let alone the code of others, only a few weeks after writing it. Not anymore! I have downloaded the JUnit and CPPUnit from the author's page and used them in all my projects with the refactoring methods described in the book. And then I went through this period of depression as I understood how much time and efforts I have lost in my existence without the fundamental guidelines described in this chef d'oeuvre. I feel better now. Thanks you!
0Kommentar|War diese Rezension für Sie hilfreich?JaNeinMissbrauch melden