Why Zero‑Based Indexing Is Preferred in Programming Languages

When we need a loop that runs exactly ten times, we typically write for (int i = 0; i < 10; i++) { } , defining an integer variable that starts at 0. This convention also appears in array definitions across C, Java, Python and many other languages, where the first element is accessed with index 0.

In the article "Why programmers prefer the 0 ≤ i < 10 form for for‑loops", Dijkstra argued that a left‑closed, right‑open range (0 ≤ i < N) is more natural. He further examined the alternative 2 ≤ i < 13 and concluded that using 0 as the first index yields a cleaner expression: 0 ≤ i < N.

Historically, the zero‑based convention dates back to BCPL, the predecessor of C. Martin Richards designed arrays to start at 0 because the array index corresponds directly to the pointer offset. When an array int arr[8] is allocated, the compiler assigns the address of the first memory cell (e.g., 0x0000001) to the array name, and the expression &arr yields that address.

Pointer arithmetic reinforces this design: initializing a pointer with int *pr = arr makes pr point to the same first memory cell. Accessing the first element can be written as arr[0] or *(p+0) . If the array started at 1, *(p+1) would need to address a different offset, requiring extra subtraction instructions.

Because most computer architectures address memory via a base address plus an offset, using 0 as the base offset simplifies implementation and improves performance. While earlier languages such as FORTRAN and BASIC used one‑based indexing, the widespread adoption of C propagated the zero‑based approach to many modern languages.

Guido van Rossum, the creator of Python, confirmed that Python chose zero‑based indexing partly for the elegance of slice notation. With half‑open intervals, common slicing patterns become concise: a[:n] is equivalent to a[0:n] , and a[i:i+n] cleanly extracts a sub‑sequence without extra +1 or -1 adjustments. One‑based indexing would force more cumbersome expressions.

Overall, zero‑based indexing aligns array subscripts with pointer offsets, yields cleaner loop bounds, and enables elegant slicing, making it the preferred choice in most contemporary programming languages.