9 ms·

Uses 0-based indexing, if you were wondering like me.

7thaccount 5y ago
I'll never understand why this is such a big item of importance for developers :). Both 0 & 1 are pretty natural in my eyes.
- moomin 5y ago
  Let's see if Dijkstra can explain it. :p https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/E...
  - pull_my_finger 5y ago
    This seems to get posted a lot in 0 vs 1 threads as a way to end the conversation in appeal to authority, but for arguments sake, Roberto Ierusalimschy (of Lua) has explained his design choice: > When we started Lua, the world was different, not everything was C-like. Java and JavaScript did not exist, Python was in an infancy and had a lower than 1.0 version. So there was not this thing when all the languages are supposed to be C-like. C was just one of many syntaxes around. > And the arrays were exactly the same. It’s very funny that most people don’t realize that. There are good things about zero-based arrays as well as one-based arrays. > The fact is that most popular languages today are zero-based because of C. They were kind of inspired by C. And the funny thing is that C doesn’t have indexing. So you can’t say that C indexes arrays from zero, because there is no indexing operation. C has pointer arithmetic, so zero in C is not an index, it’s an offset. And as an offset, it must be a zero — not because it has better mathematical properties or because it’s more natural, whatever. > And all those languages that copied C, they do have indexes and don’t have pointer arithmetic. Java, JavaScript, etc., etc. — none of them have pointer arithmetic. So they just copied the zero, but it’s a completely different operation. They put zero for no reason at all — it’s like a cargo cult. https://habr.com/en/company/mailru/blog/459466/ https://habr.com/en/company/mailru/blog/459466/
    - balfirevic 5y ago
      That doesn't explain why he picked one-based arrays, it only says the reasons C has zero-based arrays don't necessarily apply to Lua.
  - ufo 5y ago
    I have to confess that this EWD on 0-1 indexing is one of my pet peeves. Whenever the topic comes up, someone will invariably link to it uncritically, even though Djikstra's argument is biased in favor of 0-based indexing. For example, he talks about how (a < i ≤ b) is unnatural, but then fails to mention that this happens with 0-based indexing when we have to iterate backwards.
- epage 5y ago
  When you casually program in a language, being consistent with what people are familiar with is important to avoid introducing subtle bugs. A lot of times, languages like Lua get introduced by enthusiasts in a way that others have to touch when things break but not enough to master. Think of shops that have those one off Perl scripts and the challenge with touching them.
- rxhernandez 5y ago
  It can definitely create problems when translating an algorithm from one to the other. I know it was a frustration when I translated algorithms from Matlab to C++.
- lonk 5y ago
  Because 0 is first natural number and 1 is second :P
  - dkarl 5y ago
    Very unfortunate choice of terminology in this context. Most of the math textbooks I used in college used "natural numbers" to mean the positive integers. Others used it to mean the nonnegative integers. So the term "natural numbers" presents the same uncertainty to a reader as indexing in an unknown programming language does :-)
- jimsimmons 5y ago
  Off by one errors are one of the most common type of errors. So it's a real gotcha for most programmers
  - deleted 5y ago
    [deleted]
  - brabel 5y ago
    Off by one errors are also the easiest thing in the world to test. I never think much about whether I should do `n` or `n - 1`, I just write a test and then fix it if needed.
- IshKebab 5y ago
  I guess it's because there isn't a huge difference but 0 definitely is slightly more elegant than 1. And when you're used to programming with the elegant system it's really jarring to switch to an unusual and slightly worse system.
  - void_mint 5y ago
    Elegance is a term developers love to throw around to get out of having to define why something is or is not good. Your answer is nothing more than "I like it more".
    - IshKebab 5y ago
      Nonsense. Are you saying the concept of elegance doesn't exist? I didn't explain why 0 is more elegant but that doesn't mean I'm not saying that it is more elegant. One example is when you're processing arrays or matrices in blocks. Using right-open intervals (also the most elegant option) you end up with intervals like [0, 4) [4, 8) [8, 12). Pretty trivial to calculate those bounds! It's just 4N. With 1-based you end up adding and subtracting 1 all over the place. Another example is indexing into flattened arrays. To get to the relevant element it's just (row_len * col + row). With 1-based indices it's (row_len * (col - 1) + row). Basically I've done a lot of 1-based programming (in Matlab), and you definitely end up adding and subtracting 1 in places where you wouldn't need to with 0-based programming.
      - void_mint 5y ago
        > Are you saying the concept of elegance doesn't exist? No...You can feel like something is elegant. Others may not feel that way. Saying "This is elegant" doesn't explain why, and since it's totally subjective it's just kind of a meaningless thing to say. Similar to measuring something by how "interesting" it is. The rest of your post just verifies that your original post should've been "I just like it more."
        IshKebab 5y ago
        > Saying "This is elegant" doesn't explain why I never claimed it did!?
- 0-_-0 5y ago
  Because modulo arithmetic needs to include 0, so if you do modulo arithmetic on indices 0 based indexing is better.
  - romwell 5y ago
    One solution to that is have inherently modular array indexing, so that any index is valid. If A[1] is the first element, then A[0] would be the last; etc
    - 0-_-0 5y ago
      That's a good idea!
    - mst 5y ago
      I do appreciate languages that allow -1 for the last index.
      - layer8 5y ago
        That makes it difficult to calculate the distance (length of the slice) between two arbitrary indices though.
        romwell 5y ago
        Well, that's when you can use the mod operator instead of having to do it when indexing into an array (a much more common operation).
andre-la 5y ago
Is 0-based like C, but on libraries that reimplements the Lua libraries, it's 1-based as Lua, because the language aims Lua compatibility. Due to this, the string and "sequence" libraries (which works as a Lua-like vector), and the table library in the future, are 1-based.

I'll never understand why this is such a big item of importance for developers :). Both 0 & 1 are pretty natural in my eyes.

moomin 5y ago
Let's see if Dijkstra can explain it. :p https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/E...
- pull_my_finger 5y ago
  This seems to get posted a lot in 0 vs 1 threads as a way to end the conversation in appeal to authority, but for arguments sake, Roberto Ierusalimschy (of Lua) has explained his design choice: > When we started Lua, the world was different, not everything was C-like. Java and JavaScript did not exist, Python was in an infancy and had a lower than 1.0 version. So there was not this thing when all the languages are supposed to be C-like. C was just one of many syntaxes around. > And the arrays were exactly the same. It’s very funny that most people don’t realize that. There are good things about zero-based arrays as well as one-based arrays. > The fact is that most popular languages today are zero-based because of C. They were kind of inspired by C. And the funny thing is that C doesn’t have indexing. So you can’t say that C indexes arrays from zero, because there is no indexing operation. C has pointer arithmetic, so zero in C is not an index, it’s an offset. And as an offset, it must be a zero — not because it has better mathematical properties or because it’s more natural, whatever. > And all those languages that copied C, they do have indexes and don’t have pointer arithmetic. Java, JavaScript, etc., etc. — none of them have pointer arithmetic. So they just copied the zero, but it’s a completely different operation. They put zero for no reason at all — it’s like a cargo cult. https://habr.com/en/company/mailru/blog/459466/ https://habr.com/en/company/mailru/blog/459466/
  - balfirevic 5y ago
    That doesn't explain why he picked one-based arrays, it only says the reasons C has zero-based arrays don't necessarily apply to Lua.
- ufo 5y ago
  I have to confess that this EWD on 0-1 indexing is one of my pet peeves. Whenever the topic comes up, someone will invariably link to it uncritically, even though Djikstra's argument is biased in favor of 0-based indexing. For example, he talks about how (a < i ≤ b) is unnatural, but then fails to mention that this happens with 0-based indexing when we have to iterate backwards.
epage 5y ago
When you casually program in a language, being consistent with what people are familiar with is important to avoid introducing subtle bugs. A lot of times, languages like Lua get introduced by enthusiasts in a way that others have to touch when things break but not enough to master. Think of shops that have those one off Perl scripts and the challenge with touching them.
rxhernandez 5y ago
It can definitely create problems when translating an algorithm from one to the other. I know it was a frustration when I translated algorithms from Matlab to C++.
lonk 5y ago
Because 0 is first natural number and 1 is second :P
- dkarl 5y ago
  Very unfortunate choice of terminology in this context. Most of the math textbooks I used in college used "natural numbers" to mean the positive integers. Others used it to mean the nonnegative integers. So the term "natural numbers" presents the same uncertainty to a reader as indexing in an unknown programming language does :-)
jimsimmons 5y ago
Off by one errors are one of the most common type of errors. So it's a real gotcha for most programmers
- deleted 5y ago
  [deleted]
- brabel 5y ago
  Off by one errors are also the easiest thing in the world to test. I never think much about whether I should do `n` or `n - 1`, I just write a test and then fix it if needed.
IshKebab 5y ago
I guess it's because there isn't a huge difference but 0 definitely is slightly more elegant than 1. And when you're used to programming with the elegant system it's really jarring to switch to an unusual and slightly worse system.
- void_mint 5y ago
  Elegance is a term developers love to throw around to get out of having to define why something is or is not good. Your answer is nothing more than "I like it more".
  - IshKebab 5y ago
    Nonsense. Are you saying the concept of elegance doesn't exist? I didn't explain why 0 is more elegant but that doesn't mean I'm not saying that it is more elegant. One example is when you're processing arrays or matrices in blocks. Using right-open intervals (also the most elegant option) you end up with intervals like [0, 4) [4, 8) [8, 12). Pretty trivial to calculate those bounds! It's just 4N. With 1-based you end up adding and subtracting 1 all over the place. Another example is indexing into flattened arrays. To get to the relevant element it's just (row_len * col + row). With 1-based indices it's (row_len * (col - 1) + row). Basically I've done a lot of 1-based programming (in Matlab), and you definitely end up adding and subtracting 1 in places where you wouldn't need to with 0-based programming.
    - void_mint 5y ago
      > Are you saying the concept of elegance doesn't exist? No...You can feel like something is elegant. Others may not feel that way. Saying "This is elegant" doesn't explain why, and since it's totally subjective it's just kind of a meaningless thing to say. Similar to measuring something by how "interesting" it is. The rest of your post just verifies that your original post should've been "I just like it more."
      - IshKebab 5y ago
        > Saying "This is elegant" doesn't explain why I never claimed it did!?
0-_-0 5y ago
Because modulo arithmetic needs to include 0, so if you do modulo arithmetic on indices 0 based indexing is better.
- romwell 5y ago
  One solution to that is have inherently modular array indexing, so that any index is valid. If A[1] is the first element, then A[0] would be the last; etc
  - 0-_-0 5y ago
    That's a good idea!
  - mst 5y ago
    I do appreciate languages that allow -1 for the last index.
    - layer8 5y ago
      That makes it difficult to calculate the distance (length of the slice) between two arbitrary indices though.
      - romwell 5y ago
        Well, that's when you can use the mod operator instead of having to do it when indexing into an array (a much more common operation).

andre-la 5y ago

Is 0-based like C, but on libraries that reimplements the Lua libraries, it's 1-based as Lua, because the language aims Lua compatibility. Due to this, the string and "sequence" libraries (which works as a Lua-like vector), and the table library in the future, are 1-based.