Why is this CodeQuality meme funny?

Question

Accepted Answer

### Level 1: The Pool Gang-Up

Picture a swimming pool where everyone suddenly stops, forms a circle around one kid, points, and laughs — because he built two separate sandcastles instead of one big castle with shared walls. The kid looks miserable, the crowd looks delighted, and that's the whole joke: programmers can be just as cliquey as a schoolyard, ganging up over rules that sound very important but are really just fashion. And the kicker? The kid's two little sandcastles are still standing — while big shared castles have a funny habit of collapsing the moment someone changes one wall.

### Level 2: DRY, WET, and Other Pool Chemicals

The vocabulary the mockers are weaponizing:

- **DRY (Don't Repeat Yourself)**: the principle that each piece of knowledge should live in one place. Sensible — until it's applied to code that merely looks similar rather than meaning the same thing.
- **WET ("Write Everything Twice")**: the tongue-in-cheek counter-principle — tolerate duplication until a pattern has proven itself, usually by the third occurrence (the "rule of three").
- **Base class**: in object-oriented programming, a parent class that shared behavior is hoisted into, so children `inherit` it. Powerful, but it hard-wires a hierarchy: change the parent and every child feels it.
- **Generics**: writing code parameterized over types — `List<T>` works for integers, strings, anything — so one implementation serves many cases without copy-paste.
- **Abstraction**: extracting the common shape of several concrete things into one reusable form. The hard part isn't the mechanics; it's deciding whether things are *actually* the same.

Every junior hits this rite of passage: you copy a function, feel vaguely guilty, and a reviewer pounces. Here's the secret the pool mob won't tell you — choosing *when* to abstract is the senior skill, not knowing *how*. Duplicating code is a reversible decision; a published base class with five subclasses is not. When in doubt, wait for the third duplicate.

### Level 3: Duplication Is Cheaper Than the Wrong Abstraction

Eight grinning swimmers form a perfect circle in the yellow-tinted pool, every finger aimed at the one wide-eyed man standing chest-deep in the middle. Their taunts are pure code-review theater:

> "where's your base class, loser?"
> "hahaha, he duplicated code that could have been abstracted"
> "i bet he doesn't even know how generics work"

The meme works because every working engineer has stood in that water. But the senior reading flips the joke: the mob is *wrong*, or at least wrong often enough that their confidence is the real punchline. Sandi Metz's line — duplication is far cheaper than the wrong abstraction — exists precisely because the industry spent two decades worshipping **DRY** until it curdled into **premature abstraction**. The pattern is depressingly repeatable: two functions share five lines, someone extracts a `BaseProcessor`, a third use case arrives that *almost* fits, so the base class grows a boolean flag, then a strategy hook, then a generic parameter, and eighteen months later nobody can change anything without re-deriving the entire inheritance tree in their head. The copy-paste guy? He shipped. His two duplicated blocks diverged naturally, as duplicated code often legitimately does, because they were never actually the same concept — they just *looked* similar for one sprint.

The circle-of-pointers composition captures something true about **code review culture**: shaming clusters around easily-named sins. "Duplicated code" is visible in a diff; "abstraction that will calcify into load-bearing technical debt" is invisible until it's too late to laugh about. So reviewers optimize for the critique that makes them look senior in the thread, not the one that saves the codebase. Add the **OOP-purist** flavor — base classes and generics as status symbols rather than tools — and you get exactly this pool: a social hierarchy enforced through pattern vocabulary, where knowing the *names* of abstractions outranks judging when to deploy them. The miserable man in the middle isn't being reviewed. He's being initiated.

Pool of Shame: Mocked for Duplicating Code Instead of Abstracting