Thread by @sophaskins

ownership & responsibility of software has a neat property that makes it similar to the "memory hierarchy": you get higher throughput if you can efficiently manage communications latency

if a project / technology / whatever is in a single team's domain, it's like everything fitting in to L1 cache - FAST. AS. HELL.

if your team is super lucky and firing on all cylinders, you can get to the "all in registers" world and it's dopeeeeeeeee

Communicating with other teams close to you in an org is like higher levels of cache - you need a bit of work to maintain cache-coherence across sockets and cores. It's still pretty fast, but nothing like a single-team.

Few rad projects are completely in the single-team domain, so the L2/L3/etc level is really common! It's a good layer to make sure you have the best cache-coherence / team-alignment efforts in place

Beyond that, you have inside-the-same-company-but-more-distant communication: going to memory.

You've got a ton more RAM than caches, and lots of info is in them! It's a gold mine! Super rad programs can need tons of RAM

but pulling it in to cache is still expensive - you have to account for it!

Communicating with other companies is like paging in from disk - it's available to you when you need it, and can enable some seriously awesome products, but doing it _all the time_ means super-high latency for getting information and potentially starving your CPU of work

"Keeping things in L1 cache" takes _work_, both in programming _and_ in running a team. You can't run at that max throughput if communication loops are high latency! But you can only have a low-latency loop for so much responsibility!

And again, cache coherency fits this analogy super well - if you don't manage it well, teams/CPUs can work on _the wrong thing_

BUT

managing it _takes time_ and latency!