NeatNit

The Pitch Meeting video is how I first learned this movie exists. Sent it to a friend with the message:

I haven't watched the pitch meeting yet but there is no chance in hell this movie is better than the original

Secretly I was hoping I was wrong, but oh boy, that turned out to be an understatement. Turns out my friend had actually already watched it with his mother... Or rather, tried to watch it. They had to stop hallway through because of how shit it was.

So glad I didn't have to experience that.

(Note: I have since learned that the movie I was thinking about is not the original, there was an older movie and they're both based on a book)

A lot of things are crazy around here :(

I can confirm that the subtitles are accurate. But I'm less sure about the parts where they're talking over each other. Also I don't know the context that preceded this conversation but I can't imagine how it would justify this.

Pretty sure that's the obligatory "insane representation of the opposite viewpoint" panel member, as this channel isn't usually one to back these viewpoints. The other panel members argue with him for a reason. Channel 14 (propaganda channel) is where you'll hear these kinds of insane things said by the regular hosts.

It's an interesting discussion. As someone who doesn't actually deal with this and who literally never used Rust, I feel out of me depth. But it does sound like Rust has much better mechanisms to catch a programmer's mistake. See my reply to the other guy.

Thanks for this. I was paraphrasing (badly, it seems). The video actually says it better:

To write code that lives in an embedded environment, it has to run in this mode in Rust called "no standard" (#![no_std]) and this mode called "no main" (#![no_main]). Basically you have no access to any of the core utilities in Rust, you have to write a lot of them yourself.

He then explains how embedded code necessarily has global mutability which is "the antithesis" of Rust development.

So yeah, you could make all of those wrappers, but at the end of the day you'll end up with about the same amount of "unsafe" code as you would making the same thing in C++.

Edit: but if what you said still applies, it does seem like Rust would watch your back somewhat better than C++ would in that it wouldn't even compile unsafe operations outside of unsafe blocks, unlike C++ to the best of my knowledge where you kind of have to review the code yourself to make sure it only uses the appropriate wrappers.

You're still free to NOT install other browsers.

If that link contains the answer, you should at least name the relevant section.

Never used Rust but I'd like to point out the YouTube channel Low Level which covers security vulnerabilities (CVEs). He ends each video with "would Rust have fixed this?" and it's pretty interesting.

A very recent one is this: https://youtu.be/BTjj1ILCwRs?t=10m (timestamped to the relevant section)

According to him, when writing embedded software in Rust (and UEFI is embedded), you have to use Rust in unsafe mode which basically disables all the memory safety features. So in that kind of environment Rust isn't really better than C, at least when it comes to memory safety.

That's not to say Rust isn't still a good option. It probably is.

Again, I never used Rust so I'm just parroting stuff I've heard, take all of this with a grain of salt.

pic unrelated

I am in this comic and I don't like it.

Sonic the tortoise

I'm well aware that the units were redefined at various points, but the new definition was always nearly identical to the previous one. Everyday usage was never affected.