Efficient programming only comes with experience and only those who know the pitfalls know how to avoid them. This book is not for beginners. Familiarity with different API packages such as java.util, java.io, java.awt, and javax.swing is necessary.
The book is neatly categorized into eight logical sections. Each section contains several "gotchas" of Java language that can catch you unaware. Each of these "nuggets of wisdom" teaches you about some specific drawback of Java language and the different ways you can steer away from the pothole. Each topic is short, crisp and is accompanied by code.
The book has a little bit for every kind of reader. If you are not an amateur but always get stumbled on language subtleties, check out the items - Usage of String equals () method versus the = = operator, the "hidden field" pitfall, properly cloning an object and why one should avoid using a constructor while implementing clone() method. These language 'features' have the potential to make you debug the program for several days. If you are an experienced Java programmer you will benefit from the topics such as - reclaiming references when using SoftReference objects and sending serialized objects over sockets etc. For architects and the performance-savvy, the book has some interesting implementation patterns such as handling huge collections with caching and persistence, better data validation techniques, lazy loading for better performance and using object pools for excessive object creation.
The book lacks sections on popular (and error-prone) topics such as Threads, Networking and Remote Objects. Some code samples contain minor syntax errors. There are some lengthy Windows SDK programs which may not appeal to those from non-windows background. Last but not least there is no accompanying source CD. (Ajith Kallambella - Sherriff, Dec 2000)
<pre>Author/s : Michael C. Daconta, et al Publisher : Wiley Category :Advanced Java Review by : Salman Halim Rating : 8 horseshoes</pre> The book contains fifty pitfalls that are arranged in eight categories with a brief description of each pitfall at the beginning of the category. This allows the book to be used as a reference after an initial look-over. While there will be the initial item that discusses relatively less advanced topics such as language constructs or the usage of the 'finally' clause, there are plenty of other items that will hit home resoundingly. Early on, I found items 14 and 15 (both dealing with cloning) to be quite instructive. Good, solid book -- covers enough topics to contain something useful for just about everybody. Puts the problems in context and provides explanations for what might be going wrong. The pitfalls are usually illustrated with code and examples of cases where they might come up. They cover many topics such as GUI design, performance and Collections and are discussed quite thoroughly. A nice thing is that many of the pitfalls aren't programming ERRORS, per se, but design problems that might affect maintenance -- for example, the maintenance difficulties that arise from a class with a single complex constructor or lazy loading to aid performance. There IS the occasional typographical error (usually in code) but nothing crippling. Recommendation: new programmers should read the book. Busy experienced programmers could treat it as a reference and only look at topics related to their current project. However, a straight read won't be a waste of time for even experienced programmers.