Comments on: Finally, a use for checked exceptions

By: Andy Palmer

Andy Palmer — Fri, 18 Nov 2011 07:13:00 +0000

Good point. I have used Call Hierarchy, although when I read your comment, the idea that popped into my mind was ”debugging”.
I use “Find references in workspace (g)” a lot while refactoring (particularly while deleting code), but not Call Hierarchy. I’m not sure why; I’ll investigate that feeling next time I’m doing something like this.

Also, yes, the point of this is to leverage the compiler to help make sure we’ve removed all traces of the original null. I hate null checks within code I control, as that is indicative of a bad citizen (see Good Citizen)

By: Demian Alonso

Demian Alonso — Fri, 18 Nov 2011 01:29:00 +0000

Just a little contribution: Many ideas do have a way to search for references hierarchically. I now for sure that in Eclipse is called “call hierarchy”, but I am quite sure that on Idea is possible too, but I do not know the shortcuts

Still, the “it won’t compile” technic does prevent you from missing any case.

By: Andy Palmer

Andy Palmer — Thu, 17 Nov 2011 17:15:00 +0000

Good point. Although I would hope (for my sanity) that if there are catch everything blocks in the code, that they’re doing something sensible and I don’t need to go and change them at this point.
(I’ll probably go and rip them out at the soonest opportunity though )

By: Andy Palmer

Andy Palmer — Thu, 17 Nov 2011 17:14:00 +0000

Yes, although the advantage of this method is that it propagates _beyond the direct usages_.

By: Andy Palmer

Andy Palmer — Thu, 17 Nov 2011 17:12:00 +0000

The advantage is that it highlights the direct and indirect usages of someMethod. Direct usages is obviously trivial, it’s the indirect usages where the bugs usually lie.

By: Dileep Mandapam

Dileep Mandapam — Thu, 17 Nov 2011 16:28:00 +0000

I don’t see any other advantage of this refactoring technique , other than finding usages of “someMethod”

By: Ricky Clarkson

Ricky Clarkson — Thu, 17 Nov 2011 16:03:00 +0000

You’ll need to remove all the catch (Exception e) and catch (Throwable t) instances that inevitably end up in large code bases precisely because of checked exceptions.

By: Andy Palmer

Andy Palmer — Thu, 17 Nov 2011 15:46:00 +0000

If my someMethod() from above was used in another method like so:
public Result someOtherMethod() {
if (someValue) {return something;}
return someMethod();
}

then the value of someOtherMethod can also be null. So I also need to check the callers of that method, and so on, until I reach someone who either knows what the sensible thing to do with the value is or, I reach the extremities of the program (for example, the main loop or the request handler).

In the simple case, there isn’t a need to do this, but removing a null return should encompass the entire system, and this method ensures that this is the case.

You are correct about reflective calls, but I would hope that people using reflective calls were aware of the power (and therefore, danger) of that approach.

By: Alex Shneyderman

Alex Shneyderman — Thu, 17 Nov 2011 15:36:00 +0000

Hmm, I do not understand the second part of the explanation. The first five markers is all you need I would think. The rest is noise – although I do not understand why/how out of five usage places you would get another 20. If I have a method cal chain like so:
someUsageOfUsage -> usage -> npeProblem(this is the method where we add new Exception)I would only get trouble reports with the last portion of the chain (5 usages) pointing to the usage methods. The rest is noise, but I think compiler would not even complain aout the first link in the chain) and I woud not like to deal with that at all. So, I do not really see transitive use here. How?

Of course, it would be worth mentioning that the limitation of the trick is the loose coupling (reflective calls, JSP pages, etc). This method fails, and would only give the person using it a false sense of understanding.

By: Thomas Kriegelstein

Thomas Kriegelstein — Thu, 17 Nov 2011 14:39:00 +0000

Changing an API and relying on the compiler to highlight the downstream changes is so clever. I might not have thought of that several years, like 10, before. Anyways kudos for sharing that stuff. And it works with your favorite IDE, e.g. Emacs, Notepad and vi too.