One of the things that really took me a long time to map in my head correctly is that in theory async/await should NOT be the same as spinning up a new thread (across most languages). It's just suspending that closure on the current thread and coming back around to it on the next loop of that existing thread. It makes certain data reads and writes safe in a way that multithreading doesn't. However, as noted in article, it is possible to eject a task onto a different thread and then deal with data access across those boundaries. But that is an enhancement to the model, not the default.

How do you actually learn concurrency without fooling yourself?

Every time I think I “get” concurrency, a real bug proves otherwise.

What finally helped wasn’t more theory, but forcing myself to answer basic questions:

What can run at the same time here?

What must be ordered?

What happens if this suspends at the worst moment?

A rough framework I use now:

First understand the shape of execution (what overlaps)

Then define ownership (who’s allowed to touch what)

Only then worry about syntax or tools

Still feels fragile.

How do you know when your mental model is actually correct? Do you rely on tests, diagrams, or just scars over time?

I loved the idea of Swift adopting actors however the implementation seems shoehorned. I wanted something more like Akka or QP/C++...