Why Modern Languages Drop the Classic C‑Style for Loop

During a code review the author heard a senior architect criticize a newcomer’s classic C‑style for(int i=0; i<n; i++) loop, prompting a deeper look at why many modern languages have moved away from this pattern.

Classic C‑style for loop pitfalls

The traditional loop packs initialization, condition, and increment on a single line, forcing the programmer to keep track of the start value, boundary operator ( < vs <=), and step ( i++ vs i+=2). A small slip—e.g., writing i<=10 instead of i<10 —can cause array out‑of‑bounds errors, as illustrated by an embedded‑system bug that triggered a watchdog reset.

Because the three components can be omitted, constructs like for(;;) create infinite loops that confuse newcomers.

How modern languages address the problem

Language designers observed that 99 % of for‑loop use cases are simple collection traversal, so they removed the need to manage indices, boundaries, and steps manually.

Python uses a clear for item in items: syntax:

for item in items:
    print(item)

Rust offers a range‑based loop:

for i in 0..10 {
    println!("{}", arr[i]);
}

Swift follows a similar pattern:

for item in items {
    print(item)
}

Go retains some C heritage but adds range for concise iteration:

for i, v := range arr {
    fmt.Println(i, v)
}

All these forms let developers state the intent—"traverse each element"—without worrying about index mechanics.

Underlying reasons

Safety: The freedom of C‑style loops makes off‑by‑one and infinite‑loop bugs common.

Readability: Human readers can instantly recognise for item in items as a traversal, whereas for(int i=0; i<n; i++) requires mental translation.

Abstraction level: C loops are procedural, describing *how* to iterate; modern loops are intent‑driven, describing *what* to do.

When the C‑style loop still shines

In low‑level or embedded development, precise control over each iteration step, simultaneous traversal of multiple arrays, or custom stepping patterns may be required. The compiler can also optimise straightforward C loops for performance.

Choosing the right style

If you are writing application‑level code in languages such as Python, Rust or Swift, adopt the newer loop constructs for safety and clarity.

For systems, drivers, or embedded firmware where fine‑grained control and guaranteed performance matter, the classic C‑style loop remains a valuable tool.

Regardless of the syntax, remember that code is read more often than it is written; prioritize clarity over cleverness.