Separating Architecture From Implementation

2026-06-27

With our current programming languages it is difficult to separate architecture from implementation.

The reason for this is just a minor detail: functions are implemented on hardware using the CALL/RETURN instruction.

The implementation is that the CALLer suspends (blocks) until the callee returns something. This minor detail winds deep dependencies throughout code and makes it difficult to reason about what is going on.

The best way to break the dependency is to separate - control-flow wise - the caller from the callee, i.e. by using pure message sending (instead of impure message passing, as is implemented by CALL/RETURN and calling conventions). I built this into Parts Based Programming (PBP) through instinct.

Hardware ICs work this way, too. If actions need to be synchronized, the are explicitly, externally synchronized by the architect, not vagaries of the hardware such as CALL/RETURN (and cache coherency).

Further Reading / Viewing

• PBP basics (playlist)

• PBP Cookbook (playlist)

• Towards PBP (playlist)

• Building Software Using Black Boxes

• PBP Black Box Abstraction, Ports, Fan-out, Fan-in

• how to install PBP

• Hello World and simple parallelism in PBP

See also, the essays, blogs and videos listed below

See Also

Substack: paultarvydas.s. bstack.com
(earlier) Blog: guitarvydas.github.io
Videos: https://www. youtube.com/@programmingsimplicity2980
Email: ptcomputingsimplicity@gmail.com
Discord: https://discord.gg/65YZUh6J. q
Leanpub: https:. /leanpub.com/u/paul-tarvydas
Twitter: @paul_tarvydas
Bluesky: @paultarvydas.bsky.social
Mastodon: @paultarvydas
References: https://guitarvydas.github.io/2024/01/06/References.html

Paid subscriptions are a voluntary way to support this work.