4 ms·
> There is not sufficient communication between the various layers of software. I disagree with this. In fact, my conclusion is the opposite. It's a good patte
by cryptica 6y ago
> There is not sufficient communication between the various layers of software.
I disagree with this. In fact, my conclusion is the opposite. It's a good pattern to limit the complexity of communication between different layers and have strong encapsulation of state.
The simpler an interface is, the easier it is to integrate with other components and the less likely it is to run into integration issues and expose vulnerabilities.
The simpler the interface (with fewer, simpler endpoints), the fewer e2e scenarios you need to account for, this allows you to build more stable, more secure software which is easier to test.
Modules which expose a large number of endpoints tend to encourage micromanagement of that module's internal state and this leads to issues.
You need to have clear separation of concerns between layers and components in order to be able to come up with the simplest interface possible which allows different components to interact.
- ssivark 6y agoAgreed, but only if & when the abstractions are not "leaky". Robust encapsulation is simply not possible when abstractions are leaky or ill-fitting for the domain -- including an incomplete model of the domain. The latter point -- needing a complete & consistent model of the domain -- is IMHO commonly under-appreciated; a lot of software is based on poorly understood partial abstractions for their respective domains. Bits of information leaking through faulty abstractions are exactly what make conduits for "side-channel" attacks.
- specialist 6y agoAgreed. Leaky abstractions means you have the wrong mental model. Abstractions (attempt to) hide complexity. Worst cases are black boxes. Mental models attempt to clarify how something works, to make it easier to reason how a thing works.
- davidjnelson 6y agoTotally. A robust domain model is one of the main things that matters in terms of software architecture in my experience.
- cryptica 6y agoYes true. You also want the data which is passed between the different layers to be as simple as possible to avoid leakiness. I try to avoid accepting complex instances as function arguments and try to avoid returning complex instances that will allow the user to manipulate shared state. It takes a lot of effort and thinking to figure out an abstraction which fulfils all of its requirements while at the same time exposes a simple communication interface.
- specialist 6y agoAgreed. Modularity is just a strategy to mitigate bad design, not the cause. Modularity enables divide & conquer, specialization, etc. Conway's Law is a good thing. Architecture is the visible design choices, defined thru interfaces. It'd be amazing if we divined some new strategies. Like maybe GA or the newer stuff.