Why does Rust get articles about eg an operating system written in Rust, but all the Go posts are how to tie your shoe laces? Somebody explain, please.
Rust is for the lowest level code which is not assembly, with all the performance tricks, but that should be secure.
Rust is expensive to develop - if you can afford to use a GC, you should use a GC.
So people want to rewrite all the world's C and C++ to rust, for security. But people are less passionate about rewriting all the world's python into go for performance.
This has not been the case for many people using Rust, including myself. Once you learn the language, there is no "cost" to use it. In fact, the compiler simplifies much of the mental overhead when dealing with concurrency, sharing data, mutability, etc... Sure the compiler has some strict rules, but it's not expensive to develop in by any means.
I would also say Rust is in a sense higher-level than Go in terms of expressiveness and abstractions.
I like GCs, but I wouldn't make such a blanket statement. Manual memory management as implemented in Rust also eliminates data races at compile time, which are in fact the last item listed in the original article.
Rust is almost entirely at the rocket scientist end of the market.
Or maybe that's the result of a scarcity of those kinds of resources. Hard to say.
That's my excuse, anyway.
If you start out on Rust, the first thing you hit is the borrow checker. There are a billion articles on that, but the questions there seem less novice because the problem is harder.
And then when you have gotten to the point you need best practices in error handling, Rust greets you with this:
https://doc.rust-lang.org/book/error-handling.html
Go has easier problems because it's an easier language. I say this as someone who loves Rust.
n.b.: While I have seen very, very competent programmers writing good software in Golang despite the language's considerable efforts to thwart them, and doing so in a product-focused environment, my intuition, as an outsider (which I disclaim because, as somebody whose job is to build systems that do not fail, the worse-is-better ethos of the Golang community scares the hell out of me), is that there's not as much deeper discussion to be had when you are of a generally product-focused mode; many things are unspoken and many others are very specific to your tiny slice of the world--is there as much to say, publicly, about that stuff? And are the other loud people in that community even listening when you do?
Rust seems instead to attract immigrants from what I consider better programming environments; not necessarily better business environments (almost certainly not, in the cases of people I personally know) but environments that are more welcoming and enabling of building hard stuff. The Rust people I know are migrants from heavy-hitter C++ backgrounds, functional programming backgrounds (the biggest fan I know personally previously lived and breathed OCaml), and a few from the deep end of the Ruby community. Thus to me it follows that the interesting stuff that leaks out into the general public is going to be more esoteric to many outside of it (and maybe, for you personally but certainly for me, more interesting).
It also probably helps that the Rust APIs are really smartly designed and it seems--though I am a Rust novice, and this is a personal take--much harder to shoot yourself in the foot. There may just be less need for "these things work but will secretly ruin your day" in general.
A single language that can demonstrate this continuum pretty well is actually Java, I think--you see tons upon tons of "here's why you don't use == in Java"-level posts, but you also see stuff like Aleksey Shipilev absolutely throwing down useful and actionable stuff about the JMM. Java as a community is fragmentary and huge, and there's more space for, and more need for, discussion at both ends of things.