#[you_can::turn_off_the_borrow_checker]

The Linux kernel is actively looking at submissions in a language other than C for the first time in 30 years. https://arstechnica.com/gadgets/2021/03/linus-torvalds-weigh...

It is a primary language source for WebAssembly.

That is already MUCH further than either D or Dart ever got in their respective spheres.

Folks (including many with a lot of money) are noticing that Rust instead of C or C++ means 70% fewer CVEs leading to security breaches. https://msrc-blog.microsoft.com/2019/07/22/why-rust-for-safe...

I think there's a place for a lot of players: TypeScript, Python, Go, etc.

Rust however is not just an interesting side step like most languages that cannot point to real, measurable gains. When there are a limited number of languages that can fill a niche (systems, highest performance, limits on memory consumption), one of them has demonstrable improvements in ergonomics, stability, and security, and it has funding from an array of deep pockets, it would be a fool's errand to discount it even if it has a steeper learning curve than Python.

Not every language can piggyback on the first scriptable web browsers or on IBM mainframes.

I see Rust's miracle as industry adoption in cloud infrastructure even though every software engineer in that sphere already has (typically decades of) experience in C and/or C++.

Its miracle is that after all these apps were (re)written, it was not followed by the typical tidal wave (or even a steady stream) of severe CVEs that have always accompanied systems-level languages.

Most folks don't need Rust, will probably never need Rust. That's okay. A huge proportion of developers never need C, C++, or any of the myriad assembly languages.

But folks in that sphere know how fraught the systems-level languages are both from a security perspective and a packaging perspective (where's the cargo equivalent in C++ in 2022?). They are looking at their colleagues and watching the list of CVEs.

Their choices: • Zig: better than C, simpler than Rust, but very immature, and not as memory safe or thread safe as Rust • Ada: established, used by DoD, not as memory safe or thread safe as Rust (see: severe CVE causes) • Go: much shallower learning curve than Rust, but garbage collector makes it unsuitable for systems-level. Much less flexible than Rust. • Fortran: no intrinsic standard support for Unicode-aware I/O, memory safety is lower than Rust. Fortran is a muscle car with great straight line performance for scientific processing but has always struggled with general app space due to its design. • Nim: interesting alternative to C, but nowhere near mature or stable enough for general deployment in the real world. • C: dead simple with plenty of foot guns. In fairness, C taught us where a lot of the foot guns were in programming. 50+ years later, it's obvious from the CVEs that humans need some guardrails. • C++: More complex than Rust, a back history that preclude solving its worst design issues, and coupled with subtle firearms that blow your whole leg off. No standard packaging or module repositories available. Severe CVEs galore. Has spawned entire swaths of new languages just to avoid using it. (See: Java)

Rust is arguably the first popular language outside the DoD that can reliably take jobs from C++ with tremendously and measurably better reliability without compromise on resource usage.

There's a reason Linus Torvalds and the other core kernel developers never wanted C++ anywhere near the Linux kernel but are cautiously optimistic about and open to Rust development in that space.

It's not about hype; it's about the necessity of reducing the security-related blast radius even at the lowest levels of hardware and the embedded space. Everything above that level is just gravy.

I would NEVER consider writing web server software or cloud functions in C or C++ in 2022. I would consider it irresponsible. I'd write them in Rust in a heartbeat though if performance demanded it. Many others feel the same way.

All together, that's what I see as Rust's miracle.

> More code Forth than Rust

Not trying to be a dick, but do you have any evidence you can point to for these claims? I find them to be surprising and unlikely.

I wouldn't worry at all about what the adoption graph looks like. The only thing that matters is whether the language is worth adopting.