I'm not clear with it
- The good
- It reduces the complexity in the code artifacts for a simpler maintenance.
- The bad
- It increases complexity of governance of the software.
- The ugly
- It moves the complexity of the software to the network.
11 years ago David Wheeler died. Wheeler formulated one of the most important phrases for software architectures:
All problems in computer science can be solved by another level of indirection, except of course for the problem of too many indirections.
I must ask myself: what are the benefits to add the network as a layer of indirections? Handling software with networks is not trivial. The network might be not available or under heavy load. Timeouts are commonplace and many developers have never heard of the Circuit Breaker design pattern.
Governance of software is on of the most underestimated factor. In bigger systems you can't do what you want. Rules have introduced, established and must be respected. Without these rules a growing software system will collapse after a while - or maintenance costs will increase dramatically.
REST based microservice architectures are related to SOA systems. And SOA without a strong governance will create an epic cluster fuck also.
Fine grained microservices will increase the complexity of the governance. The diagrams to visualize are increasingly confusing. And we need visualizations to get an overview and understanding of the system. And as we know, a process diagram with more than 7 boxes/tasks/whatever has the tendency to create chaos in our head.
Software artifacts gets smaller. A microservice implementation should not have more than a few hundred lines of code - howsoever you measure it. This is good for refactoring or throwing the code away and write it new from scratch.
But I'm not quite sure that this is really a benefit. Do you really rewrite an implementation? In normal cases it is not a very complex tasks to refactor a code system with a few hundred lines of code. The benefit of rewriting comes in when you switch the technology stack. With microservices this is not a huge change-it-all tasks but you can change one service after the other.
More often than rewriting or refactoring a microservice (that works) is to refactor the entire system. Here REST based microservice based only on JSON can become a pain in the ass. Refactoring a not typed software system is a mess. Also the communicating of code intention without a type system. Without a type system also design and governance (see: The bad) can become very problematic.
Although some advocates of Microservice architectures do not want to read: exports not only JSON, but also XML hedged with XSD or any other technology that simple adds type safety.