If we are now considering philosophical intellectual exercises to be memes then this description is accurate.

I do think that specific point is catering too much to sloppy get-it-done-fast-and-don’t-think developers. It’s true that they are Rust’s most untapped demographic, and the language won’t reach the pinnacle of mainstream usage without getting buy-in from that group, but I really think they’ll be won over eventually by everything else the language and ecosystem offers, and .unwrap() won’t be such an unreasonable price for them to pay in the long run.

The ideas in the article are great, I’m just a little confused by some aspects of the author’s tone where it sounds like there’s an assumption that the Rust community isn’t interested in expanding the scope of the language to every conceivable use case domain and height.

For the 4 years that I’ve been paying attention the Rust language is advancing faster than I ever thought a language is able to, but more importantly that advancement has been sound and sensible. So far I haven’t seen a language feature make it into Rust stable and thought “Oh no that was a mistake”, even as features roll in at an incredible rate.

Compare that to the C++ ecosystem where I feel like almost every new language feature is arriving very slowly while also being poorly executed (not that I think the ISO committee is doing their job badly; I just think it’s effectively impossible to make new language features in C++ without gross problems so long as you demand backwards compatibility).

I fully expect everything in this very sensible list to make it into the language at a reasonable pace. I don’t object to the “bikeshedding” as much as the author here seems to because I’d appreciate if Rust can avoid painting itself into a corner with bad language design choices the way C++ has. If we’re talking about language ergonomics, I’d rather suffer some tedium now while waiting for a feature to be polished than be stuck in a corner forever in the future because a bad decision was made.

One example I can think of is I’m not convinced that his proposal around kwargs for function arguments is a good thing, at least not without some serious thinking. For example should it support the ability to reduce foo(a, b, x: x) to just foo(a, b, x) like what’s done for struct construction? If so then the optional arguments start to look too much like positional arguments and the syntax starts to get questionable to me. On the other hand if that simplification isn’t supported then that becomes inconsistent with other parts of the language. So this is something that I believe requires a lot of serious thought, and maybe the better answer is to have built-in macros for generating builder structs

That being said, the edition system of Rust could afford us some leeway on not being forever trapped with a bad language design choice, but I don’t think we want to rely too much on that.

You can’t prove that Godzilla’s bones aren’t hollow ballast tanks that can be emptied and filled as needed.

Ordinary biomatter is very close to the density of water to begin with. That’s why having a little air in your lungs is enough to be the difference between sinking and floating.

If Godzilla’s biomatter under 1atm of pressure has a density close to water then being able to compress or expand an empty chamber inside his body by even just a tiny percentage of his ordinary overall volume could be the difference between floating at sea level or sinking to extreme depths.

Or if you prefer we can imagine that Godzilla gives himself a big ole booty when he needs to come up to the surface and make a mess of things.

“Lungs aren’t really inside” is not an argument that I thought I’d be confronted with.

If you find that your lungs are not inside your body then I urge you to seek immediate medical attention.

Considering most JIT compilers for JavaScript are written in C++, I can’t conceive of a reason you couldn’t implement one in Rust.

Is part of your requirement that unsafe doesn’t get used anywhere in the dependency tree? If so you’d have to take away most of the Rust std library since many implementations in there have small strategic uses of unsafe under the hood.

In my entire software engineering career, which spans embedded systems to CAD applications, I’ve never encountered a case where GOTO is actually needed (but maybe some places where it can be used as a dirty shortcut to save you some lines of code).

As for arbitrary function pointers, if those function pointers are written in Rust then they’ll come with all the safety assurances afforded to Rust code. I suppose if you’re worried about the danger of running ussr-code with unsafe in it, you could probably have your JIT refuse to compile the unsafe keyword specifically.

You’d be right if the cavity is only compressing other organs inside the body without changing the overall volume, but I don’t know why you seem to insist on making that assumption.

I thought it would be clear from my original description, via the analogy with lungs, that the cavity would not squish the internal organs but rather expand the overall volume of the body.

My head canon for sea-based Kaiju is they have a sack of muscles somewhere inside their body that can expand a cavity, kind of like the diaphragm expands the lungs, except instead of taking in air or water it just creates a volume of vacuum inside of them. This makes them extremely bouyant relative to the surrounding sea pressure, so they rapidly ascend and can casually float like a boat near the surface.

But if they ever want to dive again, they just let that cavity collapse and all their bouyancy goes away.

I really don’t think that there is any perfect programming language.

You’d be wrong 🦀🦀🦀🦀🦀

Disclaimer that I have no experience with writing compilers myself, but conceptually I don’t see any obvious reason that someone couldn’t create a JIT compiler for Rust so that it can be treated like a scripting language and do rapid iteration…

Human beings are desperate for human consciousness to be something special, beyond the limits of the material world, because it feels special and important to each of us. Quantum mechanics is what people with overactive imaginations who like to think they’re scientifically minded use as a substitute for magic or the spiritual. Of course people will latch onto this baseless theory.

Still much better than C++ templates, and I say that as someone who used to genuinely love C++ template metaprogramming. Admittedly Rust traits+generics are far more limited than C++ templates, but very often I find that to be a positive. The list of things that I feel traits+generics are missing is small and rapidly shrinking.

A good enough compiler would prevent them from happening 🦀

As for not having underwear, well…

Sorry to be pedantic but Rust only guarantees no data races can happen. It does not prevent race conditions more generally.

Don’t get me wrong, I absolutely love the language for sparing me from the hell that is data races, but the language alone won’t solve race conditions for you.

I like to imagine the profile pic changed immediately after the transition was complete, and at the time of the “completely cis” post it was something manly, like… I don’t know, hotwheels?

Might be interesting if we could compare the percentage of pitbulls that have killed or maimed a child versus the percentage of IDF soldiers that have killed or maimed a child.

Maybe even more informative would be the average number of children killed or maimed per pitbull versus the average number of children killed or maimed per IDF soldier 🤔

🦀🦀🦀🦀🦀🦀🦀🦀

I’m not familiar enough with what you’re trying to do to offer any specific advice. I’ve spent very little time with writing dockerfiles, and have never needed to set up a Rust toolchain in a dockerfile.

I think the first step is figuring out if nightly is really needed. If there aren’t any nightly features needed then the latest stable toolchain should work fine, and worrying about what version of the toolchain to use is a red herring.