# Hilarious Conditional Bloopers!

For this Friday, I thought I’d do something a little more lighthearted and, in the tradition of bad television (or Robot Chicken’s satire thereof) post some programming bloopers. These are actual things that I’ve personally seen in source code as opposed to some kind of specific sampling of CodeSOD from the Daily WTF. Doing this series of posts about Boolean algebra made me think conditional logic fails I’ve seen both recently and long in the past.

For each one, I’ve tried my best to give it a catchy name, an explanation of the problem, an example of what it translates to in simple English (i.e. why it doesn’t “read like well written prose”), and what it ought to look like. So, without further ado, here are the bloopers:

### The Ingrown Branch

```private int _numberOfMilkCartons;
private bool _amIOutOfMilk;

public void FigureOutWhatToDo()
{
if(_numberOfMilkCartons != 12)
_numberOfMilkCartons = 12;
}
```

I call this The Ingrown Branch because of what it does. It introduces a conditional — a fork in the road, if you will — and it winds up in the same spot no matter which branch you take. In conversational English, this says “if the number of milk cartons is not 12, make it 12”. While this doesn’t sound ridiculous in the same way that others here will, consider what’s being done. If x is equal to 12, well, then do nothing because x is equal to 12. Otherwise, if it’s not equal to 12, set it to 12. What would be a simpler way to do this?

```private int _numberOfMilkCartons;
private bool _amIOutOfMilk;

public void FigureOutWhatToDo()
{
_numberOfMilkCartons = 12;
}
```

### The Tautology

```private bool _amIOutOfMilk;

public void FigureOutWhatToDo()
{
if(_amIOutOfMilk || !_amIOutOfMilk)
GoToTheStore();
}
```

In conversational English, a tautology is something that is vacuously true or redundant. In logic, this is something that is always true, ipso facto, such as “A or NOT(A)”, for instance. In terms of conversational English, this is like saying “If I’m out of milk or if I’m not out of milk, I’m going to go buy some milk.” Why not drop the spurious conditionals and get to the point:

```public void FigureOutWhatToDo()
{
GoToTheStore();
}
```

```private bool _amIOutOfMilk;

public void FigureOutWhatToDo()
{
if(_amIOutOfMilk == !_amIOutOfMilk)
GoToTheStore();
}
```

The opposite of a tautology, a contradiction is something that is vacuously false, such as primitive type not being equal to itself. With instances like this and the tautology, I usually see more complex incarnations that are harder to spot or else I give the benefit of the doubt and assume that manipulation of a more complex conditional occurred in the past and the thing was accidentally left in this condition. But this doesn’t alter the fact that I have seen code like this and that, in plain English, this would translate to “If I’m both completely out of milk and I have some milk, I’m going to buy milk.” It’s mind-bending nonsense that would best be described as:

```//Yep, nothing at all
```

### The Double Negative

```private bool _amINotOutOfMilk;

public void FigureOutWhatToDo()
{
if(!_amINotOutOfMilk)
GoToTheStore();
}
```

I realize that this may be largely a product of speaking English as a first language, since double (and more) negatives are acceptable in some other languages. But you have to look at code like this and think, did anyone read this to themselves? “If I it’s false that I’m not out of milk, I will go to the store.” Wat? Okay, so not out of milk means that you have it, so if it’s false that you’re not out of milk, it’s false that you have it, and you are out of milk… aha! Why didn’t you just say so:

```public void FigureOutWhatToDo()
{
if(_amIOutOfMilk)
GoToTheStore();
}
```

### Ifception

```public void FigureOutWhatToDo()
{
if(_amIOutOfMilk)
if(_amIOutOfEggs)
if(_amIOutOfBeer)
GoToTheStore();
}
```

An if within an if within an if… (credit to Dan Martin for this term). This is another mind-bending way of writing things that is rather jarring to the reader of the code, like saying “If I’m out of milk if I’m out of eggs if I’m out of beer, then I’m going to the store.” Dude, wat? Oh, you mean “If you’re out of milk AND you’re out of eggs AND you’re out of beer, then you’re going to the store? Well, nice to see what your breakfast priorities are, but at least that doesn’t read like the mumblings of a lunatic.”

### The Robot

```public void FigureOutWhatToDo()
{
if(_amIOutOfMilk == true)
GoToTheStore();
}
```

Perhaps this is a little nitpicky, but this explicit formation of Boolean conditionals bothers me. “If it equals true that I am out of milk, I will go to the store” sounds like some robot helper from the Jetsons or one of those shows that features a preposterous token “genius” whose intelligence is conveyed by having him speak like some robot helper from the Jetsons. Why not “If I’m out of milk, I will go to the store?”

```public void FigureOutWhatToDo()
{
if(_amIOutOfMilk)
GoToTheStore();
}
```

### The Yoda

```private Milk _theMilk;

public void FigureOutWhatToDo()
{
if(null == _theMilk)
GoToTheStore();
}
```

If program in C you do, sense this makes and a clever trick to avoid assignment instead of comparison errors this is. If program in C you don’t, annoying and indicative that you’re not adopting the thinking of the language you’re working this is. When you speak English and try to sound like a native speaker, you don’t say “If missing is the milk, go to the store”. You say “If the milk is missing, go to the store.”

```public void FigureOutWhatToDo()
{
if(_theMilk == null)
GoToTheStore();
}
```

### The Existential No-Op

```public void FigureOutWhatToDo()
{
if(_amIOutOfMilk)
{
//GoToTheStore();
}
}
```

Or, see variations where the comment is replaced by “return;” or some other similar thing. This is a conditional where, true or false, you do nothing. It sort of makes you question the very nature of (its) existence. This is like me saying to you “If I’m out of milk…” When you wait patiently for a moment and say “yes…?” I then say “nothing — that was all.” What should this be replaced with? How about just deleting the whole bit of nonsense?

### Growing Pains

```public void FigureOutWhatToDo()
{
if(_amIOutOfMilk && _amIOutOfEggs && _amIOutOfBeer && _amIOutOfCheese && _amIOutOfChips && _amIOutOfMilk)
GoToTheStore();
}
```

See what’s going on here? This conditional is growing so unwieldy that you forget by the end of it that you already mentioned being out of milk again. “If I’m out of milk, eggs, beer and milk, I’m going to the store.” “You said milk twice.” “I like milk.” How about dividing it up a bit and saying “If I am out of staples and I’m out of snacks, then I’m going to the store.”

```public void FigureOutWhatToDo()
{
if(AmIOutOfStaples() && AmIOutOfSnacks())
GoToTheStore();
}

private bool AmIOutOfSnacks()
{
return _amIOutOfBeer && _amIOutOfChips;
}

private bool AmIOutOfStaples()
{
return _amIOutOfMilk && _amIOutOfEggs && _amIOutOfCheese;
}
```

```public void FigureOutWhatToDo()
{
if(((AmIOutOfStaples())) && (AmIOutOfSnacks()))
GoToTheStore();
}
```

I think we’ve all seen one of these — someone on the team or in the group has a few too many cups of coffee and really goes to town on the old 9 and 0 keys. This is probably done to make sure that order of operations is being followed when you don’t understand the order of operations. Conversational equivalent? “If I am out of staples, and I mean staples and not whatever is coming next until I’m ready to talk about that and now I’m ready so I’m going to talk about that and that is snacks and not staples we’re not talking about staples anymore we’re talking about snacks which if I’m out of I’m also not going to the store, okay done.” Let’s dial it back to the last solution:

```public void FigureOutWhatToDo()
{
if(AmIOutOfStaples() && AmIOutOfSnacks())
GoToTheStore();
}
```

### The Fly Swallower (aka The Train Wreck)

```public class OldWoman
{
public Horse _horse = new Horse();

public object WhatDidYouSwallow()
{
if (_horse != null && _horse.Cow != null && _horse.Cow.Hog != null && _horse.Cow.Hog.Dog != null &&
_horse.Cow.Hog.Dog.Cat != null && _horse.Cow.Hog.Dog.Cat.Bird != null &&
_horse.Cow.Hog.Dog.Cat.Bird.Spider != null &&
_horse.Cow.Hog.Dog.Cat.Bird.Spider.Fly != null)
return _horse.Cow.Hog.Dog.Cat.Bird.Spider.Fly;

return null;
}
}
```

This is formally known as design with violations of the Law of Demeter, but it’s easier just to think of it as a train wreck. But the name I’m giving it comes from a nursery rhyme, which is how this starts to sound in conversational English. “There was an old lady who if she swallowed a horse who if it swallowed a cow who if it swallowed a hog who if it swallowed a dog…” How should this sound? There’s no easy fix. You need a different object model.

And with that, I’ll conclude my fun Friday post. This is meant to be light-hearted and in jest, but I’d say there’s definitely a good bit of truth here. You may not agree entirely with my assessment, but I think we’d all be well served to do the occasional double check to make sure we’re not leaving conditional bloopers in the code for others to read, triggering pointing and laughter. If you have other names for these or other conditional bloopers to mention (or you think I’m completely off base with one of these) please feel free to chime in.

By the way, if you liked this post and you're new here, check out this page as a good place to start for more content that you might enjoy.
Inline Feedbacks
11 years ago

I had a colleague who was a refugee from a shop that used The Contradiction as a means of disabling code (commenting it out would be vulgar and deletion was right out!). He said large blocks of code were surrounded with conditionals like “if (1==2)” and it eventually became a game to see who could come up with the best boolean variable names. His personal favorite was “if (HellFreezesOver)”

Erik Dietrich
11 years ago

It’s interesting that a group dynamic would evolve to do something that odd and potentially problematic. Imagine a disgruntled employee making hell freeze over just prior to shipping. Wackiness ensues. ðŸ™‚

11 years ago

Going by what I was told, that organization had a lot of “interesting” characteristics. Wackiness was their SOP; I think deliberate sabotage might have been an improvement ðŸ˜‰

ardave
10 years ago

if (_amIOutOfMilk ? true : false) {…}
is common among one group of which I have been a member. Can’t come up with comical name though. It’s kind of reminiscent of your programmer profile “The Brute Forcer.” Perhaps you could call it a Chip N’ Dale boolean expression: “You my first, dear.” “But oh no no no it must be you who goes first!”

Erik Dietrich
10 years ago

Yeah, that’s a head scratcher. You should suggest that they write an extension method that takes a boolean and returns it. Call it “IsTrue”

public static bool Seriously(this bool value)
{
return value;
}

if(_amIOutOfMilk.IsTrue())

Mmmm… clean code.

Joshua P Johnson
10 years ago

Ha. I’ve run into this same pattern as well. I want to come up with a good name for it http://stackoverflow.com/questions/16948563/whats-the-name-of-this-anti-pattern

Erik Dietrich
10 years ago

I might call ardave’s example “double checking.” The “if(condition) return true else return false” anti-pattern from your (unfortunately) closed question I might call “primitive exhaustion” or something. I’ll post later if something better occurs to me.

An interesting way to get people to see how silly this is would be to ask them to do it with all enums and chars for consistency’s sake. If that doesn’t faze them, then try ints, floats and longs.

[…] teams fail to master these techniques, and instead resort to what has been cleverly termed the Fly Swallower Anti-Pattern. That is to say, nearly every object reference is checked for null, and unfortunately, the context […]

9 years ago

[…] once referred to this as “The Yoda” in an old blog post. “If null is x, null argument exception you throw.” Anyone know why people do this, […]

8 years ago

You need a grocery service…

Erik Dietrich
8 years ago

ðŸ™‚

dave falkner
7 years ago

“The Mad Scoper” aka “The Security Blanket”

dave falkner
7 years ago

Aka “The Woobie.”

Erik Dietrich
7 years ago