I think the author sees Rust as a language which, even if it's not beyond the mind of a single person yet, trends in that direction. He puts it pretty fairly in

I think the author sees Rust as a language which, even if it's not beyond the mind of a single person yet, trends in that direction. He puts it pretty fairly in a recent blog post[1]: > Rust does something very practical: it says what properties it will enforce, but doesn’t say how. That is, you know references have to uphold the law of exclusivity, but how the compiler achieves this is subject to change. So the borrow checker is allowed to evolve over time, in the direction of accepting more programs and becoming more ergonomic while retaining safety. > The upside is that most of the time you can use Rust without thinking about lifetimes or the borrow chchecker. The downside is that the borrow checker is hard to spec (it’s basically “whatever rustc does now”) which makes is hard to have multiple implementations of Rust. Some people argue that’s fine or a good thing because multiple implementations waste effort. This argument has merit, but I think languages being specification-defined is a good thing from a stability perspective. It’s what they call a tradeoff. [1]: https://borretti.me/article/type-systems-memory-safety#rust https://borretti.me/article/type-systems-memory-safety#rust