discardable_dan

This is a cool project. The AI banner looks awful.

You should use warm water when you're washing your hands.

My larger issue, any time I have tried to learn statistics, is how fast the notation moves. You end up flipping back pages and pages just to double-check a definition that was given once and is now being extended syntactically. It's infuriating.

Handling errors in compilers has become the most interesting part of my job. If you do the math, most calls to compilers are error-yielding calls. So those calls really need to produce the best errors possible! (Maybe this is less true in LLM land, but certainly it was right before.) Tracking spans, doing extra algorithmic work, and exploring why the expectation failed in order to give a user the most-informative error possible is extra work on the main compute path. But it pays dividends: easily-diagnosable bugs and quick fixes present in the code itself. Tracking spans to point back to origin definitions, etc., always feel like plumbing work until you see the error that explains exactly what went sideways. And once you do, the errors that don't feel like a frustration you are trying to cast your net over.

It's likely AI slop.

I made a language design some years ago. More recently, I had Claude carry out some of the implementation to see if it would work. It did not. I tried again, hand-tailoring the IRs and many of the main algorithms, and it did better but the self-hosting compiler still violates many of the design principles and even behaviors in the design document. I have spent six months of free time reviewing and fixing it myself, and it's just a small pet project. I would not open-source that code any time soon.

I must imagine Mojo is in the same situation.

Imagine if artists were embracing AI the same way coders were being forced to. All that would be left there is taste, and your argument applies as readily there as well.

Why.... ?

I think you are taking the wrong lesson. The lesson is not "things make break." Many languages break things. Haskell has made it a feature, not a bug.

But this change did more than break things. It meant people using Elm in production had to abandon it, nearly immediately, as all future work would first require them to port the whole stack, in one fell swoop, to Elm (and this was before tail recursion modulo cons was implemented, but recursion was forced).

Imagine if, in Rust's infancy, it decided to remove the C FFI with the argument that people should instead, naturally, rewrite that code in Rust. What would have happened? People would have abandoned it in droves, and it would have been essentially relegated to a research language, never again suited for prime time.

And -- oh, look what happened to Elm!

You should consider doing the hard work yourself here. I sat down and reasoned through a Perceus-style RC mechanism a few years ago, made difficult by the presence of one-shot delimited continuations, and actually sorting it all out was not hard. Handing the correct semantics to Claude will produce the correct results if you take the time to understand the actual work you are attempting.

Tonka seems better equipped and free…

You should link to your resume

I've had it write Scheme with little issue -- it even completely the latter half of a small toy compiler. I think the REPL is the issue, not the coding; forcing it to treat the REPL like another conversation participant is likely the only way for that to work, and this article does not handle it that way. Instead, hand it a compiler and let it use the workflow it is optimized for.

Bro, of all the stupid shit we spend taxes on ($50 billion on corn subsidies), you're mad about space exploration?

Coining this phrase now: "It's the tokens stupid"

Hooking up to and generating calls across filesystem APIs cost multiple orders of magnitude more than calling `ls`. These tooling ideas are interesting, though. Maybe Kenneth_E._Iverson was right all along?

Talking to another senior dev over drinks tonight, we both worried not about our work but about who might come up never having written a single line of code. Never even opened a terminal. Is looking at the code something you learn in semester 5?

I think computer science education is going to stomp onward, poorly. And we will get that generation. And things like "terminal tooling is going out of style" won't even be said any more. Hacker groups will turn from discussions about new ideas to talking about doing leetcode without AI.

Our art died because we used our art to kill it. We are the last human masters.

That's a funny thing to think about.

When they are the people in charge of the nuclear arsenal, the silliness stops.