Just skimmed through rustup-init.sh and executing half-downloaded things is not an issue, it’s all function declarations, one set -u and one variable declaration (without side effects) before the last line of the script kicks off everything with main "$@" || exit 1. It’s also a dash/bash/ksh/zsh/whatever-polyglot, someone put a lot of thought in this. Also it’s actually just figuring out the architecture and OS to know what binary installer to download. So don’t worry, it won’t accidentally rm -rf /usr.

With the caveat that I’m currently blanking on the semantics of sub-shells yes I think you’re right, -f is about not executing <hmtl><h1>404 Not Found</h1></html>. Does curl output half-transferred documents to stdout in the first place, though, and also bash -c is going to hit the command line length limit at some point.

And no I haven’t tried anything of this. I use a distribution, I have a package installer.

--proto ‘=https’ --tlsv1.2

That’s how you know they care, no MIMing that stuff without hijacking the CA at which point you have a whole another set of problems, and if you trust rustc to not delete your sources when they fail a typecheck, then you can trust their installer. -f is important to not execute half-downloaded scripts on failure, -s and -S are verbosity options, -L follow redirects.

Liquorice (there’s also an actual root, not just the confectionery) is very sweet and tummy-friendly, actually recognised as a herbal remedy over here for (mild) gastritis because antiinflammatory and antispasmodic (alongside helping with coughs and having some antibacterial properties) but too much will fuck with your blood pressure, avoid it if you have any issues there. A bit will probably be fine but a habit generally isn’t “a bit”.

There’s some medicinal teas over here which pretty much only contain it to taste better (otherwise makes no sense in combination with e.g. valerian). The stuff is actually sweet and pleasant, not a neutral but woody sweetness, not to be confused with North European liquorice confectionery where the predominant flavour is Salammoniac. Which are also very good… hey I grew up with the stuff, don’t look at me like that. Anyhow if you want a naturally sweet herbal tea adding a couple of shavings of the stuff should do the trick.

But dear gamedevs, please, please, please for the sake of less savvy players, include at least some clue of what the user should do.

Look at the logs. Submit the logs in your bug report. I agree that displaying a message box would alleviate user confusion but a) that won’t contain the info devs will need to actually solve the issue, dialog boxes are too small, and a gazillion of bug reports saying “Game tells me ‘cannot initialise gfx window’” aren’t helpful and b) what if the message box fails to display. I mean technically writing to log can also fail but then the user probably is noticing that their disk is full in some other way so it’s not as much of an issue.

The ideal situation is having a secondary process watch the actual game process, if something goes wrong it will give you the choice between displaying the logs and just submitting a bug report. Another uncomfortable truth is that without a tech-savy user at the other side, some bugs just can’t be diagnosed because it’s a “works on all of our machines, we have no idea how yours is different” type of situation. As a non tech savy user your two options there are to wait, and/or refund, which you shouldn’t feel bad about.

…and if the engine you’re using doesn’t come with that kind of thing built-in no devs won’t write it. It’s a PITA to do when you’re not acquainted with the code that actually does do the basic windowing etc setup and there’s more important bugs to squash and features to creep.

There’s plenty of schemes that aren’t fully standards-compliant but I don’t think leaving out eval is common – it’s easy to implement and nothing about the standard says that it needs to run code fast.

Just wanted to point out that eval is the real static vs dynamic boundary. As to evil, sure, you shouldn’t run just any code you find without having a sandbox in place, C’s way to do the same thing is to call cc followed by dlopen, that’s way scarier, which is why people just link in lua or something instead. I guess in <currentyear> you should probably include a wasm runtime instead of using dlopen.

Fork. Setting up a whole new project infrastructure, getting fellow developers on board with your putsch and everything can be a PITA but all those are natural hurdles, due to how the licensing works the BDFL has no way to stop you.

As such, as a BDFL you rule by the grace of authority of the bootmaker. If you don’t make sense, if you aren’t respected, sooner than later the community is going to leave you behind.

Rust has affine types and gets close to linear when you include #[must_use] (you can still let _ = foo but at least it won’t be an accident, also, drop code isn’t guaranteed to run and there’s good reasons for that), refinement types there’s a library for that. GADTs… I mean sure trait magic can get annoying and coming from Haskell you’d want to do more in the type system but in the end the idiomatic rust way to do many of those things is with macros. Which, unlike Haskell, Rust actually is really good at. Really good. Tack refinement types onto the language kind of good.

Proving tools, honestly, there’s only one piece of actually proven software (SeL4) and the only language it’s really written in is Coq. Which Rust will never, ever, compete with on its home turf.

Any language containing eval in its spec cannot be (fully) compiled ahead of time, you’ll need interpretation or JIT.

Also last I checked (it’s been a while) Racket compiles to bitcode and then links in a bitcode interpreter. There’s static lisp/scheme compilers but when they come across an eval, they’re going to bail and compile in a JIT compiler or interpreter to deal with that stuff.

Who the fuck let a designer get close to the back of that thing. Only ever allow designers to view the front of anything, the back is for business.