Swift Decrements C-Style Syntax — Meme Explained

Level 1: Tiny Button Removed

Imagine a toy has a tiny shortcut button that spins a wheel once, but sometimes it spins before counting and sometimes it counts before spinning. People who know the toy love the shortcut, but new people keep getting confused. Swift decided to remove the tricky button and make everyone use the clearer handle instead. The joke is that programmers can get very dramatic about losing one tiny button.

Level 2: Increment Drama

The ++ operator usually means "add one." In languages that support it, i++ increments i after producing its old value, while ++i increments first and then produces the new value. The same pattern applies to --, which subtracts one.

That difference can matter:

// Old Swift style before removal
let oldValue = i++

// Clearer replacement
i += 1

The problem is not that adding one is hard. The problem is that ++ combines two actions: it changes a variable and can also produce a value. When code uses that value inside a larger expression, readers have to track both the mutation and the timing. That is easy in a tiny loop and unpleasant in clever code.

Swift Evolution is the process where changes to the Swift language are proposed, discussed, accepted or rejected, and eventually implemented. The screenshot shows proposal SE-0004, authored by Chris Lattner, with status Implemented (Swift 3). In plain terms: Swift's maintainers decided that this syntax caused more confusion than benefit, and the language changed.

For junior developers, this is a good example of a breaking change made for language cleanliness. A feature can be popular in older languages and still be removed from a newer one if it does not match the newer language's goals. Swift was not trying to be "C with nicer app APIs." It was trying to be a safer, clearer language for modern Apple-platform development, even if that meant telling old habits to update their resumes.

Level 3: Syntax Loses Weight

The screenshot shows a Swift Evolution proposal titled:

Remove the ++ and -- operators

The red underline under Status: Implemented (Swift 3) is the punchline's little legal stamp: this was not just a cranky blog post. Swift actually removed the familiar C-style increment and decrement operators. The second underline points to the word confusing in the introduction, which explains the meme's attitude: Swift looked at one of the most recognizable programming-language conveniences and decided it was not worth keeping.

That is funny because ++ and -- are almost sacred fossils in C-family languages. C, C++, Java, JavaScript, Objective-C, and C# all made generations of developers comfortable with i++ in loops. The operators are tiny, expressive, and visually iconic. They are also a compact source of subtlety: prefix versus postfix forms return different values, mutation is hidden inside an expression, and clever code can smuggle side effects into places where readers would prefer not to discover them.

The post caption says:

No one: Literally no one: swift developers:

That framing works because language committees and evolution processes often look absurd from the outside. Nobody in ordinary application work wakes up demanding fewer ways to add one to a variable. But language designers do think about the long-term cost of every feature: what beginners must learn, what style guides must forbid, what compilers must diagnose, what migrations must support, and what kind of code the feature encourages.

Swift's design taste has always leaned toward clarity at the call site, explicitness around mutation, and discouraging C tricks that make code dense but harder to read. Removing ++ and -- fits that personality. Swift already had x += 1, for-in loops, ranges, and collection APIs that reduced the need for manual index juggling. In that world, the operators became less like essential tools and more like heritage furniture: familiar, maybe charming, but awkward in the new house.

The experienced-developer laugh comes from the collision between ergonomics and ideology. A small operator can trigger a giant argument because syntax is muscle memory. Remove one character pair and suddenly every forum thread becomes a civilizational referendum on readability, beginner friendliness, C compatibility, and whether i += 1 is tyranny. Programming languages are tools, but developers defend their favorite punctuation like family heirlooms.