Beyond the Hype: What Microservices Really Offer (And What They Don’t)

Microservices: Claimed Benefits

Scalability : Decompose an application into smaller, independently deployable units.

Focus : Teams can concentrate on a narrow business domain per service.

Availability : Failure of one service does not necessarily bring down the whole system.

Simplicity : Smaller code bases are easier to understand and evolve.

Responsiveness : Services can be scaled out to handle varying load patterns.

Reliability : Replicated service instances eliminate single points of failure.

Critical Examination of Each Claim

Scalability for big‑data practices : The idea of pipelines and filters dates back to the 1970s Unix philosophy, which already advocated small, composable programs. Microservices do not introduce a new scalability principle.

Ease of building and maintenance : Single‑purpose programs are easier to manage, a benefit that predates microservices and is inherent in modular design.

Higher code quality : Focusing on a limited scope can improve quality, but this is a generic advantage of modular decomposition, not exclusive to microservices.

Simplified cross‑team coordination : Event‑driven communication can reduce integration overhead, yet it does not eliminate the need for heavyweight protocols (e.g., SOAP, WSDL) and may introduce new complexities such as gRPC.

Support for real‑time processing : Real‑time systems have long relied on publish/subscribe or event‑bus models; microservices are not a prerequisite for such architectures.

Accelerated growth : Reusing modular components is a long‑standing software‑engineering practice, not a microservice‑specific advantage.

Increased output : Presenting data differently for various audiences is a reporting concern unrelated to service granularity.

Lifecycle update evaluation : A/B testing and multi‑variant experiments existed before microservices and are not inherently tied to the architecture.

Scalable elasticity : Adding nodes increases network latency and can degrade overall performance; elasticity is not automatically achieved by splitting services.

Tool ecosystem : Technologies such as Hadoop, Spark, NoSQL databases, and streaming frameworks predate microservices and work equally well in monolithic or modular setups.

Historical Foundations of Modularity

The principles behind microservices echo the Unix philosophy of "do one thing well" and the seminal 1971 paper by David Parnas on module decomposition. Both emphasize clear interfaces, independent development, and traceable defects—ideas that have guided software design for over fifty years.

Distributed Computing Fallacies

Peter Deutsch (1980s) and later Ann Wolrath & Jim Waldo (1994) highlighted that distributed systems struggle with performance, reliability, and scalability. Splitting a system across networked nodes multiplies latency by orders of magnitude and can introduce new failure modes. Even when services are co‑located in containers on the same host, the additional network stack layers (OSI model) add measurable overhead.

Organizational Implications

Adopting microservices imposes extra burdens on database administrators, QA engineers, infrastructure teams, and UX designers. It often forces a "full‑stack" expectation on developers or requires matrix‑style reporting structures, increasing hiring difficulty and operational overhead. Each additional service introduces its own deployment pipeline, monitoring configuration, and version‑compatibility matrix.

Conclusion: Modules, Not Microservices

The core advantage of microservices—creating independent, reusable code units—has existed long before the term appeared. Modern practice should focus on whether a problem truly benefits from such decomposition rather than adopting the label for its own sake. In many cases, well‑defined modules, libraries, or packaged services (e.g., JARs, DLLs, .NET assemblies) provide the same benefits with less operational complexity.

References

https://americanart.si.edu/artwork/those-who-cannot-remember-past-are-condemned-repeat-it-george-santayana-life-reason-1905

https://www.integrella.com/expertise/microservices/

https://en.wikipedia.org/wiki/Unix_philosophy

https://www.win.tue.nl/~wstomv/edu/2ip30/references/criteria_for_modularization.pdf

https://scholar.harvard.edu/files/waldo/files/waldo-94.pdf

http://blogs.newardassociates.com/blog/2016/enterprise-computing-fallacies.html

Code example

相关阅读：