Last year, the Italian XP pioneer Francesco Cirillo launched his famous “anti-IF” campaign. The idea is bring down the complexity of programs by using object-oriented design; the most important trick in that bag is to replace case analysis by polymorphism. For instance, to replace

if (shape.type == SQUARE)
area = shape.getSide() * shape.getSide();
else if (shape.type == TRIANGLE)
area = (shape.getBase() * shape.getHeight())/2.0;
else if (shape.type == CIRCLE)
...

by the much nicer

area = shape.getArea();

There are many other useful tricks from OO design. But I’d like to talk about another set of tricks for eliminating IFs, namely the bag of tricks of *algorithm design*.

#### Boolean values are values too.

One simple trick is to replace

if (foo and bar or baz)
return true;
else
return false;

by

return foo and bar or baz;

Now, some people prefer the first form, because they prefer operational reasoning over reasoning over boolean values (see the comments to a previous post on this subject). I much prefer the ~~first~~second, for one thing because it’s shorter. Concision is power. And I try to avoid operational reasoning as much as I can. If we push operational reasoning to the extreme we get:

if (foo) {
if (bar) {
return true;
}
}
if (baz) {
return true;
} else {
return false;
}

This *should* be equivalent to the previous two examples. But it’s not immediately obvious that it is. It requires much more *thinking*, and thinking is something I must save for important things.

#### Encapsulate IFs in well-known functions

Suppose you must find the maximum value of two numbers. Please don’t write

if (x > y)
return x;
return y;

It’s much better to write

return max(x, y);

Try to extend these two examples to the maximum of *three* numbers and see which one turns out clearer. The fact is that while we stay in the realm of *expressions*, we can exploit many nice properties, such that `max`

is associative; in the realm of IFs it’s much more difficult to reason. You must simulate execution in your head, and that takes energy away from you; energy you might spend on other, more important problems.

Another example: replace

if (x < 0) return -x;
return x;

by

return abs(x);

If your language does not provide an `abs`

function, you can define it nicely as `max(x, -x)`

.

#### Zero is a perfectly good number

This code returns the sum of the elements of an array.

// ugly and wrong
int arraySum(int[] array) {
int sum = array[0];
for (int i=1; i < array.length; i++) {
sum += array[i];
}
return sum;
}

Can you spot the error?

*

* *

Yes, it breaks for empty arrays. If we keep it this way we'll be forced to pull ifs in the calling code, in all places where we call this method:

// very ugly
if (x.length > 0) {
s = arraySum(x);
} else {
???
}

This is ugly, and verbose. And it's not entirely clear what should happen when the length is 0. Should we give up and throw an exception? It's much better to stop treating 0 elements as an error. An empty array is a perfectly good array, and the sum of 0 elements is 0.

// still ugly
int arraySum(int[] array) {
if (array.length == 0) {
return 0;
}
int sum = array[0];
for (int i=1; i < array.length; i++) {
sum += array[i];
}
return sum;
}

Now it's correct, but there's no need to treat an empty array as a special case:

// good
int arraySum(int[] array) {
int sum = 0;
for (int i=0; i < array.length; i++) {
sum += array[i];
}
return sum;
}

Now if the array is empty, the loop will be executed 0 times, since `0 < 0`

is false. The result will be correct for all N ≥ 0.

Whenever you have to apply a binary operator such as "+" to a set of values, you should ask yourself what should be the answer for 0 elements. If the binary operator has a unit element, that is an element that leaves the other operand unchanged:

0 + n = n + 0 = n, for all n
1 * n = n * 1 = n, for all n
max(−∞, n) = max(n, −∞) = n, for all n

the result of applying the operator to a set of 0 operands should be the unit element. The sum of 0 numbers is 0, the product of 0 numbers is 1, the maximum of 0 numbers is `−∞`

. Why is that? Because it's the only logical answer. Think about this: if you split array A with 10 elements in two parts, A0 and A1, with 5 elements each, you expect that sumArray(A) be equal to sumArray(A0) + sumArray(A1). You expect exactly the same result if you split A so that A0 has 3 elements and A1 has 7. It's only natural to expect the same result if you split A such that A0 has 0 elements.