A world Without Email: Reimagining Work in an Age of Communication Overload

Stumbling into the Hive Mind
The horse stirrup enabled a new type of shock troop that the
Carolingian Empire couldn’t survive without. This led to land grabs,
which in turn upended the very nature of government, and thus we
get from the introduction of a narrowly useful bit of metal and
leather to full-blown feudalism. I just argued that more than a
millennium later, the introduction of another narrowly useful
innovation, electronic messaging, led the modern office to embrace
the hyperactive hive mind workflow. To justify this claim, let’s look
closer at the types of underlying complex forces that plausibly might
have driven us from the rational adoption of email to the less rational
embrace of the hive mind approach to work. There are at least three
of these hive mind drivers that likely played a role in this
unintentional transformation of the office.
Hive Mind Driver #1: The Hidden Costs of Asynchrony
As argued earlier, email helped solve a practical problem generated
by the growing size of offices: the need for efficient asynchronous
communication—that is, a fast way to send messages back and forth
without requiring the sender and receiver to be communicating at
the same time. Instead of having to play phone tag with a colleague
from the other side of your office building, you can replace this real-

---

time conversation with a short message, delivered when convenient
for you, and then read when convenient for the recipient.
To many, this asynchronous approach to communication seemed
strictly more efficient. One technology commenter I came across in
my research compares synchronous communication—the type that
requires actual conversation—to an outdated office technology like
the fax machine: it’s a relic, he writes, that “will puzzle your
grandkids” when they look back on how people used to work.
18
The problem, of course, is that email didn’t live up to its billing
as a productivity silver bullet. The quick phone call, it turns out,
cannot always be replaced with a single quick message, but instead
often requires dozens of ambiguous digital notes passed back and
forth to replicate the interactive nature of conversation. If you
multiply the many formerly real-time exchanges now handled
through multitudinous messaging, you get a long way toward
understanding why the average knowledge worker sends and
receives 126 emails per day.
19
Not everyone, however, was surprised by the added complexity
of drawn-out communication. As email was taking over the modern
office, scholars in the theory of distributed systems—the subfield of
computer science that I study in my academic research—were also
examining the trade-offs between synchrony and asynchrony. As it
happens, the conclusion they reached was exactly the opposite of the
prevailing consensus in the workplace.
The synchrony-versus-asynchrony issue is fundamental to the
history of computer science. For the first couple of decades of the
digital revolution, programs were designed to run on individual
machines. Later, with the development of computer networks,
programs were written to be deployed on multiple machines that
operated together over a network, creating what are called
distributed systems. Figuring out how to coordinate the machines
that made up these systems forced computer scientists to confront
the pros and cons of different communication modes.
If you connect a collection of computing machines on a network,
their communication, by default, will be asynchronous. Machine A
sends a message to Machine B, hoping that it will eventually be
delivered and processed, but Machine A doesn’t know for sure how
long it will be until Machine B reads the message. This uncertainty
could be due to many factors, such as the fact that different machines

---

run at different speeds (if Machine B is also running many other
unrelated processes, it might take a while until it gets around to
checking its queue of incoming messages), unpredictable network
delays, and equipment failures.
Writing distributed system algorithms that could handle this
asynchrony turned out to be much harder than many engineers
originally believed. A striking computer science discovery from this
period, for example, is the difficulty of the so-called consensus