t+1 - Latest Comments in Which code layout do you like more?

Re: Which code layout do you like more?

miles — Mon, 27 Jul 2009 13:03:58 -0000

return ( b ? h(g(a)) : g(a))

... assuming ternary operators...

Re: Which code layout do you like more?

Brandon Corfman — Thu, 25 Jun 2009 10:03:25 -0000

Shouldn't the function name be "price" instead? Why introduce a variable just for naming when the function name serves that purpose?

Re: Which code layout do you like more?

Michael — Fri, 19 Jun 2009 22:17:14 -0000

With multiple return points I find myself spelling out implicit else statement:

def(a,b):
__if b:
____return h(g(a))
__else:
____return g(a)

Re: Which code layout do you like more?

Guest — Fri, 19 Jun 2009 18:08:03 -0000

I'd prefer the first one, easy to read, easy to understand.

Re: Which code layout do you like more?

rgz — Fri, 19 Jun 2009 13:08:07 -0000

I on the other hand love multiple return statements in loops and --while using php-- switches. I actually find that situation a lot using switches.

In some switches I don't use break at all since all my cases end with return. Some times however I have to do additional work before getting out of the function, then it's temp variable time again.

Re: Which code layout do you like more?

Titus Brown — Fri, 19 Jun 2009 12:54:47 -0000

For me, it depends on the rest of the code in the function. Multiple obvious return statements aren't "bad":

def f(...):
if param is bad:
return None

... do stuff ...
return answer

but I don't like having returns sprinkled throughout the code, and especially not in loops, where it can complicate the logic of the execution flow.

Re: Which code layout do you like more?

Bård Aase — Fri, 19 Jun 2009 07:04:54 -0000

the indentation disappeared. Using _ as space:
def(a,b):
__if b:
____return h(g(a))
__return g(a)

Re: Which code layout do you like more?

Bård Aase — Fri, 19 Jun 2009 07:03:52 -0000

How about
def(a,b):
if b:
return h(g(a))
return g(a)

Re: Which code layout do you like more?

Charles — Fri, 19 Jun 2009 07:01:23 -0000

I first learnt to program in the early 1990s using books, and thus methodologies, that were already old and discarded by their previous owners. All I really remember was the love of flowcharts and subtle re-enforcement of the idea that multiple return statements made code so hard to read that anyone else who saw it would meet an untimely end.

I think modern teaching styles have moved towards a more understanding based approach that credits the student with a little intelligence. Consider the following fragments of introductory programming:

* All functions must return a value
* No code after a return is executed
* a function can only return one value

Nice nuggets of information that can be memorised by rote. So very early on one gets into the habit of putting the return at the end of a function because it has to be there and thinking nothing more of it. It took a long time for me to unlearn that habit.

Re: Which code layout do you like more?

Martin — Fri, 19 Jun 2009 06:39:36 -0000

hmmm

def f(a, b):
temp = g(a)
if b:
return h(temp)
return temp

Re: Which code layout do you like more?

^love *encounter ~flow — Fri, 19 Jun 2009 06:23:11 -0000

def f(a, b):
if b:
return h(g(a)
return g(a)

Re: Which code layout do you like more?

Tennessee Leeuwenburg — Fri, 19 Jun 2009 00:39:35 -0000

Absolutely... I try to do a single return where it makes no difference otherwise, but multiple returns where it makes the function that much clearer. Where I do multiple returns, I try to put a block of early return conditions together at the start of the function, then the body, then a single 'real' return value (if possible)

Re: Which code layout do you like more?

Aaron Oliver — Fri, 19 Jun 2009 00:35:39 -0000

If you follow that too strictly, you can end up with huge, unwieldy blocks of conditionals. Suppose you have a function where you want to "fail fast". Well, a single return point means you need to create a huge if/else. This is HUGE, and new programmers fall into this trap all the time.

With multiple returns, we can do:

def launch_rocket(mode):
if mode == "test":
return True
#100 lines of launch code

With only one return, we get a 100-line conditional block, not counting any other block within it:

def launch_rocket(mode):
success = None
if mode == "test":
return True
else:
#100 lines of launch code
return result

Re: Which code layout do you like more?

rgz — Fri, 19 Jun 2009 00:18:37 -0000

They are not the same, I mean, in this case they are but only because the functionality of g(x) is external to f(a, b). In fact f(a, b) is pretty much a wrapper for calling g(x) given a and b.

Suppose you are writing new code, g(x) is not defined yet and once it is defined it will only be called from f(a, b), in fact g(x) is only being defined to be wrapped by f(a, b), g(x) is a helper function.

In production, these functions will have a longer names as fubar_bloops(a, b) and fubar_bloops_helper(x) or something similar.

This is ugly. Instead you should write g(x) inside f(a, b) because that is what you really mean, using that approach you end up with the first layout.

Aaaaaaanyway, in this context I'd use *this* layout:

def f(a, b):
return h(g(a)) if b else g(a)

or just
f = lambda a, b: h(g(a)) if b else g(a)

Re: Which code layout do you like more?

Tennessee Leeuwenburg — Thu, 18 Jun 2009 23:59:01 -0000

The first approach can make for easier debugging, since you can then step through your method watching where your return value is updated, then easily override it through the debugger if you need to. It also means the function *always* returns on the same line number, so you can put a break point in immediately before it and catch the function immediately before returning. If means you can do things like

bp 1043, retVal=None

and let the debugger catch the time through the code you are returning None.

Cheers,
-Tennessee

Re: Which code layout do you like more?

tv — Thu, 18 Jun 2009 22:03:26 -0000

this one wins

Re: Which code layout do you like more?

Calvin Spealman — Thu, 18 Jun 2009 21:47:31 -0000

I can use both, depending on the context. The difference is in the intent. Is the call to g() essential to executing f() or is it coincidentally needed for both conditions?

Re: Which code layout do you like more?

LE — Thu, 18 Jun 2009 18:30:30 -0000

I'm not consistent with these things. Why would you be? I go by what is more aesthetically pleasing, in your case (which by the way says nothing about mutability?) I'd go for two returns because it's more succinct somehow.

Re: Which code layout do you like more?

John — Thu, 18 Jun 2009 17:48:45 -0000

This.

Re: Which code layout do you like more?

Paddy3118 — Thu, 18 Jun 2009 16:37:09 -0000

def to_int_or_list(fpnumber, as_list=True):
    return list(int(fpnumber)) if as_list else int(fpnumber)

if the funcction was doing something more obscure, then I might employ a temporary variable and use one exit point or two - whatever seemed more natural.

- Paddy.

Re: Which code layout do you like more?

Dougal Matthews — Thu, 18 Jun 2009 16:34:29 -0000

I prefer the first. However, if its a simple 5 line function then the second. Larger functions then I try to keep one return point...

If you end up with more than 2 return points it gets ugly and confusing.

Re: Which code layout do you like more?

Markus Gritsch — Thu, 18 Jun 2009 16:17:45 -0000

Returning in the middle of a function is bad. It is like using goto. It violates D-diagramm conformance (you can find out more about this by using Google). Using a variable has the additional benefit that it can have a meaningful name which makes it more clear *what* the function returns -- for example price = ... And the return price. temp in your example is a bad name anyway.

In you case you can use Pythons relatively new ternary operator to have both advantages: Only one assignment and only one return statement at the end of the function:

def f(a, b):
price = h(g(a) if b else g(a)
return price

Re: Which code layout do you like more?

Aaron Oliver — Thu, 18 Jun 2009 16:12:03 -0000

Well shoot. Ignore the second part of my comment then.

Re: Which code layout do you like more?

Peter Shinners — Thu, 18 Jun 2009 16:06:07 -0000

The only reason I don't like the second one is that it packs too much functionality on a single line. I don't care about preferences for a "single return". But I don't like how g(a) is called from two different places in the second version. Imagine adding logging or exception handling to this function. Which version is more modifiable?

I prefer dgou's code.

Re: Which code layout do you like more?

Brandon Corfman — Thu, 18 Jun 2009 15:49:46 -0000

return h(g(a)) if b else g(a)