And yet that's inherent complexity, not accidental complexity. The way that other languages simplify this is by hiding the complexity behind a garbage collector, which Rust's domain can't tolerate.
He talks about the inherent complexity in resource contention.
I will point out one choice quote:
"It's making things complex because that's a decision that needs to be made by someone who has better information."
Rust addresses this by forcing you to highly parameterize code statically, which is probably the least bad solution we have right now for this sort of stuff in a low-level language.
I know Rust is complected somewhat, that's why I specified that it's simple to write correct programs in Rust. So in that perspective, it's very simple at tackling such a complex problem. You'll find doing so is even more complected in C.
I'd agree that to me that's just inherent complexity. Let me explain.
Imagine the safest language ever, literally, by design, it prevents all bugs, except for functional ones.
Now implementing anything to the extent that there's 0% bugs is inherently complex. It might be so complex that possibly no program ever written even achieves this, in any language.
That hypothetical language would not be able to make that complexity disappear, because it's part of the problem space, and not the specific design of the language.
In most languages, we avoid this complexity by ignoring it. We allow buggy software. We generally say, as long as the bugs that exist either don't occur in practice, or don't impact users that much, it's good enough.
But, let's go back to Rich's talk. Why was he talking about Simple vs Complex? Because complex code leads to bugs. If your language's complexity leads to bug free software, the argument would change. In this case, just work harder to understand the complexity and get it done. You're then guaranteed safety.
Rust is by no means this language, but it's the closest we have currently in that space. Because of that goal, it's tackling quite a lot of complexity. Maybe some of it is accidental, and Rust2 could improve on that.
Having said this, sometimes it's fine to allow bugs, if it allows productivity. Use Clojure in those cases :p
