With the exception of Matlab (and Octave), which the 1-indexing behavior is inherited from, just about every other programming language indexes arrays from 0. So common is this practice that it's the origin of the claim that mathematicians do not include \(0\) in the set of natural numbers, but computer scientists do!
As a quick aside, I actually think that 0 does not belong in the set of natural numbers. If you fundamentally think about what the natural numbers are, they are counting numbers and they do not include any negative numbers because we are only representing that which exists, not that which does not exist.
For example, if I have four cows in front of me, I am going to count them, one cow, two cow, three cow, four cow. I don't look at an empty field and think zero cows. If there are no cows, then I'm not counting any cows! I can think I have zero cows, but there's no need to represent that which has no presence so I'm not recording the lack of any cows being present in my field.
If I want to represent things which do and do not exist, then I would use the integers. Because in such a case I've expanded my counting set to include not only the cows which do exist, but the cows which do not exist as well.
Why do computer scientists (and software engineers) like 0-indexing and why does it make more sense? Because it simplifies a lot of index calculations. I personally find a lot of value in 0-indexing, however I imagine the 1-indexing practice was inherited to simplify the migration of Matlab/Octave code into Julia. As great as a bunch of indie languages may be, there's a "dark side" to popularizing a language and it being ultimately accepted by the masses which has a lot to do with who picks it up. The harsh reality is that sometimes design choices may go into a language for the sake of it getting picked up and a lot of Julia's early adopters were Matlab users. I imagine a lot of Matlab users were like, "well, it's super easy for me to pick up Julia because it has all of these features I use and love from Matlab, plus it does all this other great stuff too." This is likely a similar mantra of the adopters which migrated to Julia from Python.
This is one of the few features of Julia which I am not ecstatic about, but I suffer silently because it's the single aspect of the language with which I don't find immense value.
Now, one could also argue that a lot of situations where one ends up doing more complicated index computations should be avoid in Julia as there are often other ways to accomplish such tasks, so the impact should be low. In fact, for most data scientists, one will rarely deal with the challenges associated with 1-indexing. However, when recently writing up the Binary Search post, I was re-introduced to the complications of 1-indexing.
An example is when you're writing crypto code which uses the modulo operator to convert numbers into letters.
std::vector<unsigned long> message = get_message();
std::vector<unsigned long> output;
for (size_t idx = 0; idx < message.size(); idx++) {
output.push_back(alphabet[message[idx] % 26]);
}Migrating this code into Julia isn't as straight-forward because it will throw an exception everytime I hit a multiple of 26. Instead of that pointing to the first letter of the alphabet, I would need to add a + 1 to line it up properly, which complicates matters a bit.