Skip to content
DevMeme
173 of 7435
The Ultimate Coding Style Holy War
CodeQuality Post #211, on Mar 9, 2019 in TG

The Ultimate Coding Style Holy War

Why is this CodeQuality meme funny?

Level 1: The Great Bathroom Argument

This is two pictures of the exact same toilet paper roll — the only difference is which way the paper hangs, front or back — and someone has stamped one "Good" and the other "Bad" like it's a law of nature. The joke is that people argue about this with their whole hearts even though the paper works perfectly fine both ways. Programmers shared it with the caption "coding style" because they do the very same thing at work: huge, passionate arguments about tiny choices that don't change anything — like siblings fighting over which way the cereal boxes should face in the cupboard. The fight isn't really about the paper; it's about being right.

Level 2: Why Teams Fight About Nothing (On Purpose)

Concepts this image smuggles in:

  • Coding style / conventions — agreed-upon cosmetic rules: indentation, naming, brace placement. The compiler doesn't care; humans reading the code do. Consistency matters far more than which convention wins — a codebase that's half "over" and half "under" is worse than either.
  • Holy war — a long-running dispute where positions are identity, not analysis. You'll meet your first one in your first code review, typically when someone reformats your file and the diff is 400 lines of whitespace.
  • Bikeshedding — spending meeting time on trivial decisions because they're easy to discuss. If your team debates a variable name for 40 minutes but approves a database migration in 4, you've witnessed it.
  • Linters and formatters — tools (eslint, prettier, black) that enforce one style automatically. The professional move you'll learn early: adopt one, accept its defaults, and redirect the arguing hours toward actual bugs.
  • "Good/Bad" labeling — note that the image offers zero justification. Style guides often work the same way; the honest reason for many rules is simply "we had to pick one."

The early-career trap to dodge: winning a style argument feels like competence, but the senior engineers you admire are usually the ones who say "either is fine, let's match the existing file and move on."

Level 3: Bikeshedding, Now in Chrome and Two-Ply

There is no code in this image — just two photos of the same chrome toilet-paper holder on the same brown tile, one roll draped over the front labeled "Good" in green, one hanging under against the wall labeled "Bad" in red. The original post caption supplies the punchline that makes it a developer meme: "Coding style."

The mapping is surgical. Both orientations dispense paper. Both configurations work. The functional delta is approximately zero — and that is precisely why the argument never ends. This is Parkinson's law of triviality, better known as bikeshedding: the observation that committees approve a nuclear reactor in minutes but argue for hours about the bike shed's color, because everyone feels qualified to have an opinion about the shed. Tabs vs spaces, snake_case vs camelCase, K&R braces vs Allman, vim vs emacs, single quotes vs double — the holy wars that consume code reviews are never about the hard parts of the system. They're about the parts where opinion is cheap, stakes are invisible, and certainty is total.

The meme's framing — flat declarations of Good and Bad with no argument attached — is exactly the rhetorical register of style debates. And the delicious twist seniors love to deploy: this particular holy war actually has a spec. Seth Wheeler's 1891 toilet-paper patent illustrations unambiguously show the roll in the "over" position, making "over" the rare style preference with an authoritative upstream document — the RFC of bathroom fixtures. Citing it mid-argument is the equivalent of settling a formatting dispute by linking the language's official style guide: technically conclusive, socially useless, because the "under" faction (whose actual arguments — cat-proofing, RV travel — are use-case driven) was never arguing from the spec anyway.

The industry's mature answer mirrors plumbing's: stop debating and automate the convention. gofmt, prettier, black — formatters won not because their choices were optimal but because they made the argument unprofitable. The roll goes over because the linter says so; CI rejects under. Peace through tyranny, and everyone secretly relieved.

Description

This image uses a well-known, non-technical debate as a metaphor for programming arguments. It shows a two-panel comparison of toilet paper orientation. On the left, a roll is mounted so the paper hangs over the top, which is labeled 'Good' in green text. On the right, the paper hangs from the bottom, against the wall, labeled 'Bad' in red text. The post's caption, 'Coding style', makes the analogy explicit. The meme humorously equates the fierce, often subjective debate over how to hang toilet paper with the 'holy wars' in software development over coding styles, such as tabs versus spaces, brace placement, or naming conventions. It speaks to the tendency of developers to have strong, seemingly arbitrary preferences that become major points of contention within teams

Comments

8
Anonymous ★ Top Pick I've seen PR comments longer than the actual code change debating brace placement. It's the modern equivalent of arguing about toilet paper orientation, except one of them can actually break the build
  1. Anonymous ★ Top Pick

    I've seen PR comments longer than the actual code change debating brace placement. It's the modern equivalent of arguing about toilet paper orientation, except one of them can actually break the build

  2. Anonymous

    Architecture guild verdict: “over” gives constant-time paper access; “under” turns it into an O(n) edge-hunt - non-deterministic behavior is grounds for PR rejection

  3. Anonymous

    The team that spent three sprints debating toilet paper orientation just shipped a critical API that returns HTTP 200 for every response, including errors

  4. Anonymous

    The 1891 patent settled this - 'over' is the spec. Everything else is a downstream fork that should've been rejected in review

  5. Anonymous

    This is the equivalent of discovering your senior architect has been implementing the Singleton pattern by creating a new instance every time. Sure, it technically works in their isolated test environment, but it violates the fundamental specification (US Patent 459,516, 1891) and creates unnecessary friction for every downstream user. The 'Bad' implementation is like code that passes CI but fails the architectural review - functionally operational but architecturally wrong, and everyone who encounters it will silently judge the implementer's understanding of established conventions

  6. Anonymous

    Over is O(1) end discovery and idempotent tearing; under is wall-coupled hidden state that turns 'find the edge' into distributed tracing with exponential backoff

  7. Anonymous

    Over: trailing commas prevent git merge hell. Under: your PRs deserve the linter flames

  8. Anonymous

    Left is gofmt: one canonical orientation; right is “engineer discretion,” which guarantees a 200-comment PR and three bikeshed meetings

Use J and K for navigation