Honestly, I've had better luck on the bleeding edge. Newer Linux kernels almost always are better (and when they're not, it gets fixed quickly). Wayland is definitely better than X. Newer Gnome is better than old Gnome. Ruby 3 and 3.1 is definitely better than 2.7. Rails 7 is way better than 6, even in alpha state. Deno is nicer than Node (although the ecosystem needs to catch up). Hell, V8 and then Node led to a boo…
Life is too short to depend on unstable software
81–90 of 175 posts
Re: Life is too short to depend on unstable software
#82Earlier quoted context omitted.
It is nowhere near as simple as you make it out to be. Yes, the freedesktop runtimes ship extensions with newer versions of Mesa and its dependencies. This doesn't entirely solve the problem. For one thing, libstdc++ before GCC 5 did not maintain a backwards-compatible ABI, so if the app was compiled too long ago it won't work with a new libstdc++. Steam is now working around this problem by using dlmopen() namespace…
> NVidia client-side library must exactly match the version of the loaded kernel module Sure about that? I was sure I’ve run Docker containers with GPU stuff compiled for different versions than my driver. Like their nbody container image runs every time I set up the nv container runtime with Docker, regardless of driver version.
https://docs.nvidia.com/datacenter/cloud-native/container-to...
Re: Life is too short to depend on unstable software
#83Earlier quoted context omitted.
Do you have nay more details on this? I am very curious.
I still have the Mac. It's now over 35 years old! Remember that the computer only had 128K of memory. There were like three applications. MacWrite, MacPaint, MacDraw. MacDraw was the most crash-prone. What else might you like to know? I'll have to dust off some old neurons.
Re: Life is too short to depend on unstable software
#84In theory we all mostly agree with this: stable, well understood software is to be preferred. In practice , it's not true most businesses or teams want newer software just to be "on the bleeding edge". The bleeding edge is not a goal on its own. What usually happens is that you need a feature (for actual business reasons) that is not available in the older version of the software you are using; or there is a serious…
people deployed new machines with new stacks at the building I'm, most things are better except for a few conflicts which turn some tasks 3x slower
people don't mind about things unless they cost them too much
Re: Life is too short to depend on unstable software
#85we believed that continuous integration/continuous deployment (ci/cd) will only bring good. but we started optimizing for metrics such as profit, ignoring actual customer issues. we started solving issues that are not real customers issues. people claim that software in the past was very unstable. sure, but let's start putting some context and numbers around these claims. or at least cite such software. in fact, let'…
maybe android web players are better than winamp but every month there's a new one which differs a bit, the others will update and modify lots of things just because they can and there's a new fad.
the experience of 90s software was obviously slower, more risky too (if you had a bug you had it until the next service patch 18months later). But it made people make long term choices and you as a user enjoyed a longer trip on the same plane. Humanly it feels more fulfilling (even though technically, I got less new features per month than with Chrome pace for instance)
Re: Life is too short to depend on unstable software
#86Huh, I have the opposite impression, particularly if the project has a CHANGELOG of the breakages. Smaller releases are easier upgrades, and the changelog tends to indicate what call sites require investigation/changes prior to upgrading; projects with absolutely massive amounts of breaking changes that require rewriting everything are so much more painful.
Re: Life is too short to depend on unstable software
#87Users of only "stable" FOSS releases almost never contribute, in code, or to its health or longevity. They are leeching it, sometimes over decades. They don't contribute to testing either, since they just consume releases and ignore development, then wonder loudly why there are bugs. Don't be that guy... if you want your dependencies to have a long life being maintained, find some time to contribute. Leeching is not…
I don't bother filing bugs or sending PRs. I spend hours filing a detailed bug report. No response. I spend hours crafting a PR. Ignored. I file a bug report along with several possible solutions. I get a snarky response totally unrelated the proposed solutions. But I get it. Maintainers are overworked and jaded. I'm on the receiving end as well, with 95% of the issues like: "help, it's broken" (with no error message…
But I've also had maintainers who were very helpful. Recently had to deal with the DST cross-sign expiring, and needed a third-party container to be rebuilt on a later version of Debian. Filed an issue with really nothing more than "Would you mind releasing with a newer version?"¹ and the maintainer had it published within like a day! Greatly made my life easier.
So I really want to separate out those maintainers that are doing a stellar job; certainly some merit your criticism, just not all.
¹I didn't have time then to track down the Dockerfile & figure out the required patch. Might have once my time freed up, but the maintainer beat me to it.
Re: Life is too short to depend on unstable software
#88Honestly, I've had better luck on the bleeding edge. Newer Linux kernels almost always are better (and when they're not, it gets fixed quickly). Wayland is definitely better than X. Newer Gnome is better than old Gnome. Ruby 3 and 3.1 is definitely better than 2.7. Rails 7 is way better than 6, even in alpha state. Deno is nicer than Node (although the ecosystem needs to catch up). Hell, V8 and then Node led to a boo…
Same experience here. Everything is just better when I'm running the latest software. My system is not "unstable" either.
Re: Life is too short to depend on unstable software
#89Honestly, I've had better luck on the bleeding edge. Newer Linux kernels almost always are better (and when they're not, it gets fixed quickly). Wayland is definitely better than X. Newer Gnome is better than old Gnome. Ruby 3 and 3.1 is definitely better than 2.7. Rails 7 is way better than 6, even in alpha state. Deno is nicer than Node (although the ecosystem needs to catch up). Hell, V8 and then Node led to a boo…
I have the same experience, my linux experience (as an user) improved by an order of magnitude when switching to Arch which has the same bleeding edge philosophy.
I think there needs to be a trade-off between bleeding edge and stability and I find that Gentoo tends to hit it on the head. I've yet to have the system break anything for me without explicitly warning me before hand, providing me a full mitigation & migration plan, and then requiring me to explicitly continue.
Arch has been pretty stable in the past but I've had problems come up numerous times due to the bleeding edge philosophy.
Point being that you should really only be going as bleeding edge as your community can reliably audit and provide support for. I think Arch toes that line most days and sometimes hops past the line. Gentoo however tends to stay a few steps back from the line and gets close to it but never actually steps over it. And then most other distros are sitting comfortably half a mile back.
Re: Life is too short to depend on unstable software
#90I've been thinking about learning Crystal recently and using it for a personal project. However, now that I have lots of experience with Node.js, Golang and others, I'm torn between the "use what's mature" and "learn a new language" decision. Sure, I'm using Crystal now to learn a new language, but what if this becomes a serious project? Anyhow, I agree with this blog post somewhat but it's always good to expand your…
For example, instead of Crystal, you could try something like Common Lisp or Haskell, both of which are really, really stable.
I would even put Rust into the "stable" category... they value backwards compatibility very highly, while allowing breaking changes to happen in newer "editions" of the language (without breaking code written for previous "editions"). Stable does not necessarily mean old.