Listen, the Nintendo Entertainment System did not have a Prometheus dashboard, but it had 99.999% availability.
When you plugged Super Mario Bros. into a front-loading NES in 1985, you were not deploying an application. You were physically extending the system bus of the host computer. The cartridge slot was not an interface for a peripheral; it was a bridge that mapped the cartridge’s Read-Only Memory (ROM) chips directly into the CPU’s address space. There was no operating system to boot, no container runtime to initialize, and no virtual network interface to configure.
We replaced this elegant, copper-to-copper simplicity with five layers of virtualization, and we wonder why our page-duty alerts go off at 3:00 AM.
The Absolute Zero of Cold Starts
To understand why the cartridge was bulletproof, look at what happens when you flip the physical power switch. The Ricoh 2A03 processor inside the NES clears its registers and reads the memory address at $FFFC and $FFFD. This is the hardware reset vector. On a cartridge, those addresses map physically to the PRG-ROM chip inside the plastic shell.
.org $FFFC
.dw Start ; Reset vector points directly to code
SEI ; Disable interrupts immediatelyThe time from “power on” to “first instruction executed” is measured in nanoseconds. There is no kernel space versus user space. There is no systemd waiting for network-online targets. There is no kubelet checking a local Unix socket to see if the container engine is healthy.
Compare this to a modern Kubernetes “cold start.” You deploy a microservice. The scheduler assigns it to a node. The container runtime talks to the image registry—assuming the registry isn’t currently rate-limiting your IP. The image is pulled, unpacked, and mounted. The runtime creates the namespaces and cgroups. The pod network overlay allocates an IP and updates the routing tables. Finally, your Go or Java binary starts, only to crash because it tried to read a database credential from a secret volume that wasn’t fully mounted yet.
We built “self-healing” systems because our systems are too fragile to survive their own startup sequences.
The Immorality of Mutable State
A Nintendo cartridge represents the ultimate architectural safety: absolute immutability. The silicon wafer containing the game code was printed at a factory in Japan. You cannot write to a ROM. You cannot corrupt its filesystem because there is no filesystem. You cannot run out of disk space. If a pointer in the game code goes wild and tries to write to the program space, the hardware simply ignores it. The code remains pristine.
I say this as someone who, last Tuesday, spent three hours debugging why a static HTML landing page was throwing 502 Bad Gateway errors. I had built a distributed, auto-scaling, Multi-AZ Kubernetes cluster to run a page that could have been served from a raw socket on a Linksys router. A minor cluster upgrade had restarted the cert-manager webhook, which failed to start because of an API deprecation, which prevented the ingress controller from renewing the TLS certificate, which caused the load balancer to drop the backend.
I had engineered a system with fifty moving parts to do the job of a single piece of copper wire, and I called it “high availability.”
The Error-Handling of the Physical World
Of course, cartridges had failures. Dust, corrosion, and soda residue on the connector pins would prevent the system from booting, resulting in the infamous flashing red power light. But consider the remediation protocol. You pulled the cartridge out, blew on the pins (accidentally coating them in moisture that caused long-term corrosion, though we didn’t care), and shoved it back in.
This was physical circuit-level debugging. It forced a complete hardware reset. It cleaned the contacts. It did not require a post-mortem, a Jira ticket, or a configuration change. It was a stateless recovery of a stateless system.
In our current landscape, we run etcd on local SSDs, writing Raft consensus logs every millisecond. If the underlying cloud provider experiences a 15-millisecond disk latency spike, etcd loses its leader, the control plane goes read-only, the kubelet starts killing healthy pods because it can’t report status, and the ingress controller starts dropping traffic. We solved the problem of dirty connector pins by building a virtual machine that panics if its shadow doesn’t look right.
The warning light on the rack is blinking yellow. Node k8s-worker-09 is suddenly NotReady. The cleaning crew just bumped the ethernet switch in the cabinet, and the control plane is currently holding a vote to decide if the node still exists.
