I've always wondered (seriously, not rhetorically) which are the technical grounds that make Windows update so bad.
In addition to reboot loops:
- WU has a long history of hanging; it took I think a couple of years to release the "final" patch for update hangs. I'm not even sure if it works; I wouldn't bet that a machine with Windows 7 would be able to download all the updates without hanging or taking days (we're talking about around 100 updates; apt, for reference, manages a pool at least 2 orders of magnitude bigger)
- the workflow is not deterministic; updates may or may not succeed
- the UX is abysmal: the status descriptions are unclear; the progress percentage doesn't reflect the actual time, or is disbalanced towards stages which don't make evident why they take so much time; the error messages are completely unhelpful.
- it's also completely unclear why some updates need to be applied both after shutdown and before startup.
"Thankfully" they gave the option to download them once a month, which all in all, equals to choose between usability and security.
The rationale goes like this: If you confront users with error messages, they get confused. The more technical the message, the worse the confusion.
Now what Windows does is to hide everything, ignoring that to be able to do that, your systems must never ever have any errors, lest you throw away useful information. I've got a Windows 8 installation I can't upgrade to 8.1 because all the update system does is not install the updates. There's no telling why -- the next time it still sits there telling you "by the way: there are updates you should install".
Contrast this with "user unfriendly" linux updates: They tell you loud and clear that things didn't work and give you a message you can google, if nothing else. OTOH, the Windows side of things involves reading tea leaves, clearing obscure chaches, wondering if mercury is in retrograde, deleting or adding random registry keys and in the end doing a totally new installation anyway.
In general terms, I think it's subpar in terms of usability, at least, when talking about "Google standards". Going down to details:
1. the web interface uses a sort of "dark pattern": it enforces delayed updates, to the point of ignoring user requests for refresh; when the user clicks on the refresh button, s/he'll see the spinner in action, but when it stops, there's no guarantee that the updates have been sent - in fact, attempting to close the browser at the point frequently shows a browser alert, then the spinner will spin again for the "real" update. It's a matter of seconds actually, but it gives the impression that the program is "lying" to the user.
2. the automatic recognition is extremely annoying when a note includes numbers and symbols that don't represent phone numbers/email adresses - Keep will forcefully recognize them as such, so that when one clicks on an auto-recognized string, a dialog will pop up, forcing the user to click Cancel, then hope that the landing character is the right one, otherwise, when clicking on another character, the popup will show again.
3. the reminders workflow is bizarre; it assumes that the main use case is the user setting alarms at four semi-fixed (fixed but customizable) times of the day. this doesn't really make sense to me, and adds one extra stage in the setup
4. at some point it seemed they introduced a clever reminders workflow - when the user would add one, the default would be around three hours from creation (with the exception of the night). this is not stable though - sometimes, the three hours interval is not respected.
5. I recently hit a bug where, when I select it from the Android task manager, the window closes.
Point #2 is definitely the worst for me; it really bites me on notes that include numbers and are frequently updated (eg. a gym schedule); I think this is a legitimate use case.
Point #1 may be a bug, although it's in a core functionality, which makes me think that it's intended.
News flash! I've just found a bug. There are four semi-fixed times of the day; but in the settings, one can only customize three.
Practically speaking, I think there isn't (enough) dogfooding in its design. More abstractly, I really doubt that it's up to standards with a company that is supposed to have the best IT professionals in the world.
IIRC on newer versions of the OS, updates are applied on a separate partition without interrupting you. I don't know if it causes performance loss during that time, so far it has been seemless for me but I don't have updates everyday either .. Only when the update completes will the OS asks you to reboot so it can start from that new version.
Sure it uses a ton of storage to do things this way, but it is very secure and pleasant to use.
Ubuntu also completely blows itself up into an unbootable state at least once a year after updates.
Windows Update and testing suck, but Linux package management and upgrading suck just as badly. Systemd upgrade bugs seem to cause the most un-bootable systems in my experience, with alarming frequency, even on LTS servers that see little churn.
and on servers (20+ VMs and a few hypervisors, some LTS some not) I had even fewer problems. for me things got especially smooth sailing after ubuntu switched to systemd.
The seamless updates feature originally came from Chrome OS. It's easily one of the best features of that OS.
https://www.xda-developers.com/how-a-b-partitions-and-seamle...
Fun fact: The Android update_engine which handles seamless updates is basically ripped straight from Chrome OS. Only recently were strings containing "Chrome OS" removed from update_engine’s log to avoid confusion for anyone who happens to check logcat.
I have often wondered if Microsoft could use this type of system for Windows 10? Not only would it make the update process more reliable, but faster too (especially when it comes to feature updates).
The other thing Microsoft should sort out is WSUS. It is such a flaky system!
From what I understand this isn't far from what Windows 10 does? Windows doesn't use a separate physical partition because it can't trust any specific OEM or user to follow a specific partition scheme, so it uses something more of a "virtual" overlay in NTFS for big Windows changes, based on how I understand it. It's something like a partition scheme in that it virtualizes entire directories (like C:\Windows) and then swaps them. For dumb backwards compatibility reasons, Windows can't just assume that it can just outright swap one C:\Windows directory for another one, so supposedly a lot of the time in major updates is stuff like inventorying directories like C:\Windows for non-Windows stuff and copying it across to the new pseudo-partition before the swap.
And JunOS (the juniper network appliance operating system based on freebsd.) has had this since version 10.4 which was released in 2010.
The contrast with linux is night and day.
My other two top annoyances, for anyone curious, are the appalling filesystem performance and the high process-creation overhead.
How else do you prevent people from overwriting each other's changes to the same data? Whether the lock is at the file level, field level, etc., how else do you manage collisions? It seems so obvious that perhaps I misunderstand your question.
This allows running programs to be updated.
From my understanding with how the winsxs store works, almost every system binary is really a hidden symlink to the right binary in winsxs (with some having different cpu optimizations).
One of the cool things about symlinks is handles don't hold on them, they just hold on to the target, so you can change a symlink target without interrupting or getting blocked by handles that have that symlink open.
Windows update could put all the new binaries in to new winsxs loctions then just swap over all of the symlinks on next boot.
I know this works because I use it to deploy updates to a running game server binary so that the next time it restarts itself on round end it's using the new binary.
We also update the loaded dlls it uses this way.
However, Windows does allow you to rename such files. So you can rename an existing file to some random name somewhere in %TEMP%, and then put a new file with the same name in its place.
As another person said, you can rename opened files and then deal with deleting them separately.
Your Ubuntu desktop only takes security and bugfix updates regularly.
If you've tried going from an Ubuntu LTS to another Ubuntu LTS, 2+ years on, you'd find tons of things changed too -- even if your old LTS had everyday updates.
If MS did commercially release Enterprise LTSC it wouldn't sell. Instead it would just encourage piracy.
Windows follows an LTS model. It can't go changing from under pros and businesses that use it everyday...
> Your Ubuntu desktop only takes security and bugfix updates regularly.
A rolling release explicitly doesn't just provide security updates, so my point is Windows updating more core components than Ubuntu LTS is no excuse.
That's like me saying it takes over an hour to update my OctoPi instance when I remember to do it semi annually, therefore all *nix updates are broken.