The tone is disappointing

Quite. The specific choice of examples rubbed me up the wrong way too. Operating systems? Assuming this means kernels, they run at maximum privilege level and absolutely need both tools to help you write complex data structures with fine control (since they usually have to reimplement most of them) and tools to avoid memory problems (since they are extra-disastrous). Meanwhile, performance is usually not an issue for 95% of the code in a kernel, and the remaining 5% attracts a lot of thought (and what matters there is usually better algorithms rather than the language it's written in).

System tools? Performance almost never an issue at all, need data structures already there because they are not going to want to reimplement them. Needs to avoid overruns and memory problems because often run as root.

Compilers? They *eat* data structures and very complex allocation patterns for breakfast. I don't know of any large compiler that doesn't have at the very least its own allocator, often several: they usually end up with full-blown garbage collection because the data structures just get so knotty that doing it by hand is utterly impractical. Rust-style ownership tracking usually ends up crudely bodged in :P so it would be helpful to have some of that already there.

Networking software? Exposed to, well, the network. Absolutely must be robust against attackers. I'd prefer it if the things were formally proven correct, but in the absence of actual living flying unicorns at least using heavily-tested datastructures and a memory model that makes common classes of fault next to impossible (like, say, Rust's, or almost any managed language's) is better than nothing. Speed is of marginal interest except for the sort of thing that ends up on network backbones and the occasional thing like the heart of a file transfer system that might find itself at the wrong end of a domestic or datacentre multi-GbE cable, where suddenly every single CPU cycle counts and you'll probably be either bottlenecked in the kernel or using direct-to-userspace stuff and writing core loops in asm to wring *everything* out, with a relatively unimportant and untested fallback in some other language for slower systems. (Almost no applications fall into this category.)