I have great respect for Dr. Stroustrup. C++ was a really, really good thing in its time. But I think its time has come and largely gone at this point. It's simply grown too big for ordinary mortals to be able to use safely, not just for writing new code, but interacting with legacy code.

I find that a lot of Linux software is written in C or C++ for reasons I don't quite understand. Managed languages/tools seem so much more productive to me. And most toolkits such as Qt, Gtk, SDL, wxWidget, etc. have perfectly good bindings to higher-level languages. I don't really get why anyone would use a memory-unsafe and very complicated language just to be able to draw some pixels on a screen, for something like a typical LOB database front end where performance really isn't an issue.

It's possible to do the first, but only a limited number of people actually can, and, I'm not either one of them.

I'd be able to do a passable job of writing modern C++.

But working with other developers whose subset of C++ is different from mine and/or each other's? Probably not so much. Because the entire language is MUCH too bit to fit into my head.

I've inherited unsafe C#, but haven't ever needed to write any myself. I have done a very tiny bit of C, called from C#, to interface with bespoke hardware that would have been otherwise difficult to control from a non-hard-realtime OS.

Most of the rest was to wrap calls around the Win32 API, and, ironically, I found that the managed framework was quite capable of similar functionality via safe, managed code.

Also, a lot of that old code did things like using ints rather than IntPtrs, or otherwise assuming a 32 bit word size, which caused it to gradually rot over the past couple decades. So over time it's tended to be replaced anyway, and, along with it, most of the "Heisenbugs" caused by crapping all over somebody else's memory.

That is my feeling as well. C++ is useful when you need something that can be a high and a low level language at the same time. But that's pretty rare, because you can almost always use higher-level languages for the bulk of the code, and drop down to C or Rust for the spots where something close to bare-metal performance is needed (e.g., when you aren't waiting for a network packet, a piece of user input, or some spinning ferric oxide.)

I've needed to drop to C only once in my very long career, and that was because of a hardware interface that needed deterministic real-time signaling.

Inhaling any form of asbestos, in any amount, is bad news. Asbestosis, lung cancer, and mesothelioma are just a few of the reasons why. And the resulting sequelae can take a long time, sometimes several decades, to manifest.

Perhaps you need another cup of covfefe?

Interesterified "oils" and tropical oils/fats, most notably palm oil.

And more sugars and salt.

And coming soon: a return to animal fats from factory-farmed animals who spend their whole lives stressed and sick.

Even in allegedly "plant-based" products (some of which aren't any more healthy than their animal-based counterparts to begin with).

Ultraprocessed food is really, really bad news. Much more so than most folks realize. So are factory-farmed animals.

I'm also fine with Linux distributions not appealing to the masses.

At the same time, though, I think there are a lot of things we could do better, and some of those things would broaden the appeal of desktop Linux to a wider variety of users, without detracting from its appeal to more traditional users like myself.

The kernel can typically run forever without issue, as can most mature services, if sanely configured. However, end-user apps sometimes can't. I would probably reboot every month or two even if I didn't do that already for kernel or toolchain updates (which are frequent for me, because Gentoo gives me the choice to remain fairly up to date if I wish).

But I've seen uptimes of many months, even years, on systems that didn't need kernel upgrades. The teamviewerd daemon always flakes after a couple months and no longer allows copy/paste, but everything else seems fine.

YMMV.

There has been slow but steady progress toward that goal for a long time now.

HTML/CSS/Javascript apps don't tend to care that much about the underlying OS, and it's possible for most well-written apps using modern, higher-level platforms (including but probably not limited to that stack plus C#/.NET and Java) to be ported to multiple architectures with, at most, relatively modest difficulty.

I use nothing but Linux at home, but at the office, I have one of the last remaining Windows 10 systems here. Everyone who's been "upgraded" to Windows 11 hates it.

We have a piece of software designed for tablets, based on WPF (the ONE major non-cross-platform thing in modern .NET), that ran perfectly before. The Windows 11 "upgrade" causes the on-screen keyboard behavior to be entirely non-deterministic, depending in part on what tablet model, whether or not an external display is connected, whether or not an external display has ever been connected, and numerous other factors we think we know as well as some we very likely don't. Users see this as a problem in our software that we need to fix, but it is a problem we did not have until Windows 11, and probably can't be fixed in our code due to lack of reliable APIs. It's probable that the only real fix will be long-term, and will be to do what we've started to do anyway, which is to slowly migrate many of our desktop apps off of Windows and into HTML5/JS/CSS.

I didn't move to a *BSD on account of systemd, but I did stick with a distro (based on Gentoo) on which it was not required, and that was part of the reason why. If not Gentoo, then Devuan would have been my second choice.

(Wayland also is not required; I would like to switch when I think it's ready, but as yet I don't, chiefly because XFCE has not yet been fully ported over.)

I'll try to be respectful. :)

While I agree that most "regular users" aren't a great fit for desktop Linux, your information is quite out of date. Ubuntu 10.4 is well over a decade old, and modern Ubuntu will install without difficulty on any supported modern hardware, as will Debian, Mint, and any other distribution designed for desktop use.

Also, arguably, "the year of desktop Linux" arrived as soon as Android and Chromebooks came out. They're not Linux as you know it, necessarily, but they are Linux under the covers, more or less, and they are proof that an end-user-friendly Linux is possible, although traditional users such as myself aren't crazy about the level of dumbing-down and choice-removal that would be needed in order to make it universally popular.

I for one am OK with the way things are playing out. I don't want Linux to be more popular if, in order to do so, it has to stop being Linux.

But my wish list: (a) Wayland is finished and somewhat de-fragmented (most compositors implement a sufficient API and in the same way so coders can code to it without relying on a specific desktop environment). (b) Systemd dies horribly in a fire. (c) We continue to have desktop environment options other than KDE and Gnome. (d) Most software that can become Web-based does so. (e) Hardware vendors finally figure out that desktop Linux, while maybe not the biggest part of the desktop market, is still well worthy of their support. (f) The recent moves away from software freedom get smacked down in courts all over the world. (g) We eventually standardize on more or less one of the modern packaging formats (AppImage, Flatpak, or Snap). (h) Python gets a modern packaging and deployment story. (i) People gradually stop using C and C++ where they don't belong; most end-user apps should use mostly higher-level, and safer, languages.

I'd argue that while both Windows and desktop Linux have improved over the years, Linux still has the slight edge in terms of reliability (in spite of systemd). It wins easily on the security front (again in spite of systemd) for multiple reasons, including that it does not attempt to phone home and sell your data, that most of the core of desktop Linux is open source, and that fragmentation has caused it to become a very difficult target to attack, though you're of course correct that dumb users can poke security holes through pretty much anything if they try hard enough.

Ironically, I think it's the cost issue that I think drives a lot of folks to Windows. There's a learning curve to Linux, and that costs money and time that many users and organizations don't want to pay, even though it can and should be viewed as an investment, and even though the Microsoft forced-upgrade and monthly subscription costs may end up costing far more over time.