Why Array Indices Start at Zero: History, Memory Layout, and Practical Benefits

Preface

When we first learn programming, many wonder: Why do array indices start at 0? In everyday life we count from 1, so why does code start from 0?

Ancient Computer "Genetic Inheritance"

In 1957, when the first high‑level language Fortran was created, array indices started at 1. Ten years later, the predecessor of C, the B language , introduced the "0‑based index", a convention later inherited by C and spread worldwide with the rise of Unix.

Underlying Truth

In memory, array elements are stored contiguously. Assuming an integer array where each element occupies 4 bytes:

Address of element 0 = base address + 0×4

Address of element i = base address + i×4

If indexing started at 1, the formula would become "base address + (i‑1)×4", meaning every access would require an extra subtraction. In the 1970s, this extra operation added unnecessary load to already scarce CPU resources.

For Coordination and Aesthetics

Dutch computer scientist Edsger Dijkstra published the short essay "Why numbering should start at zero" in 1982, offering an elegant mathematical proof.

Assuming an array has N elements, using a left‑closed right‑open interval [0, N) yields:

Number of elements = upper bound – lower bound (N‑0 = N)

Adjacent sub‑intervals fit seamlessly (e.g., [0,5) and [5,10))

The empty set can be represented as [i,i) without special handling

This perfectly resolves boundary issues in loop traversal:

# Python classic loop: 0‑based makes code concise like poetry
for i in range(0, len(arr)):
    print(arr[i])

Appendix: Expert Manuscript

Butterfly Effect in Modern Programming

From C’s 0‑based indexing, several advantages emerge in the new era:

Bit‑operation magic : In hash tables, computing the slot with index = hash % size naturally fits 0‑based indexing.

Multidimensional array calculation : Memory address of arr[i][j] = base address + (i×columns + j)×element size.

Type‑system uniformity : Pointer offset ( ptr+0 points to the first element) aligns perfectly with array indexing.

Slicing sugar : In Python, arr[2:5] represents elements 2 to 4, avoiding off‑by‑one confusion.

In contrast, 1‑based languages like Matlab often require handling channel indices as either 1‑3 or 0‑2, leading to confusion.

Languages That Stick to 1‑Based Indexing

There are notable exceptions that illustrate why the rule exists:

Fortran : Designed for scientific computing, matching mathematicians' habits.

Lua : Its designers felt "labeling the first element as 1 feels more natural".

R : Statisticians are accustomed to 1‑based indexing.

These languages tend to stay within specific domains, while general‑purpose languages have adopted 0‑based indexing as the factual standard, much like the QWERTY keyboard layout—suboptimal in theory but entrenched by ecosystem momentum.

From Counterintuitive to Intuitive

Beginners find 0‑based indexing counterintuitive, but seasoned programmers see:

Loop termination condition can be written directly as i < length , avoiding off‑by‑one errors.

Memory address calculation no longer needs redundant -1 operations.

Bitwise, modulo, and other low‑level operations fit naturally.

This shift in thinking marks the divide between programming mindset and everyday intuition. Saying "the 0th element of an array" essentially means "the position offset 0 units from the start of the array".

Conclusion

Zero‑based indexing is not a quirky programmer habit; it is the optimal solution distilled from decades of computer evolution. It acts like a prism, refracting the essence of computer science—balancing abstraction with reality, mathematics with engineering.

1. Feeling my code is terrible and lacking motivation

2. ZhongAn Insurance lottery, tempting offer!!!

3. The hardest IT company to get into in China.

4. Microsoft’s fake Edge uninstall guide

5. Create React App deprecated by React team!