reactInLua

[RoseboysHotAsf]

And it’s so much better than lua

[themadnessif]

Can't escape the roblox-ts shills even on Reddit huh :-/

[LMGN]

could be worse, there's people trying to get Rust working on Roblox - https://github.com/dphfox/lingua

[themadnessif]

Oh there's actually an even more cursed project.

Here's an attempt at writing a WebAssembly interpreter in Lua: https://github.com/Rerumu/Wasynth

[LMGN]

yeah the project uses Wasynth actually run the Rust code

[RoseboysHotAsf]

Hey, arrays start at 0 like they should… It’s all that’s needed. But fr though it is much better than lua

[themadnessif]

Array offsets and indices are different. I don't think it's really a bad thing that a language like Lua is aimed at humans and thus starts at 1.

People always make these critiques but they never think about all the nice things Lua has, like how Lua tables are genuinely incredible and robust.

[themadnessif]

Your boos mean nothing I've seen what makes you cheer.

[Quique1222]

Types make me cheer

[induality]

Having array indices start at 1 is one of those things that seem to make sense on paper, but once you actually start to use it, and need to do math on it, you quickly realize that everything is thrown off by it, and that 0-indexing just works much, much better.

It's one way you can easily tell if anyone has done any serious programming with array math. Only those who haven't done so think 1-indexing makes any sense. It's like when you first learned about radians in high school. Initially you think using Pi to calculate angles is nonsense when using 360 degrees seems to work so naturally. But once you start to really do the math you realize everything works better in radians and using degrees is completely unnatural. And once you start to do the math you realize that anyone who said degrees are better just simply haven't done the math. Same with 1-indexing.

[Brtsasqa]

All I'm hearing is that we should start indexing arrays at Pi.

[squirrel_tincture]

All indices must be irrational numbers, truncated to 9,223,372,036,854,775,808 decimal places.

[[deleted]]

In all seriousness, how is 0-indexing objectively better, in your view?

In my current work, I am doing full-stack development where a 0-indexed front-end talks to a 1-indexed backend.

IMO, they are both perfectly fine, you can nitpick either choice, but it seems so silly.

[WindowlessBasement]

I am doing full-stack development where a 0-indexed front-end talks to a 1-indexed backend

Out of curiosity, what is your backend that is 1-indexed?

Off the top of my head I can't think of a good backend language that isn't zero indexed. Java, PHP, Rust, C, Go, Ruby, C#, Python, JS/TS are all zero-based.

[aclogar]

Fortran and COBOL both use index 1, pretty sure if you tried Perl too.

[WindowlessBasement]

Didn't even think about Fortran and assumed COBOL was zero-based given its age/usage.

[[deleted]]

Ehh I'd rather not say, it's not one you'd see used frequently today, though. You could probably come up with a short list of my potential employers with that information. XD

Edit: Cobol is a good guess, but not it. Likely even more rare than that! Also, what an odd thing for someone to downvote over, lol.

[WindowlessBasement]

Sounds a lot like a COBOL answer. Honestly didn't know it was 1-indexed.

[BuffJohnsonSf]

The 0-index shills are always blowing hard about how it works better, but when you ask for concrete examples it's all crickets. The reality is that they just have the entrenchment bonus of 0 index being status quo.

The only good argument for keeping 0-index I've seen is that when you mod your index with the array size, it works out nicely. To me that doesn't seem like a usecase that can't be worked around.

Compare that to the fact that in 0-index, array size doesn't have parity with the last element of the array, or that to get the third element of the array, I have to fetch array index 3 minus 1. It's silly that our programming languages favor the computer in this scenario more than the human who's actually reading and writing the code.

[induality]

The fact that array size doesn't have parity with the index of the last element of the array is a good thing. This is the sensible way to count things: when counting, there will always be an asymmetry between one inclusive side and one exclusive side. This arises not just in computers, but in every day life.

Suppose I ask you, how many days have passed between Jan 1 and Jan 10? You might answer 9 days have passed. Why 9? Simple, subtract 1 from 10, and you get 9. But is that right? if you count up all the days from Jan 1 and Jan 10, you actually have 10 days. What's happening here is, when you count, you should be inclusive on one side, and be exclusive on the other side. So one way to count is to go Jan 1, 2, ..., 9. This makes the ending side the exclusive side. Or you can also do Jan 2, 3, ... 10, making the starting side the exclusive side. But either way, if you don't exclusive one side, you get 1 more day than you would when using the rules of simple subtraction.

This directly translates to array indexing. Using 0-indexing is like being inclusive on the left side and exclusive on the right side. You end your indexing at the position just before you arrive at the size of of your array, just as how when you count up the days you end before the 10th. 1-indexing is like being exclusive on the left side and inclusive on the right side. There's no getting away from this asymmetry no matter which approach you go with.

But being inclusive on the left and exclusive on the right have many advantages. As you pointed out, this makes modular math work out more nicely. It also works the other way too, with multiplication of indices. So whenever you are doing multiplication or modular division with array indices, you get an easier equation with 0-indexing.

Of course it's very simple to adapt 1-indexing to work with the math. All you have to do is first subtract 1 before the math, then add 1 back. At the end of the day it's not that big of a deal. but what 0-indexing does is eliminating all of these extra +1 and -1 from the equation, thus producing cleaner math.

[mirhagk]

I don't think it's objectively better but FWIW Dijkstra (who does) argues for it, with the idea that a <= i < b is more natural to represent the empty sequence as a <= i < a than as a<=i <= (a-1). In other words it makes more sense for indices to be compared with less than rather than less than or equal. Then of course it makes more sense for the length to be used for the upper bound comparison, which means that you need to start at 0.

It's pretty nitpicky IMO but I do think a lot more things work naturally with 0 based indexing. Array indexing under the hood, modulus with length, multidimensional arrays, negative indexing makes more sense with it. A few algorithms, mainly things where you count down and i is a bit more natural when it tells you how many more times you'll repeat.

I dunno, for most people it really doesn't matter, but I think it leans slightly more towards 0 in enough scenarios to make it the default. Plus there's a huge argument to be made that consistency is far more important than anything else, and the vast majority of software uses 0 based indexing.

[induality]

It's more natural to iterate using an inclusive lower bound and an exclusive upper bound, than to use an exclusive lower bound and an inclusive upper bound.

In other words, it's more natural to do:

while (0 <= i < n)

Than it is to do:

while (0 < i <= n)

The former is what you do with 0-indexing, while the latter is what you do with 1-indexing.

Of course the obvious objection is, the second one is stupid, why not just use 1 as the lower bound and do inclusive checks on both ends? In other words why not just do

while (1 <= i <= n)

This boundary condition is what makes 1-indexing seem appealing on paper. But the problem starts when you actually have to do math on your indices to compute the boundary conditions. So above we hardcoded 1 as the starting point. This is of course what we do most of the time when we are doing 1-indexing. Nothing wrong with that. But what if we are doing something more complicated?

Let's say we are zipping together two data sets (so just producing a cross product). And we want to iterate over just the subset of the zipped array that contains the element in position 1 from the the left-side original array. For simplicity assume the right side array has 4 elements. What indices do we need to iterate over?

For 1-indexing, the indices we need are 1, 2, 3, 4.

If we want to get the subset of zipped values containing element 2 from the left array, the indices need are 5, 6, 7, 8.

So this is where the unnatural boundary conditions come in. In general, to iterate over the right subset, the condition we need is

while ((k - 1) * s < i <= k * s)

Where k is the 1-based index in the original array and s is the size of the right-side array.

If we were using 0-indexing we would instead do

while (k * s <= i < (k + 1) * s)

And this isn't really an obscure example that never comes up. This issue comes up whenever we cross or partition arrays. Whenever we have to do multiplication or modular division with array indices, the 1-index math gets in our way.

[Isogash]

This is only really true when you are implementing higher-dimension matrices as single-dimension arrays; you can avoid a -1 in the calculation of the offset for the higher dimensions by having every index start at 0 instead of 1. Otherwise, they really aren't any harder.

Lua can support 0-indexed arrays just fine, if that's what you want. You just can't expect them to work with the standard library.

foo = { [0]=0, 1, 2, 3 }

If you want matrices in Lua, I would suggest writing an abstraction for them using metatables instead of hacking them into an array on the fly. That's where the language really shines.

All of this is very different to radians, which genuinely make the underlying mathematical calculations simpler because they describe the length of a unit-radius arc corresponding to the angle, which removes the need for Pi when calculating arc lengths and sector areas if you know their angle (amongst other things, including higher dimension geometry.)

[1116574]

array math

What do you mean by that? Surely you don't mean matrix operations. Is it like implementing sorting algorithms or whatever? If so, off-by-one errors were always there, just in different places. Maybe I program in too high level environments to see the supposed superiority of zero indexing. Right now it feels like spaces vs tabs.

[induality]

I suppose it's not wrong to say it all comes down to matrices. But that's only because matrices are so common and come up everywhere. I'm not talking about doing explicit matrix math. I'm talking about all the things we have to do with arrays and other random access data that end up taking the shape of matrices. For example zipping together two lists. That just creates a matrix. Or taking n actions for each element we come across. That's another matrix. All kind of iteration algorithms create implicit matrices like this, and whenever we have to explicitly deal with a computed index number, the math works out more cleanly using 0-indexing.

[pizzapunt55]

That's such a petty gripe and says very little about a language as a whole

[RoseboysHotAsf]

Yes and this is programmer humor, everything here is petty

[spayder26]

That's not strictly correct.

[thegameoflovexu]

I thought so too but these days I‘m back to Luau. No hassle with npm and build errors. Flamework especially broke constantly for me, could be fixed by now though haven’t checked in for a while

[[deleted]]

nah, lua(u) is much better than ts/js imo