Lua is overrated. I’m always disappointed by it. It reminds me of Go in having a cool underlying runtime/interop but a terrible language on top.

Re indexing for arrays, the author says “In Lua, indexing generally starts at index 1, but is only a convention. Arrays can be indexed by 0, negative numbers, or any other value (anything but nil).” I agree and disagree with “only a convention.”

Yes, it’s only a convention in the sense that a Lua interpreter will not throw an error if you create an array-like table starting from 0 (or some other number). But, no, it’s not only a convention in the sense that the standard library for tables and built-ins like ipairs assume array-like tables with indexes starting at 1. So, for nearly all practical purposes, you probably want to index your array-like tables starting at 1. (As Programming in Lua says, “The Lua libraries adhere to th[e] convention [that array-like tables start at 1]; so, if your arrays also start with 1, you will be able to use their functions directly.”)

foo = { [0] = "fizz", [1] = "buzz" }

for _, word in ipairs(foo) do
    print(word)
end
-- Prints only "buzz" 

A similar point applies to what the author says about nil-terminated arrays. If you know (or suspect or worry) that you may have a sparse array, you must not use ipairs to loop over that table. Instead, you can use pairs (or next) to get at the whole set of items without stopping at the first nil. (If the order matters, however, you’d have to save the items in a new table and sort that table before use.)

Maybe the bigger point is that Lua does not really have arrays in the sense of sequences. There’s just tables, and the tables are always key-value hashes. Sometimes the keys are integers, but—by a (strong!) convention—the indexing of array-like tables should start at 1 and usually the sequence shouldn’t have any gaps.

This week I’ve been playing with Love2D, a simple game engine, wrote a prototype in Lua, and found it a refreshingly clear and a pleasant language.

Btw, the game Balatro - which is amazing IMO - is written in Lua on Love2D.

Another thing that I love about Lua is its coroutine implementation. It’s a very elegant implementation that composes different coroutines well. You don’t need to remember to yield to an inner coroutine like in python, it just nests properly and yields as needed. Return values also work like you’d expect. E.g.

function g()
  coroutine.yield(3)
end
co = coroutine.create(function()
  coroutine.yield(1)
  coroutine.yield(2)
  g()
  return 4 -- shows up in the stream like you'd expect
end)
while coroutine.status(co) ~= "dead" do
  local status, value = coroutine.resume(co)
  print(value) -- prints 1, then 2, then 3, then 4
end

This stuff is possible in other languages, but it feels more bolted on and more kludgy. With Lua, you write the straightforward cooperative threading logic, and it works as expected. I think that’s great :)

Lua has 1-based indexing for strings as well as arrays. In my experience it’s a pain in the arse.

The length of arrays is tricky. It’s possible for ipairs(t) and #t to disagree.

I’m not a fan of languages that can’t detect misspelled variables at parse time. Perl was my first dynamic language, and I was dismayed that other dynamic languages are worse at detecting typos.

Lua is so underrated

It is often perceived as a niche language

Is it though? I feel like I hear about it all the time. According to various surveys it’s one of the most popular languages in the world:

https://survey.stackoverflow.co/2023/#section-most-popular-technologies-programming-scripting-and-markup-languages

https://www.techrepublic.com/article/lua-moves-into-top-20-of-marchs-tiobe-index-python-retains-top-spot/

https://www.developernation.net/blog/language-communities-who-leads-the-way/

I”ve been using Lua quite a bit recently. Sol3 makes it incredibly easy to embed from C++, you can call cast Lua functions to std::function, expose functions to Lua by just assigning them to indexed elements in the Lua VM wrapper, and expose entire class types by just passing method names and pointers (or lambdas if you want the Lua version to be a lightly sugared version of the underlying C++ one). It transparently converts Lua tables to C++ collection types (anything with iterators). Unique and shared pointers inter operate with Lua memory management, with the destructors being called from the GC.

100% agree. I embedded Lua into my hobby 2D game engine and with macros and a bit of template magic to unroll and pass function parameters and return values as appropriate types it’s absolutely magical to be able to bind things from C++ with only a few lines.

PS_LUA_BIND_HANDLE(Actor)
PS_LUA_BIND_HANDLE_MEMBER_FN(Actor, getPosition)
PS_LUA_BIND_HANDLE_MEMBER_FN(Actor, setPosition)
PS_LUA_BIND_HANDLE_MEMBER_FN(Actor, getComponentByName)

Not mentioned in the article is the amazing hooks Lua provides to be able to examine the state call stack, profile, and other options. I’m able to generate incredible script error reports with not much more than the built-in capabilities.

I love Lua. My favorite thing is that being a small language, I don’t spend a lot of time thinking about the right way to do something. If I can bang together a loop over a table to do my computation that’s good enough.

One interesting Lua application out there is Path of Building, a sort of theorycrafting simulator for the game Path of Exile. It’s a giant complex pile of Lua code with many outside contributions. And has an intensive GUI too. It works just fine.

This post comes down to: lua is fast and embeddable, and two notes about arrays (which as @telemachus says may not be correct).

I’ve been enjoying lua-for-configuration in Neovim and Wezterm recently while setting up a new computer. Especially in Neovim, it’s so great to go from the very quirky and weird Vimscript config to Lua where a setting looks like a setting, and a function call looks like a function call. More or less.

Neovim and many modern written-for-nvim plugins also sport great type documentation coverage, so you can get great completion and in-editor type checking… once you get your config running and install the lua checker.

For general programming I find the situation with array/list/sequence “nil termination” unacceptable. It’s bad enough in C strings but to have the same kind of wonky issue for the basic “ordered compound type” in a dynamic language is just… ugh. It will hide nil pointer mistakes and instead turn them into silent data loss, horrendous. I guess people deal with it because large amounts of production lua do exist, and there is the type checker stuff. I just don’t want to have to think about such things when programming.

My favorite part of Lua is that it has so many compile-to-Lua options (similar to JavaScript) which means you can choose something you personally find more ergonomic.

Lua is a language I’d recommend anyone check out, and I’m glad to see an article showcasing some of its coolness. That said, I don’t know if I’d recommend it for anyone’s primary programming language. (Not to say that it shouldn’t be!) I’ve used it for configuring WezTerm, as well as some fun coding adventures in Minecraft through ComputerCraft: Tweaked and similar mods. At one point, I even was working on a Twitch chat display for fun.

It’s got a lot of power, and its proliferation definitely comes from its ease of embedding. Though it’s a language that, to me, always feels foreign. Coming from mostly JS/TS, and everything feels just a little “off” when working with it, but the language is one that’s probably easiest for me to hold in my mind while I’m using it. And there are some projects like Moonscript that transpile to Lua that can make it feel a bit more familiar.

I’m hoping to build up enough interest in a game development class to pilot a course using Lua. We shall see. If it happens though there are a lot of opportunities for learning that I’m really excited about.

[Comment removed by author]

Tables as the only container type in Lua is something really interesting to me. It’s like the cons pair in Lisp. There’s some tantric superpower in the simplicity of a network of tables that enlace.

Worked on an embedded lua project. The C API is a pleasure to use.

And even better, the type system lines up so well with a certain other language that you can use TypeScript to write it: https://typescripttolua.github.io/