This is the story about consequences of eliminating checked exceptions in Groovy. All observations made on relatively big project, around 60 developers.
Observation 1 - catch them all :)
In some cases it was Exception, in some Throwable (like you can recover from OutOfMemory). As a result, non-recoverable exceptions are often treated as recoverable and otherwise. They are logged with same level and escape bug tracking system.
Observation 2 - invent complex return types
If exceptions can't be used as class API, developers start inventing complex return types that wrap value together with response status. This had several consequences:
1) propagation of this status is a pain. Just imagine calling several methods and checking whether there was an issue after each call.
2) Many transaction definitions were broken. They were handled by Spring and were supposed to be rolled back on exception, but method just returns error code, no exception.
3) No stack traces. Often this was a result of "catch them all -> return error code. The only way to figure out real cause is to debug.
3) No stack traces. Often this was a result of "catch them all -> return error code. The only way to figure out real cause is to debug.
As a conclusion, I would advice to become friends with exceptions and try to avoid cowboy style languages. There are definitely areas where Groovy rocks, like scripting, but don't try to push it everywhere. Keep in mind that coding is easy and does not take much time. Debugging does.
