It Works If You Restart It: An Uncomfortable Defense of the Oldest Fix in Tech

Let's get the shame out of the way first: you have fixed a problem by turning it off and turning it back on, and you have done it this week. Maybe it was your laptop. Maybe it was the Wi-Fi router that controls the entire northeast quadrant of your house. Maybe it was the office printer, which is less a computer and more a haunted appliance with a network port.

The IT Crowd made the reboot a punchline twenty years ago, and we've all been happily laughing while quietly relying on it as our primary troubleshooting methodology. So let's do something nobody does on the internet: let's defend it. Seriously. Formally. With citations of the heart.

What a Reboot Actually Does (Besides Buy You Time)

A restart feels like a non-answer because you didn't learn anything. But look at what it mechanically accomplishes:

It flushes memory. Leaks happen when a program requests memory and forgets to give it back. Over days, that forgotten memory adds up until your browser is using 14 gigabytes to display a recipe. A reboot is the only intervention that reliably says "no, ALL of it" and takes the whole heap back.

It kills zombie connections. That database socket that's been "open" since Tuesday? The one where both sides think the other is listening? TCP calls this a half-open connection and rebooting is the guillotine it deserves.

It clears stale caches. A cache is a lie we tell for speed. Sometimes the lie gets old, and the only way to stop believing it is to forget everything. Rebooting is industrial-strength forgetting.

It resets the state machine. Most software is a giant state machine with more states than anyone documented. When your app wanders into a state with no exit — the dreaded "this shouldn't be possible" state — a reboot is the emergency exit. It's not elegant. It's a door.

The Horror Stories, Annotated

Every sysadmin has a reboot story. Mine involves a load balancer whose connection pool had been quietly rotting for so long that traffic was being routed to a server that had been decommissioned. Nobody noticed because the errors were intermittent and intermittent errors are the sasquatch of ops — everyone's seen the blurry footage, nobody can prove anything. A scheduled restart fixed it instantly. We then spent two weeks pretending we'd found the "root cause."

Ask around and you'll hear about the Kubernetes node that needed a periodic restart like a 1998 Honda, the cron job that only worked after the server was rebooted (nobody knows why, nobody is asking), and the smart thermostat that required a full power cycle to remember that winter exists.

The Part Where We Get Uncomfortable

Here's the thing the reboot reveals, and why it stings: if cycling the power fixes it, the bug was state. And state is the hardest problem in computing — harder than algorithms, harder than scale, harder than convincing your team to write tests.

Code is deterministic. Give it the same input, it does the same thing. But state is the input you didn't plan for: the accumulated residue of every request, every retry, every partial failure from the last three weeks. The longer a system runs, the further it drifts from any state a developer ever imagined. The reboot doesn't fix the bug. It evicts the bug's entire apartment building.

This is why the cloud industry quietly adopted the reboot as a philosophy. Ephemeral containers. Immutable infrastructure. Serverless functions that live for 300 milliseconds. All of it — ALL of it — is the industry's way of saying "we gave up on managing long-lived state, so now nothing lives long enough to get weird." The reboot won. We just gave it a job title.

A Modest Proposal

I'm not saying ship it broken and schedule a restart. I'm saying the next time a reboot fixes something, don't just feel the relief — feel the clue. Something somewhere was holding onto state it shouldn't have. Find it, or at least file a ticket about it so future-you has something to ignore.

Until then: turn it off. Wait ten seconds — the ritual matters — and turn it back on. It's not a hack. It's the most honest debugging tool we have.