Rating: 
Summary: Average At Best
Review: Java Pitfalls is an average book that junior level Java developer may find useful. The book is divided into several sections, with each section containing one or more ideas, tips, advice, pitfalls, "what not to do," etc. Java Pitfall is a fairly dry read and is not as solid as other books on the market that follow a similar style (think Practical Java by Peter Haggar and Effective C++ by Meyers).Java Pitfalls covers the obvious and mundane (variable scope, how to compare strings, and try/catch/finally), GUI topics, and a handful of interesting areas such as thread synchronization, deadlocks, and string concatenation inside of loops. Junior developers should find some of the topics useful, but experienced developers will find much of the book lacking - perhaps worth a cursory glance at best. With that said, maybe the book should be marketed to novice developers because my overall criticism of the book is that it is not useful book for experienced Java developers. There is always a place for introductory Java books, but Java Pitfalls does nothing to excel and stand out from an otherwise already crowded retail bookshelf. The most disappoint aspect of this title for me is the GUI coverage - there is too much! Of the 322 pages, over 119 pages (a third of the book) are dedicated to GUI topics. My personal opinion is that GUI topics should have been relegated to another title because the authors could not dedicate enough space to be really useful for AWT and Swing developers. At the same time the included material is worthless for the majority of Java developers that work with some derivative of the J2EE architecture (J2EE is not the focus of the title, but I think the criticism is fair). I found a few topics in Java Pitfalls interesting and worth reading, but most of the topics are fairly lightweight for anyone that is moderately experienced with the Java language. I cannot help but think that novice developers will find useful tips and practices within the pages of Java Pitfalls, but there are much better Java books on the market, which serve the same purpose. Java Pitfalls is not a book that I will keep handy in my day-to-day use, and I doubt that it will ever show up in my rotation of references that I turn to when I am stumped and need to research an issue. There too many good books on the market for me to recommend a title as average as Java Pitfalls.
Rating:
Summary: Average At Best
Review: Java Pitfalls is an average book that junior level Java developer may find useful. The book is divided into several sections, with each section containing one or more ideas, tips, advice, pitfalls, "what not to do," etc. Java Pitfall is a fairly dry read and is not as solid as other books on the market that follow a similar style (think Practical Java by Peter Haggar and Effective C++ by Meyers). Java Pitfalls covers the obvious and mundane (variable scope, how to compare strings, and try/catch/finally), GUI topics, and a handful of interesting areas such as thread synchronization, deadlocks, and string concatenation inside of loops. Junior developers should find some of the topics useful, but experienced developers will find much of the book lacking - perhaps worth a cursory glance at best. With that said, maybe the book should be marketed to novice developers because my overall criticism of the book is that it is not useful book for experienced Java developers. There is always a place for introductory Java books, but Java Pitfalls does nothing to excel and stand out from an otherwise already crowded retail bookshelf. The most disappoint aspect of this title for me is the GUI coverage - there is too much! Of the 322 pages, over 119 pages (a third of the book) are dedicated to GUI topics. My personal opinion is that GUI topics should have been relegated to another title because the authors could not dedicate enough space to be really useful for AWT and Swing developers. At the same time the included material is worthless for the majority of Java developers that work with some derivative of the J2EE architecture (J2EE is not the focus of the title, but I think the criticism is fair). I found a few topics in Java Pitfalls interesting and worth reading, but most of the topics are fairly lightweight for anyone that is moderately experienced with the Java language. I cannot help but think that novice developers will find useful tips and practices within the pages of Java Pitfalls, but there are much better Java books on the market, which serve the same purpose. Java Pitfalls is not a book that I will keep handy in my day-to-day use, and I doubt that it will ever show up in my rotation of references that I turn to when I am stumped and need to research an issue. There too many good books on the market for me to recommend a title as average as Java Pitfalls.
Rating: 
Summary: Good book
Review: Pros: *)Covers a lot of java topics, from language syntax, API (JFC) to performance issues. *)Concrete, real examples. *)OO design issues, as MVC patterns, lazy evaluation, etc. *)Some issues are java related, which have different behaviors in C++, as "Passing Primitive by Reference", "Boolean Logic and Short-Circuit Operators", well done. Cons: *)Explanation can be deeper, and clearer. *)No contributions to enterprise java: javabean, JDBC, RMI, Servlet, JSP, EJB. *)Some explanations are not accurate: for example: Abstract methods must be overridden should be replaced by "Abstract methods must be overridden in CONCRETE classes". *)No references at the end of the book, <Effective C++>>, <<Design Patterns>> can be listed. Suggestion: Buy this book with <<Practical Java Programming Language Guide: The Addison-Wesley Professional Computing Series>> (ISBN: 0201616467) and/or <<The Elements of Java Style>> (ISBN: 0521777682).
Rating: 
Summary: A flawed and poorly written book.
Review: The first paragraph in the book uses the word 'effective' six times an obvious attempt to be associated with Scott Meyer's successful "Effective C++" and the genre of "Effective" books it spawned. Fortunately, the authors were wise enough not to use 'effective' in the title, as this book is not up to the standards established by previous books that have. Better to get "Effective Java" by Joshua Bloch, a book that does justice to the quality standard associated with books on effective programming in other languages. There are some good nuggets of advice in the book, but more often than not the book suffers from confusing and wordy explanations, or worse, from inherently flawed concepts. The book has many factual errors and code fragments that contain compilation and/or execution errors. The 50 items in the book are categorized as addressing either pitfalls, confusing APIs or best approaches. While I could go through and list the best and worst, the book doesn't merit that level of effort. Bottom line: while there is some value in the book, it is overshadowed by its many flaws and weaknesses.
Rating:
Summary: A flawed and poorly written book.
Review: The first paragraph in the book uses the word `effective' six times an obvious attempt to be associated with Scott Meyer's successful "Effective C++" and the genre of "Effective" books it spawned. Fortunately, the authors were wise enough not to use `effective' in the title, as this book is not up to the standards established by previous books that have. Better to get "Effective Java" by Joshua Bloch, a book that does justice to the quality standard associated with books on effective programming in other languages. There are some good nuggets of advice in the book, but more often than not the book suffers from confusing and wordy explanations, or worse, from inherently flawed concepts. The book has many factual errors and code fragments that contain compilation and/or execution errors. The 50 items in the book are categorized as addressing either pitfalls, confusing APIs or best approaches. While I could go through and list the best and worst, the book doesn't merit that level of effort. Bottom line: while there is some value in the book, it is overshadowed by its many flaws and weaknesses.
Rating: 
Summary: Bad choice to buy this book !
Review: The issues raised in this book are few, and they are well-known and they are not interesting. E.g. the stuff about Strings in Java, well everyone knows it after 0.2 hours of practice. No word whatsoever on J2EE subjects, internet/web stuff, nor anything else interesting. What is covered is only interesting for those who have no experience at all (on earth) or those who lived on Mars for the last 10 years. This book is not useful for either beginners or advanced Java users. It is a waste of time and money that you had better spend on a more informative and useful book.
Rating: 
Summary: Absolute Classic
Review: This appears on a number of lists of must have Java books, and it is definitely on mine. The first time it saves you five hours otherwise spent on some little Java detail that compiles but doesn't work as expected(with over 1000 classes it is getting difficult to know all of them by heart), it has paid for itself over and over again. Since I lack the time to inspect the Java source code to understand precise implementation details, I find this book invaluable. I only hope that another edition comes out.
Rating:
Summary: Beware the Pitfalls in this Book
Review: This book explains some of the more common pitfalls in Java programming. While I can't totally disagree with the any of the suggestions on avoiding the pitfalls, the explanations the authors give are often incomplete and confusing. Take, for example Item 17, where three pages are devoted to explaining what exceptions are. Then there is an example of catching an exception, printing some diagnostics, and re-throwing exactly the same exception. Suddenly, the topic veers to catching OutOfMemoryError. Where is the explanation of the pitfall of mistakenly catching exceptions when they should not be caught, or catching Exception instead of a subclass of Exception? In my experience, these are the pitfalls that Java programmers are more likely to run into. The authors simply didn't explain how 95% of exception handling code should be written. Another example is Item 12, where synchronization is introduced in five pages. The pitfalls I see Java programmers falling into is believing that only one synchronized method in a class may be called at a time, not understanding how static methods are synchronized, and not understanding memory barriers. The authors skip right over those topics and start discussing how to avoid deadlocks. In my first hour of looking through the book, I also found the authors confusing references with objects, passing a reference by value with passing an object by reference, setting references to null and calling System.gc() with rational memory management, exponential growth with quadratic growth, simple assertions with design by contract programming, the semantics of the C assert macro with the semantics of a Java assertion method, the Adapter pattern with a simple superclass, and the Java import statement with the #include directive of C. All of these are pitfalls that Java programmers often run into. Also be aware that nearly half of the book covers GUI pitfalls. This part of the book will be of no use to server-side Java programmers. I can recommend this book only to intermediate-to-advanced Java programmers who write GUI code, and only in addition to other books on Java style or idioms.
Rating:
Summary: Great companion to a Java language guide
Review: This book is wonderful. It contains a bunch of problematic situations that have been documented with clear, concise examples of how not to fall into traps. It is well written, and very beneficial for a Java developer with, say, 1 year's experience and who has mastered the language syntax, but who now wants to have a better insight into the trickier bits. For example it has excellent coverage of ways to deal with outOfMemory errors, and a good section on SoftReferences. It does not in anyway replace a Java language guide, but is a great companion.
Rating:
Summary: Excellent Book For Every Java Developer
Review: This is the best book I have read on Java language. There was lot of stuff I never thought about. Lot of issues is addressed in Java Developer Connection but it is hard to search into it. The best part of the book is modular approach for each concept. After reading this book I feel that if this have been released a year ago, I must have done better job. I guess this is the abstract of someone real time experience in book format.
| 
