discardable_dan

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.

I do not want to read a bunch of gross torture porn, though.

Greg Egan is far more interesting and spares you that.

As someone who has implemented full match in several industrial languages: this isn’t really match; it doesn’t not handle unpacking. And that is by far the only interesting bit. This feature is more accurately called `cond` à la Scheme, and you can fully expand it away ahead of type checking. Looking at unpacking in the arms, even with Scheme’s truth-y values and `=>`, could be neat.

Optimizing well-known jumps is useful, as is branch reordering, but the tombstone flag is unnecessary; you can simply write down a list of all targeted / called blocks and perform dead block elimination more generally that way.

I watched an older sibling go off the rails. That is what kept me from doing it.

Shouldn't compaction be exactly that letter to its future self?

How's the war effort?

It is referred to as "simple sabotage": https://www.cia.gov/stories/story/the-art-of-simple-sabotage...

It also doesn't matter because Claude 4.6 is so much better at writing code that nobody cares what OpenAI is doing.

So, to be clear, you pulled your children out of public school because students were being educated to accept other people who do not adhere to their own set of religious and cultural beliefs, in a country founded on freedom of religion?

And now instead of learning science in a lab and socializing, they are forced to maintain your farm?

What an good job you are doing!

It's pretty easy to do at runtime without weak pointers, people who write rust are just allergic to reference counting. Which is absurd, because most programmer use RC values thousands of times every day without even thinking about it. It's really this easy: https://pastebin.com/SAeKG7Sw

Rust will when when I can finally match through boxes.

My thoughts exactly: he figured out in 2025 what the rest of us knew in 2022.

I have retreated into only accepting small snippets from it. Asking it to write print functions, that sort of thing, or a specific loop that I hand-review. For the same reason.

The issue is most developers do not bother to write any, and the ones that are written are most-often vapid typing failures ("these`int`s cannot be negative" should be handled by a type). I studied this field in grad school, and the entire problem almost always devolves into convincing developers to engage with the system.

This sort of manual has since been gamified by Zachtronics, and I think it is genuinely a better alternative. If you are trying to pick up the basics of programming assembly and are already committed to use a "fake" language, why not enjoy the experience as a video game?

And it does not help that this page starts with a dick joke.

Luckily, humans are rather expert water-boilers at this point in time.

And why are they called quadlets?