5 ms·

1 based indexing? is there any particular reason Julia uses 1 based indexing? seems like a pointless thing to differentiate from other languages

est31 8y ago
> We have chosen 1 to be more similar to existing math software. https://github.com/julialang/julia/issues/558#issuecomment-4428498 https://github.com/julialang/julia/issues/558#issuecomment-4...
kryptiskt 8y ago
It's common in the area, R and Matlab uses 1-based indexing. Fortran does it by default too.
dralley 8y ago
Math/Science focused languages have usually used 1-based indexing, historically. Fortran, MATLAB, R, etc. In the primary fields where Julia is expected to be used, 0-based indexing would be a differentiator, not the other way around.
ZeroCool2u 8y ago
Personally, I find it annoying considering it's just based on convention from other math software. Otherwise, an amazing language.
- kbenson 8y ago
  Whereas 0 based indexing is based on convention from other languages where it arguably made more sense because it was just a convenience over pointer arithmetic. What reason other than convention is there for 0 based array indexing in any any language where an array isn't just a memory location and the index a calculation of type-size times index bytes?
  - murderfs 8y ago
    Edsger Dijkstra on why numbering should start at zero: https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/E...
    - kbenson 8y ago
      Which is a valid argument for numbering starting at zero, but not just for programming languages, but in general and including human spoken languages. The common counter-argument is "People don't generally think that way unless trained to do so". Like many things in life, often convention and momentum often trump reasoned argument. In general, much of what's chosen for language design is influenced to some degree by convention. This is a valid design choice, because you're maximizing use of existing domain knowledge of your audience. In this specific case, I would argue that since in many languages where an array isn't a small shim over memory management (Ruby, Python, Perl, JS, etc) where easing user friendliness is at a premium over performance, 1 based array indexing would make better sense... if most people adopting those languages weren't already fairly well acquainted with 0 based indexing from CS programs or exposure to other languages (and it wasn't a simple concept to understand). Since many new users are familiar with it, and it is easy to understand, it's simple to just go with what some percentage of people already know, so convention wins out.
    - int_19h 8y ago
      There are many rebuttals to this claim by Dijkstra, too.
    - superlopuh 8y ago
      Funny how the argument about veering into the unnatural numbers is voided by a Maybe type.
    - samatman 8y ago
      The One True Wiki has a fairly complete discussion of this question: http://wiki.c2.com/?WhyNumberingShouldStartAtZero http://wiki.c2.com/?WhyNumberingShouldStartAtZero What I find most persuasive is that 0 based indexing brings measurement into accord with enumeration.
- xiphias2 8y ago
  It's bad for me too, also missing some other features of Ruby (for example or, and keywords; ,,if'' keyword as a modifier, using blocks for passing a function as a parameter for functions), but there were some great surprises: the windows support seams superior to Ruby's, where I get a lot of compile errors; of course more/better math libraries.
- Certhas 8y ago
  When I started Julia I was annoyed by it. Then I realized that 90% of my mental gymnastics with indices got simplified. Explaining indexing to newbies is now immediate where before it took a slide, several examples, and a clever picture. Slicing is also more natural: "1:3 picks out index 1, 2 and 3, which are the first, second and third element of the array." Instead of the python version of "0:4 picks out index 0, 1 and 2, which are the first, second and third element of the array."
  - petre 8y ago
    Less off by one errors for one.
  - saghm 8y ago
    > "0:4 picks out index 0, 1 and 2, which are the first, second and third element of the array." I don't think that's right? It should pick out four things, not three. Of course, you could argue that getting that wrong proves your point! I personally still prefer 0-indexing, but I definitely agree with you that having an exclusive upper bound is confusing.
    - Certhas 8y ago
      You're right of course. Not intentional. 0:3 picks out index 0, 1, 2. So 1:3 picks out the second and third element, which are indexed by 1 and 2 respectively. My guess is that what one prefers probably depends entirely on the data structures one works with most....
      - shele 8y ago
        I like how you got it wrong, proving your point.
bitwize 8y ago
Because they're designed for people, not machines. People count from 1.
- pault 8y ago
  Are you counting the fence posts or sections of the fence? Edit: I think I screwed up that analogy.
- bsder 8y ago
  There is no more correct. There is simply more to purpose. 0-based indexing won in programming because it is simply more to purpose in programming. We rarely operate on ranges, but we operate on offsets all the time. And 0-based wasn't solely "C won so 0 won". We had 1-based languages for a LONG time, and, if they were sufficiently superior, they should have displaced C. They did not. In addition, in proper programming languages you don't count--you iterate, fold, accumulate, etc.--and avoid the index altogether because it is error-prone. 1-based indexing causes all kinds of havoc in circular ranges. In particular when you try to access things in a circular manner (very common in programming--uncommon in mathematics), it causes grief. // 1 based new_index = index % N + 1 new_index = (index - 1) % N // Careful: the parentheses are REQUIRED new_index = (new_index == 0 ? N : new_index) // 0 based new_index = (index + 1) % N new_index = (index - 1) % N Range discussion from Dijkstra in 1982: https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/E...
  - xiphias2 8y ago
    Actually what's funny here is that (index - 1) % N doesn't work in C, as it can be negative. You have to use (index+N-1) % N. I still prefer 0 based indexing (for example for calculating the size of an array), but the worst thing is inconsistency between languages. 0 won, that's it.
    - bsder 8y ago
      Oh, that's hilarious. I tested this in Python where it worked fine and forgot that C has a "broken" modulo operator: Python: >>> -1 % 20 19 C: printf("%d\n", (-1 % 20)); -1 Even worse, it still fails even on unsigned: printf("%d\n", ((unsigned int)0 - (unsigned int)1) % 20); 15 So you still need to add N: printf("%d\n", ((unsigned int)0 - (unsigned int)1 + 20) % 20); 19 Thanks for the reminder of humility. (Side Note: For those reading this, the C operator isn't "broken", per se. There are three properties that modulo can adhere to but two of the three are mutually exclusive.)
deleted 8y ago
[deleted]
cdsousa 8y ago
There seems to be a kind of Godwin's law for Julia that states that "When on an online discussion someone mentions Julia, the probability of a complaint about 1-based indexing is 1".
- cdsousa 8y ago
  Or maybe it should be "When on an online discussion someone mentions Julia, the probability of that discussion turning into a 0-based versus 1-based indexing discussion is 1"

est31 8y ago

> We have chosen 1 to be more similar to existing math software. https://github.com/julialang/julia/issues/558#issuecomment-4428498 https://github.com/julialang/julia/issues/558#issuecomment-4...

kryptiskt 8y ago

It's common in the area, R and Matlab uses 1-based indexing. Fortran does it by default too.

dralley 8y ago

Math/Science focused languages have usually used 1-based indexing, historically. Fortran, MATLAB, R, etc. In the primary fields where Julia is expected to be used, 0-based indexing would be a differentiator, not the other way around.

ZeroCool2u 8y ago

Personally, I find it annoying considering it's just based on convention from other math software. Otherwise, an amazing language.

kbenson 8y ago
Whereas 0 based indexing is based on convention from other languages where it arguably made more sense because it was just a convenience over pointer arithmetic. What reason other than convention is there for 0 based array indexing in any any language where an array isn't just a memory location and the index a calculation of type-size times index bytes?
- murderfs 8y ago
  Edsger Dijkstra on why numbering should start at zero: https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/E...
  - kbenson 8y ago
    Which is a valid argument for numbering starting at zero, but not just for programming languages, but in general and including human spoken languages. The common counter-argument is "People don't generally think that way unless trained to do so". Like many things in life, often convention and momentum often trump reasoned argument. In general, much of what's chosen for language design is influenced to some degree by convention. This is a valid design choice, because you're maximizing use of existing domain knowledge of your audience. In this specific case, I would argue that since in many languages where an array isn't a small shim over memory management (Ruby, Python, Perl, JS, etc) where easing user friendliness is at a premium over performance, 1 based array indexing would make better sense... if most people adopting those languages weren't already fairly well acquainted with 0 based indexing from CS programs or exposure to other languages (and it wasn't a simple concept to understand). Since many new users are familiar with it, and it is easy to understand, it's simple to just go with what some percentage of people already know, so convention wins out.
  - int_19h 8y ago
    There are many rebuttals to this claim by Dijkstra, too.
  - superlopuh 8y ago
    Funny how the argument about veering into the unnatural numbers is voided by a Maybe type.
  - samatman 8y ago
    The One True Wiki has a fairly complete discussion of this question: http://wiki.c2.com/?WhyNumberingShouldStartAtZero http://wiki.c2.com/?WhyNumberingShouldStartAtZero What I find most persuasive is that 0 based indexing brings measurement into accord with enumeration.
xiphias2 8y ago
It's bad for me too, also missing some other features of Ruby (for example or, and keywords; ,,if'' keyword as a modifier, using blocks for passing a function as a parameter for functions), but there were some great surprises: the windows support seams superior to Ruby's, where I get a lot of compile errors; of course more/better math libraries.
Certhas 8y ago
When I started Julia I was annoyed by it. Then I realized that 90% of my mental gymnastics with indices got simplified. Explaining indexing to newbies is now immediate where before it took a slide, several examples, and a clever picture. Slicing is also more natural: "1:3 picks out index 1, 2 and 3, which are the first, second and third element of the array." Instead of the python version of "0:4 picks out index 0, 1 and 2, which are the first, second and third element of the array."
- petre 8y ago
  Less off by one errors for one.
- saghm 8y ago
  > "0:4 picks out index 0, 1 and 2, which are the first, second and third element of the array." I don't think that's right? It should pick out four things, not three. Of course, you could argue that getting that wrong proves your point! I personally still prefer 0-indexing, but I definitely agree with you that having an exclusive upper bound is confusing.
  - Certhas 8y ago
    You're right of course. Not intentional. 0:3 picks out index 0, 1, 2. So 1:3 picks out the second and third element, which are indexed by 1 and 2 respectively. My guess is that what one prefers probably depends entirely on the data structures one works with most....
    - shele 8y ago
      I like how you got it wrong, proving your point.

bitwize 8y ago

Because they're designed for people, not machines. People count from 1.

pault 8y ago
Are you counting the fence posts or sections of the fence? Edit: I think I screwed up that analogy.
bsder 8y ago
There is no more correct. There is simply more to purpose. 0-based indexing won in programming because it is simply more to purpose in programming. We rarely operate on ranges, but we operate on offsets all the time. And 0-based wasn't solely "C won so 0 won". We had 1-based languages for a LONG time, and, if they were sufficiently superior, they should have displaced C. They did not. In addition, in proper programming languages you don't count--you iterate, fold, accumulate, etc.--and avoid the index altogether because it is error-prone. 1-based indexing causes all kinds of havoc in circular ranges. In particular when you try to access things in a circular manner (very common in programming--uncommon in mathematics), it causes grief. // 1 based new_index = index % N + 1 new_index = (index - 1) % N // Careful: the parentheses are REQUIRED new_index = (new_index == 0 ? N : new_index) // 0 based new_index = (index + 1) % N new_index = (index - 1) % N Range discussion from Dijkstra in 1982: https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/E...
- xiphias2 8y ago
  Actually what's funny here is that (index - 1) % N doesn't work in C, as it can be negative. You have to use (index+N-1) % N. I still prefer 0 based indexing (for example for calculating the size of an array), but the worst thing is inconsistency between languages. 0 won, that's it.
  - bsder 8y ago
    Oh, that's hilarious. I tested this in Python where it worked fine and forgot that C has a "broken" modulo operator: Python: >>> -1 % 20 19 C: printf("%d\n", (-1 % 20)); -1 Even worse, it still fails even on unsigned: printf("%d\n", ((unsigned int)0 - (unsigned int)1) % 20); 15 So you still need to add N: printf("%d\n", ((unsigned int)0 - (unsigned int)1 + 20) % 20); 19 Thanks for the reminder of humility. (Side Note: For those reading this, the C operator isn't "broken", per se. There are three properties that modulo can adhere to but two of the three are mutually exclusive.)

deleted 8y ago

[deleted]

cdsousa 8y ago

There seems to be a kind of Godwin's law for Julia that states that "When on an online discussion someone mentions Julia, the probability of a complaint about 1-based indexing is 1".

cdsousa 8y ago
Or maybe it should be "When on an online discussion someone mentions Julia, the probability of that discussion turning into a 0-based versus 1-based indexing discussion is 1"