A More Logical Alternative to 'else'

Level 1: Made-Up Words are Cooler

Imagine you have a simple rule for doing chores. Your parent says: “If your room is clean, you can play video games. Otherwise (or else), you have to clean your room now.” That word “else” just means “if the first thing isn’t true, do the other thing.” Now, this meme is joking that someone doesn’t like using the normal word “else.” Instead, they pretend there’s a fancy new word, “ifn’t,” which basically means “if not.” It’s like making up a new word to replace an old word because you think it sounds cooler or funnier.

In the picture, the famous rapper Drake is used in two panels. In the top half, he’s saying “no way” to the regular word else – like he refuses to even consider it. In the bottom half, he’s smiling and pointing, saying “yes, this one!” to ifn’t, the silly made-up word. It’s as if a kid said, “I don’t wanna say ‘otherwise’ or ‘else’ anymore; from now on I’ll say ‘if not’ in a super short way: ifn’t!” It’s funny because nobody actually talks like that, and in real programming, there’s no real keyword ifn’t. The joke highlights how people (especially programmers) sometimes invent their own quirky terms or prefer a funny alternative just to be different.

So basically, this meme is laughing at the idea of someone ignoring a perfectly fine, normal word and using a pretend word instead. It captures a feeling kids and adults alike can recognize: thinking “my way of saying it is better!” Drake’s expressions make it super clear – he doesn’t approve of the plain old way, but he loves the new goofy idea. Even if you don’t know anything about coding, you can chuckle at the dramatic preference for a made-up word. The emotional core here is playfulness: it’s amusing because it’s a silly exaggeration of how we sometimes insist on doing things our own way, even if it’s as simple as choosing one little word over another.

Level 2: If Not vs Else

At its core, this meme is about the humble if/else statement, which is one of the first things you learn in programming. An if statement lets the computer decide whether to execute a block of code based on some condition. When that condition is false, an else clause can specify an alternative block of code to run instead. For example, in plain English you might say: “If it is raining, then take an umbrella; else (otherwise), wear sunglasses.” In code, that looks like:

if is_raining:
    take_umbrella()
else:
    wear_sunglasses()

In the meme’s first panel, the word “else” is shown on the right, and Drake is rejecting it with a hand wave. This represents a coder saying, “No thanks, I don’t like using else.” In the second panel, Drake is happy and pointing to “ifn’t” – which is a made-up contraction for “if not.” This implies the programmer would rather write their logic as “if not X do something” instead of using an else branch. It’s a play on syntax: ifn’t is not an actual keyword in any programming language, but it humorously suggests writing an explicit negative check. In real code, writing “if not X” usually means using a negation operator (like ! in C/Java/JavaScript or the word not in Python) in front of a condition. So if we wanted to avoid else, we could do something like:

if (!isRaining) {
  wearSunglasses();
}

This if (!isRaining) is basically saying “if not raining, then wear sunglasses.” It covers what the else branch would have handled (the case where it isn’t raining). The meme joke is that some developers might prefer this style – explicitly checking the opposite condition – rather than relying on else.

Why is this funny or relatable? In programming culture, there are often style debates on what makes code more readable. One debate is about using else vs. using early returns or separate if statements. Some programmers feel that avoiding else can make code cleaner. For instance, instead of:

if (valid) {
    processData();
} else {
    handleError();
}

they might write:

if (!valid) {
    handleError();
    return;
}
// if we reach here, it means valid is true
processData();

In this second style, we handled the “if not valid” case first and exited early (notice the return; inside that block). That way, we don’t even need an else for the happy path. This is a common pattern to simplify logic: address the “negative” case upfront, so the main case doesn’t get nested inside an else. Many code quality guides suggest this approach to reduce nesting and cognitive load. It’s sometimes called using a guard clause, and it can indeed make some functions easier to follow.

However, not everyone agrees – some find this inverted logic harder to read, especially if overused. It’s really a matter of personal or team preference. The meme plays with this idea of preference by using the Drake format (a famous meme template for expressing dislike vs. preference). Here Drake humorously “prefers” a completely made-up keyword ifn’t to the perfectly normal else. That’s like saying, “I so strongly prefer the if not style that I’ve invented a whole new word for it!” It exaggerates the attitude of a programmer who would do anything to avoid writing else.

This ties into language quirks too. Some programming languages have actual syntax for negative conditions: for example, Ruby has an unless keyword, which executes code only if a condition is false. In Ruby you might write:

unless logged_in
  redirect_to_login
end

This reads like “unless logged_in, do the redirect,” which is the same as saying “if not logged_in, do the redirect.” It’s an alternative to writing a regular if with a negation or an else. Not all languages have this, but it shows that the idea of emphasizing the “if not” case isn’t totally foreign in real life. The meme’s ifn’t is like taking that idea and giving it a playful twist in languages that don’t actually support it.

So for a junior developer or someone new to coding humor, the key points are:

• if/else: basic conditional statements. “If condition is true, do something, else do something else.”
• “if not”: using a negation to check the opposite of a condition. In code this might be if (!condition) or if not condition. It lets you run code when the condition is false.
• Code style preference: Some developers like to avoid else by handling the false case explicitly or by exiting early. They find it cleaner. Others stick with if/else because it’s straightforward.
• The joke: Drake rejecting “else” and approving “ifn’t” is a funny way to show a dramatic preference for the “if not” style. It’s not a serious suggestion to actually change the language; it’s poking fun at how seriously we sometimes take these tiny stylistic choices. It resonates because many of us have seen or participated in these little debates, so it’s very much relatable humor for coders.

In summary, the meme uses a popular format to make a lighthearted joke about syntax and code readability. It highlights a quirky aspect of programmer culture: the tendency to bikeshed (argue over trivial things) like whether using else is good or bad style. And by creating a fake keyword ifn’t, it adds an extra layer of silliness that says, “Wouldn’t it be nice if the language just bent to my personal style?” 😄 It’s all in good fun and part of the larger world of developer humor where we laugh about the peculiar ways we write and prefer our code.

Level 3: Rebel Without an Else

In the top panel of this Drake meme, our puffer-jacketed protagonist is waving away the plain old else. In the bottom panel he’s pointing approvingly at ifn’t, an imaginary new keyword representing “if not.” This joke hits on a classic control-flow style war in programming: some developers just can’t stand using else and would rather flip the logic around. The meme exaggerates this by inventing a quirky contraction – “ifn’t” – instead of using the boring standard else. It’s poking fun at our love for syntax humor and the lengths programmers go for code readability (or for showing off a clever idea).

On a serious note, every programmer learns the basic if/else conditional early on. It’s the bread-and-butter of conditional logic:

if (condition) {
  doThing();
} else {
  doOtherThing();
}

But as you gain experience, you encounter peers (or style guides) who insist on minimizing the use of else. One common technique is to use guard clauses or invert the condition so that you can exit early instead of having an else block. In essence, you handle the “if not” case up front, which renders the else unnecessary. The code ends up looking like two separate if statements:

if (condition) {
  doThing();
}
if (!condition) {
  doOtherThing();
}

In this exaggerated scenario, Drake’s saying he’d prefer an explicit “if not” check every time – hence the fictitious keyword ifn’t – rather than rely on an else branch. Why would anyone do this? Well, some code quality gurus argue that avoiding else can make code simpler and reduce nesting. By handling the negative case first (for example, logging an error and returning early if something isn’t true), the rest of the function doesn’t need to be wrapped in an else block. It’s a known strategy to prevent deep indentation, sometimes jokingly called the “avoid the arrow-shaped code” principle. Each else you eliminate can flatten the code structure, which can improve readability if done judiciously. So the meme is a humorous nod to those who take this idea to the extreme – preferring to write a negated if over using else at all, even if it means conjuring up a mythical new keyword.

This relates to real language quirks and style debates. For instance, Ruby actually has an unless keyword, which is essentially “if not” in natural language – you might write unless hungry { orderPizza() } instead of if (!hungry) { ... }. That’s real syntactic sugar for a negative condition. Python doesn’t have a special keyword, but you can write if not condition: which is very close to reading like English. Some developers enjoy these forms because code readability is subjective and they find if not X clearer than else. Others find that too many ways to say the same thing can lead to confusion – there’s an old joke that Perl has “There's more than one way to do it” as a motto, whereas Python folks prefer just one obvious way. An ifn’t keyword would definitely be another way to do it, and likely spark a thousand style arguments on Stack Overflow!

From a language design perspective, inventing a new keyword like ifn’t is pretty absurd. Keywords in programming languages are carefully chosen, and you almost never see punctuation like an apostrophe in them. (Imagine a compiler trying to parse ifn’t – is that an if token followed by a stray character? It would probably choke 😅.) The meme isn’t suggesting this should really exist – it’s playing with the idea that a developer might wish it did, just because they personally dislike writing else. It highlights the relatable humor in how programmers sometimes have strong, almost quirky preferences for one syntax over another, even if both are logically equivalent. We’ve all seen those petty debates in code reviews or style discussions: “I’d rather invert the condition than use else” versus “Just use else, it’s straightforward!”. This meme takes that tiny preference to a comical extreme with Drake literally preferring a non-existent syntax.

In short, this is developer humor about being extra: it teases the notion that some of us would rather bend the language (or invent new syntax) than write code we consider “unclean.” It’s the same energy as a dev saying, “I find else too mainstream – I only write if-not conditions.” Most experienced engineers recognize it as a tongue-in-cheek commentary on coding style zealotry. After all, whether you write:

• if (condition) {...} else {...}
• or rewrite it as if (condition) {...} and then if (!condition) {...} on the next lines,

the computer does the same thing. But to humans, the style can spark endless debate. The meme gets a laugh by capturing that silly culture war over syntax in one simple, absurd image. It’s Drake pointing to the contrarian choice, which every programmer immediately recognizes as a shared joke: “ifn’t” ain’t a real keyword – but wouldn’t it be nice if it was? 😄