Man doing live reactions, he won.

This is why you should use -1 based indexing like DreamBerd.

Imagine going to a conference in person, to see a speaker lecture in person and still watching a recording

Prime at its Prime. I felt the emotions in the end. This is a man truly talking about what is important to him and he does not hide his feelings about this. I admire this fucking guy.

0 makes sense because it's an offset. If you want someone to stand still, you don't tell them to walk 1 mile.

0 base array works great with modulo arithmetic.

1-based gets nasty the moment you need to do any index arithmetic. Like let's say you have a pixel array of WxH pixels and you need to generate an index given x and y. With 0-based thats just "x + W * y", while with 1-based it becomes "x + W * (y-1)" I can't think of any code where 1-based is better beyond it being slightly more intuitive for beginners.

The problem with 1-based is that when you do modulo and integer divide operations, there's a missmatch in indexing. Like if you have an array of 20 items and you want to associate them evenly for like 1000 elements, you'd do items[i % items.length()], this way, it'll always be contained within items. But with 1-indexing, item[40 % 20] = item[0], which would error out.

1-based indexing is significantly worse for higher dimensional arrays. If I have a cubic 3-dimensional grid of width 16, its way more intuitive to index it like this (0-based): grid[x + y*16 + z*256] As opposed to this (1-based): grid[x + (y-1)*16 + (z-1)*256]

Fun fact already on minute two. In Germany we are actually counting floors starting with a a zero floor. "Erdgeschoss": ground floor, "1. Etage" is up one level from ground floor (and now I am already confused what it is in English). So 0 based index systems have been working well for a couple hundred years.

I don't know how I feel about live reactions, it's just... If I ever go to a Primeagen event, I would like him to talk about something himself, just like the course he made for Frontend Masters

As a mathematician, some times it's more sensible to start a sequence at 0 (such as a geometric sequence, where the index tells you the power of the common quotient), some times it's more sensible to start a sequence at 1 (such as the harmonic sequence where the index tells you the denominator). It's the fact that programming languages can't be flexible about it that's the real issue here.

Tldr: instead of INDEX say OFFSET, because as human readable point of view we are mistaking index and our numeric counting. By this definition arrays must at ZERO based offset

Edgar Dijkstra wrote a great short paper explaining why 0-based is intrinsically better. Source: EWD831 "Why numbering should start at zero"

Can we just agree on this: - in languages that start arrays with 0, let's call it an offset (or subscript if you're fancy) - in languages that start arrays with 1, let's call it an index That way, both can coexist. It even allows for languages with both.

As soon as he mentioned the c specification I paused to look it up. C99, c-11, and c-17 all refer to square brackets as subscripting operators, but also refer to the elements of an initializer list as being "indexed". Further, c-2x (since at least August 2022) has all that plus the explicit mention of 0-indexing in relation to bits in the stdbit.h section. Also _Lua_ stores the array portion of tables in an actual c array. ..Counter-ackshually-d.

"Lua is actually right" alr fine, ill hear you out but i doubt you will convince me

Tom Scott in his "bodge" video was using lua, it went exactly the way one would expect

In the late 90s, my teacher explained like this: "Don't think of indexing as regular counting. Think of the numbers used in indexing as symbols. Instead of numbers we could have used letters starting with A to Z and then AA to ZZ etc. just like in columns in spreadsheets. However since offset calculations need to be done under the hood to access specific parts of the array, the symbols A-Z would eventually need to be turned into numbers anyway. That is why it's more efficient to just use numbers in the first place. The reason we start with zero as a starting point is, because we want to use as many different symbols as possible using non-negative numbers, so we don't want to waste the symbol zero. Hence we start with the symbol zero. Historically this has its roots in memory addresses, where the lowest memory address also starts with zero, for the same reason, to use the lowest possible non-negative symbol. Because memory addresses already use zero-based indexing, it makes calculation of memory addresses and offsets more efficient if the array also starts with zero indexing. Additionally it aligns with mathematical concepts and simplifies certain algorithms and calculations." I always liked this way of thinking about it. It helps get over the confusion of thinking of indexes as regular counting.

When a baby is newly born, we don't start counting their age as being 1 year old immediately when they come out of the womb. All the age counters for every unit of time start at ZERO intuitively!! A recently born baby would be something like 0 years, 0 months, 0 weeks, and maybe 3 days old... However, it's common in human languages to omit saying the units that are currently zero, but they are still there and we all know mathematically that they are there.

Yooooooooo that Brazilian shirt is fire 🔥🇧🇷

But have you seen a language in which it's possible to have an array indexed -69..69? How can you not love Pascal

my favorite example of 1-based indexing is used where it makes zero sense is intervals in music. if you add together two third intervals you get a fifth interval. 3+3=5. 5+4=8. the first interval, the unison, is a zero offset

I started my programming with Lua, starting at 1 made so much sense to me starting out UNTIL I dealt with time. Hours are 0 - 23 so I constantly had an off by 1 error which flew under the radar for about 3 weeks until I started running everything together. Threw me through a loop and I really see both sides of the argument from this.

In Persian, weekdays are zero-based. "shanbe", "yek shanbe" "do shanbe", .... yek means one. do means two, ...

By writing "-1" when you index, you can use 0 based indexing lika a 1 based indexing. Like this arr[3-1].

I do a lot with SQL. It’s 1 indexed. I think it makes sense for the stuff you do with SQL. For anything that needs math, actual locations, modulus operator, etc., I am all for 0 index. Also, thanks for the closing thoughts! No one looking at you now would guess what you had to go through to get to where you are.

My daughter knew very well at age 2 that when were doing a count down, shit happens at 0, not 1, so debunked.

That end speech should've been an entire video. Got me real emotional. Those people that skipped the end really missed something.

C introduced the 0-based indexing. Most languages prior to C, and in the Algol lineage used 1 based indexing: Ada, Pascal, ALGOL 68, APL, AWK, CFML, COBOL, Fortran, FoxPro, Julia, Lingo, Lua, Mathematica, MATLAB, PL/I, RPG, R, Ring, Sass, Smalltalk, Wolfram Language, and XPath/XQuery

Those who didn't watch the whole video, please don't skip the last 5 mins. It's the greatest life lesson from Prime ever. Clip that part and save it on your device. Everyone needs to remember that advice forever.

❤️ Props for the ending. That took some guts. And you’re absolutely right.

If you start counting seconds, and you go "1, 2, 3" and stop, you'll have counted 2 seconds. My son counts from 0 (where it is) for knight chess moves too.

In my opinion, one of the strongest arguments for 1 based indexing, at least in Python, would be the following logic, "In Python, if negative indexing starts at -1, then why _wouldn't_ positive indexing start at 1?"

Hours start at 0. We have 0:00, not 1:01. We can interpret 0:30 as "since midnight, 0 hours and 30 minutes have passed", but what would 1:31 mean? But centries start at 1. And it only brings problems. Year 00XX is ceuntry 1, year 01XX is ceuntry 2 and year 20XX is ceuntry 21. Years also start at 1, and it also brings problems. Year 1 b.c. is year 0, year 2 b.c. is year -1, year 3 b.c. is year -2. Starting at zero also makes it easy to do unit conversion. 1 inch = 2.54 cm therefore 10 inches = 25.4 cm. This only works because 0 inches = 0 cm. But degrees start at -273 C or -459 F. And this again brings problems: if 0 C = 32 F then multiplying both sides by 2 gives 0 C = 64 F. Binary numbers in computers also start at 0. uint8 covers integers 0-255. So if we started indexing arrays from 1, we would get a smaller range 1-255 and 0 would be wasted.

Those feels at the end... Thank you Prime for thinking with us about technical stuff, having fun while doing so, AND being a great human being. At least that's what I can see from your videos. Thanks for sharing your life's journey from time to time with us, and thanks for your sincerity, we need more of that on the internets

Thank you for sharing your wisdom and motivating words! 👏👏👏

Count and index are different integer types... however, I'm a physicist. we invented the concept of potential... when you are forced to do calculus for a semester on your pointers before you even get to take the math classes that cover the prerequisite concepts I'll sympathize with this perspective. I wake up every day of my life off by one and bump into everything until the coffee and training kicks in.😂 Oh...and BTW iterators are the devil. Historical note: for several algorithms in memory limited numerical computations, it is sometimes significantly more efficient and faster to do computations in the address space rather than on the data itself hence we retain the choice of zero based indexing for these purposes. Symmetry about a zero index becomes an important mathematical property here.

Man, that took a hard left turn from a purely technical talk to passionate advocacy for self-care and spending quality time with your loved ones... And I am 100% here for it. Zero notes.

I was coding many years in Matlab (1-based index) and now programming in C++ (0-based, you know...). 1-based index feels indeed more natural for counting, but 0-based index is MUCH more convenient when you do modulo operations. With 1-based indices, you basically always convert your index to a 0-based index, do the modulo operation and than convert it back to a 1-based index. So annoying.... The counting "issue" with 0-based can be fixed relatively easy with ranged-base loops (or STL algorithms).

First element is at the address you have, the index is just used as offset, so you get the first element with offset 0. This is the root of why the first element exists at index 0. If we'd have called it 'offset', and you would dereference your array providing an offset, would you accept that providing offset 0 yields the start of the array, which is the first element?

The man is turning reaction videos into live performance art… what an innovation 🤯

Subscript vs index is a distinction without a difference. EVERY realistic time that you need to do some amount of arithmetic to compute an index, 0-based requires no additional math, and 1-based requires subtracting 1 at the beginning and/or adding 1 at the end of the formula. The preference is not baseless dogma. Lay intuition and ease of accessing last element are the only benefits of 1-based indexing, and they're not much. In real world code, the times you need to specifically access the last element are few and far between, and programmers usually quickly develop a separate 0-based intuition.

"I had my head really far up index zero", and "I can only lose time from here on out," are hilarious and sobering respectively. This was a really nice talk. Thanks Mr. PrimeTimeagen

Many countries start counting building floors from "ground floor" (0th floor) and nobody finds it confusing. Pizza delivery guy who finished just 9 grades at school is able to deliver pizza to correct floor and doesn't get confused when he hears 1st floor he knows he needs to climb 1 floor to deliver pizza and he never gets it wrong. And here we have people who finished computer science degrees and struggle to get over the fact that array indexes start at 0.

As comp.sci people would say: "There are 2 hard problems in computer science: cache invalidation, naming things, and off-by-1 errors." Coming from a hardware background, it's always worth remembering that 0x0 is a valid address. Also, when doing ASM, some architectures access data by referencing a base pointer with an offset (again, 0 is a valid offset). As C was conceived as some sort of portable assembly, it makes sense for C arrays to be 0-indexed. I believe there's no objectively good or bad approach as long as it has a consistent behaviour and doesn't suffer from performance penalties.

Man this is such a great video. TBH I got so emotional on the last minutes. Such a great advice I heard in a long time. Thanks!

You are such an inspirational person! Especially the end. Thank you!

The moment I realized he was doing a live reaction to a video during a talk I died laughing, this is way too meta😂😂☠

When you enter a building and go up, do you start from the ground floor or the first floor?

I appreciate you brother! You are like one of those marine recruiters that imposed their will on unsuspecting youths in high schools and hooked them into the military... But you are using your power to fill the ranks in the greater geek-verse.

Easy solution, just declare a map like this and use it to convert English to indices: {"first": 0, "second": 1, "third": 2, "fourth": 3, ...}

The notion that he is advocating for data not being stored contiguously means he wants to get cache misses as he reads enumerated data.

If you think of it in a continued way (a simple ruler), makes sense, you start at 0, and at 1 you start with the next. The zero-based index always made sense for me, the only time I feel lightly challenged mentally is accessing a position of a string.

As a French where the ground floor is floor 0 and the first floor up floor 1 and the first floor down is -1 it makes me smirk to hear Americans defend indexing starting at 0 ;p

In "How JavaScript works" book Douglas Crockford introduced "zeroth", "wunth", "twoth", "threeth" as a clear indication and disambiguation of the indexing (does not help with fourth and on, but at that time it should be clear what is going on). He also did a survey and analysis of all known arguments for 0 vs 1 start index and it came out inconclusive in the end...

live reactions is wicked work

RAM traditionally works in 0's and 1's to indicate whether or not voltage exists. I always just figured the concept of 0-based indexing originally stemmed from this, because 0 would indicate the first of two existing options and is the default when there is no power

Thanks for your advice at the end, I really needed that right now

You know what's crazy? When talking about physics, we have so many things starting at x=0 when we make graphs out of data or phenomenon. So our first point is always at 0.

Programmer with a heart and a soul and able to share that? You're somethin special primetime. Glad to have found your channel which has indeed been inspiring me to keep trying.

The 'zero didn't exist as a concept historically' pop-meme is the kind of massively overblown nonsense that makes actual historians cringe in the same way that programmers cringe watching Hollywood representations of computer programming. It falls into the same category of 'modernism' that leads to ideas like 'those people 4000 years ago couldn't have possibly built those structures that I, personally, can't work out how they did it, so aliens [or (white) foreigners, before aliens became the contemporary go-to] must have done it for them." Of course people knew what it meant to have 'none of something' - it was a pretty common situation for most. And they certainly had no problem with the idea that if they had 5 of something and sold or lost 5 of them they had none left. Or if they had none and acquired five they then had five. What they lacked was a discrete written symbol for "0" . They could state or write the word "none" (in their local language) just fine. And there are plenty of written records from the times - including arithmetic - where this was exactly what they did. Even finger-counting starts at zero, even if you don't say the 'zero' out loud. If you don't believe me, ask a math-historian and I'm sure they will happily show you their clenched fist. Real-close-up! 😛 The moment anyone drags out the "They didn't know about zero" trope, I just switch off and bin them with the anti-vaxers, con-trailers, Bill Gates 5G Microchippers and the lady living in the apartment below me who watches Ancient Aliens unironically (nice enough lady, but I just let what she says on anything more intellectually advanced than long-weekend changes to bin-night wash right over me). ... Also, we do have a pretty good idea how they built those things - they left written instructions on how to do it - in so much detail we even know the pay-grades for the work forces involved. We just took a few hundred years of telling ourselves we knew better before we decided to just RTFM!

There is already another example of automatically reading/thinking of different numbers - whenever reading a 24 hour clock you see 15 and read 3, or you see 18 and read 6.

So, I learned a lot of math before I got into coding. In math, you just explicitly say what your starting index is each time, because sometimes it's more convenient to start at -1, 0, 1, 2, whatever. (In more advanced notations, like Einstein index notation, you don't even say what your starting/ending indices are. You work with placeholder indicies that each imply a loop over the entire range.) So, I think there's a lot of merit to the variable-first-index thing. I've written a lot of R, which is 1-based. Honestly, I ran into fewer off-by-one errors in R. Though, I think a lot of that is due to how R allows you to avoid using loops and explicit indices through vectorization. I think that's the real takeaway. Whether it's through vectorization, iterators, or whatever else, avoiding explicit loops is a good idea.

Dunno... Starting with zero makes sense.... Because if you are at 1 it means you have already gone to 1. We don't start walking from 1km, we start from 0km.

Prime: "For those that don't use neovim..." Also Prime: "That's odd, because the people who said they use neovim didn't raise their hand".

The concept of 'nothing' or 'zero' definitely existed. They just didn't have agreement on how it worked in math (or a system to use it effectively).

I deliberately avoid using “n-th element” when talking elements in lists. I use “the index-n element”. Only exceptions are “first” and “last”, and maybe “second”. Everyone knows that “first” is index-0 and “second” is index-1.

How old were you when you were just born? 1 year old? No. 1 month old? No. 1 day old? No. But you are in your first year, first month, first day. That is how I interpret this 0 indexing vs the first element.

A good programming language will never make you think about indexes, but when you insist on it, you choose the indexing, bottom and top value.

My first language after basic was pascal, and it had 1-based string indexes, so most of the time you would define arrays as 1-based as well array[1..100] of integer it took me a long time to learn 0-based indexes, or the fact range() returns length-1 as maximum. for the for loop the only difference is, whether you use < or

This may have been one of the nerdiest things I have watched yet lol. That ending though you almost made me cry :' ) your an inspiration to many Prime stay hard!

The problem is, he criticizes us for not liking 1-based indexing because it isn't familiar to us. Then he argues that 0 based indexing is bad because it isn't familiar to how we talk about ordinal numbers.

One of the best arguments for 0-based indexing is time. The 1st second starts ticking at 00:00:00. Can you imagine if we started at 01:01:01?

I had a class on this in college 2 semesters ago. This addition-asterisk-address magic actually makes sense (it's not magic, I get it) and it blew my mind that a[i] is same as a + i. One more thing was blown away recently, my eardrums while watching this video. Cheers

A great argument for 0-offset notation is languages that allow indexing from the end, like Python. What's the obvious index of the very last element? -1. If you 0-index, the absolute offset is just (length + index). If you have ten things, the last thing is at -1, 10-1=9, array[9]. How do you make this intuitive for 1-indexing? You can't use 0 for the last element, that's insanity, and -2 is the wrong direction, so it's still -1. Now the math is 10-1+1 = 10, 10-2+1 = 9, etc. You are adding 1 just to make up for the implicit -1 from starting at 1.

yo Brazil mentioned!!! suddenly caralho

TJ the type of guy to say he's 6ft when hes actually 5 cause he like to start from 1

You know Prime, I'm extremely glad that you came to Brazil, it meant a lot to us, your story, your determination and your good humor it's something that we really appreciate. But still, I would prefer to start at 1

Two crucial mistakes in his reasoning: first, he confused indexing with counting, and second, he completely neglected to consider that indexing math only works with 0-indexing. People often make these two mistakes. Let me explain: An array of 10 elements will still have a *count* of 10 elements (10 loop iterations) regardless of whether it's indexed from 0 or 1. Indexing and counting are very different things. The "first element" is a count, not an index. Index 0 points at the first element. The only thing that guy got right was the statement _"that's what "indexes" do: they point at things"._ But then he failed to realize that "counts" don't point at things, and are not the same thing as "indices" (the plural is "indices", not "indexes"). This mistake nullifies almost every argument he makes, because they're based on this premise that he got wrong. And what programmer doesn't think about indexing math? Indexing math (converting an index to X and Y coordinates and vice-versa) is what you use to access an element in a 1D array that represents for example a tile in a 2D grid of tiles for an RPG, or a voxel in a 3D chunk, or a cell in a 2D text buffer, or a quad slot in a data structure for sprite batching, etc, etc. Indexing math dictates that, even if your language is 1-indexed, many of your arrays *have to* be indexed from 0, or else the math won't work. In practice, you can have every array indexed from 0, but you can't possibly have every array indexed from 1 (which causes some problems in 1-indexed languages). And man... that "index finger" argument is just absolute nonsense. It sounds like a desperate attempt at having one more flimsy argument. Speaking from experience, though: I love Lua like no other language. But it's because I've been using it for some 5 years that I can say that 1-indexing is a perpetual rock in the shoe. It's not a deal breaker because Lua is otherwise an excellent language, but it only brings problems, error proneness and traps: - it expects loops to go from 1 to limit (inclusive), and so whenever you need 0 to limit-1, you have to not forget the explicit -1. This requires some extra attention to what you're doing, lest you forget it. - you need to be extra careful about using certain language tools, like *_ipairs, #_* or *_table.insert()_*, because they won't work with 0-indexing. - the language creates 1-indexed arrays by default, and you can't run away from it. This makes your code inconsistent, such that you have to pay extra attention to not get your index variables off by 1, or if you're using them across multiple arrays with different indexing, etc. - utility functions that deal with arrays are harder to make/debug, because you never know what users will throw in them, so you have to account for 0 and 1 base. Or if you don't account for that, then your functions won't work for every use case where they'd be needed. - you'll perpetually have to be considering when to let the language have it's way with arrays and when not to. And sometimes you'll get it wrong and have to waste time re-writing some code. - it's harder to port code to and from 1-indexed languages because you'll have to be extra careful to not break the algorithm you're porting by allowing 1-indexed arrays in it. And then if the algorithm doesn't work, you'll have extra stuff to double-check with extra attention. There's just no world where 1-indexing is the sane option.

0-indexing is right for C, and optional for other languages (base of the legend of C - php, python and others). You don't teach kids counting from 0, as well as you don't teach a kid's poinmter's arithmetic in C.

The difference between ordinals, indexes, and offsets. (Words are tricky; e.g. is an offset essentially an index, or is it the product of an index and some stride, or something else; your mileage may vary.) As for a real-world example of starting at 0: I have on many occasions, in many different places, seen elevators where the ground floor is labeled as "0".

21:00 it’s not JUST that 0 made sense as offset it’s also that in math we like to think abt the 0th, “initial” state (zeroth iteration (bc u haven’t iterated yet)), and then the first iteration, second iteration (third item), etc

holy shit, i was not expecting the brazilian soccer team shirt

I have thought about this concept a lot and know all the history of 0-based versus 1-based indexing. Ultimately, it all boils down to two philosophical approaches. The older, more intuitive, and easier method is 1-based indexing. I believe this is correct-it simply points at the index, meaning you count the elements from the start and determine at which count the index is. This is 'real' indexing. The other approach is more similar to a 'ruler' or 'offsets'. If you place your hand on a wall, the 'distance' is zero. As you measure a greater distance, it increases. In this approach, you aren't really 'indexing' or pointing to an element. You operate on a lower level, simply asking, 'Where in the memory does the element or the thing start?' or "Where the thing starts?". This is not indexing but can be used as indexing. It's too bad that almost everyone copied 0-based indexing from C because C was so popular, even though there was no reason for these higher-level languages to adopt it-on the contrary, the only reason for 0-based indexes in C isn't valid in these languages, and thus we lost the opportunity to use more intuitive and 1-based real indexes.

In programming, we typically use an index to access elements in an array. The index represents the position of the element within the array, starting from zero. For example, if we have an array called `myArray` and we want to access the third element, we would use the index `2` (since arrays are zero-based). Although subscripts are sometimes used interchangeably with indices in programming, they are more commonly associated with mathematical notation or chemical formulas rather than array access. C spec is confusing by design because it was writen by dorks.

"How do we show 1? With our index finger, what a coincidence!" -Anglos not understanding that there are cultural differences and the whole world doesn't work like their home town, exhibit 572984. There are lots of different ways different people count on their hands, including starting with your thumb (e.g. Germany), curled fingers being the "active" ones rather than the straight ones, and even counting using knuckles instead of whole fingers.

TJ isn't lying, he's just confidently wrong.

Gigachad ending

Such a crazy argument. Pascal sorted this years ago by letting you specify the upper and lower bounds, so you could have whatever made sense. Need indexes from 7 to 12, array[7..12]

Crestron designed a bastardized language (SIMPL+) where arrays are 1 based, but if you say 0, it gives you the same element as index 1. When they were explaining this language to me, I just looked at the instructor and asked if they really use this language. Don't get me started on their "symbolic" representation (SIMPL) where they misuse and redefine a whole host of existing computer software terminology.

Zero-based indexing comes from the fact that values are stored in memory locations. The zero-th index of an array represents the memory location where the array starts and each additional index represents an offset multiplier against the size of the data type being stored. Instead of having to know the memory address of where the array starts and then having to add an offset to the starting location of an array to retrieve a value at a particular location in contiguous memory, we use a zero-based index instead. Zero-based indexing isn't meant for counting the number of items in an array, it's to facilitate referencing values stored in the array. Despite the analogy of home addressing that is often used to teach people about indexing, memory allocation and data storage doesn't correspond one-to-one with real-world, physical objects. Storage in memory has to take into account the different sizes involved with different types of data, and the different sizes obviously affect the memory addresses those values end up getting stored at. Whereas a house of any size can be assigned an address and wouldn't affect the address of the next house because we are counting discrete physical objects. If addressing was based on plot size, than houses would be addressed in the same way as zero-based indexing to make the life of the postman easier.

No Hood. Unsubscribed.

in C the third element of an array is not at a+2, it is between a+2 and a+3. The address point at the start of the object. x[n] refers to the object that is in the memory range between addresses x+n and x+n+1. Once you start giving addresses to the gaps between bytes and not to the bytes themselves everything makes a lot of sense.

In England the elevator uses zero for the ground floor. In the USA the 1st floor is the ground floor.

I was introduced to programming in Pascal which is 1 based. It made sense to me, it had never occured to me that 0 based indexing was a thing. Later on i worked with java, javascript and python, all 0 based. It felt weird at first, then it just felt normal. And then i stopped using indexes for the most part, because iterators were better. I mostly agree with teej here. But i'll chime in. 0 based indexing is like implementation leaking into the public api interface. Every human will recognize 1 as being the first item, until theyre brainwashed by big C lol.

Ill say this: 1. Linear algebra is base 1 and those folks LOVE arrays/vectors more than anyone 2. I used to be a die hard base 0 fanboy until i used R, which is base 1. I will say, after the initial stage of getting used to it, I actually experience first hand how much more intuitive it is. Indexing =/= slicing, and this is what programmers are confused on. I’ll use whatever, but if im being honest, in my heart of hearts, i really think base 0 for indexing for higher level languages is almost an anti pattern. Base 1 for indexing is just so much simpler after you really give it a chance. Its like that sludgey feeling you get when you go back to the legacy part of a codebase after leaving it for a while. Its just a haze looming over your code.

SAP’s ABAP language doesn’t have arrays in the normal sense. Instead it has internal tables so the first entry is at line 1.

As someone who has fucked up in life and now is trying his hardest, I really appreciate you man. Knowing that you also made a bunch of mistakes before getting where you are gives me hope for my own future.

Indexing should absolutely be indexed from one in high-level languages. 0-based indexing exists primarily because of low-level pointer arithmetic, which does not exist in high-level languages. I often felt alone with this personal belief. Sometimes, there are languages designed by people who are mathematicians, and they create languages with 1-based indexing (like Julia, for example). By the way, ultimately, there is nothing we can do about this issue in languages already using 0-based indexing, so we are stuck with it as it is.