I am an electrical engineer and almost 50 years old and I have been writing code since 1982, so my entire adult life and most of my childhood on 80s micros.
Here's what I've had to learn: C, C++, Pascal, COBOL, Fortran 77, dBase III/IV/FoxPro, 6502 assembly, 8086 assembly, 80386 assembly, Matlab, Python 1/2/3, Perl, Lua, Forth, Java, various flavors of SQL, and probably tons of stuff I am forgetting. It got so bad that I could write an entire page of code before I realized I was writing it in the wrong language.
I started to dislike programming during the 90s with the battle between Microsoft and Sun. It was clear that the whole Java vs. .NET was not about making life better for the programmer, but forcing the programmer to commit to learning an extensive system of idiosyncratic libraries to be able to do their work, thus taking time away from learning a competitor's idiosyncratic language and libraries. Things have not improved much since then, except for perhaps the presence of open source being an alternative that motivates the commercial software vendors not to engage in excessively deleterious behavior.
Generally the more fanatical the support of a language is, the less practical the language. While I can see some value to the design choices made in Rust, in particular the aspect of forcing the programmer to "prove" to the compiler that certain aspects of their program likely work as intended, it seems that there is an idea that Rust code makes code which is inherently bug-free and self-documenting, and that this is the revolutionary part of Rust. Rust forces certain design patterns on the programmer that can be proved by the compiler to work in a particular way (but not necessarily the way that is desired), and any deviation from these patterns requires unsafe code for which the proofs are not required. This could be helpful to ensure certain guarantees about code quality, for example, the prevention of memory or resource leaks. Perhaps in some cases that may be a reason to adopt Rust vs. another computer language that has much wider adoption and support. Other aspects, for example, ensuring that worst case dynamic memory allocation and fragmentation doesn't result in unavailable memory, or that worst-case latencies are not excessive, seem harder to prove.
I think the only real proof will be to see the astounding productivity that embedded Rust programmers have, with millions of dollars saved from not having to roll out emergency bug fixes or firmware updates. But creating a language that makes programming harder is going to be a non-starter for most people, because of the effort paid up front for only prospective future gains. One of the craziest things I find about most Rust documentation is that it tends to spend more time explaining what one should not do, rather than how to do something. This already takes a language that is manifestly unfriendly and makes it downright unapproachable.