
Why can't computers boot instantly? (2013) - anon35
https://superuser.com/a/693611/128376
======
diego
That is not a good answer. It's perfectly possible for computers to boot in a
fraction of a second.

The argument that computers need to go from a useless state S0 to a useful
state S1 and _that takes a long time_ is just bullshit. The question is, how
close can you bring S0 to S1. This is a question of optimization. What happens
is that S1 is different for different computer configurations, and processing
needs to happen. Then the question becomes, how much effort do software
companies spend optimizing that processing? The answer is "as much as they
feel that they need to."

Computer boot times have been constant over many years because performance
gains enable companies to add more features. As long as the boot time stays
within tolerable bounds for the typical user, there is no need to optimize
further. But there are tons of other computer systems in the world
(particularly embedded) that must boot instantly, and they do so.

~~~
petra
// What happens is that S1 is different for different computer configurations,
and processing needs to happen.

The computer and OS config doesn't change often.

And it's doesn't seem slow to test that.

So caching at boot should work.

And caching is a low effort optimization. So it should have been implemented
early.

But we don't have caching at boot, why?

~~~
salawat
The two hard things in computer science are naming things, and cache
invalidation.

Remember; the computer could quite literally have been completely reconfigured
out from under the BIOS. Testing that everything is the same from the
computer's point of view is anything but straightforward.

Also, most recognizable boot time isn't spent waiting on BIOS and POST; it's
spent waiting for either the boot loader, disk encryption, or the OS to spin
up all the background stuff (graphics stacks, session managers, HAL's, message
busses, desktop environments, network services... etc) it needs to offer for
fulfilling the particular purpose the system is intended for.

Computation is amazingly fast, but by no means either free or magic.

Everything takes time. However, I make no excuses for Windows: They had 3-5
second boot nailed for a while. Then, they done bloated it to the point of
unrecognizability.

~~~
egypturnash
Usually the configuration stays the same, though - why not a way for the user
to indicate when it _has_? Hold down an awkward combination of three far-flung
keys while booting, the BIOS wakes up and checks every device plugged into it,
otherwise it just pulls it in from a cache.

(And how much does the average computer's config change? How many users never
change a single part of the hardware configuration of their computer for its
entire lifetime? A hobbyist who built their own might swap out
CPU/GPU/drive/ram/etc, but how many people upgrade their laptops in _any_
way?)

Get all that backup stuff spun up. Save the state of the entire computer the
same way you're saving a hibernation snapshot. Next boot, just pull that
snapshot up. Something makes that snapshot crash? Reset and run the slow boot,
either because the system caught this, or because the user held down the
"invalidate bootup snapshot" chord.

Although realistically I never reboot my computer any more unless I'm doing an
OS upgrade anyway. It's all just "sleep" and "wake up" nowadays for me, so I
don't care if bootup adds a minute or two to the end of the half an hour or so
my computer spent downloading the update and applying it. Maybe a cold boot
just isn't _worth_ optimizing any more.

~~~
cududa
As someone who worked on boot up sequence in Windows, that won’t work. You
could kill components in the system if someone forgets to press the right keys
on bootup. The snapshot method you mention is essentially how it already works

------
argimenes
When I was in high school their Amiga would cold boot into a GUI within 3
seconds. It was the same for the Acorn Archimedes in the UK. These computers
had the entire GUI OS burnt into the ROM. After that I remember the shock or
getting a 386 and waiting minutes for Windows 95 to load. It was like the
future had died and was buried by a conspiracy of silence in the industry.

~~~
unnouinceput
386 and W95? Not a good combination. By the time W95 was out on the market P5
was the latest and greatest and a 486 was the low budget one. You might want
to reconsider those memories. As for loading times it all boiled down on how
many check-up you wanted or not in your BIOS. As a rule I've always did memory
check by BIOS only one time when buying/putting together a new PC and after
that I've check it off in BIOS, halving the time it need it to boot. It was
perfectly easy to have a 3 seconds BIOS time, sometime was even a nuisance to
make it that short because you'd had to be fast to press Del (or whatever the
BIOS key was) if you wanted to go to BIOS instead.

~~~
avian
> By the time W95 was out on the market P5 was the latest and greatest and a
> 486 was the low budget one. You might want to reconsider those memories.

Maybe the 486 was the low end of what you could buy at the time, but not
everyone bought a new computer. My parents upgraded their 386 from Windows 3.1
to 95. It was slow, but usable.

~~~
unnouinceput
In 3rd year at Uni, in good old '96 I had a P5 with W95 in my dorm room.
Granted, not mine, but the friend and colleague who had it was not some rich
parents kid, just middle class. We played HOMM2 on it all day long, much to
his gf dismay.

------
bane
All of the answers here are missing something. In the old days, the OS was
often on a ROM that was simply mapped into some unified memory location. Thus
the system went from a state of "off" to "ready to go" pretty much
immediately. There wasn't a need to copy the data from the ROM to RAM and then
execute some stuff to get into an initialized mode.

If you hunt around a bit for things like "atari 800 memory map" you can find
diagrams showing how this all worked. In fact on some systems, you could
selectively map certain things from ROM into the memory map to get more RAM if
you wanted.

Today, the move to put the OS onto disk, the memory hierarchy, and virtual
memory eliminate this approach. You basically have to let the virtual memory
system map things from disk into some page space, and often things need to be
copied into RAM, work their way up the cache hierarchy and be executed
somewhere in order to set the system into an initialized state. I've honestly
forgotten nearly all of the details so maybe somebody else can provide a
better explanation.

So the reason computer can't boot instantly:

1) We have a complex memory system these days that prevent mapping the OS into
the memory address space.

2) OS's aren't in ROM anymore. They sit on disk in a state different than when
under operation.

3) Simple engineering willpower. Nobody wants to bother to figure it out
because once the system is booted it doesn't really matter (with modern sleep
modes and whatnot).

~~~
animal531
I just built a new desktop PC (albeit with great parts) and it boots to a
usable state in Win10 in just a few seconds. To be honest it's good enough to
no longer worry about it.

Of course mileage on a laptop with non-quality parts will vary.

~~~
MrMember
Windows on an SSD is pretty amazing when it comes to boot time. My computer
spends more time on the BIOS splash screen than it does booting Windows.

------
kstenerud
There are a number of reasons:

1\. Hardware

Hardware is a big problem for boot times. Most hardware is poorly
standardized, or not standardized at all, or doesn't even follow the
standards, or tries to be backwards compatible with older hardware, or is just
plain buggy. This means that the initialization code has to poll and retry and
work around a whole bunch of things just in case the hardware happens to be
slow in responding or gives a weird response. This is the main reason why POST
is so godawful slow, and why the initial linux boot sequence takes so long.
Apple hardware can boot quicker because they control what hardware is in the
machine and can optimize their initialization code for it.

2\. Software

The operating system stack is HUGE. There's a LOT of state that needs to be
initialized, and most of it is not very efficient (we tend to optimize the
runtime operation vs the startup operation of a software package). You
absolutely could cut the software component of an OS boot sequence by an order
of magnitude, but the development costs would be massive, and the gains
pathetic in terms of the work-over-time the machine will do over its lifespan.

3\. Protocols

A large number of the protocols we use for inter-process and inter-device
communication have poorly designed latency characteristics. Either they are
too chatty (requiring multiple messages back and forth to do a task), or have
ill-defined timeouts (requiring clients to wait longer than they should), or
ambiguous states, or some poorly built implementation has become the de facto
standard. This is an area I'm personally tackling.

4\. Formats

We use a number of formats for the wrong kinds of things. Appending to a tgz
file, for example, has horrendous time implications, especially as the archive
size grows.

~~~
catern
This is a really good summary of some of the main reasons - more interesting
detail than many of the other comments here.

Now what would really be interesting is if we had the same kind of knowledge
about the typical causes of userspace software and distributed systems being
slow to start. In my experience, for proprietary software, it's mostly because
people inserted random calls to sleep()...

------
verisimilitudes
Windows is a bloated mess, so it's obvious there.

As for anything POSIX, it's because UNIX is shitware; it took a long time to
boot decades ago and it takes a long time to boot now, because more garbage
has been piled on top.

It's possible for a good operating system to boot in less than a second,
however. People have simply been conditioned to accept this unacceptable state
of affairs, no different than a TV that takes ten seconds to become usable for
no reason other than the manufacturer was lazy.

~~~
galfarragem
I still remember the day I got a new TV (despite old CRT working) for my
parents and see their faces the first time time we turned it on. Now they are
used but at the beggining the boot time was difficult to grasp: it used to be
negligible with the _obsolete_ tech..

~~~
tempguy9999
I'll beat that: I was watching a modern flat-screen fancy tv. It blacked out
and rebooted while I was watching. Screw startup if they can't even stay up.
OMG TVs can now crash...

~~~
amiga-workbench
Not to defend that, but it reminds me of a project for the raspberry pi that
would let it output teletext signals over its composite port. The original
version was a bit buggy and would crash the onboard computer in CRT TV's.

------
mojuba
A bigger question for me is, why can't monitors boot instantly? So annoying
that a monitor that went to sleep can sometimes take 10-20 seconds _longer_ to
wake up than the computer it is attached to.

~~~
gruez
If it's really 10-20s, I'm guessing it's because it's because it's cycling
through the various input sources looking for a signal.

~~~
ebg13
But it could just look at all of the input sources at the same time. And
anyway, these are solid state electronics, not hamsters and flywheels. Taking
seconds to send "give me electrons" and for the other side to say "here are
some electrons" is bonkers.

~~~
jamesissac
Being able to observe all inputs sources at the same time requires extra
hardware(more utilisation of the FPGA resources), considering only one input
is connected to the display at a time. So it's probable that the check is
sequential.

~~~
ebg13
"More" isn't a meaningful qualifier without a quantifier. I'm not convinced
that it would take more than $0.01 worth of resource. I could even see doing
it in a purely analog fashion with an extremely basic component like a mosfet.
If a pin goes high because the computer responded to your request to send
electrons, it sets the corresponding channel.

> _So it 's probable that the check is sequential._

It's a user unfriendly design for the process to be "send request, wait 5
seconds, send request on next channel, wait 5 seconds, send request on next
channel, ..." when it could instead be sending requests across all channels
rapidly and then that getting a response on a particular channel _activates_
that channel by analogue means.

------
CGamesPlay
A lot of these answers are why computers _don’t_ boot instantly but none
really talk about why they _can’t_. The accepted answer talks about it on a
physical/mechanical level but eschews practicality: what can’t computers boot
arbitrarily quickly?

~~~
enneff
They can. But the more software you need to initialise the slower it is. And
modern machines run a lot of software.

~~~
adsche
But then the questions are, why does it need to initialize? Why doesn't it
start in an initialized state, what factors make it impossible to determine
that initialized state beforehand and storing it? How close can we get?

~~~
magicalhippo
As an example, consider the PCIe bus controller. Say it had some non-volatile
memory so that when it powers on, it just reads the bus configuration from the
NVM instead of enumerating and initializing the devices on the bus. Lots of
time saved.

Well that wouldn't really work without the PCIe devices also storing the
configuration in NVM. If I plug a x16 device into a x4-only slot (as is
typical for the third PCIe x16 slot on motherboards that have it), the device
needs to know it has to only use 4 lanes, not the full 16.

Ok, so say the controller has some way to tell the devices to save their
state, and when powering on they all read from NVM and can just go on talking
with each other right away, no further initialization required. Yay!

Except then you power off your machine, and swap that GPU for the new one you
bought from your friend. Now the new GPU has the configuration from your
friends motherboard, and your bus controller has no idea about this new
card... so this is doomed to fail.

Of course this could be worked around by querying the bus for the devices we
expect to be there... except that's the initialization step we were trying to
avoid in the first place...

~~~
cesarb
All that PCIe enumeration takes much less than a second, in my experience. The
current boot on the machine I'm using to type this took only 2.3 seconds for
the kernel part (source: systemd-analyze).

~~~
msbarnett
Enumeration, yes. But then you need to load and initialize all of the drivers
for the stuff you just enumerated.

------
kerkeslager
I remember when Ubuntu was first becoming popular. At the time, Windows boot
times were long--I don't have timings, but my memory seems to say something
like 5 minutes. And Intel processors were in the middle of their highest-
energy-use period, so they ran _hot_ , meaning you couldn't just leave your
laptop on all the time. So reboot time was a significant part of my experience
as a Windows user. When I first booted Ubuntu, the boot time was fast,
something like a 1 minute, and later I tried Xubuntu which was closer to 30
seconds. This was an advertised advantage of Ubuntu, and it was a big part of
why that was "the year of desktop Linux" (if only for me).

In the following years, I noticed significant improvements both to boot times
in Windows and to their "sleep"-type features. I suspect this was motivated at
least in part by competition from Ubuntu.

~~~
bonoboTP
> I suspect this was motivated at least in part by competition from Ubuntu.

Ubuntu has such tiny market share that I strongly doubt this.

~~~
dannypgh
Ubuntu and Linux may have a small market share in the general population, but
they enjoy a larger share among software developers. And we all know
("developers, developers, developers!") MS has chased that demographic.

------
mehrdadn
More interesting question to me is why the hell some firmware boots take so
long now. I know laptops from years ago much, much faster than what I have
now, which is otherwise much faster than them. And the firmware initialization
times for some servers I've seen seem completely obscene (on the order of
minutes).

~~~
aardvarklegend
Surprisingly power is a huge factor. Spinning up 48/96 drives on boot can
surge beyond what power supplies could handle, so things supported staggered
spin ups. This allowed huge banks of drives to start without blowing a power
supply, but you don’t know how many drives or if staggered spin up is enabled
until it times out. This was a huge boot delay for servers.

~~~
mehrdadn
That's interesting to note, but I'm just talking about computers with 1 drive
connected to them. Both for the servers and the laptops. In fact the older
(faster) laptop had both a DVD and an HDD, whereas the newer one just has an
SSD...

------
ohiovr
My POST sequence takes longer than the boot process so no matter how blazing
fast my drives are it still takes a long time to get to the boot loader.

~~~
faissaloo
Nail on the head, UEFI/BIOS is increasingly the bottleneck for startup speeds
nowadays

------
air7
This is a good question, and the "answer" avoid it by essentially saying "it
can't be zero."

Why does boot time take ~10 seconds? CPUs run in GHz, meaning 10^9 operations
per second. That means that booting takes around 10^10 operations. Why that
order of magnitude and not any other? Obvious answer is "that's where the
optimization efforts stopped", but could it be 10^9 or 10^8?

Obviously booting time isn't just (or mostly) CPU, but the question extends to
other peripherals: Harddrives access is in the 10^8 B/s range. RAM is 10^9
B/s. USB ~ 10^7 B/s. Wifi 10^6 B/s. etc. Why does booting, with all it's
internal sub processes still take ~ 10^1 seconds and not any other OoM?

~~~
Veedrac
10⁹ ops/s is an incredible underestimate; CPUs tend to have an IPC around 4,
and at least two cores, even on mobile. Which means at 3GHz, you should have
closer to 10¹¹ ops/s.

The real question is not whether a computer can boot in a second, it's whether
it can boot in a frame.

~~~
fulafel
Actual observed IPC tends to be 1 or less unless you are running well tuned
computational workloads. And mostly software doesn't utilize multiple cores
well.

~~~
Veedrac
Even ‘perf stat libreoffice ./somedocument.odt’ give an IPC of almost 2, and
that's hardly a well-tuned computational workload.

> And mostly software doesn't utilize multiple cores well.

Most software sucks, that's the point of this whole conversation.

~~~
fulafel
Valid correction, seems I was out of date, let's say 2 or below today. (I got
1.3-1.7 with a few libreoffice startup & command-line conversion experiments).

However during the boot process I think the IPC will be notably less, because
there will be periods of waiting for disk IO and hardware initialization
waits.

To zoom out, there are two dimensions here - it's good for software to run at
a good IPC, but even better to do the job with fewer instructions.

~~~
Veedrac
Sure, I think the point of measuring CPU speed is not to say that it suffices
for a fast boot, but to say that whatever it takes to boot, the CPU should not
be a limiting factor.

When I think of all the things necessary to booting; discovering connected
devices, loading drivers, setting up memory and permissions, loading
filesystem data, starting up the graphics hardware, ... I struggle to think of
many things where ‘a few milliseconds’ is not plenty of time. For sure, you
might have electrical limitations, spinning disks might take multiple
milliseconds, and loading dozens of megabytes of data is not instantaneous,
but, really, you've got _16 whole milliseconds_ in a frame at 60Hz! Is that so
much to ask for?

------
jokoon
Further question would be:

"If I saved all my work, why do I need to properly shut down my computer? Why
does it take so long to shut down?"

------
Bakary
A silver lining of long boot times is that you can contemplate what you are
about to use the computer for and catch yourself in the middle of a habit
loop.

~~~
kalleboo
I bet adding a 15 second wakeup time to my smartphone would abort about 75% of
my social media usage

------
swebs
>When you turn on your computer, it instantly executes code in BIOS or UEFI
boot manager. It doesn't take much time to execute BIOS or UEFI boot manager.
It will initialize your hardware, scan your storage devices for operating
system, and run the operating system. It is usually the operating system that
requires much time for loading.

Eh, it takes from 10-15 seconds on my computer from pressing the power button
to getting to GRUB. After that, it's only another 10 seconds or so to boot
Ubuntu.

~~~
tsjq
> it's only another 10 seconds or so to boot Ubuntu.

that's nice.

is that on SSD?

~~~
swebs
Yeah, a Samsung 840.

------
basicplus2
My old valve televisions are up and running long before ANY smart tv, AND its
quicker to change channels

------
vilhelm_s
It could probably be faster if people cared to optimize it, e.g. some
experiments to boot an embedded linux system to the console prompt in less
than 1 second ([https://fossforce.com/2017/01/linux-zero-boot-
second/](https://fossforce.com/2017/01/linux-zero-boot-second/)), or to the Qt
Camera Preview app in 3 seconds
([https://www.e-consystems.com/Articles/Product-
Design/Linux-B...](https://www.e-consystems.com/Articles/Product-Design/Linux-
Boot-Time-Optimization-Techniques.asp)) or to a Debian desktop in "5 seconds"
([https://wiki.debian.org/BootProcessSpeedup#Tests_results_of_...](https://wiki.debian.org/BootProcessSpeedup#Tests_results_of_users)).

------
cookingrobot
Here's a proposal.. Don't do any network stuff during boot, and don't let it
depend on anything super volatile like user files. Then store the boot memory
state as an image (like a hyberfile). Whenever a bigger change happens to the
system that will affect the boot state, like installing a new driver, or an
app that has any kind of background service, recreate a new boot image. But do
it right away when the new app is installed, don't wait for the next boot, or
shutdown (which is annoying), just do it in a virtual machine right away as
part of the app/driver install. Installing impactful apps will take longer,
but that can happen in the background and is not too disruptive, and doesn't
happen very often anyway.

------
kzrdude
I'm pretty happy with boot times, the longest wait is the boot loader and
inputting the password. (Linux with full disk encryption).

------
MrQuincle
The more optimization in boot times, the higher the maintenance burden.

I think this can only be solved on an architectural level by introducing
"specialization" in a "general" manner. In other words, have a supervising
process monitor times and adjust the system to the local hardware and software
demands. The adjustments to be good probably require some kind of learning
mechanisms, which you also don't want to have in a kernel itself. Just my two
cents.

------
usernam33
This reminds me of something I read about memristors. Once they get cheap and
fast enough to be sold in gb or tb sticks they might replace ram and
ssd's/hdd's for some computers. This would allow a computer to boot once (at
the factory) and then just return to the state it was when powered on again.

------
fulafel
Trivia: some compuers have a single level memory store, so there are no
separate disk and ram concepts from se PoV. I think as/400 and maybe Multics
are like this. But i don't know if they boot instantly from whete they left
off, probably not. It would be within relatively easy reach though.

~~~
trn
For new install and first (cold) boot for a Multics system, the system is
loaded from a Multics System Tape. As part of this process, the entire MST is
loaded in Multics memory; Multics is partially started up to configure all of
hardcore for the current hardware configuration; Multics then transfers back
to BCE without shutdown.

BCE captures this configured Multics hardcore memory image, and saves it to a
file in the BCE disk partition. BCE then returns control to Multics hardcore,
so it can continue system start-up.

Subsequent (fast) boots from BCE boot the preconfigured Multics memory image,
loading it from disk into memory, and transferring into the image, just as was
done when the image was first saved.

------
gregw2
If computer makers put the OS in ROM memory rather than RAM and had a well
defined way of overlaying the two so the ROM state could seem to be modified
by writes to RAM, you could get instant boot. Early PCs worked that way like
the Commodore64, right?

~~~
unilynx
The Commodore didn't copy itself from ROM to RAM, but that was a trick you
could do yourself to speed up BASIC execution - the RAM was faster than ROM

------
sansnomme
I have a question too: why does radios take so long to start up and acquire a
signal? Same for other I/O devices similar to radios，on the embedded side you
have keep on polling until finally it acquires the signal.

~~~
simcop2387
One common thing is that the radio needs time for it's clock source to
stabilize. To make them cheaper they usually use things like phase locked
loops to take a lower frequency clock and multiply it up to the clock they
need. This can take tens to thousands of milliseconds to bnot be bouncing
around when first configuring the loop. And with modern radios, these loops
get programed at run-time from the firmware because they need to be at a large
range of frequencies. During this startup you can't transmit anything, because
you'll transmit with another signal (the clock jitter) mixed in which adds
noise, at best, and possibly even at a completely incorrect frequency which
will result in fines or possibly jail time. The safe route is just to wait
instead.

Receivers work similarly, using PLLs to downmix the signal they want,
generally, and while they can begin trying to receive while waiting on it to
stabilize, it's usually pointless because you'll just be getting
unintelligible garbage from the noise or wrong frequency.

------
tbyehl
What gets me is how long servers take to reach the bootloader from power on.
Your average modern Dell/HP desktop or laptop is there within a second or two,
Windows 10 and systemd-based Linux distros on SSD can be at the login prompt
within 5 seconds total. I haven't touched a Mac in a long time but I'd bet
they're no worse.

But a typical server BIOS takes 3-5 minutes do its thing. If you're lucky you
might be able to disable enough stuff to shave off a minute. Insanity.

~~~
kalleboo
I bought an old 1/10 Gbit managed switch for $25 on an online auction to play
around with, and was surprised just how long (minutes) a _switch_ can take to
boot.

~~~
tbyehl
A managed switch is basically an embedded server with super-slow storage. If
it's of a certain age you might pop the cover and find a CompactFlash card.

I run my most critical piece of home infrastructure (PiHole, of course) bare-
metal on an ancient NUC-like thing with a $20 SSD because it boots and is
responding to network requests in like 6 seconds.

------
Doubl
Hibernate is my preferred option when going off the computer but Windows
doesn't offer it out of the box and more. You have to tweak settings. Why is
that I wonder?

~~~
tsimionescu
My understanding is that on Desktops, the default is for Sleep to do 'Hybrid
Sleep' \- prepare for a hibernate, but sleep instead; if you have a power
failure while the computer is sleeping, you should see it waking from. The
hibernate when you turn back on, instead of booting from scratch.

I know that this was the case at some point when I checked during the Windows
8 years, I don't know if this is still true.

~~~
Doubl
Interesting, I'll investigate

------
bin0
Let me take a moment to vent on the garbage that is the dell UEFI firmware. I
have an excellent, new machine, an XPS 15 9570. According to systemd-analyze,
it took eight seconds to get past firmware, corroborated by my observations.
There is flat-out no reason why it ought to be so slow. Dell makes the
absolute worst BIOS.

------
mschuster91
You can do warm boot images (Sony's Linux-based Alpha cameras do this, for
example), but these have to be tailor-made for each model... feasible for a
camera manufacturer, impossible for a Linux distribution.

But I do wonder why WBI generation and automatic usage upon first boot isn't
more common (or possible at all)...

~~~
flowless
GoPro cameras run RTOS and one of the threads run Linux which is cold booted
only once (or during an update) and stored for next fast hot boots - it was
only used for providing WiFi and streaming functionality.

------
lazyjones
All this guessing and conjecture is pointless. Someone should simply measure
what takes so long with the profiling tools available and post an analysis.

------
jasonhansel
The real answer: the cost (in developer time) of making computers that boot
instantly is too high to justify the benefits.

~~~
orbital-decay
Yes, but it's just one of the factors, and actually all major user-facing OSes
do care about boot times. Other factors are the design by committee and
platform fragmentation. Hardware manufacturers don't care about initialization
times, and standard makers are issuing insanely complex specifications with
lots of compatibility cruft and edge cases.

------
thrownhwn
Has someone explored the area of writing software that spits out resume from
disk images?

~~~
amelius
You mean hibernation?

That exists for a long time now, but is technically not booting.

~~~
jarfil
Alternatively, booting is just an inefficient "resume from disk", using a
generic initial state instead of one adapted to the device.

------
niklasd
The link in the answer titled "state machines" is a bit misleading, since it
directs to the Wikipedia entry about Finite-state machines. But most computers
(the ones we are talking about here) are Turing complete rather than being a
(computationally much more limited) finite-state machine.

~~~
muthdra
[https://en.wikipedia.org/wiki/State_machine](https://en.wikipedia.org/wiki/State_machine)

------
thecopy
Because of state.

------
imtringued
Because everything takes non zero time. If a state transition from turned off
to booted takes no time then doesn't that mean there is no state transition at
all? The only way for it to take zero time for a computer to boot is if it is
already booted or there is no difference between an unbooted computer and a
booted one.

How much time does it take for a circle to become round? None at all. It
happened instantly.

~~~
jarfil
It also takes hours to compile everything from scratch, but we don't see
computers taking hours to boot, do we? Most of the process "from initial
state" is cached, and there is little reason to not keep the trend.

Booting, as in detecting and initializing the hardware, including the RAM,
should only be needed when hardware is changed, and even then it should be
possible to cache the state of any unchanged parts.

