It appears that people believe that words like "concurrency" used in popular programming languages mean that things are happening at the same time, which is not the case except for special circumstances, i.e. no cache misses in L1 private cache on multi-core, or actual parallelism on the internet.
The current crop of synchronous, sequential programming languages are built on a foundation of "interleaving" ("time-sharing") instead of true "running at the same time".
Conflation of the concepts of "parallelism" and "time-sharing" is encouraging people to have a warm-and-fuzzy feeling that doing more-of-the-same will eventually provide notations for doing-things-at-the-same-time. (Or worse, believing that we already have a notation for programming massively parallel systems).
I think, though, that we need to switch to using notations for doing-things-at-the-same-time instead of beating our heads against the recursive-parameterized-value-returning-subroutine (aka "function") chimera.
I don't advocate dumping the synchronous, sequential programming paradigm, but, I advocate simply recognizing the limitations of this paradigm and of using a hybrid of multiple paradigms.
We got away with time-sharing methodologies for decades because CPUs were too expensive to be used like candy. Now, the tables are turned and CPUs are inexpensive, so we can use zillions of them in our designs. We no longer need to time-share them, and we no longer need to share memory and worry about what problems that causes, nor do we need to use programming languages and operating systems that encourage time-sharing and worrying about memory sharing issues. If a multi-threaded design causes angst due to its parallelism, just throw another CPU-with-private-memory at the problem.
Our current computers and programming languages and operating systems can only simulate concurrency and parallelism. The technology of the 1960s operated fast enough to fool humans into perceiving concurrency. It’s 2025, it’s not 1960 anymore, yet, we still use workflows based on the biases of time-sharing and hand-wringing due to the use of unnecessary memory sharing.
The PBP stuff that I favour, also, only simulates concurrency, but, it does so in a way that can be mapped onto parallel hardware better, IMO, than the current FP paradigm can.
See Also
Email: ptcomputingsimplicity@gmail.com
References: https://guitarvydas.github.io/2024/01/06/References.html
Blog: guitarvydas.github.io
Videos: https://www.youtube.com/@programmingsimplicity2980
Discord: https://discord.gg/65YZUh6Jpq
Leanpub: [WIP] https://leanpub.com/u/paul-tarvydas
Twitter: @paul_tarvydas
Substack: paultarvydas.substack.com