Customer Reviews

Robust Java: Exception Handling, Testing, and Debugging

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

 

 

Unfortunately I am disappointed with this book. I guess I had high hopes that it was going to provide a lot of information that I didn't know and principles (backed by examples) that would help me learn some really valuable exception handling patterns.

I'm not sure who the intended audience is. The book is probably ok if you are relatively new to Java and it's exception handling features, but on the whole it did not add much to my skill set. But then there are also a couple of sections that reference concepts from Servlets/JSP and EJB, so if you are a newbie you might be confused.

In my opinion most of the book covers basic topics that you will already know or just as easily get from the API docs. For example, chapters 7-9 (130 pp.) talks about "core" Java classes, Collections, I/O, distributed APIs, and J2EE. It describes the various types of exceptions that can occur and what they mean. Unless you don't know how to read the javadocs, there is no new, useful info there.

It also seems to lack focus throughout. Too much of the book covers material outside of the scope of exceptions. For example, it discusses common software patterns and then just throws in a couple of sentences about exception handling to tie it back in. However, for the most part the exception handling techniques are not described well enough and lack thorough, concrete examples.

I wish the author would have made chapter 12, exception handling patterns, the bulk of the book. Then maybe I would feel closer to the book's claims of "Master application-wide exceptyion handling startegies" and "Learn proven design patterns for handling exceptions in code".

Maybe I was just expecting too much. After reading the books description I was expecting something like "Core J2EE Patterns" for the exception realm - something that would get me excited about applying a bunch of new patterns/techniques. But I really got a book of general information.

If you already have a solid grasp on exceptions (e.g. concepts like chaining, when to handle vs declare, custom application exceptions, multi-tier environments, etc) then I don't recommend this book.

Nobody wants to think about all of the things that can go wrong in an application. We all want to think about everything the application should do when everything goes right. But such is not always the case and we need to think about what happens when errors occur and exceptions are thrown.

This book starts with the basics of exception handling. Going through the do's and dont's in a very well written and informative manner. It then presents the exception handling specifics for each of the API, from the Java core, all the way through J2EE. Perhaps the most interesting part is saved for last as the author presents design patterns for exception handling.

This is an excellent work on error handling. It teaches the basics and leaves you with a good feeling that have you tools at your disposal to handle the errors. As opposed to trying to effectively disguise your head as you stick it in the sand.

I've been using this for a couple of months now, and it's already paid for itself. I like that the author actually spelled out best practices for exception handling in the first part of the book. There are also good pointers for how to avoid common programming problems in Java.

In the second part of the book, there's a lot of good info about exceptions in the Java APIs. It's helpful that the author actually tells you reasons behind WHY code breaks and gives advice on how to deal with problems in code.

Robust Java covers a lot of ground from how to view exceptions in Analysis and Design, to how Java uses exceptions, to how specific APIs use exceptions, to testing and so on. The book's greatest strengths are in the areas of Design and Architecture in which Steve provides solid principles and guidelines for creating an exception model across a multi-tiered system.

This book is very helpful! I strongly recommend it!