It's amazing how some good practices limp on for decades beyond their expiration date. I still encounter people who insist that a method should have only one point of return - as if we're all still littering our code with GOTOs, and the concept of a "black-box" function was never invented.

The way these same people go on about multiple exit points, you'd think they were headlining in one of the grislier episodes of ER trying to patch up the latest guest-star casualty while predicting dire consequences for the patient as they lie, bleeding to death.

People who prefer the single exit point tend to feel very strongly about it. But the reasons they give have never struck me as especially convincing. The following stream of generic reasons reminds me of the cookie-cutter platitudes that they roll out at the end of the more nauseating US TV series that seek to emulate ER, over the soul-grinding background warble of James Blunt:

1. Bailing out early causes resource leaks. That's why we have the "finally" block. (If you're determined to have a single exit point, finally is the only way to achieve it. But purists take note, System.exit() still gets around it.)
2. Multiple exit points make code harder to refactor. Yes, because simpler, clearer code is always harder to maintain.
3. Multiple exit points is a return to GOTO and spaghetti code. Ironically, it's single-exit-point code that's the anachronism. The whole reason this misguided principle came about was the reaction to spaghetti code that was structured programming. In modern languages and runtimes, single-exit-point code is outmoded and can even be dangerous. For example, the ubiquity of exceptions means that no method is ever guaranteed to have a single exit point. Code as if it is, and you're asking to be caught out.
4. Bailing out early creates an invisible "else" clause. What rubbish. A guard clause such as this:

if (account == null) return;

at the top of a method is much clearer, than:

if (account != null)
{ // 20 lines of code
// (that are totally irrelevant if account is null)
// later...
}
// and out we pop

Sometimes, trying to weave your code into a single return point results in setting of pointless flags and excessive nesting of "if..else" conditions. It's like wrapping a paper napkin around a seven-dimensional helix and trying to read the agile documentation off it. Figuring out whether each block of code is relevant to the current program state becomes a game of lining up the curly braces to figure out where each clause finishes.

It's easier to simply say: "Hey, I'm halfway through a method but I'm done. I'm outa here!" Artificially stretching the program flow to the end of the method just results in misleading code: implying that a block of code is relevant to a given state when the runtime really has no business still noodling around in there. If it's time to exit a method, exit the method already.

Adhering to an outdated maxim like "single exit point" results in a "one size fits all" approach to programming, which is hardly a good thing. But religiously hacking in multiple return points would of course be bad as well. If in doubt, go for the simpler, more expressive option which best communicates what the code means. It's more an article of faith than anything else. It's important to be able to take a step back and make a rational judgement call: this alone helps sort out the thinkers from the believers. ®

Agile Iconoclast Matt Stephens has co-authored Use Case Driven Object Modeling with UML: Theory and Practice, which explores ways to drive functional tests and unit tests from use cases.

More comments…

Related stories

The secret to evolutionary code (24 March 2008)
Uncovered: the lost humor of flowcharts (17 March 2008)
10 ways to improve your code (10 March 2008)
Agile lands role in games and business software (28 February 2008)
UML officially an unfunny matter (20 February 2008)
Tools vendors stuck on UML and agility (13 February 2008)
Penguin-powered UML modeling (29 January 2008)
Dip into concept programming (16 January 2008)
Telltale signs your model is stuck (3 January 2008)
Sequence diagramming that's fit for purpose (22 December 2007)
How to avoid the model quagmire (18 December 2007)
Why simplicity starts with design (16 December 2007)
Close the gap between analysis and design (14 December 2007)
ITIL deeds don't go unpunished (10 December 2007)
CodeGear bets on Application Factories to transform JBuilder (3 December 2007)
Code scavenging goes formal (30 November 2007)
Java 6 for OS X 'weeks away' (28 November 2007)
Model use cases that work (23 November 2007)
The ICONIX Process in pieces: Domain modelling (13 November 2007)
A simple unit test for GUIs (12 November 2007)
Don't unit test GUIs (22 October 2007)
Why UML won't save your project (8 October 2007)
Shotgun Wedding: Enterprise Architect 7.0 (31 August 2007)