Why Modern Programming Languages Have Dropped ++/-- Operators: A Design‑Philosophy Perspective

Many developers notice that several modern languages (Python, Rust, Swift, etc.) no longer support the ++ and -- operators, and this article explores the design‑philosophy reasons behind that trend.

Origin : The increment and decrement operators first appeared in the B language, the predecessor of C, introduced by Ken Thompson. Although often attributed to the PDP‑11 auto‑increment/decrement addressing mode, historical records (Dennis Ritchie's memoir) show that B predates the PDP‑11 and that the operators were inspired by the PDP‑7’s auto‑increment memory cells, not by specific assembly instructions.

Performance myth : A series of experiments compiling a simple C loop with #include <stdio.h> int main(void) { for (int i = 0; i < 5; i++) printf("%d", i); return 0; } on Ubuntu 22.04 using gcc (no optimization, -O1 , and higher levels) show that the generated assembly uses add instructions, never the inc or dec opcodes. The same holds for clang . Therefore, the operators do not provide a measurable speed advantage on modern CPUs.

Side effects and functional programming : ++/-- are the only operators (besides assignment) that have side effects, which conflicts with the immutability principle of functional programming. Languages that emphasize pure functions (e.g., Scala, many FP‑inspired languages) therefore omit these operators.

Iterators replace ++/-- : Modern languages favor iterator‑based loops (e.g., Java’s enhanced for , JavaScript’s for…of , Go’s range , Rust’s iterator adapters). These constructs provide both element access and index handling (via enumerate , range , etc.) without mutable counters, reducing the need for ++/--.

Assignment expression return values : In C/C++ an assignment yields a value, enabling chained assignments like a = b = c = 5 . Many newer languages (Go, Rust, Python) treat assignment as a statement without a return value, further diminishing the usefulness of ++/-- as expression shortcuts.

Operator overloading ambiguity : If ++ were automatically tied to += 1 , overloading += on non‑numeric types could produce confusing results (e.g., string concatenation). To avoid such ambiguities, some languages forbid overloading ++/-- or remove them entirely.

Conclusion : While ++/-- were historically valuable for brevity and low‑level code size, modern compiler optimizations, functional‑style design, iterator abstractions, and concerns about side effects and overload ambiguity have led many languages to deprecate or drop them. Their relevance now is limited to specific low‑level or legacy contexts.