Concurrency (Part 2 of 2)
2026-06-24
“Concurrency” is a concept tuned for allowing multiple functions to operate independently in the synchronous, sequential paradigm. It essentially uses a “trick” to allow this to happen - it assumes that the multiple functions are internally synchronized and it makes them run in a sequential manner.
This “trick” is useful for allowing us to think in terms of computation, but it doesn’t address asynchronous systems. Hence, it only addresses about 5% of reality (this number is pulled out of thin air and is not measured, yet, I base it on the fact that cosmology is based on the functional paradigm which pushes aside 95% of the problem that can’t be addressed in functional form, and calls it “dark matter”)
only simulates parallelism, is not full parallelism
teaching this has obscured the fact that concurrency is not true parallelism - people think that they are getting parallelism when using “thread libraries”, but they are only getting time-slicing, i.e. multiple functions running on a single computer in a synchronous - not asynchronous - manner.
micro-managed sharing of memory at the cell level instead of message-passing between isolated components
upper-level, explicit message-passing vs. lower-level, implicit memory sharing
the simplest, most efficient system would be a computer that is running exactly one program and not time-sharing the same computer with other programs
this would remove the need for a lot of internal complexity, i.e. “thread safety”, since the single program does not share memory with any other program, hence, the compiler and the programming language could be massively simplified
If we imagine multiple such devices running single programs, but not sharing memory, then the best way for them to communicate and synchronize would be to pass message packets to one another
This is what PBP does - it creates “parts” that are self-contained and do not share memory with other parts, it uses
send(...)to explicitly send message packets (“mevents”) between parts.You are forced to write code that contains explicit message passing, instead of writing code that relies on implicit memory sharing. This maps to asynchronous reality better. # See Also
Email: ptcomputingsimplicity@gmail.com
Substack: paultarvydas.s. bstack.com
Videos: https://www. youtube.com/@programmingsimplicity2980
Discord: https://discord.gg/65YZUh6J. q
Leanpub: https:. /leanpub.com/u/paul-tarvydas
Twitter: @paul_tarvydas
Bluesky: @paultarvydas.bsky.social
Mastodon: @paultarvydas
(earlier) Blog: guitarvydas.github.io
References: https://guitarvydas.github.io/2024/01/06/References.html
Paid subscriptions are a voluntary way to support this work.