Java Pitfalls: Time-Saving Solutions and Workarounds to Improve Programs

I can not say enough good things about Java Pitfalls. I actually recieved this book as a gift and was overwhemingly surprised with the amount of applicable knowledge that this book provided me almost immediately after I started reading it.The premise of Java Pitfalls is primarily to help those who are familiar with the langauge and have had some experience producing applications in Java. As with all programming languages, there are always better, more efficient ways to do things. Some are obvious and usually cross many languages, and some are not so obvious and are very language-specific.Java Pitfalls points out a lot of common mistakes made in Java development as well as providing optimization and means of producing much cleaner code that runs faster and uses less memory.The examples are very thorough and the book is very concise in its reasoning for why certain ways of implementing Java are faster than others, complete with benchmark results comparing the common ways of implementing solutions to their more optimal solutions. The book doesn't just show you how to write code more efficiently, it also explains to you why some methods are better than others.Again, I can't say enough about this book. It's like having a group of experienced Java engineers sittings beside you as your program. A great book all around.

I've found this book to be excellent in its coverage of key Java concepts, problems, and Java-related programming challenges. Several of the items covered may be old news to you or issues you have already picked up on along the way. However, those items that the book addresses that you have yet to come across will save you many hours of tears & toil by reading it now.

I've reviewed quite a few Java books about improving the attributes of Java software. Some concentrate on improving the design, others the robustness of software or the performance. While they usually start out promising, by the end of the book you're left with a good understanding of theory but little practical skills. Java Pitfalls : Time-Saving Solutions and Workarounds to Improve Programs, breaks free of that mould, by providing a wealth of techniques and code that has real practical application. The title does not do it justice, however. Not only does the book show you how to improve programs, the advice contained within also saves you time, frustration, and effort. After reading through even a few pages of tips within the book, you understand that the advice isn't dry theory, but practical advice gained from real-life problems that Java developers face. Michael Daconta, and his co-authors, offer warnings gained from the trenches of software development using Java. The book is divided neatly into eight sections, covering different aspects of Java programming. A wide range of areas are covered, from the obligatory Java language syntax, to more fun topics like graphical user interfaces (using AWT and Swing), the utilities package and collections, input and output (I/O), and even improving Java performance. The one significant area lacking from the book, in my opinion, is a section on network programming pitfalls, and perhaps other advanced topics like databases. These areas are fraught with pitfalls for the unwary. However, for readers not involved with such areas, this is a moot point, and it leaves more room for other tips. There are a total of 50 individual pieces of advice, and each is packed full of detailed code examples. Whether you're a Java newbie, or an experienced Java developer looking to improve your coding and reduce the frustration and time of software development, Java Pitfalls is an ideal addition to your book collection. With the usefulness of this advice, you'll probably find it taking a place on your desk though, rather than the bookshelf. -- David Reilly, reviewed for the Java Coffee Break

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.

I always enjoy reading these types of "tips" books. Generally speaking, this book offers good tips and solutions to Java's "pitfalls" by using well-written examples. And by reading this book I understand Java more and more. Without it, we could read and read more about the "Java Programming Language" book in order to understand throughout where the "pitfalls" are. So this book can save us a considerable time! Another similar book, "Practical Java Programming Language Guide" of Peter Haggar, also offers excellent tips and solutions. To some extends, both provide inside understanding of Java and some problems that Java programming may encounter. This book mentions a more variety of problems while "Practical Java Programming Language Guide" provides more deep explanations. Get both if you can afford! They are worth the money!