This isn't a new topic; it comes around every few years. A few years back I wrote about the debate surrounding checked exceptions, and the debate continues to rage. My problem is that I think most of the vocal opponents of checked exceptions are objecting for the wrong reasons (back then, I wrote: "My opinion is that, while properly using exceptions certainly has its challenges and that bad examples of exception usage abound, most of the people who agree [ that checked exceptions are a bad idea ] are doing so for the wrong reason, in the same way that a politician who ran on a platform of universal subsidized access to chocolate would get a lot of votes from 10-year-olds").
Reading through the against-checked-exceptions commenters on Neal's blog, we can divide them into three primary groups:
- "I don't like checked exceptions because they're too much work."
- "Checked exceptions were a nice idea in theory, but using them correctly makes your code really ugly, and I'm left with a choice of ugly code or wrong code, and that seems a bad choice."
- "Checked exceptions are a good idea, but the world isn't ready for them." (Frequent refrain from this group: "Man, have you looked at some of the code out there?")
To the people in camp (1), I say: engineering is hard -- get over it. Error handling is one of the hardest things to get right, and one of the easiest things to be lazy about. If you're writing code that's supposed to work more than "most of the time", you're supposed to be spending time thinking about error handling. And, pay for your own damn chocolate.
To the people in camp (2), I have more sympathy. Exceptions do make your code ugly, and proper exception handling can make your code really ugly. This is a shame, because exceptions were intended to reduce the amount of error-handling code that developers have to write. (Ever try to properly close a JDBC Connection, Statement, and ResultSet? It requires three finally blocks. Ugly if you do it right. But, almost no one ever does it right. (The real culprit here is that close() throws an exception -- what are you supposed to do with that exception? But that's fish under the bridge.))
But perhaps there's a way to not throw the baby out with the bathwater, by providing better exception handling mechanisms that are less ugly. Dependency injection frameworks did a lot of that for us already, for a large class of applications -- and the code got a lot prettier, easier to write, and easier to read. AFAICS, the two biggest removable uglinesses of exceptions are repeated identical catch clauses and exception chaining.
The repeated catch clause problem is when you call a method that might throw exceptions A, B, C, and D, which do not have a common parent other than Exception, but you handle them all the same way. (Reflection is a major offender here.)
public void addInstance(String className) {
try {
Class clazz = Class.forName(className);
objectSet.add(clazz.newInstance());
}
catch (IllegalAccessException e) {
logger.log("Exception in addInstance", e);
}
catch (InstantiationException e) {
logger.log("Exception in addInstance", e);
}
catch (ClassNotFoundException e) {
logger.log("Exception in addInstance", e);
}
}
You'd like to fold the catch clauses together, because duplicated code is bad. Some people simply catch Exception, but this has a different meaning -- because RuntimeException extends Exception, you're also sweeping up unchecked exceptions accidentally. You can explicitly catch and rethrow RuntimeException before catching Exception -- but its easy to forget to do that.
public void addInstance(String className) {
try {
Class clazz = Class.forName(className);
objectSet.add(clazz.newInstance());
}
catch (RuntimeException e) {
throw e;
}
catch (Exception e) {
logger.log("Exception in newInstance", e);
}
}
My proposal for this problem is to allow disjunctive type bounds on catch clauses:
public void addInstance(String className) {
try {
Class clazz = Class.forName(className);
objectSet.add(clazz.newInstance());
}
catch (IllegalAccessException | InstantiationException | ClassNotFoundException e) {
logger.log("Exception in addInstance", e);
}
}
My compiler friends tell me that this isn't too hard.
The other big ugliness with exceptions is wrapping and rethrowing:
public void findFoo(String className) throws NoSuchFooException {
try {
lookupFooInDatabase(name);
}
catch (SQLException e) {
throw new NoSuchFooException("Cannot find foo " + name, e);
}
}
Now, the wrap-and-rethrow technique is very effective -- it allows methods to throw exceptions that are at an abstraction level commensurate with what the method is supposed to do, not how it is implemented, and it allows you to reimplement without destabilizing method signatures. But it adds a lot of bulk to the code. Since this is such a common pattern, couldn't it be solved with some sort of declarative "rethrows" clause:
public void findFoo(String className) throws NoSuchFooException
rethrows SQLException as NoSuchFooException {
lookupFooInDatabase(name);
}
The rethrows clause is part of the implementation, not the signature, so maybe it goes somewhere else, but the idea is clear: if someone tries to throw an X out of this, wrap it with a Y and rethrow it.
An alternate approach to this would be possible with closures and reified generics; it would be possible to write a pseudo-control construct that said "execute this closure but if it throws X, wrap it with a Y and rethrow it." Unfortunately, with the current state of generics, we can't write such a generic method, we'd have to write a separate one for each exception type we want to wrap.
These approaches focus on the symptom -- because the arguments in group (2) are about symptoms. If we could alleviate the symptoms, people might grumble less.
The people in camp (3) are saying something slightly different. I don't really have an answer for them, because what they seem to be saying is that no matter what mechanism you give people for dealing with failure, they won't follow it. Checked exceptions were a reaction, in part, to the fact that it was too easy to ignore an error return code in C, so the language made it harder to ignore. This works on a lot of programmers who are slightly lazy but know that ignoring exceptions is unacceptable, but apparently is worse than nothing for some parts of the population. (We'd like to take away their coding rights, but we can't.)
Checked exceptions are a pain, and in some frameworks (like EJB before dependency injection), can be really painful. Once the ratio of "real code" to "error handling code" rises above some threshold, readability suffers greatly, and readability is a fundamental value in the Java language design. Even if the IDE generates the boilerplate for you, you still have to look at it, and there's a lot of noise.
On the other hand, my experiences using third party C++ libraries was even more painful than anything Java exceptions have ever subjected me to. Virtually no packages ever documented what might be thrown, so you end up playing "whack a mole" when exceptions did pop up -- and usually at your customers's site. If people are not forced to document what errors their code throws, they won't -- especially the people that the people in camp (3) are afraid of. As long as those folks are allowed to code, the value we get from checked exceptions forcing developers to document failure modes overwhelms the annoyances.
But, as I said above, I think many of the annoyances can be removed by adding a small number of exception streamlining constructs. This doesn't help Neal with simplifying closures, but it does help us get our job done with a little less pain.
Finally, a meta-note -- its really easy to misinterpret the volume of support for "removing checked exceptions" as any sort of gauge for community consensus. We're intimately familiar with the pain that checked exceptions cause; we're substantially less familiar with the pain that they free us from. (Obviously, neither approach is perfect, otherwise there'd be no debate.)
