A Captain's Forbidden Thoughts on Array Indexing

Level 1: The Thought Too Naughty for Land

A ship captain sails far out to sea, past where any country's rules apply, just so he can finally think a thought so forbidden he'd get in trouble for it at home. The thought? A silly idea about how to number a list — like insisting that the first stair in a staircase is "step negative one-half." A sailor overhears and is absolutely horrified, but the captain just smiles peacefully. It's funny because everyone has one weird opinion they keep secret — like pineapple belonging on pizza and in cereal — and the comic imagines needing to escape civilization itself just to think it safely.

Level 2: Why Zero, Why One, Why Never One-Half

The background you need:

• An array is a numbered row of storage slots. The fight is over what number the first slot gets. Most languages (C, Java, JavaScript, Python) say slot 0; a few (Lua, MATLAB, Fortran) say slot 1.
• Zero-based feels alien at first — the first element is a[0], the tenth is a[9] — and the off-by-one error you'll write in your first month (looping <= length instead of < length) is a rite of passage that crashes with IndexOutOfBounds or, in C, silently corrupts something and ruins a future afternoon.
• The reason for 0: under the hood, the index measures distance from the start. The first item is zero steps away. Once that clicks, zero-based stops being weird and starts being obvious — which is exactly when you become insufferable to 1-based people.

-0.5 is a joke because it's impossible: indexes count whole slots, so "half a slot before the first one" points at nothing. It's the programming equivalent of asking for the room between floor 0 and the basement — and proposing it in a meeting is how you discover your team has strong feelings.

Level 3: Beyond the Reach of Any Style Guide

The comic borrows the "international waters" format — the captain sails past all jurisdiction specifically to think what he'd be arrested for on land:

AT LAST! BEYOND THE REACH OF ANY NATION, I AM FREE TO THINK THE FORBIDDEN THOUGHTS I WOULD NORMALLY BE ARRESTED FOR.

And the thought bubble, witnessed by one horrified sailor: "Arrays start at -0.5".

The format maps perfectly onto developer culture because our community genuinely does police opinions with quasi-legal force. The 0-vs-1 indexing question is the oldest holy war in the business — alongside tabs vs. spaces and vim vs. emacs — and like all holy wars, its function is tribal, not technical. Stack Overflow comment sections, code review threads, and conference Q&As act as the territorial waters where heterodox takes get you flagged, downvoted, and summarily wontfix'd. The joke's escalation is precise: defending 1-based indexing is merely controversial (Lua and MATLAB people do it at parties); proposing a fractional, negative starting index is so far outside the Overton window that no nation's linter will have you. He needed maritime law.

There's a sharper observation under the silliness: every developer carries one or two genuinely cursed takes they've learned never to say in standup. "We should rewrite it in PHP." "The monolith was better." "I like YAML." The serene final panel — the captain's face at peace — is the punchline experienced engineers feel in their bones: the relief of privately entertaining the forbidden thought without a single colleague able to open a thread about it. The horrified crewman is the audience surrogate: even here, even in international waters, someone heard, and somewhere a linting rule stirs in its sleep.

Level 4: Dijkstra's Half-Open Heresy

The reason "Arrays start at -0.5" reads as a war crime rather than mere nonsense is that array indexing isn't a convention — it's arithmetic. In C and everything descended from it, a[i] is defined as *(a + i): the index is a pointer offset, a count of how many element-widths to skip from the base address. Zero-based indexing falls out of the hardware for free; the first element is at offset zero because you skip nothing. One-based languages (Fortran, Lua, MATLAB, Julia) pay a hidden -1 in their address computation — or shift the base pointer before the loop — every single access. Dijkstra's famous 1982 note (EWD831) made the mathematical case: represent ranges as half-open intervals [0, n), and you get empty ranges without degenerate bounds, lengths computed by simple subtraction, and adjacent ranges that tile perfectly. The 0-vs-1 war thus has actual theory on one side and human ergonomics on the other, which is why it never ends.

Now consider the captain's proposal. An index of -0.5 demands a fractional pointer offset — half an element-width into unallocated memory before the array. It violates three layers at once: the type system (indices are integral by definition — fractional subscripts have no meaning in the address algebra), memory safety (negative offsets walk backward past the allocation into whatever the heap put there), and the compromise space itself. A diplomat might propose 0.5 as the midpoint between camps; -0.5 is below both, satisfying no one and dereferencing memory that belongs to no one. The closest legitimate relatives are interpolation tables in numerical computing, where f(2.5) means "blend elements 2 and 3" — but that's function semantics layered atop integer storage, not actual indexing. The captain hasn't found a compromise. He's found the one point in the design space that requires violating IEEE-adjacent decency and the C abstract machine simultaneously.