Hacker News

> (Ruby-ish)

Thanks for the chuckle.

There is another one, which is not a transpiler: https://github.com/rochus-keller/luon

> Fennel (Lisp-y),

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.

They both have type systems and such. The comparison doesn't have to be about the compilation/transpilation process, but the developer experience is still important.

As someone who wrote entire stacks and apps on top in LuaJIT that I got paid for and are running without any problems after many years, this is getting a little tiresome to hear.

I still remember when static linking was the only option compilers would give us.

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.

How well does Lua plug into Rust libraries? Also how good is Lua for UIs?

I find that in practice the amount of +-1 is about the same for zero-based and one-based indexing. Each has situations it is better suited for. For example, iterating a list backwards is nicer with one-based indexes.

That is absolutely not the case.

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 ...

These days all you gotta do is ask your local LLM to write you a Lua with 0-based indexing. Sure beats complaining about 1-based indexing on HN until the end of time.

I ported a mod I made to Teal when adding a feature was taking me way too long in regular Lua to get working correctly (I freely admit that I'm seriously crippled in my ability to write correct algorithms without being able to define types that I can enforce). This was before I had ever tried to use an LLM to code before.

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.

Probably half ass web platforms nobody uses.

Burn!

so true

Can't you ask your agent to spit out binary in the first place?

Right? It's not like as soon as LLM coding became a common thing everyone who was using TypeScript threw it out and went back to vanilla JS.

The main thing is getting feedback. I've been doing some intense agent iteration on Lua projects, and so long as the error output is clear and it's easy for the harness to restart/inspect/stream logs it seems to do very well with Lua

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

Not only that, but the most important thing that a programming language does from an expressiveness perspective is define what your can't do. I often like to say that when there are an infinite number of programs you could write, programming is the act of narrowing that space until you're left with one program that you did write. Bugs are deviations from the one you were targeting, and a programming language can dramatically improve the process by eliminating a lot of the ones you don't want up front (ideally ones that might be easy to accidentally hit instead of your target)

that's not controversial to me. Programming languages that prioritize LLM creation/editing/reasons over it, while making it easy for humans to review and edit, but not being the primary author of the literal code.

Learning a new programming language and getting good at it is extermely satisfying. I get no satisfaction out of AI writing code I dont understand, its quite the opposite actually.

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.

vibes2wasm