tags  
[Programming Languages](id:9d566115-cfc1-4fec-833e-636e69a4e4fe)

Rust is interesting because it occupies contentious programming language
territory: it attempts to graft lots of semantic type information to
previously unencoded ideas of memory sharing semantics. Why? Because
developers likely can't be trusted with memory management in any form.
This borrow checking enforces a very consistent, cohesive style across
Rust programs; memory can only be shared in a particular fashion, which
impacts the data flow architecture of your entire application.

Jon Blow's [Entity systems and the Rust borrow checker … or
something](https://www.youtube.com/watch?app=desktop&v=4t1K66dMhWk) and
[Ideas about a new programming language for
games](https://www.youtube.com/watch?app=desktop&v=TH9VCN6UkyQ) talks
are essentially rants against Rust; he claims that manual memory
management is fine and necessary for being ergonomic, that
exception-based control flow can be useful, etc. The talks are worth
skipping around throuhg on 2x speed to get the gist - they're rants,
really, with a couple of legitimate nuggets of information.

Despite claims about not having a runtime, [Rust
does!](https://blog.mgattozzi.dev/rusts-runtime/) Even if compiled
without runtime, we do have some setup for generating threads and such;
this is particularly necessary for allowing code to actually run on
Windows systems.

This fun hack, [Rust in an
instant](https://fnordig.de/2020/05/02/rust-in-an-instant/), shows how
you can easily redefine libc functions, then link with them, in the same
file - as Rust knows to link with some C function with some name, and it
can also provide C functions with those names.

[Five years of Rust - a cross-platform programming language for the next
decad…](https://gendignoux.com/blog/2020/06/16/rust-5-years-cross-platform.html)
is a huge Rust puff piece enumerating the good parts. Probably phrased
better than I could! But always remember that strong type systems come
at the cost of programmer brain. They're nice for serious production
work, but not necessary for prototyping. Rewriting in Rust is good, but
I'm not sure if the first draft has to be.

<https://tiemoko.com/blog/blue-team-rust/>: What does memory management
mean for Rust? Great take from a security perspective.

[Polonius](https://github.com/rust-lang/polonius) contains the algorithm
that specifies the Rust borrow checker; if you're interested in a deep
dive, this is absolutely the place to start.

[The Pain Of Linear Types In Rust -
Faultlore](https://faultlore.com/blah/linear-rust/) is a type-theoretic
investigation of Rust's type system, an explanation of why it is **not**
actually linear, and elaborates on the pain that a real linear type
system would cause in Rust.

[Bryan Cantrill on Rust and Why He Feels It’s The Biggest Change in
Systems De…](https://www.infoq.com/podcasts/rust-systems-programming/)

Rust replacements for standard tools are quite popular.
<https://www.youtube.com/watch?app=desktop&v=A65w-qoyTYg>: zero-cost
copy in Rust! [The Rust Embedded
Book](https://docs.rust-embedded.org/book/) elaborates on methods for
writing embedded software in Rust.

[GitHub - doctorn/trait-eval: We all know Rust's trait system is Turing
comple…](https://github.com/doctorn/trait-eval) [GitHub -
rust-lang/datafrog: A lightweight Datalog engine in
Rust](https://github.com/rust-lang/datafrog)