Here's a thing I find weird in the monoliths VS. microservices discussion:

1. We get told monoliths are naturally badly structured (hint: they aren't, *naturally*). This allegedly is due to the fact that it's so easy to introduce unwanted dependencies between modules. 1/5

2. We get told microservices naturally lead to more modular systems (hint: they don't, *naturally*) because it's harder to violate module boundaries. We pay for that with a lot of accidental complexity in code and at runtime (latency, circuit breakers, discovery). 2/5

3. Our industry spends an enormous amount of effort on making this complexity easier to work with to make developers feel like they're working with locally available code completely ignoring different forces at play (like connascence: https://en.wikipedia.org/wiki/Connascence#Degree). 3/5

If 3 succeeds, aren't we back to 1 but with all downsides of the network introduced? What about the allegedly natural means to avoid the structural degradation? Why would we actively want to work on removing the aspect that was presented as solution to our original problem? 4/5

That said, I am fully aware that other factors (team and organization structure, other operational requirements) play into this. It just strikes me as odd that 1 & 2 are still an undisputed line of thinking in so many blogs and conference talks. 5/5