this post was submitted on 19 Sep 2024
1461 points (98.7% liked)
Programmer Humor
32562 readers
355 users here now
Post funny things about programming here! (Or just rant about your favourite programming language.)
Rules:
- Posts must be relevant to programming, programmers, or computer science.
- No NSFW content.
- Jokes must be in good taste. No hate speech, bigotry, etc.
founded 5 years ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
Bullshit.
Every programmer knows that
'A'in['A', 'B', 'C', 'D']would be the 0th item; the first item is'B'That would be wrong in every technical sense. You're saying that
.first()would skip the 0th item.First = leftmost.
That's because the word "first" in
first()uses one-based indexing. In true programmer fashion it would have been calledzeroth()but that is wholly unintuitive to most humans.I maintain that the element with the lowest index is called the "zeroth" element in zero-based indexing and "first" in one-based indexing. The element with index N is the Nth element.
No, there is simply no such thing as "zeroth", that's not how ordinal numbers work. If I have the following numbered list:
Foo
Bar
Baz
The first item is "Foo" which is indexed 5. It is not the fifth item, because the item indexed 5 comes first in the list, so the item indexed 5 is the first item. Ordinal numbers don't refer to index, they refer to order.
Okay, I will admit, you got me there. I did confuse indexing with numbering. From now on I will use the term "numbering" instead.
It is entirely how ordinal numbers work in zero-based numbering. There is no "right way" for ordinal numbers to work. You can create a valid ordinal numbering system starting from any integer, or just some other ordered list. You cannot assume one-based numbering is "correct" and use it as an argument against numbering beginning from any other number.
I encourage you read up what is meant by "zero based numbering" because you and everyone else who has replied to me has tried to use "but that's not how it works in one-based numbering" as an explanation for why I'm wrong. This is as nonsensical of an argument as trying to say i (the imaginary unit) is not a number because it's not on the number line. It's only not a number in the domain of the real numbers. Similarly, zero-based numbering is only nonsensical in the context of one-based indexing.
Zero-based numbering would number "foo" as the zeroth element, "bar" as the first element, and "baz" as the second element. "zeroth", "first", and "second" are labels representing ordinals. Your list has a length of 3 (which is a cardinal quantity unrelated to ordinals).
Although, I would like to point out, it is perfectly valid to construct an ordinal labelling system that assigns "fifth" to the element with the lowest index, "sixth" to the next, and so on. That system is mathematically coherent but it is just troublesome to when it comes time to convert ordinal numbers (such as the index of the last fence-post) to cardinal numbers (such as the length of fence to buy).
But this is now getting into the weeds of pure mathematics and most people here are engineers.
Foo is both the first and fifth item - Foo is the first item in that segment (or slice if you're a weird golang programmer) but it is also the fifth item in some sir-not-appears-in-this-film list that is responsible for the odd numbering. If I said "I just finished the fifth item on our todo list" you'd mark off Foo because that's clearly what I was referring to.
Places can have two labels (or more!) and, for bonus points, zeroth is a thing because we both know what that word means.
Most humans wouldd never write the word
firstfollowed by(). It absolutely should have beenzeroth(), and would not cause any confusion amongst anyone who needed to write it.It absolutely should not have been named zeroth() because the reasoning for that is purely pedantic and ignores WHY arrays are 0 indexed. It's not like the people in the early days of writing programming languages were saying "the zeroth item in the array" - they would refer to it using human language because they are humans, not machines. Arrays are 0 indexed because it's more efficient for address location. To get the location in memory of an array item, it's startingAddress + (objectSize * index). If they were 1 indexed, the machine would have to reverse the offset.
Function/Method names, on the other hand, should be written so as to make the most sense to the humans reading and writing the code, because the humans are the only ones that care what the name is. When you have an array or list, it's intuitive to think "I want the first thing in the array" or "I want the last thing in the array)," so it makes sense to use first and last. That also makes them intuitive counterparts (what would be the intuitive counterpart to "zeroth"?).
My argument is purely pedantic. Pedantry is the lifeblood of programmer "humour".
I'm not arguing that we should adopt zero-based numberingin real-life human applications. I am arguing that in zero-based numbering, the label "zeroth" refers to the same ordinal as "first" in one-based numbering. I am poking fun at the conversion between human one-based numbering and computers' zero-based numbering. That is why I am saying it should be called
zeroth(); because human language should adapt to match the zero-based numbering their tools use. Whether I actually mean what I say—well, I leave that up to you.It does not matter why indexes start from zero in computing. The memory offset argument is only salient if you are using it as an argument for why computers should use zero-based numbering. It is not an argument against the properties of zero-based numbering itself.
Of course—that’s why we have such classics as
stristr(),strpbrk(), andstripos(). Pretty obvious what the differences are there.But to your point, the ‘intuitive’ counterpart to ‘zeroth’ is the item with index zero. What we have is a mishmash of accurate and colloquial terms for the same thing.
explode('brain', 'ai')Indexes start from zero because they're memory offsets, but
array[0]is still the first element because it's an ordinal number, not an offset. It's literally counting each element of the array. It lines up with the cardinality—you wouldn't say['A', 'B', 'C']has two elements, despitearray[2]being the last element.Zero-based indexing redefines the meaning of the labels "first", "second", "third", and so on. It adds a new label, "zeroth", which has the same ordinal value as "first" in one-based indexing. The word "first" does not mean "the element with the lowest index" in zero-based indexing.
If you are using a zero-based numbering system, you would absolutely say that
array[2]is the final element in the array, that element having the ordinal label "second", and yet the length of the array is 3 (cardinal). There is no fundamental connection between the ordinal labels "zeroth", "first", "second", and "third" and the cardinal numbers 0, 1, 2, and 3. The similarities are purely an artefact of human language, which is arbitrary anyway. You can make an equally mathematically valid ordinal numbering system that assigns "third" to the element with the smallest index, "fourth" to the next-smallest, and so on. That ordinal numbering system is mathematically coherent and valid, but you're just causing trouble for yourself when it comes time to convert those ordinals (such as array indexes) into cardinals (such as memory locations or lengths of fencing to buy).You can make an argument for why one-based numbering is more convenient and easier to use, but you cannot use the notion that zero-based numbering doesn't make sense given the assumed context of one-based numbering as an argument for why zero-based numbering is invalid.
I encourage you read up what is meant by "zero based numbering" because you and everyone else who has replied to me has tried to use "but that's not how it works in one-based numbering" as an explanation for why I'm wrong. This is as nonsensical of an argument as trying to say i (the imaginary unit) is not a number because it's not on the number line. It's only not a number in the domain of the real numbers. Similarly, zero-based numbering is only nonsensical in the context of one-based indexing.
It does not matter why indexes start from zero. The memory offset argument is only salient if you are using it as an argument for why computers should use zero-based numbering.
Yeah, fair enough. To my mind I guess I don't think of array indexes as an example of actual zero based numbering, simply a quirk of how pointers work. I don't see why one starting from zero has anything to do with the other starting from zero. They're separate things in my head. Interestingly, the article you linked does mention this argument:
That said, I suppose I still use normal one-based numbering because that's how I'm used to everything else working.