Hacker News Reader

> [...] There are many class libraries available for lua. Just pick one. [...]

Alternatively, embrace the prototype-based programming and just... don't add classes.

In practice though, is prototype-based inheritance useful for anything other than implementing your own class system on top of it?

I hold an opinion that, if you use the prototype-based approach, you should avoid inheritance like the plague ;)

You should avoid it whether prototypes are involved or not.

Also,

> unfamiliar semantics: no classes, use tables, start indexing at 1 and other oddities, just as being able to call functions with the wrong number of arguments and returning nil on the way

Other than 1-based indexing, those semantics should be very familiar from JavaScript.

It still feels weird to me to call table an array, a hash table and do classes via metatables in very different ways. For sure it is powerful.

But it does not fullfill well the zero-friction I was looking for when integrating. You have to change a bit your mindset when integrating and using this stuff.

In Wren you have lists, which are basically arrays and dictionaries, ranges and all things I already know how to use from Python/C++.

That said, inheritance is not working smooth and ChaiScript does not even have inheritance itself. But for my purposes a class, concurrency and familiar data structures and patters was enough.

Javascript is not known for its intuitive and sane design, and certainly not from the perspective of C/C++ devs

The criterion was "familiar", which is nothing if not Javascript -- nobody said anything about intuitive or sane :)

I grumbled about indexing starting at 1, but once you get used to it it makes a lot of problems easier.

I've spent the last twenty-ish years in C and string manipulation just sucks. Think about it, you declare a buffer of length 20, the indexes are from 0->19, and the 19th byte needs to be a null if you are using it as a string and are using the entire buffer. Also, the standard library is not guaranteed to null terminate in all situations.

Lua's string indexing feels far more natural to me.

This. The insistence on using 0-based string offsets is purely a C thing (where it makes sense) inherited on to languages that wanted to stay close to C or appeal to C devs (even though it does not make sense). An easy way to check is looking into awk which, as a DSL for string manipulation written itself in C, deliberately uses 1-based string offsets, and where many/most common string expressions collapse to a very compact form, which makes even more sense because empty string results are interpreted as false in conditions.

It's not a C thing, it's a math/utility thing.

Dijkstra: Why numbering should start at zero https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/E...

Which is funny because Lua got it’s 1-base from FORTRAN which, I believe, adopted it to make TRANslating math FORmulas easier.

I agree in part that it's a C thing. More accurately it's an offset from the array base thing.

The first element is at index 0 because its address is base + 0 * sizeof(element)

The second element is at index 1 because its address is base + 1 * sizeof(element)

Small correction. The 20th byte (at index 19) needs to be null.

The mismatch with the English language and how people naturally count is definitely there and annoying. And yes, string manipulation in C is especially broken although I think the indexing is the smallest problem there.

However, it’s extremely natural when you think about it in terms of memory access. For example, in a 1-based indexing system, ptr[0] would point 1 character behind your pointer (weird) and ptr[-1] would point 2 back (wtf). Having the index map neatly to the offset makes a lot of sense to me. In fact, when I first started programming in VB6 20 years ago and only had a math background, the 1-based indexing was natural but I could never figure out why I had so many bugs related to array and string offsets.

I’ll also note that most programming languages are 0-based and interop with C is not really the goal (Java, JavaScript, Ruby, Python, etc). In fact, Python and Perl’s string manipulation is some of the best out there and they are 0 indexed.

I figured that someone would pipe up about the 19th byte vs 19th index, and I'm glad. This is just semantics, but does index 0 represent the first byte or the zeroth byte?

I completely agree regarding memory access, but would argue that strings and memory should not be treated in the same way. Having the index represent the length - 1 has caused countless off-by-one bugs [1] that would not have been there in the first place if string indexes started with 1.

Java, JavaScript, Python, (maybe Ruby, I'm not fluent there) also bite the user if you attempt index data outside of the string's range. C will happily index whatever you want, and these bugs can often remain hidden for decades.

1. https://cwe.mitre.org/data/definitions/193.html

Index N represents "skip N elements". That gives you very easy additive/subtractive behaviour, unlike "how many numbers are there from 7 to 17?" scenarios.

Sure, 17-7 gives you 10, but that's not the final answer, you have to add 1 to get the right answer, 11. Sorry, no, you actually subtract 1 and the right answer is 9. Wait, no: 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, okay, 11 in total, so you have to add 1, got it right the first time.

Another way to look at it, in languages like Python that support slicing, is that the indices refer to the boundaries between the elements rather than the elements themselves.

     a b c d
    0 1 2 3 4

From this 4 character string you can slice s[1:3] and get 'b', 'c'. s[i:j] will always have j - i characters (ignoring negative indices). s[i] is as if it were short for s[i:i+1] e.g. s[3] is s[3:4] and that gives you 'd'.

Admittedly C++ doesn't have slicing so this is less relevant, but I think it's still an interesting aspect to the discussion (without getting bogged down in ideology).

It has with std::span

The indexing starting at 1 is something that has always annoyed me. I just haven't seen any other language make that decision, and I'm not sure the reasoning for it really outweighs the fact every other language just goes with 0 due to the origin of it.

Lua is a great language for sure though.

Pascal did, but I believe that was because index 0 contained an 8-bit length. There was no need for null termination, and strings were limited to 255 bytes.

Fortran, Matlab, and Julia all start arrays at 1, either always (Matlab) or by default (Fortran, Julia).

Erlang indexes starting at one, except when it doesn't.

Tuples are 1 indexed, lists are 1 indexed (in the standard library, anyway), but binaries are zero indexed.

Lua is the C of scripting languages.