If Lua had gotten "out in the wild" earlier, it would be where JS/TS are today. It's just as powerful as JS and more in some ways, such as embedding and encapsulation. It's also widely used as a modding language in the game industry precisely because it can be "dropped into" another project and allow coding in a limited way without affecting the other project.

Is it so difficult to create a struct by just memcpy-ing some data into a malloc-ed buffer and not even putting a tag anywhere? No, it is not. Neither is reading the fields back by using the pre-computed offsets. But people for some reason dislike writing such easy code by hand.

I think it’s doing pretty well and am happy with this fact. I think its success is well justified.

So I’m not sure about it being overly-criticised.

Getting worked up about defending the honor of programming languages is a waste of time. People either have technical reasons to choose one language over another within a specific use case, which is valid, or else their opinions are based on aesthetics or memes, which you can't really argue against effectively. Just accept that sometimes people won't like the things you like, for reasons you can't accept.

Also if you want to use arrays and structs in Lua, and you're fine being stuck with 5.1, you can always just use LuaJIT and have actual C structs and arrays. Best of both worlds, in my opinion.

Lua felt like JS and PHP had a secret child they abandoned and somehow survived up growing up in a dumpster.

I know I should not bash open source software: I know it takes a lot of work to build/maintain it. I'm merely reacting to this post.

But I'm not sure java is exactly without criticism either.

Lua and Love2D (and with Fennel on top) makes for a good teaching setup, IMHO.

When you say "fennel on top", sure that makes all the difference! I've argued in favour of using a LISP/Scheme for teaching students in the local uni i'm active in, but the businesses requesting "give us close to Java/C# certified graduates" won.

Edsgar Dijkstra wrote a nice piece on this.

https://www.cs.utexas.edu/users/EWD/transcriptions/OtherDocs...

Something like this? You replace % with mod0()

I find it a bit difficult to write, but that's probably lack of experience with it.

I normally use it for customizing something that forces me into using it, so I don't really want to spend the time knowing its intricacies, so anything where it diverges from more popular languages it grinds me and I try to avoid.

But this is true of any language that feels unfamiliar.

Anyway, Language adoption is a bit of luck and a bit of personal taste. A language needs a certain critical mass to become popular.

I had some hope that Luau https://luau-lang.org or Teal https://github.com/teal-language/tl would make things better but with the following example

    function foo(x: number): string 
      if x == 2 then return nil else return "foo" end
    end
    
    x = { foo(1), foo(2), foo(3) }
    
    for i,v in ipairs(x) do
     print(i,v)
    end

    1 foo

Fortunately there are other configuration languages available now besides Lua which provide type checking, so I remain hopeful that a future version of Lua or one of the newer typed Lua variants will eventually learn from those.

When you register local variables, they are merely defined as register locations and have a default value of nil which is absence and hence memory saved. They would have to mark nil explicity as a new data structure which is probably wastage as they would have to allocate memory for every variable declaration that may or may not be used.

It is just nil, nil at a literal level with the exception being local variables which are handled differently as offsets to register locations than other dynamic languages without such 'local' qualifiers.

> I had some hope that Luau https://luau-lang.org or Teal https://github.com/teal-language/tl would make things better

Inline type annotations are not a prerequisite for typechecking; there's nothing stopping you from writing straight Lua (or whatever) and then having a separate tool that does typechecking _without_ having to change the language. People are failing to take away the most important lessons from TypeScript.

The same goes, frankly, for languages that ostensibly have typechecking but have such deficient type systems that it's not exactly that much better than not having one. (Like C, for example.) Considering that type annotations are more valued for being a form of documentation than they are valued for making it easier to write the compiler's code generator...

If you have a function like printf that is ostensibly typechecked but not really, and you already have documentation (like man pages) for that function that says that the arguments need to be such-and-such, but the typechecker for your compiler/IDE isn't able to factor that in at or before build time, then that's a compiler/IDE problem, not anything that necessitates a change to the original grammar.

https://github.com/caligian/lua-utils

The former uses the latter for nvim. And the latter makes lua perl with structs. We all loved perl for its lispy functions to deal with lists - grep, map, push, shift, unshift, etc. Nested ops are inspired by elixir.

Another example is python iterators which requires a separate instance with __next__ method. It is not generic because now you can create n instances for n dicts just to use it in for syntax. Whereas in lua it is a simple closure returning the next value until nil