zongor [comrade/them, he/him]

C and Lisp programmer here, although I have used Rust in the past. I really enjoyed this video as it sums up my experience working with Rust. It obscures a lot of issues, and there are many edge cases where its guarantees can’t work. The biggest for me was needing to use unsafe because the system I was interfacing with was unsafe according to the Rust compiler. Also Rust views memory leaks or similar outside of its memory safety guarantees.

Another critique is that most developers don’t even use Rust’s more advanced features. For example they tend to rely on cloning to ensure concurrency safety, rather than dealing with Rust’s complex ownership model.

I can’t say why exactly but I get the impression that history will remember Rust in the same way as “Pascal”. An attempt to write a safe programming language that got replaced by a fast “worse” language.

The “just use SIMD” solution was brought up multiple times, but I find it is kind of a crutch; it’s great on modern systems that support it. In retro computing or embedded systems you cannot just make it faster by using those systems because they don’t exist. It massively reduces the portability of your software. Same for the idea of relying on the OS to just give out more pages.

I would also be interested in understanding how Haskell or the other languages handle memory at the very lowest level as I found many languages obscure allocation and deallocation with abstractions that don’t look like memory management but the compiled code is doing it under the hood.

The points about dynamic linking are great. It’s one reason why I dislike Linux’s Flatpak or similar systems.

Points about typing were great. Makes me want to look at OCaml, Haskell, Idris, and Granule more closely. It seems like they sound like they have some interesting ideas I would like to steal.

philpilled

This is Muttley erasure