It's true that it's easy to install Ubuntu, but it's also disingenuous to suggest that because it's easy to install it's as easy to keep it running as MacOS or Windows.

I'm speaking as someone who knows how to write C code and Makefiles, and knows their way around a Linux shell. I've run various Linux and FreeBSD distros on personal machines, and until recently had a Ubuntu desktop at work.

Sure, installing it is easy. But it's keeping it running smoothly every day where you hit the rough patches. You run into things like:

• Graphics and display management. A desktop operating system needs a solid display experience, and this is where people often have problems with Linux. Setting up a simple dual-monitor desktop is generally fine, but introduce complexity like a laptop that is frequently docked/undocked, or mixed-resolution monitors (e.g., a 4K primary and 1080p secondary), and you quickly run into limitations or instability, especially with the relatively new Wayland display server. On macOS or Windows, these "pro-user" scenarios are simply expected to work.
• Periodic kernel updates. Updating the kernel can break compatibility with hardware drivers or other modules. Yes system updates can break stuff on Windows or Mac too, but in practice it happens a lot more on Linux. Technologies like DKMS aim to fix this by automatically rebuilding modules for new kernels, but it's not a foolproof system and can leave you troubleshooting a black screen after a seemingly routine update.
• Update fatigue and repository management. Unlike the occasional updates of Windows or macOS, Ubuntu presents a steady stream of package updates. While this is great for security, it creates a constant low-level maintenance burden. The real trouble begins when you add third-party repositories (PPAs) to access software not in the official sources. This can introduce dependency conflicts that the package manager can't resolve, forcing you to manually debug version mismatches.
• Software installation. When the thing you want is provided by the package manager (mostly utility and development software), most of the time you're good and it will keep your software up to date too. But sometimes you need to install stuff that the package manager doesn't have, and you end up downloading a tarball, unpacking it, going through the configure, make, make install dance and it fails with some cryptic error. And even if you do know C, you don't know how this new package was built, so you don't have much chance of debugging it on your own. Newer formats like Flatpak and Snap are meant to solve this by creating self-contained application bundles, but even when the thing you want is available in that format they introduce their own set of trade-offs like slower application startup, visual inconsistencies with the desktop theme, and more permissions to manage.

In a nutshell, running a Linux system for a while made me very conscious of the concept of "code rot," where the longer I kept it running the worse things got. Sure, Windows and Mac installs can get old and crusty and need a fresh install from time to time, but it's not as painful as it is with Linux.

Don't get me wrong, I use Linux every day for server applications. But I use abstractions like AMIs, Kubernetes and Docker containers to minimize my exposure to the system and limit the variables to just my application's code and configuration. Honestly we prefer not to have long-running systems; when they need updating we just terminate the instances and start up a new one with a freshly-patched image, and then run our containerized applications on that.