Rating: 
Summary: Excellent practical advice
Review: As an intermediate Java programmer, I've hit several of the items in this book, and it's already saved me time in finding my mistakes. As my application gets more complex, I know that some of the more advanced topics will be useful - for example, memory management when dealing with large amounts of data, and a detailed discussion of cloning that I'm working with right now. I recommended that we get a copy for my development group, and I've told everyone in the group that they should read it, but they're complaining that I'm always using it! :-)
Rating: 
Summary: Good concept, but has no depth.
Review: 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.
Rating:
Summary: Excellent examples/solutions to java pitfalls
Review: Banging your head trying to solve java problems? Try "Java Pitfalls". This book exploits problems that Java developers commonly face. Java Pitfalls provides short concise sections that describe common problems and provides excellent code examples and solutions. These guys did their homework!
Rating: 
Summary: Don't buy unseen
Review: Don't buy this book unseen. I did and I regret it. It was certainly not the eye-opener I hoped it to be. I'm sorry, but I just don't find the examples very useful, the book offers solutions to problems which I personally have never encountered.
Rating:
Summary: A Must-Have!!!
Review: For anyone serious about learning and understanding the issues programmers think about! Daconta helps you plug those holes in the technology that other authors or instructors never tell you exist!!! A must-have, not only to see the issues running through a programmer's mind, but if you're serious about "being that mechanic with all the tools" and want to know HOW to the use those tools!!!
Rating:
Summary: Good Tips and Solutions
Review: 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!
Rating:
Summary: Experienced to Advanced, this book is a must-have!
Review: 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.
Rating:
Summary: Excellent Coverage of Key Java Problems
Review: 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.
Rating:
Summary: Excellent and practical guide for all Java developers
Review: 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
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.
|
