Perhaps people's tastes vary? I find Lua an easy to use language. Easy to embed into C/C++ projects for scripting purposes. Also great when you can only spare 100 kB or so for an interpreter. (Arguably that was more important in the past.)

For me it is a much easier language than, say, Erlang.

Erlang has multiple higher level barrier of entries than other languages. For starting, its syntax.

but Erlang isn't a scripting language, it's a full-blown language with a rich ecosystem and framework (BEAM).

Lua is also a full blown language, with an ecosystem as well.

Perhaps the road block that you've run into is because you've been treating it as just a scripting language.

Again, tastes. I found Erlang to be one of the easiest languages I ever used. I just immediately "got" it. Unfortunately I've had very few professional opportunities to use it.

Agree, I find it a PITA. I think the good reviews are in contrast to C++ and vimscript. Fine for a small embedded script, but I hope WASM or some better language ecosystem starts to fill this niche.

There are languages that compile to Lua. Have you investigated those? For example, you can use a TypeScript syntax and pick up free typechecking along the way: https://typescripttolua.github.io/

There's also the venerable MoonScript: https://moonscript.org/

And YueScript, a personal fave: https://yuescript.org/doc/

A whole list: https://github.com/hengestone/lua-languages

Don't forget Fennel, if you are a Lisp lover!

I would suggest using it to add scripting functionality to your own C or C++ project. That's when it really clicked for me.

When you're doing stuff in nvim or HammerSpoon, you're dealing with someone else's interface and the decisions that they've made.

It really depends. I learned Lua in order to contribute to kulala plugin for neovim and found the language nice and easy to learn.

Of course it has its warts, but given the topic, almost everything is better than a vimscript imho.

it's easy, but the 1 indexes and global by default suck

The 1 indexes are only a difference from what you're used to. Lua was made by mathematicians, who of course wanted to address the first element as 1, the second element as 2, etc.

0-indexing makes sense in the context of C where the index operator is syntactic sugar for pointer arithmetic. In higher-level languages like C# and Python and others, it's pretty much just a leftover habit from C devs that we all got used to.

Global by default is a perpetual issue, agreed.

And a lot of the time it makes the syntax more compact than it would be with 0-indexing.

  for i=1,#arr do
    foo(arr[i])
  end

I don't feel that strongly for or against either way of indexing though, they both have their pros and cons.

Perl is usually used with the first element being zero and the same loop would be

    for (0..$#arr) {
        foo(arr[$_])
    }

Whatever you're feeling is not in starting at one.

You are correct that 1-based indexing is the norm among mathematicians, but none of the creators of Lua is a mathematician, AFAIK. You can read about the early history of Lua here:

https://www.lua.org/history.html

> The 1 indexes are only a difference from what you're used to

The left handed scissors are only a difference from what you're used to.

> Lua was made by mathematicians

The default value is nil and using nil as an index on a table returns nil. Yet nil + number is not valid and results in a runtime error.

> it's pretty much just a leftover habit from C devs

It's reflective of the fact that these languages are either intended to work with C APIs or are implemented in C itself. This makes writing FFI and extensions _far_ easier than it would be otherwise.

Lua is the scripting language of [Recoil]. I've been writing some fairly complex game code on it for a few years now, I lost a lot of prejudice over time on 1-indexing.

In fact, at least for this application I've come to enjoy its practicality!

Recoil: https://beyond-all-reason.github.io/RecoilEngine

Lua 5.5 will change the way global variables work: AFAICT you’ll be able to opt out of global-by-default

Too bad the Lua ecosystem is split between 5.4 and 5.1 due to LuaJIT.

I wrote about this in:

https://andregarzia.com/2021/01/lua-a-misunderstood-language...

I like 1 based indexes and the globals don't hurt me on my projects. It is like JS, it has its own bits that are different than other languages, once you learn them you see that it is mostly fine.

I absolutely love Lua. It’s like scheme without the ((())((((()(((())))( noise.

I’ve never understood what people like about it

The thing that always sticks out to me with Lua is the and/or operators. It's such a minor thing but the way they are used drives me absolutely nuts.

It all depends on what you been exposed to in the past, right? I find Lua simple because it is a minimalist language in which there are very few things to learn. You can buy "Programming in Lua" for the version you want to use and with a single book you learn about basically all of the language and its internals. That is not the same with some other languages.

>> I don't understand why people say it's an easy language

> I find Lua simple

The comment you've replied to is correct: "easy ≠ simple". Lua is indeed simple, but it chooses simplicity over ease-of-use. For example, even printing the contents of a table requires explicit logic.

OTOH Python, for example, prioritises ease-of-use: `l = [1, 2, 3]; print(l)` does what you'd expect. But Python only achieves this ease at the expense of simplicity: not only does the implementation of `print` need to be more complex, its output can be complex and unpredictable as well - for example, in the case where `l` refers to itself.