1. I stand corrected - I just ran a few simple tests which prove your case. I still hold that in certain situations, 0-based can produce faster machine-level code than non-0; clearly this is not one of them, due to runtime recalculation concerns. 2. Technically you are correct, but unless there are some really pedantic people out there, I know of noone who would say they just turned 'X years and X weeks' old on thier birthday (depending on how many weeks they gestated for - not everyone spends 9 months in the womb). In some ways, the difference between 0 and 1 in this discussion is moot, because eventually everything comes down to 0-based ADDRESSING in machine code anyway. As far as 'indexing' (an entirely different thing to 'addressing', mind you) in a high-level language is concerned, there are 3 basic options which are entirely preference-dependant: a. 0-based indexing, mimicing addressing to nullify/trivialise index-to-address calculations; b. 1-based indexing, mimicing the human perception of quantity; c. N-based indexing, allowing the user to specify the base index to complement a particular indexing system used 'natively' by a code block. Personally, I prefer the 0-based approach, because the machine works that way for addressing anyway, and any other indexing system can be emulated (for almost no cost these days) by simply adding an offset value: 1-based = index + 1, 12-based = index + 12, -345-based = index + -345; not hard at all. If I was to write a high-level language of my own however, I admit I'd probably code in the option of preset array offsets, with a default offset of 0 if one wasn't specified at array allocation. All of these options have been used to great effect in many languages over the years, and all of them have pros and cons. If you're writing a high-level/scripting language, your best bet is to go with the indexing system that works best for you first, and if others like it, that's a bonus.