Your computer is a distributed system

Most computers are essentially a distributed system internally, and provide their more familiar programming interface as an abstraction on top of that. Piercing through these abstractions can yield greater performance, but most programmers do not need to do so. This is something unique: an abstraction that hides the distributed nature of a system and actually succeeds.

Many have observed that today's computers are distributed systems implementing the abstraction of the shared-memory multiprocessor. The wording in the title is from the 2009 paper "Your computer is already a distributed system. Why isn't your OS?". Some points from that and other sources:

As the shared-memory multiprocessor is actually a distributed system underneath, we can, if necessary, reason explicitly about that underlying system and use the same techniques that larger-scale distributed systems use: But most programs do not do such things; the abstraction of the shared-memory multiprocessor is sufficient for most programs.

That this abstraction is successful is surprising. In distributed systems, it is often supposed that you cannot abstract away the issues of distributed programming. One classic and representative quote:

It is our contention that a large number of things may now go wrong due to the fact that RPC tries to make remote procedure calls look exactly like local ones, but is unable to do it perfectly.
Following this, most approaches to large-scale distributed programming today make the "distributed" part explicit: They expose (and require programmers to deal with) network failures, latency, insecure networks, partial failure, etc. It's notoriously hard for programmers to deal with these issues.

So it is surprising to find that essentially all programs are written in an environment that abstracts away its own distributed nature: the shared-memory multiprocessor, as discussed above. Such programs are filled with RPCs which appear as if they're local operations. Accesses to memory and disk are synchronous RPCs to relatively distant hardware, which block the execution of the program while waiting for a response. But for most programs, this is completely fine.

This suggests that it may be possible to abstract away the distributed nature of larger-scale systems. Perhaps eventually we can use the same abstractions for distributed systems of any size, from individual computers to globe-spanning networks.