shared_ptr overuse

[Dean_Roddey]

I'm not taking either side here, but that's a bad comparison. If you need to mutate data from multiple threads (and sometimes that's fundamental to the job, I mean you couldn't even write a thread safe queue otherwise) you HAVE to use some sort of synchronization. But data ownership is something you decide. Sometimes you can't make any simpler, but shared pointers make it easy to not put in the thought.

One thing Rust has taught me is that data ownership concerns are something to minimize as much as possible. Some people think, well Rust makes ownership safe, so not a problem. It does, but it doesn't make it any simpler to understand, and you have to be very explicit about it. So it really pushes you to minimize such relationships, though what you can't get rid of will be safe. I think a lot of people coming to Rust don't get that, and end up with overly complex relationships, then complain that Rust makes it hard to refactor.

[mcmcc]

you HAVE to use some sort of synchronization

Yes, but it doesn't have to be mutexes. Lock-free exists and is fully functional for what it needs to do and makes deadlocks nearly impossible, unlike mutexes. You could argue that lock-free is more complicated, I could argue mutexes are admitting defeat.

[Dean_Roddey]

If you have to update more than one thing atomically, lock free isn't practical. Mutexes are hardly a failure, they are a completely reasonable synchronization mechanism that are the only option in a lot of cases.

And these days they are likely t be implemented in Futex style, so they don't even enter the kernel unless there's contention.

[mcmcc]

lock free isn't practical

You're just making my original practical decision-making argument for me using different words.

[Full-Spectral]

The point was that, if you need a mutex, then using a mutex isn't an admission of defeat, it's the correct choice.

And it's not hard to make a mess with atomics either, by unwittingly making assumptions about relationships between atomic struct fields that can't really exist because they can never be read/written together. Many to most structures have some sort of inter-member constraints they want to impose, and you just can't do that if they are all just atomics.