Comments
It seems like type hints are good for any dynamic language, since they wind up in most of them overall.
It’s part of the big three Lua syntax flavours: Teal (Typescript-y), Fennel (Lisp-y), Moonscript (Ruby-ish)
For all (most?) intents and purposes, Fennel is lisp-language, not just lisp-y. It's Clojure-y if anything, which makes sense considering the creator of Fennel.
FWIW I didn’t mean to imply anything here, just draw the parallel between the ergonomics of transpiled Lua. Spiritually I consider Lua to be a Lisp, and Fennel a tool for revealing this quality. I’ve actually recently combined Teal and Fennel to create a statically typed Fennel compiler, which really improves QoL for larger projects. I’m doomed to enjoy lispy or command invocation languages, both of which have fallen out of style.
Lots to learn from each.
Techomancy is Fennel's maintainer, but Calvin Rose created it (and then Janet). Here are interviews with both:
- technomancy https://alexalejandre.com/interviews/interview-with-technoma...
- calvin rose https://alexalejandre.com/interviews/interview-with-bakpakin...
Personally I am not the biggest fan of lua as it really is such a light language in every sense of the word (meaning, syntax too and features - too light IMO). But it's good that creativity keeps pushing things forward.
Lua is great for high-level control of a program written in C/C++. When setting that up, I’ve often appreciated that I could removed features like file I/O from the Lua standard library and the rest keeps on trucking.
Lua is terrible for writing programs by itself. People keep trying to make it happen. But, for anything non-trivial, it’s a fool’s errand.
As for how light it is, I don't disagree with you that it's frustrating, but as someone who only started using it at the beginning of last year for making a mod, I've realized that in a lot of ways, it feels like it's JavaScript if it were designed properly from the start. Both use a single map data structure for everything, including having arrays be "maps with incrementing integer keys", but Lua anticipated that iteration for arrays should work differently made the loop syntax give you a way to specify which way you want. Neither has a particularly large set of APIs that are available out of the box, but Lua defined a module system from day one (I assume, I guess I don't know for sure) and even provides a way to use it as for defining objects; JavaScript has a prototypical inheritance system that's probably more complex than it ever needed to be, and it took decades for a standard way of importing things to be defined. Lua also doesn't have the famous warts of implicit type coercion for operators (including the more familiar looking of the two equality checks); I'd take arrays starting at 1 over that any day.
I don't love working in Lua, but given how unfathomable it is to me that so many people genuinely seem to enjoy JavaScript, Lua seems more than sufficient in terms of the language features at least.
Some of them had this cool modern idea of overlays, where we would manually manage loading additional code segments into the same process memory slot.
Numerical loops in Lua are inclusive:
for i=1,#t do t[i]=0 end
With 0-based indexes, and that numerical loop format, it would be minus-one everywhere:
for i=1,#t-1 do ...Jokes aside, I did start to do a conversion like this manually some years ago, but it wouldn't really be Lua at that point. I just got bored because I knew it wouldn't really have value to anybody.
2. I don't see anything wrong with coding for purely artistic purposes?
3. Presumably a static type checker would be quite helpful for LLMs, since it would help them catch lots of their mistakes.
[0]: https://github.com/teal-language/tl/blob/main/CHANGELOG.md#0...
Now that LLMs are a common thing for coding, modding communities (which in practice have a large number of people using Lua since quite a lot of the most widely modded games use Lua for mods) are having to adapt a bit to handle the influx of a huge number of mods from people who have never programmed before, which I tend to view as a good thing in the long run, but right now LLMs seem to be rather abysmal at writing reasonable Lua. There's a meme (in the original sense of the word) that you can tell when a mod is LLM generated because it will use pcall in ridiculous ways, seemingly because it's a lot quicker to abuse it as a retroactive control flow mechanism than to go back and add proper checks up front (and probably restructure the code in the process). Teal doesn't fully solve the underlying issue of LLMs apparently being very poorly trained on Lua but it does at least give a pretty good way of statically enforcing what the actual types it should be using are.
Surely that’s useful, no matter whether you’re writing the code yourself or having an agent do it.
Though, I am not really in the lua camp either. But I had to comment on the "only AI counts" transfigurative statement.
In fact, I'd say it's more "fun" watching an agent work on something in Lua as the iteration loop is tighter: more restarts, more feedback, instant running. When I deal with typed languages (in my case, Swift) the feedback loop is dragged-out by the compile time which makes the whole process feel slower
Ideally you'd want both. In this case though, if you're paying per token you'd prefer the typed language, since compiler invocations are presumably less expensive. So the interactive compilation strategy where it has to continually consume compiler output and run inference on it is going to be more expensive than letting the compiler do what it's good at. (I wonder at what point that math would invert and what would happen if it did.)
That's why something like Teal is perfect for AI, to answer the original question of "why this when there's AI now?" You'd want to add types to Lua to check what you can beforehand precisely because it helps give you the best of both worlds.
LLMs are already so incredibly capable and will only get better and faster with time.
Learning a new programming language just feels redundant now.
It will be people who understand things and experiment still that will succeed in the world of AI. People who are meat proxies are screwed its already making you lazy and probably giving your brain a disease we haven't named yet, a type 2 diabetes-esque of the brain.