Code readability vs conciseness

Question

What are the merits and demerits of the following two code snippets:

return n==0 ? 0 : n==1 ? 1 : fib(n-1) + fib(n-2);

and

 if(n==0)  
    return 0;
 if(n==1)
    return 1;
 return fib(n-1) + fib(n-2);

for calculating the nth letter in the Fibonacci sequence?

Which one would you favour and why?

Answer 1

The first one is the devil and must be purged with fire.

Answer 2

I would favour:

return n <= 1 ? n : fib(n-1)+fib(n-2);

Answer 3

I would prefer writing:

if (n == 0) {
    return 0;
}
else if (n == 1) {
    return 1;
}
else {
    return fib(n-1) + fib(n-2);
}

This is very readable code. I don't even like omitting braces as the code is not that readable and when you maintain code that omits braces, you easily make bugs.

Answer 4

Everything in life is a matter of equilibrium. Finding the right compromise between two opposite ends of the spectrum. Optimality is a scoring function that is highly dependent on the evaluator, and the situation, but you should strive for the sweet spot in everything.

Programming is not different. you should evaluate

• simplicity
• terseness
• efficiency
• practicality
• artistic freedom of expression
• time constraints

and find the sweet spot.

Your first construct is clearly powerful and geeky, but definitely not easy to understand.

Answer 5

I prefer the second over the first, mostly for readability.

The second "reads" well - it has the code broken up, so it reads most like English. This will make it easier to understand for many developers.

Personally, I find multiple, chained ternary operations difficult to follow at times.

Also, I personally find "conciseness" to be a poor goal, in most cases. Modern IDEs make "longer" code much more manageable than it used to be. I'm not saying you want to be overly verbose, but trying to be concise often causes an increase in the maintenance effort, in my experience.

Answer 6

If you're asking for readability, I'd prefer the second option because it doesn't contain the (double!) ternary operator. Usually you're writing code that other people also have to read, and from the second snippet, it's clear at first sight what the function does. In the first snippet though, one has to resolve both ternary operators "in your head" and additionally think about associativity (I'd think about that automatically because parentheses are missing).

But anyway, you could reduce the two if statements to one:

if(n <= 1) return n;
return fib(n-1) + fib(n-2);

Answer 7

Of the two, the second is easier to understand at a glance. However, I'd consolidate it as

if (n <= 1) 
  return n;
else
  return fib(n-1) + fib(n-2);

Or, if you're not into multiple returns:

if (n > 1)
  n = fib(n-1) + fib(n-2);
return n;

Answer 8

I often find that indentation can make the multiple-ternary operators a lot more readable:

return n == 0 ? 0 :
       n == 1 ? 1 :
                fib(n-1) + fib(n-2); 

Answer 9

I'd prefer neither because they are both too slow. Readability should not come at the cost of an exponential explosion in runtime, especially when there exists a simple way that runs in linear time.

I'd do this something like this (pseudo-code):

a = 0;
b = 1;
n.times { a, b = b, a + b; }

In C you'd have to use a temporary variable unfortunately, but the principle is the same.

Answer 10

I'd bet there's no difference in the compiled code. I'd at least try to make it a little more readable:

return n==0 ? 0 : ( n==1 ? 1 : fib(n-1) + fib(n+1) );

Answer 11

I prefer the second one in most situations, but there are times where it seems a bit of a waste to not do it in one line. For instance, I'd prefer

text="my stuff_"+id==null ? "default" : id;

to

text="my stuff_";
if(id==null){
  text+="default";
}else{
  text+=id;
}

Note, this also helps with DRY because now if you need to change the name of text then you only change it in one place, compared to 3.

Answer 12

if you use the ?: operator two or three times you will get used to it so i would go with the first

Answer 13

I'd say even more than @Lauri:

if (n == 0) {
    tmp = 0;
}
else if (n == 1) {
    tmp = 1;
}
else {
    tmp = fib(n-1) + fib(n-2);
}
return tmp;

It's good to have just one exit point.

Answer 14

As a generic rule, you should write readable code, which means code which is most readable by the people who will actually read it. Most of the time, this means "yourself, three weeks later". When you write code, the good question is then "will I be able to read and understand it again next month ?".

Apart from that, the first expression is buggy (it uses fib(n+1) instead of fib(n-2)) and both exhibit the exponential explosion which makes Fibonacci sequence a classical tool for teaching some important practical aspects of algorithmics.