From math, we know that X < Y is the same as Y > X. But in programming, they're not the same.

Oh, I'm not talking about situations where X and Y have side effects that interact badly. Instead, I'm talking about situations where one may be more error prone than the other.

Although the two expressions are mathematically equivalent, they're not *linguistically* equivalent. One focuses attention on something being smaller, and the other focuses attention on something being bigger. For example, it is a relatively common mistake to go the wrong way when searching a binary search tree. However, almost every time I run into this error, the student has also written the comparisons backward from the direction I think of as “natural”.

Consider the following function for determining whether a given key `x` appears in a binary search tree `t`:

function member(x,t) is if t = null then return false if t.key = x then return true if t.key < x then return member(x,t.left) if t.key > x then return member(x,t.right)The fact that I've written this using recursion instead of iteration is irrelevant. What matters is that the third case goes left when it should go right, and vice versa for the fourth case. But looking more carefully at that third case

if t.key < x then return member(x,t.left)I'm not particularly surprised by the error. The comparison

`t.key < x`focuses attention on something being smaller, and the left side of the tree is where the smaller keys go. By asking whether

`x`is smaller than

`t.key`, rather than whether

`t.key`is smaller than

`x`, I think we're much less likely to fall into this trap.