Why Common Lisp is now the best programming language

misterchocolat

Happy to discuss

ellg

cant you do most of this with smalltalk too, or erlang? I dont really understand what macros get you when llms exist since a llm doesnt really need to create dsls to get work done

VikramBhamre

I mean its cool but what about all of the extra infra I need to write because support for the lang is not as extensive and so more code I need to maintain?

mstep

related: https://opusmodus.com/forums/blogs/entry/4-connecting-an-ai-...

giancarlostoro

> In Common Lisp your program won’t crash, it’ll stop and open a debugger with the whole stack and all the variables. You can just point your LLM at the debugger, and it’ll make its fix and resume the program. > To my knowledge Common Lisp is the only mainstream language that does all of this. Sounds like someone who has never used C# and Visual Studio? Even JavaScript is capable of doing this, honestly JavaScript might be the one language with the richest developer tooling of all time (possibly?), sad to say because there's nicer to work with languages out there.

jaggederest

I've had some of the same ideas, I would love a full macro system on a dependently typed language. My stab at it earlier in January was not quite the right thing, but I do think this is the way. Weirdly enough concision is even more important in LLM context than in regular human context.

ltbarcly3

Common Lisp isn't even a good programming language. There's nothing in CL that isn't in a ton of other languages now. When it was being designed it was way ahead, but now it's just way behind. Maybe you could take CL as a foundation, introduce modern features and uniformity to the language, remove some of the insane complexity, tame the unhygienic macros, and come up with a pretty good language. Since about 7392 different flavors of scheme have tried to do this and mostly failed, I think this is very unlikely.

gorgoiler

”Would you agree that some programming languages are better than others? If so then one of them must be the best.” False. A partial ordering doesn’t guarantee a maximum element!

mumin00

don't think software companies will user change their software

BurnerBurner

Nah with llms the most used lang prolly has the best output

andrewstuart

Now as ever, there is no “best programming language”. There’s the right tool for the job, there’s compliance with requirements, there’s personal preference. Don’t let anyone ever tell you you are programming wrong.

fithisux

In the benchmarks though here it is slow and consumes too much memory https://benchmarksgame-team.pages.debian.net/benchmarksgame/... But I find ideas like Carp very attractive. Still common lisp is designed very good.

nurettin

In my experience, LLMs instantly find the reason for the crash and fix. They don't even need to go through the debugging phase anymore. It doesn't matter if you're generating c++ lisp or cobol.

drivebyhooting

Won’t you have to write entire stacks of code from scratch for lack of prior art in CL?

alexjurkiewicz

I think half the article talks about why CL is good because it can resume from an exception, and half the article talks about why DSLs are good. I think others have pointed out that most modern scripting languages can halt at exceptions without unwinding the stack. Python & Node both support this with core tooling. As for DSLs, they constrain the LLM which generally helps with code quality. However why implement your DSL in the unconstrained chaos of CL? You can write DSLs in Rust which gives you static typing, a borrow checker, and clippy.

Karrot_Kream

I keep bouncing the idea around of building a core in C or Rust then writing everything atop it using Janet. I love how readable lisps are (with macros, you can really move up the abstraction ladder quickly) and working on a live image should make iteration a breeze in an LLM.

bitwize

Astronaut 1: So... now Lisp is the best programming language? Astronaut 2: Always has been...

shikck200

Lisp allows for some really, really complex and spaghetti code bases. I have seen the ultimate macro-hell from top to bottom. I know syntax does not matter, but i just cant honestly say i read lisp code as clear as something like Go. I guess it boils down to style. I have seen 100 lisp styles, and only one Go style.

rspeele

I recently wrote a comment on another thread that I think fits even better here: In my circles I've noticed it's very easy for us to rationalize why our previous favorite language is also the perfect language for the agent era. If your favorite language before was Python, why, LLMs are fluent in it! So much training data! So many libraries! Home of machine learning! None of that pesky compile time, agents don't need compile time safety anyway, they write such good test coverage! It's The Perfect Agentic Coding Language. If it was Rust, by jove, an agent can easily handle the headache of satisfying the borrow checker, and now you get the best of all worlds! Safety! Near-C runtime performance! Abstractions! The only reason people didn't use Rust before was it was Too Hard and there were Too Many Furries and now it's not hard and you don't have to interact with them, so get on board. It's The Perfect Agentic Coding Language. If it was Golang, oh my goodness, what a choice. Pretty fast compile time and pretty fast runtime. Agents get a tight feedback loop with build->run->test->edit. Not very complicated, code has to be written in a straightforward banging-rocks-together way. Good stable ecosystem! Rob Pike designed the language for people he said were "not capable of understanding a brilliant language but we want to use them to build good software." That's an arrogant, demeaning way to describe your colleagues but if they're LLM agents it's dead on! It's The Perfect Agentic Coding Language. I could go on and on. I'm not immune either! My own favorite language is F# and when I feel like self-justifying, I play the same game: It has access to the .NET ecosystem like C#, but I don't have to constantly remind the agents to prefer a style with immutable data and pure functions, they idiomatically do that in F#. Files have to be in order and can only refer to symbols defined "earlier" in order, if you want mutually-referential types or functions they have to be declared as such in a joint statement, so spaghetti is hard to create: each project's codebase naturally ends up in a layered bottom-to-top architecture. The language is terse enough to be token efficient, without being symbol soup. FSX scripts can be generated during agentic code reviews to demonstrate repros for discovered issues. If there's any type of code that still warrants me jumping in and writing some myself, that code would be data type definitions/domain modelling, and F# is a joy to write those in. It's The Perfect Agentic Coding Language.

aussieguy1234

That's a lot of power to mess things up that I wouldn't be putting into the hands of an LLM I don't trust.