ARRAY(0xae36d300)
 
Profil für Amazon Customer > Rezensionen

Persönliches Profil

Beiträge von Amazon Customer
Top-Rezensenten Rang: 3.340.482
Hilfreiche Bewertungen: 21

Richtlinien: Erfahren Sie mehr über die Regeln für "Meine Seite@Amazon.de".

Rezensionen verfasst von
Amazon Customer

Anzeigen:  
Seite: 1
pixel
The Pragmatic Programmer. From Journeyman to Master
The Pragmatic Programmer. From Journeyman to Master
von Andrew Hunt
  Taschenbuch
Preis: EUR 32,95

17 von 22 Kunden fanden die folgende Rezension hilfreich
1.0 von 5 Sternen What rubbish!, 18. Mai 2000
I like to consider myself a master craftsman. My craft is that of programming. I live for programming. Programming is rarely from my thoughts. I am constantly thinking of ways to improve my craft. Learn a new skill. Develop a new tool. What went wrong? How can I do better next time?
Programming is a rapidly changing craft. A machinist can learn to work a lathe or a milling machine, and expect that his knowledge will stand him in good stead for the rest of his working life. Not so for the craftsman programmer. Ours is a new craft. We are still learning how to do it. Having survived in the game for a decade or two, and having learned dozens of languages, operating systems, database management systems, transaction processing managers, editors, we come to the realisation that this is a hard game. Each of us learns skills that help us cope with all that change. We learn basic programming skills. We go on learning them. We learn to see what is coming, and move in anticipation. We learn what is important, and what is not. We watch those who are successful, and try to emulate them. We watch the unsuccessful with horrid fascination, and try to learn from them also. "There but for the grace of God go I!"
I don't know how to make an object oriented design. I can do design sketches. So I start from there. I build my system, dealing with the problems as they arise. I rely on my experience to keep me out of trouble. When I see commonality between two classes, I take the opportunity to refactor and eliminate the commonality. I am quite happy to rewrite any piece of code to make it better. You know what happens? I end up with a well-designed system despite myself. I am an opportunistic programmer.
I saw the title of this book, and thought: "That's me!"
So I bought it. What a disappointment! It is full of platitudes. It reads like a writer's style manual. It is good to do things this way. It is a bad idea to do it that way. It has no meat to it, no depth. If you want to know more about the topics they discuss, you won't find it in this book. You won't find much of it in the references either.
Let me quote a typical example from the section entitled "Text Manipulation". "Pragmatic Programmers manipulate text the same way woodworkers shape wood ... We need a general purpose text manipulation tool ... Text manipulation languages are to programming what routers are to woodworking. They are noisy, messy, and somewhat brute force. Make mistakes with them, and entire pieces can be ruined ... in the right hands, both routers and text manipulation languages can be incredibly powerful and versatile..." What rubbish! The analogy flows on, and is followed with the advice to learn a text manipulation language, and a list of things possible with such a language. There is not one practical example.
This continues for section after section. In Appendix A: Resources, the authors say "The only reason we were able to cover so much ground in this book is that we viewed many of our subjects from a high altitude. If we'd given them the in depth coverage they deserved, the book would have been ten times longer." All I can say is that they should have covered ten times fewer subjects, to the depth of coverage they deserved.
A journeyman programmer wanting to become a master is advised to study at the side of a master. Buy Kernighan and Pike's The Practice of Programming.


Refactoring: Improving the Design of Existing Code (Object Technology Series)
Refactoring: Improving the Design of Existing Code (Object Technology Series)
von Martin Fowler
  Gebundene Ausgabe
Preis: EUR 40,95

4 von 5 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Making tired old code better, 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.


Fundamentals of Object-Oriented Design in UML (Addison-Wesley Object Technology)
Fundamentals of Object-Oriented Design in UML (Addison-Wesley Object Technology)
von Meilir Page-Jones
  Taschenbuch
Preis: EUR 37,20

5.0 von 5 Sternen Practical OO programming with UML, 4. April 2000
I must say immediately that OOD is a great weak point in my armoury. I do my designs largely by refactoring as I build from my business level objects. I also re-use the architectural level objects I developed in this way in earlier projects. I still tend to do the UML after I have done the programming, if then.
The book that has helped me a great deal to get things right despite my pragmatic approach is Meilir Page-Jones's recent book "Fundamentals of Object-Oriented Design in UML" (Addison Wesley ISBN 0-201-69946-X).
This book brings up to date Page-Jones earlier book "What Every Programmer Should Know About Object-Oriented Design" (Dorset House ISBN 0-932633-31-5). The biggest differences are that in Fundamentals he uses a subset of UML instead of his own notation, and he has a good chapter on component or interface design.
Both books have lots of examples and exercises, which I hear is a good thing.
The first part of Fundamentals introduces OO. The second part discusses the parts of the UML that are relevant to OOD. He does not discuss Use Cases as being beyond the scope of the book. Instead, he has chapters on Class Diagrams, Object Interaction Diagrams, State Diagrams, and Architecture and Interface Diagrams. The third part of the book is the really useful part. Here Page-Jones discusses good designs and how to achieve them.
I cannot recommend this book too highly.


Infinity's Shore (New Uplift Trilogy)
Infinity's Shore (New Uplift Trilogy)
von David Brin
  Taschenbuch
Preis: EUR 6,00

5.0 von 5 Sternen A real gripper! I could not put it down until it was done!, 19. Februar 1998
David Brin has invented the best aliens since Poul Anderson's Trouble Twisters. You really get into their minds. It is so good. The only bad thing about this book is that I will have to wait another year for the next part.


Seite: 1