Customer Reviews

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

5 star:		(12)
4 star:		(1)
3 star:		(2)
2 star:		(2)
1 star:		(2)

 

 

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 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.

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).

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.

At first this looks like a really valuable book. It shows the common pitfalls of Java and elegant ways to get around them. Who wouldn't want to know this stuff? After delving into it, however, this book turns out to be very weak. A major problem is that the book assumes that the user is very new to Java (and OO in general), and therefore the advice is very superficial. For instance, the section on finally blocks start out by consoling the programmer on how annoying it is to have to put a try-catch block around certain code just to compile. He gives no in-depth guidance at all about what try-catch (or exceptions in general) are even for, but instead throws pages upon pages of code that doesn't really prove anything. Unfortunately I cannot recommend this book for any reason, since it is not a comprehensive Java book (like Thinking In Java) and instead focuses only on the pitfalls at a very easy level, which doesn't help the new Java programmer much at all. Any Java developer with 6 months of professional experience will know at least 80% of what's in this book simply because it comes with experience.

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!

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.

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.

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.

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.