Comments by "p11" (@porky1118) on "You Are WRONG About 0 Based Indexing" video.

But nobody actually calls it 0. It's usually E.
20
And the intuitivity issue can be fixed by fixing natural language and teaching children to count from zero from birth :)
8
I could answer the question: The simplest way to implement negative indexing would be this: value = array[mod(index, array.length)] If you implement it like this, the first element wold still be 0, and the last element (using negative indices) would be -1, just like it usually is now. So that's why negative indexing starting with -1 is rather an argument for positive indexing starting with 0.
7
@spacelem Yeah, indexing would be the proper term. But since the maximum index represents the count, it's just the same. But still, you'd still count the same way since you usually don't care about the indices. But calling myself the "zeroth" (I don't like the term) would make sense. If the rank is just the same as the number of people who are better than me, that's just more intuitive.
5
@spacelem Yeah, intuition is the wrong term in this case, since intuition might be subjective. My point is that it reveals more information. The number has an actual meaning (how many people are in front of you), where calling the best rank 1 doesn't provide any useful information.
3
@drdca8263 I also had the thought of prononcing the 0-element "first", since it linguistically doesn't really look related to one. But I would then continued "oneth" or something like that, else the prononciation will get weird later (26th, prononced "twenty seventh")
3
@milanstevic8424 I think it comes down to the distinction of ordinal and cardinal numbers. Ordinal numbers (first, second, basically indices) should start with zero. The offset from the start. Cardinal numbers (1, 2, 3, basically counts/quantities) should also start with zero. But zero in this case means no elements. An array of length 0 doesn't have an element 0. And ranges should be inclusive at the start and exclusive at the end. And these should probably be different types, too.
3
 @cybernetic-ransomware1485 I was thinking about elevators. It's often E and U. But I guess 0 and -1 exists, too.
3
@milanstevic8424 I guess I just don't understand. It just doesn't make sense to define centuries to include the last year (1900, 2000) while the decades of the century don't.
2
1:30 Natural language is wrong there. That's why nobody counts like this :) 2:50 Counting is different. The number of elements starts with 1. The lenght of a list with no elements is 0. The length of arrays with one element is 1. Ordinal numbers should be treated different than cardinal numbers. Programming languages should have ordinal number types for indexing and cardinal number types for array length. The first index of a range should be inclusive, the last index exclusive, so that "last-index - first-index = count". 7:20 This subscript logic also might apply to real life. If you take part in a race, and you are at rank 3, how many people do you have to overtake until you reach the best place? In one based, it's 2. In zero based it's 3. Which is more intuitive?
1
No, the offset IS the index. But I'd appreciate a language where you have some specific index type, so there might also be a different index type.
1
@dc443 I just came up with another idea. If you put a dot after a number in some language, it will be the index/ordinal type. Like 1. (first), 2. (second), 3. (third)... But 1. will internally just represented as 0, and if you do math with ordinal numbers, it just uses the internal representation. So most of the math you need for fancy indexing operations, which is easier for 0 based, still works.
1
@rikschaaf Yeah, in the simplest way, you don't even need a different type.
1
@spacelem Not sure what you want to say with your test example. The score is counting, not ordering, I agree.
1
@funkstication That's a bad idea. The len is much more important than the max element. For example if you have one index, but multiple arrays, you could do something like this: while (index > array[arrayindex].length) { arrayindex += 1 index -= array[arrayindex].length } return array[arrayindex][index] Something like this is easiest with zero based indexing and a direct accessor to the length.
1
@voskresenie- I don't remember most of this conversation. When you include zero in your natural numebers, which often makes sense, 0 is the first number. Starting to count from 0 doesn't really make sense. If you count, it's like jumping over the elements. You start at zero, but you don't say it. I would only make ordinal numbers start from zero, not cardinal, just like it already is in most programming languages. So I start at 0, this is my "first" (0st) element. Then I move to place one, there still is an element, so it's element 1. Then I go to place two, and if there still is something, it's 2. And I repeat this until there is no element anymore. The resulting number is the count. The first index with doesn't have an element. That's one way to view it.
1
@milanstevic8424 What's tricky about that? It obviously belongs to the 21st century (1-based). If there is a definition which doesn't put the year 2000 into the 21th century, it's just not such a good definition.
1
 @milanstevic8424 I don't get your point. The whole premise is weird. The year 2000 just doesn't belong to the 20th century. That would solve the problem, right?
1
@drdca8263 To most western people this probably seems weird. And maybe in the future people will think "Traditionally they called the year before they got one year old year one, not year zero"
1
@Norsilca Yup, he mentioned it in another comment. But that does't make sence to me. The 1th year has to be the oneth year if 0st is first.
1