Arch Linux

Anecdotally, big infrequent updates have been much more likely to cause problems for me. If you have a small update it's also easier to debug what's gone wrong when you do get problems since you have a smaller set of updates to reason about.

Ah yes, I know the feeling well. I know it sounds crass, but I see this as one of the features of Arch.

Solving this will teach you things about your computer, and computers at large, that you'd otherwise never encounter.

If your box breaks due to updates often, one of two things is wrong:

• You have a brittle install that relies on low quality or conflicting packages
• Your procedure for updating needs refinement

Let me tell you what I mean by that:

• if you build a lean system that only contains the necessary dependencies for your use case, it should be easy to track down where your issue originated.
  • Use dmesg or journalctl to search for problems
• When you update, you should read the output of your terminal and respond to it. It will typically let you know if there's any issues.

I wouldn't be half the sysadmin I am today if I hadn't spent literal weeks fixing things I broke by upgrading, changing something and rebooting, or similar practice.

The next level is finding the commits to the FOSS responsible for your problem, and pushing the fix yourself.

That being said, there have been several occasions when Arch will post an update on their homepage titled "Manual intervention required". Following the contained advice, if you're affected by the issue, will usually be the easiest path forward.

I know you came here looking for answers, I'm sorry, I don't have them for you. What I do have is encouragement, and the wisdom of someone who's gone through the same gauntlet you're going through now. Stick with it. You will succeed if you try hard enough, and it is worth it in the end.

I'd say because of the frequent updates, you've simply not run into a bunch of issues that you would have otherwise. Updates most often are a preventative measure, it's pretty rare, like you say, that you run into an issue and it then gets fixed. Because you just don't run into the issue in the first place.

I would say there's not really a difference in upgrading rarely or often. It may happen that if you update more rarely, an issue in the intermediate versions was present and already fixed, so you "skipped" having this problem. But in the end, whenever you update, the new version you get has the same chance to have an issue like the intermediate versions that you skipped. So you'd roughly end up with the same amount of issues if you only change the rarity.

However, a thing you can do is to not update when you're sure that everything is working, and update more often when you're waiting for a fix for something. That way, you increase the time period of everything working, and reduce the time period of something not working. This increases your average stability, but the drawback is that you also get security updates less often and thus you might be vulnerable to some attacks, possibly.

But also, you're talking about quite a specific issue, has this been reported properly? Most often, developers depend on user reports because they don't have the exact environment a user might have. So far, for very many projects, I've found that if you report a problem you at least get a response if not a faster fix. Is your problem properly reported at the correct places? Have you received no answer?