I think this quote from the "revisiting modules" post exemplifies something that I think is missing from, or at least not nearly common enough in, the C++ community:
As Quote of the Week material, I guess it's a bit long and context-dependent. Here's a slightly edited version:
<@brson> i just rejected a rust-dev post from somebody complaining about the performance of the rust game
<@acrichto> brson: haha
<@acrichto> at some point those posts will start to decline
Abomonation has no safe methods. [...] If you are concerned about safety, it may be best to avoid Abomonation all together. It does several things that may be undefined behavior, depending on how undefined behavior is defined.
From u/Quxxy on r/rust about rules of thumbs for use:
Do I use a specific name many times? use that name.
Do I use many things from a module, but only use them infrequently? use the module.
Do I use something only very rarely? I don't use it, I write the full path out, or I use only within the functions it's actually needed.
I don't wildcard unless I'm being sloppy and writing something I don't care about.
Whether I export a module structure or just flat symbols depends entirely on expected uses. Does the module structure matter to the user? No? pub use to create a flatter API. Does the module structure help with having lots of names? Keep it.
you can ask a Future "are we there yet", to which it can answer "yes", "no", or "don't make me come back there"
an Iterator is something you can keep asking "more?" until it gets fed up and stops listening
Display is just a way to say "show me your moves", with the other formatting traits being other dance moves
if something isn't Send, then it's a cursed item you can't give away, it's yours to deal with
if something isn't Sync, then it won't even appear for other people, it's possibly an apparition inside your head
things that are Clone can reproduce asexually, but only on command. things that are Copy won't bother waiting for you
When programmers are saying that there are a lot of bicycles in code that means that it contains reimplementations of freely available libraries instead of using them
Presumably the metric for this would be bicyclomatic complexity?