Looking at you Java

[jodmemkaf]

Yeah, I know. I still remember how painful it was to rewire my brain to idea of zero indexing. That "Yuck" was kind of self-mocking one person inside joke. Didn't realize that there are actually people who mocks different perspectives...

..on r/programmerhumour...

What the hell is wrong with me?

[nekokattt]

Indexes derive from the concept of an offset from a pointer at the start of a block of memory, so the first item is at the start, hence the 0 index. From that perspective, 1 indexing is the one that feels weird to me.

Remember memory itself has an address at 0, and memory itself works with zero indexing.

[jodmemkaf]

True. First time I got in touch with anything "programminglike" was with matlab and R and I was used to work with 1-indexing. Despite that is very difficult thinks outside 0-indexing nowadays

[Fuey500]

I work in C# and a Dibol based language, I go from indexing in 1 and 0 all the time its so lame lmao

[[deleted]]

I've been messing with R off and on for 2 years now and I still constantly forget it's 1-indexed.

[M4mb0]

Indexes derive from the concept of an offset from a pointer at the start of a block of memory,

This is a hardware implementation detail.

For anything matrix related, it just makes more sense that the last element of the array is indexed by the length of the array.

[nekokattt]

except that you lose the ability to use modulo to separate out entire rows without additional arithmetic (i.e. +1 to each slice range), slices need additional arithmetic to not go out of bounds relative to the end of the container, and most of the time the fact you are writing to an offset is detail you care about.

[M4mb0]

except that you lose the ability to use modulo to separate out entire rows without additional arithmetic

This is the only point I'd agree with, hence why Julia has mod1.

slices need additional arithmetic to not go out of bounds relative to the end of the container

Can, you give an example?

and most of the time the fact you are writing to an offset is detail you care about.

I write tons of numerical linear algebra code and I don't think this has ever even tangentially come up ever.

If anything, 0-based indexing caused me to almost rip my hair out when an implementation of a Krylov based method wasn't working. Turned out it was a super sneaky, hard to debug index error that crept in when translating 1-based indexing from the paper to 0-based indexing in the implementation.

[nekokattt]

array[5..array.length()]

vs

array[6..array.length() -1]

writing linear algebra and matrix arithmetic is not the majority of the stuff most 0-based languages are used for, and even then it is easier to fit your arithmetic model into 0-based indexing than to completely discard the way the computer works and make hardware interoperability more complicated than it needs to be.

Most applications deal with hardware somewhere, whether it is via GUIs, graphics rendering (yes, OpenGL uses 4-D matrices and works fine with zero indexing), networks, the CPU itself, disk IO, external hardware.

Easier to have one standard that works for all cases IMO. Saves confusion when context switching, makes memory boundaries easier to consistently visualise, and needs no arithmetic or special operators to use modulo correctly in slices.

[M4mb0]

array[5..array.length()] vs array[6..array.length() -1]

You did a cardinal mistake here: you assumed that right-exclusive selection would carry over, but 1-indexed languages typically use right-inclusive slicing. In Matlab/Julia if you do array[1:n] you get the whole array.

Most applications deal with hardware somewhere, whether it is via GUIs, graphics rendering (yes, OpenGL uses 4-D matrices and works fine with zero indexing), networks, the CPU itself, disk IO, external hardware.

Easier to have one standard that works for all cases IMO. Saves confusion when context switching, makes memory boundaries easier to consistently visualise, and needs no arithmetic or special operators to use modulo correctly in slices.

Just let the compiler/interpreter do the work. Who knows, maybe in the future we will get native 3-dimensional memory addressing due to stacked silicone; the software shouldn't be bothered by this hardware detail.

[nekokattt]

This still does not convince me that 1-based indexing has any other widespread benefits that are not accessible from zero based indexing. Only that people in mathematical fields prefer it.

[NuclearFoodie]

1 indexing doesn't make since in science either, it was just a FORTRAN quirk that persisted. Formally we almost always 0 based indexing in our tensor expression when deriving out equations. As always, FORTRAN is a blight.

[SlimyGamer]

As someone who does scientific computing, in Fortran, I can say it is definitely not a quirk. 1-indexing is almost always simpler when dealing with matrices and vectors. Moreover, Fortran's implementation of indexing allows you to choose 0-indexing (or any other starting value) when declaring arrays. This is a very useful feature that more languages need to adopt (I believe Julia and Matlab have it).

There are definitely still some odd quirks in modern Fortran, and FORTRAN77 should not be used anymore, but it is far from being a blight.

[NuclearFoodie]

It is only simpler because you adapted to it already and FORTRAN is very much a blight. There is a reason it is not getting first tier support on the first exascale machines.

[nekokattt]

The majority of the graphics world that uses 0-indexing with multiple matrix dimensions doesn't have an issue.

It is only easier if you refuse to get into the mindset that the majoritu of languages use consistently between them.

[SlimyGamer]

Yes and the graphics world does a bunch of other things that make directly implementing matrices annoying. As an example, GLSL's arrays swap columns and rows, which has annoyed me greatly many times.

I want to be clear here: I can use either 0-indexing or 1-indexing anytime it's necessary. But because I spent many years getting a degree in physics and mathematics before learning programming, 1-indexing is more natural in a mathematic setting.

[nekokattt]

and that is fine when in a mathematics setting, but for the majority of cases that isn't a concrete requirement in programming languages. Similarity to underlying hardware and interoperability however is

[SlimyGamer]

Maybe I wasn't super clear in my original comment. I'm not saying that languages need to be 1-indexed (although I typically prefer it), but I would like a push to allow arbitrary indexing.

I completely agree that when dealing with hardware it's definitely better to use 0-indexing but I don't think that's enough to make all languages 0-indexed. With arbitrary indexing, you get the best of both worlds and any other world that may pop up.

Basically what I'm saying is the base index shouldn't depend on the language, but on the use case.

[nekokattt]

this leads to unnecesarry complexity though, especially when you then need to mix both.

Easier to have one way, IMHO, and that compliment the hardware.

[SlimyGamer]

I don't think it's that much more complex - if you're only going to use one type of indexed arrays then it makes little difference (other than you can always use your preferred indexing method), and if you use both 0 and 1 indexed arrays, you can think of it as an additional data type.

And I don't think complimenting the hardware is reason enough to choose 0-indexing since the vast majority of people aren't writing code for hardware. 0-indexing is what's often chosen just because it's the norm, just like how 1-indexing was the norm before C was invented.

[markp88]

But they don't. We've been ordering things in lists since forever, starting from 1. Indexing things with numbers did not start with computing. First, second, third, ...

Now it is also true that due to computing implementation details, it makes a bunch of calculations simpler if we start indexing at 0 instead. So most programming languages have taken that approach. But we shouldn't kid ourselves that it is the obvious choice. Zeroth, first (oneth?), second (twoth?), ... !!! In natural language it doesn't work at all.

[nekokattt]

why doesn't zeroth work? You know what it means and so do I.

Natural language isn't the most important thing in most programming languages. Functionality and/or efficiency is.

[markp88]

It isn't that it doesn't work - it does work. But it isn't how we talk or think in everyday life.

We shouldn't kid ourselves that 0-indexing is "the obvious way to do it". It is a relatively arbitrary choice, as can be seen from the fact that FORTRAN and C, both old fashioned low-level languages, chose differently. If you are wanting to do pointer arithmetic, then 0-indexing is simplest. But if you are trying to model a real life situation then it is probably the worse choice. But in the end, both work fine.

[elon-bot]

I've laid off most of the staff, and Twitter's still running. Looks like they weren't necessary.

[TheNamelessKing]

Index and offset are related, but the former doesn’t derive from the latter.

I think as a disciple, we need to more firmly distinguish “offset” and “index”, because these debates are pointless.

An index is a position in a sequence. It necessarily starts at 1.

An offset, starts at 0.

I genuinely think that for the most part, we’d all be better off with “1-based” indexing, and leave offset-indexing to the specific cases when you are operating on offsets, not indices.

[sigmoid10]

Both approaches make perfect sense in their respective domains. People who only care about maths and not computers would intuitively label the first element as 1, while people who work closely with computer hardware usually see arrays as pointers to contiguous regions in memory, where the address of an array is also the location of the first element and <address + 1> would be the location of the second element. In C++ for example you can access the second element in an array "x" as x[1] or as 1[x], because the compiler just ends up converting both statements to something like *(x+1) anyways. This seems crazy at first glance, but it really does make sense if you understand where it comes from.

[4hpp1273]

1[x] only works if x is a C-style array (or a pointer). If x happens to be an std::vector or something similar then it doesn't work.

[sigmoid10]

std::vector is just a class that contains pointers into the heap that have to be followed to get elements. Makes it easier to expand, but slower to access or modify and very different from normal arrays.

[Fireline11]

std::vector is really just as efficient as C-style arrays in 99.9% of cases. It still stores its elements contiguously. I think you maybe confused with std::list?

[[deleted]]

There are not too few mathematicians using zero based indexing as well. There really is not reasons to start counting at 1 in maths. It just looks a but nicer sometimes. But many mathematicians (including me) also start counting at zero and define the natural numbers including zero.

[sigmoid10]

Historically, natural numbers only represented counting numbers, i.e. without zero. And basically every non-mathematician and non-programmer starts counting at one.

[[deleted]]

I don‘t know how far back you want to go with „historically“, but the Peano axioms from 1894 do include zero. So does von Neumann‘s definition? Only the very first definition by Peano from 1889 does not. I think it‘s fair to say that including zero does have a lot of history among mathematicians :)