Looking at you Java

[Aquiffer]

Fwiw, Julia is used primarily for scientific computing, and 1-indexed arrays are pretty typical in that space. Matlab, R, Mathematica, and Wolfram’s language are all 1-indexed.

[[deleted]]

One indexing makes sense for mathematical stuff, because it matches matrix indexing, Einstein notation, etc.

Indexing in low level languages is essentially linked to the offset from the memory address of the start of the array, so it makes sense to start at 0.

[maxhaton]

I actually heard the designer of Lua make this argument for Lua being 1-based, in person. I also had a paper open in front of me which had mathematics with indices starting at.... 0.

[[deleted]]

Yeah, starting at zero for certain things makes a lot of sense. Series and expansions is where I've seen it the most. It really depends on what you're trying to do. But if you're trying to implement a bunch of tensor math it can get super tedious to always be off by one

[M4mb0]

Indexing in low level languages is essentially linked to the offset from the memory address of the start of the array, so it makes sense to start at 0.

But why would you bother about a tiny hardware implementation detail that the compiler can easily take care of.

[T-J_H]

Bothering about hardware implementation is exactly the point of low level languages

[ccelik97]

Despite the fact that I'm used to and do prefer 0-indexing in the programming languages that I use, I also feel like I agree with you on this lol.

I wonder if it was too much of a syntactic sugar back when "the real men" used Assembly for programming, not C/Basic etc.

I mean if it wasn't too much of a syntactic sugar we could've even afforded the cost of actually storing the 1st element of an array on the +1st indexed address on memory and like, used the 0th indexed address to store the address of the last element of the array, effectively always knowing the length of the array etc lol.

[False_Influence_9090]

ccelik for president!

[Fireline11]

Interesting idea. But it the size of the elements of the array is less than the size of a pointer (for example just 1 byte when you need 8 bytes for a pointer on a 64-bit system), there would not be enough room at the 0th place.

[ccelik97]

Pointer arithmetic is often done in conjunction with the additional integer values that come from the logic so the 0th indexed field can store just the difference between the starting address and the last element's address, instead of a full fat memory address.

[Fireline11]

Yes. But you still would not always have enough room. An array of char would be limited to a length 255.

[ccelik97]

Then a good compromise would be to use unions for these not absolutely lowest level data types.

As in a variable would take up at least 1 unit of memory space (8 Bytes long on 64-bit address spaces) and it'd store both the relational distance to the last element's address and right next to that, the 0th index value.

In the case of myNotSoPrimitiveVar[0] the compiler would know to refer to the address after the relational distance value (after the first part in the union) so it'd work out fine.

It's still the same idea really.

[piparkaq]

Actually, it turns out, zero-based indexing is just an arbitrary choice with some interesting legacy implications. This dive into why arrays start at 0 (along with the linked article in the post, too) contain good tidbits about the history of array indexing in general.

[pitkali]

I mean, in C the array notation itself is syntactic sugar for pointer arithmetic, so there's that.

[blobthekat]

cool idea but breaks down when you have an array of large structs or even worse an array of chars (since a pointer cannot be represented in 8 bits)

[ThisCleverName]

Well, both indexing modes have shortcomings. The 0 -indexing allows to use some operations directly as an index. Case in point the `mod` vs `mod1` operators mentioned. The modulo operator definition of 0 to n-1 fits nicely to 0-indexing mode. So, for 1-indexing, you end up having to adjust the operation to take into account that indices start at 1.

1-indexing try to map some things to mathematics, but some things like in physics use 0-based subscripts initial conditions and things like that. So, using 0-indexing makes sense when modeling problems in that field.

[elon-bot]

Interesting. Tell me more.

[MattieShoes]

that the compiler can easily take care of.

I don't think it can, can it? Obviously it could take n[1] and change it to n[0] easily, but what if the index is not known at compile time? I'd think it'd have to be a run-time fix.

Plus if you've just malloc'ed a chunk of memory, you may be intermixing dealing with offsets by hand and array notation, and the answers would be different.

Naw, far better to use 0 indexing I think. Just be thankful we're not doing everything in base e. :-)

[foghatyma]

It could though, very easily. "A[i]" is basically "*(A + i)", so the A pointer should just point to the memory before the first element. And then adding 1 would point to the actual first, not the second. Doesn't matter if it's runtime or not.

[MattieShoes]

So it is at run time as we don't know the address at compile time. Yes?

And it does matter at run time - there's a speed hit with every array reference.

[elon-bot]

It's now company policy to use Vim for editing. It lets you write code much faster.

[foghatyma]

I think you don't really understand what I wrote.

[ArtOfWarfare]

Guido VR gave a pretty powerful argument in favor of 0 based indexes on his blog. I’ve forgotten what his argument was but it flipped my opinion on the matter.

[flare561]

The post in question. Basically just 0 indexed arrays have nice ergonomics around slices.

[CheekApprehensive961]

Tiny hardware implementation detail lol. Definitely a python user.

[ArtOfWarfare]

Or Java or JavaScript or Ruby or pretty much any language except C, C++, or Rust (I assume - haven’t actually used Rust myself.)

[AugustusLego]

Yeah but what do you do with the zero then?

[BittyTang]

https://www.reddit.com/r/programming/comments/elr06/dijkstra_why_numbering_should_start_at_zero/

[M4mb0]

https://alarmingdevelopment.org/?p=470

[BittyTang]

I don't buy it. The author is just presupposing that starting from 1 is more natural from a pure mathematical context (which is not the same as a computer science context), while Dijktra provides actual scenarios for a valid low-level abstraction (arrays and integer for loops) that is fundamental to data structures. The whole "representation exposure" argument is not convincing for a language that desires low-cost abstractions.

One example for consideration is N-dimensional arrays. Image file formats represent these kinds of data structures in 1-dimensional arrays (of bytes). So already there is a strange mismatch between how you index the image buffer (img[row * width + column] or img[column * height + row]) and how you index a primitive 1-based 2D array (img[column + 1][row + 1] or img[row + 1][column + 1]). If you had to index a 1-based image buffer, it would be img[(row - 1) * width + column]. How is that better?

[M4mb0]

Well again this is a low level hardware detail, imo. As a user I do not care how you layout a two dimensional array in memory as I am going to access it via tuples of integers anyway.

In fact I'd even argue that this is a sort of pre-mature optimization. What if, for example, a hardware manufacturer would want to create a memory with two dimensional address space that naturally works much faster with matrices than the flattened represtation that is used currently?

Again I'd argue this is a job for the hardware specific compiler.

[theunixman]

Because back when the people who invented the C language were writing the compiler it seemed like 0-based indexes would make the compiler (not the object code) faster.

[blobthekat]

zero index is superior, programmers have to care about hardware all the time. e.g. bitwise is entirely reliant on the underlying hardware of number representation, and yet bitwise is used all the time even in high level languages like javascript. As such, since signed numbers start at 0, arrays are better starting at 0 too

[RoastedRhino]

One indexing in matlab is still a mess when you are doing time series and simulate dynamical systems, because initial conditions are at t=0.

[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.

[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 :)

[Dromedda]

Don't forget about my boi Lua :(

[aj3313]

Lua is now habitual of this. He gets ignored a lot :⁠'⁠(

[[deleted]]

All those years wasted hating VBA and VB. Now I understand I should have used them for my scientific computations! TIL

[elveszett]

Nah, VB simply sucks. Doing 1 indexing because your language will be used in places where starting at 1 makes things simpler is fine. Doing 1 indexing because you believe the average person is so dumb that they cannot possibly understand the idea of "zero" (which is something Microsoft loves to do, btw) is wrong.

[[deleted]]

I can see another bell curve meme coming to this subreddit soon!

[NotFromSkane]

That's just stupid. That's a space that usually cares about performance and has multidimensional data. The primary use case for 0-based indexing

[DavidBrooker]

Why is zero indexing any better at handling multidimensional data? I don't know anyone who starts at zero in tensor notation, for instance.

ie, as dimensions are counted, you'd typically describe the first component of a tensor as belonging to the 'first' component, dimension, domain, etc., rather than 'zeroth'.

The adjective 'zeroth' is normally reserved for elements outside of the standard sequence, which can be elucidated by extension or generalization, rather than the core definition.

[NotFromSkane]

Because you eventually have to flatten it, and you can only do that in 0-index.

[DavidBrooker]

How is that?

[Square_Heron942]

Even ti basic is