Everyone in this thread seems to believe that 1-based indices is a non-problem because Julia "offers a choice".

My reaction:

   - the default is 1-based, which means the bulk of Julia code will adopt the convention and therefore the vast majority of coders in 2018 will have to do mental gymnastics to understand what the code does.

   - when I read Julia code, I will never know which convention the code was written with unless I dig to find where that particular flag is set.

   - passing 0-based arrays to a library routine that expects 1-based stuff, what happens then?

   - for code that will be 0-based and uses library code that expects 1-based (assuming that's possible without paying copying overhead) will force the code to mentally switch between the two modes. Ugh.

In short: offering is a choice is maybe even worse than enforcing 1-based.

I think you misunderstand that the offset is encoded in the type of the object, so only your 1st concern is valid.

For concern 2, it's as easy as finding the type. And without knowing the types you wouldn't know what the code did anyway.

For concern 3, a type error.

And for 4, because it's a type there is zero runtime overhead. A view of the array with the offset the code expects is constructed, often automatically based on the types involved. This view is often a zero cost abstraction at runtime because of how Julia specialization works. So at worst you pay some (extremely minor) compile-time/load-time costs.

Languages that have offered that choice have been around for decades - Pascal, for example. It was never a problem in practice.