BatmanAoD

That's the mrustc project the author mentions. He wants Rust to be bootstrapped earlier in the process.

Okay. That's just imposing a different (and at least equally arbitrary, if not moreso) definition of bootstrapping. Why does it matter that the author didn't explain their "deeper reasoning" for having an interest in bootstrapping, or the Bootstrappable Builds project specifically? If you feel like that project isn't meeting a sufficient bar for what counts as "bootstrapping", or that using C as the first high-level language they bootstrap is "tragic", take it up with that project, I guess.

The author doesn't explain exactly what their interest in bootstrapping is, but the goal is pretty explicit:

So, for me, it would be really nice if there was a Rust compiler that could be bootstrapped from C. Specifically, a Rust compiler that can be bootstrapped from TinyCC, while assuming that there are no tools on the system yet that could be potentially useful.

There is nothing special about C.

I wish that were true, but isn't it somewhat wishful thinking? Even an assembly-language Lisp would require an operating system in order to build a functioning compiler, wouldn't it? And operating system APIs are in C.

Edit: more importantly, as the post explains, the special thing about C is the existence of TinyCC.

Yeah, that part is pretty wild and definitely Microsoft's fault.

The Crowdstrike problem was in fact a Crowdstrike problem. It affected Linux too, but of course there are vastly fewer users of Crowdstrike on Linux: https://www.google.com/amp/s/www.theregister.com/AMP/2024/07/21/crowdstrike_linux_crashes_restoration_tools/

This is pretty obviously a Microsoft problem.

What were the issues you've had with WSL? I've been happily using that for a while now.

I agree with everything in the article, which makes it all the more unfortunate that I really detest Go as a language.

(It's getting better, though.)

I hear you, but here's my experience:

I've had one coworker whose personal coding style actually somewhat resembled that in the Clean Code examples. He wrote functions as small as possible, used many layers of abstraction, and named everything very verbosely and explicitly.

Now, to be fair, I don't think he did that because of Clean Code, and he also didn't follow most of the good practices that Martin recommends. Most egregiously, he almost never tested things, even manually (!!). He once worked an entire weekend to finish something that I needed for my part of the project, and when he was done, it didn't work, because he hadn't actually run it at any point (!!!!!).

But even when his software did work, it was horrendous to navigate and modify, specifically because of that style of writing code. I know, because when he retired, I was the only person on the team who could deal with it, so his part of the project fell entirely on me.

Now, I've also had to work with code that had the opposite problem: short names, no abstraction. And a sort of "worst of both" codebase where the functions were exceedingly long and full of near-duplicate functionality, but overall there was a fair amount of modularity and abstraction.

But in my opinion, it was much harder to deal with the code that hid all of its weirdness behind layers and layers of abstractions, despite those abstractions being carefully documented and explicitly named.

That's great, but surely, from time to time, you have to deal with code that other people have written?

I'm a Rust fan, and I do think they eventually struck a pretty good "visibility vs noise" balance with ? (which was highly controversial at the time).

It's not a strawman, though, because Martin's actual example code in the book is like this, including a full module he rewrites toward the end.