Why does rebooting solve so many tech issues?
An acquaintance on Facebook asked:
What is it about complex modern technology that turning it off and on will resolve a problem? Can we not develop some workaround or better yet design something so this never comes up?
He got many answers that were a bit lame, from people who obviously don’t know all that much about technology. Here’s a non-lame answer, with the critical caveat that there can be no satisfying answer in principle, because the answer is overwhelming dominated by “it’s complicated.” It’s like asking, “What is it about biology that it glitches all the time?” Because of an almost infinite number of reasons! People think that tech is simple and logical and computers “only do what you tell them to do,” which is technically correct, but only the same sense that molecules “only do what they have to do,” which is also technically correct, but the consequences are about nine orders of magnitude more complex than the human mind can actually grok.
In spite of all that, here’s a stab at an answer that is a little more satisfying than just “it’s complicated.”
Rebooting is surprisingly good at squishing tech bugs because the “stack” is so deep.
There are many layers of technology in a modern operating system, like geological strata, where each layer depends on the functionality of the one below it. Technologists call this structure the “stack.”
If something goes wrong down in the code sub-basement, then everything upstairs is potentially affected. What looks like the exact same circumstances from one day to the next is an illusion that derives from the complexity/depth of the stack, from elaborate branching consequences. Your computer isn’t really “the same” today as it was yesterday anymore than you are. It contains more than enough complexity to be unpredictably different every minute of every day.
When you reboot, you’re basically resetting each layer, one after the other. Whatever layer had the glitch is restored to nominal status… which has disproportionate positive consequences for the layers that rely on it..
Relevant cool science fiction idea, from the novel Fire Upon the Deep, by Vernor Vinge (previously mentioned on this blog, and for the same reason):
Vinge, a computer scientist, describes a very busy galaxy, chock-a-block with civilizations united by a kind of galactic internet and a lot of shared and exotically powerful “automation” (code, basically). He extrapolates from something we’re already seeing in computer science today: the stack only grows. If there are bugs or deficiencies with old code layers, it’s basically impossible to rip it out and start fresh with modern standards, because the job is just too immense, and too many things depend on them. The only economically realistic option is just to compensate with another layer.
And so the stack just gets deeper and deeper, and in Vinge’s novel it has been growing for eons instead of fifty years. Unintended consequences bubble up from the depths semi-regularly, occasionally including godlike and malevolent AIs — very serious “bugs.” 😉 Which is basically the premise for the story.