Microdesign and red flags -- or "why else-clauses are red flags"
blog.borud.no
blog.borud.no
I've heard the advice (p291 Code Complete 2) is to put the most commonly executed code-path (i.e. the one that occurs if all guards are passed) at the top of your function, and the fails below. However I've also heard the advice "fail fast". I suppose that a compromise could be to separate your functions into safe and unsafe versions, with the former containing the guards and if appropriate, calling the latter. This could be worked into the pimpl idiom quite well.
There are obviously cases where the "else" statement is the best option.
To sum up, complexity of code is often a trade-off, and it's rarely well-defined anyway.
In fact, if I did present you with those statistics you should be even more wary because of the tendency of people to accept "research" without question. A good example is the "research" that has been done on pair-programming. The only conclusion I am able to reach from what I have read on the subject is that "it depends". Of course, I can interpret what has been published in ways that'll make the case both ways and mislead the uncritical reader to my liking :-).
I am also wary of what I call "dogmatic programming". Just because some "authority" says you should do something doesn't mean that it is correct or valid in other contexts. For instance something that is a good practice in Pascal might not be at all applicable in Lisp.
The concrete examples given in the blog posting may divert attention away from the main point I was trying to make about "red flags" and the need to stop and think. Indeed, most people who have commented on the posting (on Reddit and in email) seem to get hung up on the second, "cleaned up" form of the example given. My bad.
One reason is to have result or loop variables, which help debugging. You can ask debuggers to watch the value change, or print it, and so forth. Almost always create variables; ignore premature-optimization "experts" who think they've sped stuff up because they used fewer variables.
Cleanup isn't repeated. I despise "hunting" for return statements to ensure the same 3 things always happen. Yes, maybe functions shouldn't do so much; but if you're stuck maintaining something you didn't write, you still have to be able to apply a change correctly.
Another problem with multiple returns is inconsistent types. I've seen code where one person did "return false" and another did "return 1.0" in the same function; whereas, if you're forced to type "isOK = 1.0", you'll see the problem immediately.
And a single return point keeps overly-complex logic in your face, so that you have good incentive to fix it. You're less likely to put off refactoring an ugly and oversized function if you keep having to scroll through it to figure out what a single case is doing. Less code is ultimately good for maintainability.
Now, an important point is that I use different languages these days than I did in the 80s. Also, back then I didn't write a lot of (or any?) concurrent/asynchronous code, so the programming style was far more linear and synchronous. The things that applied to my 1980s Pascal or C programs are not necessarily true for my Java/Groovy/C/C++ programs today.