March 24, 2026
Tiny services, huge fight
Microservices and the First Law of Distributed Objects (2014)
Dev guru says “don’t hide the network”—commenters brawl over tiny services, AI, and chaos
TLDR: Fowler says microservices don’t break his “don’t hide the network” rule, but warns they add messy complexity between parts. The crowd split: some say async and AI make small services shine, others claim it’s glue-hell without strong patterns—and one demands event sourcing from day one.
Software legend Martin Fowler dusted off his old rule—“don’t distribute your objects”—and the internet immediately asked: does that kill microservices? His answer: not really. He’s fine with small, separate services if you treat network calls like the slow, flaky beasts they are and keep the messages chunky. But he warns: tiny services can push hidden complexity into the wires.
Cue the comments cage match. One camp cheered: “100% true in retrospect,” arguing the real horror isn’t the code, it’s the glue between services. Another crew said the world has changed—async (programming that doesn’t wait around) is normal now, so remote calls aren’t weird anymore. One commenter even dragged in AI: today’s code helpers “program better with smaller scope,” so breaking things up is a win. Meanwhile, a dreamer proposed a miracle fix: a SQL for services that lets you declare “A needs B and C, C needs D,” and the system just figures it out—like Zapier meets databases for your backend. And then came the spicy take: if you’re not doing event sourcing (saving every change as an event) from day one, building distributed systems is “stupid beyond imagination.”
Translation for normals: microservices are like turning one big kitchen into many tiny food trucks. Faster to focus, but good luck with the delivery routes. The crowd? Divided and loud—just how tech likes it.
Key Points
- •The “First Law of Distributed Object Design” advises against distributing objects because remote and in‑process calls differ fundamentally.
- •Distributed objects attempted to make in‑process and remote use transparent via middleware (e.g., DCOM, CORBA), but this fails due to latency and failure modes.
- •Remote calls require coarse‑grained, batched APIs, unlike fine‑grained in‑process interfaces, so a single class/interface cannot serve both transparently.
- •Microservices do not violate the first law because they do not seek transparency; they favor coarse‑grained document exchange over HTTP or messaging.
- •Distribution increases complexity: handling failures, consistency/availability trade-offs, performance, and harder refactoring across service boundaries.