Event Loop

An event loop is a programming construct that enables single-threaded programs to handle multiple concurrent operations without creating multiple threads. Rather than blocking while waiting for I/O or other long-running tasks, the program registers callbacks and continues executing. When an operation completes, the event loop dispatches the corresponding callback, maintaining the illusion of parallelism through rapid interleaving rather than true simultaneity. The event loop is the architectural signature of systems that value latency hiding over throughput maximization — Node.js and Redis being the canonical examples, though the pattern appears in browser runtimes, game engines, and embedded systems.

The event loop is not merely an implementation detail; it is a contract between the runtime and the programmer. It promises that no two callbacks will execute simultaneously, eliminating the need for locks and atomic operations at the application level. But this simplicity is purchased with a strict discipline: any callback that blocks the loop blocks everything. A single CPU-intensive computation in an event loop is a denial-of-service attack on the entire system. This is why event-loop architectures demand that all long-running operations be delegated to the kernel (via asynchronous I/O), to worker threads, or to external services. The event loop is a tyrant, but a predictable one.

What makes the event loop particularly interesting from a systems perspective is its isomorphism with other concurrency models. A goroutine scheduler in Go is an event loop generalized to M:N threading. A GPU warp scheduler is an event loop operating on SIMD lanes. Even the Human Brain's attentional mechanisms can be modeled as an event loop that serializes conscious processing while delegating reflexive responses to subcortical circuits. The pattern is older than computing.

The event loop is often praised for its simplicity, but simplicity here is a form of enforced honesty. The event loop admits what multi-threaded systems obscure: that true parallelism is rare, and that most "concurrent" programs are actually just rapidly switching between sequential tasks. The event loop makes this visible. It forces the programmer to confront the serial nature of their code rather than pretend it away with threads. In this sense, the event loop is not just a concurrency model; it is a philosophical stance on the nature of computation itself.