Rating: 
Summary: Care to become an instant effective developer?
Review: then, read this book and live by it. this book will instantly make you a better programmer by reading and understanding it. the author saves us from actually acquiring these precious knowledge ourselves thru years of experience. instead, we can acquire all these knowledge thru him by reading this little gem. thanks peter!
Rating:
Summary: Excellent source for guidelines
Review: This book could be a very good source if you are developing your own company or project guidelines. The discussion is structured around lessons that are called PRAXES by author. Each PRAXIS has a well-chosen title which is expressed as a one sentence guideline.
The book covers general Java/OO topics and, in addition to that, has extensive sections devoted to performance and multi-threading.
Most guidelines are simple enough to be understood by any Java programmer. The discussion is on intermediate level in most cases with some advanced stuff included. Many examples, especially, in a performance section are illustrated by JVM bytecode snippets. The ability to read bytecode would be a plus for a reader but unfamiliarity with it should not prevent a reader from understanding material.
Overall, the book is a worthy reading for any Java developer.
Rating:
Summary: Effective Java
Review: This book documents all those things every Java programmer should know. Like Scott Meyer's "Effective C++" series, we use it to settle arguments over the 'right-way' to write code (for Java in this case). Not only does it provide an easy to reference list of these 'Praxises' but it explains why. It is much easier to agree on how when the book has explained the why.I do have to agree some of the negative reviews which state that some of the tips are obvious but I have worked with some well-seasoned Java programmers who still don't get them. If the obvious ones were not included I would be here critizing the book for incompleteness. This book is definitely for all Java programmers. As future Java versions are released and adopted by the industry, I am hoping to see a "More Practical Java" book like Scott Meyer's "More Effective C++".
Rating:
Summary: Excellent reading for intermediate programmers
Review: This book is excellent reading for the Java programmer who has mastered the basics, but I'm sure more advanced programmers would also find it interesting.
As a warmup, the book exensively covers implementing the equals() method, exception handling, and other general techniques. Then it moves on to performance tuning and multithreading. Performance tuning includes analyzing the bytecode for similar implementations, and the author's performance test results. Some of the results may be surprising, such as synchronization efficiency.
Rating: 
Summary: Crisp, useful tips to Java programming techniques
Review: This book provides clear, detailed instructions on how to avoid the most common Java programming mistakes -- ones that can lead to erroneous results, thread deadlock, or just poor performance. Best for the beginning or intermediate Java programmer. Much of the material in this book is covered in more detail in Eckel's "Thinking in Java" (still waiting for the 2nd edition!) or Lea's "Concurrent Programming in Java", but this is a much shorter read. One drawback: most of the section on performance improvements is not sufficiently rewarding to be useful by most programmers, and could distract from the more crucial tips offered in other sections.
Rating:
Summary: Every java developer should have a copy
Review: This book was published prior to "Effective Java". So for a while this book was the one to beat until Effective Java was published. Since we cannot assume that a Java Guru knows everything-which is impossible due to the constraints imposed by the learning process, available time, concurrent accumulation of additional knowledge, human memory limitations...- then I would recommend this book to the novice as well as the experienced developer.
The book is full of gems:
Page 11 "Praxis 5: Prefer polymorphism to instanceof". Anybody who has done some good design/object modeling work should know that, but again I have seen code written by C/C++ `gurus' that used extensively the non-object-oriented instanceof. What I also love about the author is his modesty and open mindedness. Page 15 "Praxis 6: Use instanceof only when you must" demonstrate that `object-oriented purity' is ideal but not always possible to achieve. Sometimes we are faced with a dilemma; we either don't have the source code for a library we are using or we don't have enough time to refactor existing code. Haggar's coverage of "Objects and Equality" (Praxis 8 through 15) is excellent; clear, concise and uses simple examples (equality between Golfballs!). It fully exposes the nuances between "= = ", equals(), primitives, objects while not missing the pitfalls associated with their use. So, the book is well thought out, well organized (5 areas divided into 68 praxes) and full of useful information. Novices should digest everything while experienced developers should read it in case they aren't perfect and have missed/forgotten something. Regardless, this is one of those reminders we keep on our bookshelf to help us stay in the right path of software development. Again, I had liked the book so much that 3 years ago I asked a coworker to take my laminated copy with him all the way to JavaOne (I couldn't attend due to a conflict with a project's delivery date) to have it signed by Haggar who was teaching a session based on his book.
Rating:
Summary: Every java developer should have a copy
Review: This book was published prior to "Effective Java". So for a while this book was the one to beat until Effective Java was published. Since we cannot assume that a Java Guru knows everything-which is impossible due to the constraints imposed by the learning process, available time, concurrent accumulation of additional knowledge, human memory limitations...- then I would recommend this book to the novice as well as the experienced developer.
The book is full of gems:
Page 11 "Praxis 5: Prefer polymorphism to instanceof". Anybody who has done some good design/object modeling work should know that, but again I have seen code written by C/C++ 'gurus' that used extensively the non-object-oriented instanceof. What I also love about the author is his modesty and open mindedness. Page 15 "Praxis 6: Use instanceof only when you must" demonstrate that 'object-oriented purity' is ideal but not always possible to achieve. Sometimes we are faced with a dilemma; we either don't have the source code for a library we are using or we don't have enough time to refactor existing code. Haggar's coverage of "Objects and Equality" (Praxis 8 through 15) is excellent; clear, concise and uses simple examples (equality between Golfballs!). It fully exposes the nuances between "= = ", equals(), primitives, objects while not missing the pitfalls associated with their use. So, the book is well thought out, well organized (5 areas divided into 68 praxes) and full of useful information. Novices should digest everything while experienced developers should read it in case they aren't perfect and have missed/forgotten something. Regardless, this is one of those reminders we keep on our bookshelf to help us stay in the right path of software development. Again, I had liked the book so much that 3 years ago I asked a coworker to take my laminated copy with him all the way to JavaOne (I couldn't attend due to a conflict with a project's delivery date) to have it signed by Haggar who was teaching a session based on his book.
Rating: 
Summary: Wait for "Effective Java Programming"
Review: This is a book for the beginning Java Programmer only. It'snot that the advice is bad: it's just that if you've programmed inJava for a while, most of it is obvious. Things like avoiding unneccessary object creation, especially complex objects with long inheritence chains. Or arrays are faster than Vectors. Or arraycopy() is faster than looping through the array. Josh Bloch's upcoming book, written in the same essay style, "Effective Java Programming," looks to be much more useful for the medium to advanced programmer.
Rating:
Summary: Good general book for experienced Java Programmer
Review: This is a neat little book (278 pages). It can be used by programmers who have completed a study of Java basics and have knowledge equivalent to that of a Sun Certified Java Programmer. I myself am reading it before submitting my programming assignment for the Sun Certified Java Developer certification. The book is organized into small sections(average 3 to 4 pages) of tips on good programming practice. So if I want to see if I have used exceptions correctly in my assignment, I can read the 12 sections (the author calls each section a praxis) on exceptions. I like the 18 sections on performance. Instead of stating that "doing it this way is faster", Peter actually went to the trouble of looking at the code generated by the Java compiler and used that as a basis for performance optimizations. You can still follow the discussions on performance, even if you do not understand the JVM bytecode instructions. There are 13 sections on multithreading. If you are writing a multithreaded program, be sure to read these to see if you have designed for all the possible snags and pitfalls that await you. There are 68 sections total and for the most part, they can be read in any order. This is one of the cleanest computer books I have read recently. First of all the author has a gift of explaining things clearly. Then the author and probably others actually proofread the material before publishing it. It is remarkably error free. What a concept! Other authors and publishers please take note. I hope Peter Haggar writes other books - Peter, how about a good book on Design Patters Using Java?
Rating:
Summary: Useful, easy to browse or to look for a particular topic
Review: This is a pretty good reference, providing a collection of 'praxes' on how to write better code. It covers issues of design, performance, concurrency, readability, and so on. Although not all this material is new to me, it is presented in a format that is easy to thumb through or to use as a reference when making design decisions. One drawback -- I find the text is in places repetitive, where the author reiterates a point in several ways without providing any new insight. So I've found myself skimming in a few places. This does not affect the overall readability and usefulness of this book, though, and I recommend it to intermediate/advanced developers looking for ways to improve their code.
| 
