> The type system makes it impossible to mess up your usage of things like atomics and mutexes.
You can still cause deadlocks and livelocks in well-typed code, which I put into the category of "messing up your usage of mutexes". It would take a more powerful type system to prevent these errors. It is also unclear whether the behavior of mutexes in the face of task failure is correct for all use cases.
I think what he meant is that the compiler gives you certain guarantees that in some cases will mean that you don't need to directly use atomics and mutexes at all. Rust still allows you to arbitrarily harm yourself, but it usually makes sure you are more clear about your intention to do so.
I think Rust prevents data races. That's pretty much the reason it has mutable variables. Compiler won't allow two places to borrow the same variable mutably.
Well put! Rust shines in that these sorts of abstractions (channels being just one example) which must be builtin in other languages can be expressed as library types in Rust. It is a distinct strength, not a weakness as this article seems to imply.
Ironically, channels are a great example of this. Rust used to have a channel keyword, and the language used to reason about them directly, but nowadays, the type system is strong enough that they (and in fact, all of I/O) is just a library, yet just as safe.
Rust also has strong enough guarantees that channels aren't always as necessary as they might be in other languages. For example, we can catch data races _at compile time_, which means shared memory just isn't as dangerous. The type system makes it impossible to mess up your usage of things like atomics and mutexes.
Anyway, if people don't know what Rust is about, it's ultimately a failure of our marketing. We'll get there. :)