Context, reconciliation, and performance

I believe the software industry needs a word to differentiate the design of performant software from the inside (or bottom up) versus the outside (or top down). There is a heavy focus on algorithms and data structures in the software engineering world, which is great if you are designing performant software from the inside out (bottom up). But this will only be performant so long as there is one monolithic structure. As soon as there are competing components (or silos of functionality) that need to integrate together, the integration of the components often becomes a performance bottleneck. And this phenomenon is unavoidable because there is a limit to any human's working memory. Large problems are broken down to smaller problems so that they can be more easily grappled with. But the choice of how things are isolated often can incur a performance gain or loss that is just as significant in magnitude as choosing the right data structures and algorithms. And it is this way because data structures and algorithms are precisely the tools used to reconcile state between independent components. If two components are designed in a way where they are opposed to each other's existence, then one would essentially need to copy the entire state from one to the other to reconcile their states. Sometimes the reconciliation algorithm is even worse than copying if copying is not an option (such as when the data tied to the component is too large to copy, e.g. a component is a database).

There does not seem to be a word to measure how holistically designed a set of components are. There does not seem to be a way to talk about how well a system is intelligently designed. Often a system that uses the simplest algorithms within the components (but integrates the components coherently) out performs a system that uses the best algorithms within the components (but does not integrate the components coherently). People think this is all still falls within the realm of data structures and algorithms because all state reconciliation is a data structure and algorithm problem. But what I am more interested in is having a way of measuring how intelligently designed a system is holistically. The absence of extremely powerful algorithms is a sign of good holistic design in my opinion. A very intelligently designed system should have one core algorithm in my opinion. Yet it is very hard to distill complex problems to simple mechanisms. There has to be a word to describe someone's ability to do this distillation. And it needs to be a common word in the software engineering industry. It's just as powerful a tool as choosing the right data structure or algorithm. It's the ability to hold many things in the mind at once. I would use the term "working memory", but the term could be overloaded from existing definitions. The term I am looking for should describe the ability to create handles on the many dimensions and aspects of a problem, so one can swiftly mold the problem into a shape that can be solved in the simplest manner possible. It is a compressive and expansive dance.

Every talented software engineer has this substance in spades. They subconsciously break down complex problems to simple ones. Their designs allow components to integrate smoothly with each other because all friction was preemptively removed in the design process. And it is not something that is easily observable (e.g. you can't ask someone to demonstrate this quality because the ability is essentially a neurological phenomenon) outside of the final work. Bad software engineers don't even know of this substance's existence. They are blind to it. Or worse, they think they have a monopoly on it (and they think people who don't follow in their footsteps have poor taste), yet their final work fails to leave an impression.