Lets say I am doing something with V8, CLR, JVM, GCC, LLVM, CUDA, Metal, outside the managed languages that sit on top of those runtimes, compiler toolchains, GPGPU.
That infrastructure code is written in C++, and making use of Rust means adding yet another layer on how to compile, interop and debug, on top of what is already there.
As for safety in general, I am a believer of systems programming languages with automatic memory management, and polyglot programming, we aren't yet there because industry has the tendency to take decades to finally adopt good ideas, and only on a partial way.
Thus while I appreciate what Rust has achieved bringing affine types into mainstream, not an easy job, I consider this a transition step until we get both approaches in the same language, automatic resource management with affine,linear,effects,dependent types.
However this ultimately won't matter as much, when we eventually get our AI buddies good enough that they can spew executables directly.
Citation needed. The empiric evidence I’ve seen has shown the opposite.
https://rustfoundation.org/media/unsafe-rust-in-the-wild-not...
https://thenewstack.io/unsafe-rust-in-the-wild/
https://github.com/sslab-gatech/Rudra/blob/master/rudra-sosp...
https://internals.rust-lang.org/t/canvas-unsafe-code-in-the-...
Again, not a criticism of the language itself per se, and certainly not trying to imply that all Rust programmers go around writing unsafe code all day long. It's just kind of funny to me that it is touted as being so much more safe than C++ when the reality is that at least some of those features are in fact disabled for one reason or another in real-world programs.
This is very different than
> in the name of speed, efficiency, etc
And also does not demonstrate that
> the end result being a program which isn't much more secure than its C++ equivalent.
At all.