LLMs Make Hard Languages Like Rust and Zig the New Normal
Fast and Hard Code
Armin Ronacher observes that LLMs have made language choice nearly irrelevant, leading developers to pick 'hard' languages like Rust and Zig for speed and size. Projects such as Cloudflare's Artifacts and Vercel's fx are largely LLM-assisted, and developers are now tackling previously gatekept technologies like DWARF, eBPF, and custom crypto. The result: more slop, but also more developers who want fast, small software.
So maybe the world will have more slop, but it might also have more developers in it, that want things to be fast and small.
- qsera
> All of a sudden I have seen people do some really impressive stuff with DWARF files, eBPF, custom network drivers, custom crypto and really old computing hardware. Many of these things were previously off-limits for lots of developers. In some cases (eg: crypto) you were even pushed away because those things were intentionally gatekept by the people in the know.
Before at least some of us were forced to understand stuff, because without understanding it was not possible to do stuff that we really wanted to do, and some those got passionate and kept digging, and some of us even made even better stuff based on their experience.
Now no one needs to understand anything, and now we will never have better stuff.
- willtemperley
I think this is true to an extent, but it really depends on how much information the LLM has on a topic.
They’re amazing at maths because maths has been open source since day 0. They’ve great at algorithms for similar reasons. C bindings are a doddle because there’s so much prior art available. They’re terrible at using cutting edge features in languages because there’s not much data yet.
I think it’s fairly easy to predict what they’re good at on this basis. I’m not sure why they suck at UI design though.
- noduerme
As someone not in the know about cryptography, I know just enought that the words "custom cryptography" scare the hell out of me.
- superjose
I'd say it depends.
On the degree the software evolves and will be used.
The reason we've spent years discovering patterns, creating special syntaxes has been to tackle certain domain problems more efficiently and to have systems that can evolve through time.
The only constant is change.
Albeit LLMs chunk out code (and with great know how impressive output), the developer must have the know how to pass a certain threshold.
Writing in unknown languages may seem fine at first. But once you go to the edge, you'll be finding certain quirks, inefficiencies along the way that the LLM may work around it instead of removing it from root.
For example, I've been learning Effect.ts for some weeks now. I've used LLMs extensively, but before that there were a series of manual coding rounds first.
To understand composability, the nitty gritty, where things break, how, how the syntax is formed, and how could I structure some observability challenges I had around the library.
If I hadn't gone through that process, the code quality would be subpar. It wouldn't have been evident at first, but once the system would begin to evolve and adapt to feedback, things would be brittle, existing customers would be affected, and more.
I like to move fast without breaking things
- jbstack
> one thing is pretty clear: the act of familiarizing yourself with a language no longer matters
I completely disagree with this statement as a premise to the article.
Sure, if you have zero care about whether the agent's work is reliable or not, then there's no need to learn a language. But if you're a developer who cares about their work and isn't just outputting 100% vibe code, then at a minimum you should be familiar enough with the language that you can review the agent's output ,follow along with the code, and make an informed decision about whether to commit.
Interestingly, I've found that my approach to learning languages has fundamentally changed. Before, I'd study a book on the one or two languages which were important to me at that time. The goal was to become proficient. Now I choose to read about a variety languages simply because they demonstrate some interesting paradigm that is new to me (e.g. Haskell -> functional, Elixir -> concurrency). I read a programming book like I'd read an engaging narrative non-fiction book: cover to cover relatively quickly, then I'm done. This gives me that "familiarity" which is useful for agentic coding, without bothering to learn every obscure bit of syntax or library call. My priority has become breadth (get an overview of many languages and paradigms) rather than depth (learn a language or two really well).