• 1 Post
  • 185 Comments
Joined 2 years ago
cake
Cake day: June 12th, 2023

help-circle









  • Another time I left my computer while I went out for a walk, came back, and it was like I just rebooted… all my work was gone, and it was starting fresh from the login screen.

    Well, I’m pretty sure I had this happen once or twice in the recent past after wake from suspend I think, but it might be that my CPU is just one of the faulty intel ones.

    Either way the rest of this does not reflect my experience at all. Try distrohopping, I feel like you’ll find one that you like and doesn’t have these issues. openSuSE is always one of my suggestions, it was the one that I used for a long time when I started out as well, but tbh I’m out of touch with the more mainstream distros, I’ve only touched Gentoo and NixOS in the past >5 years. (I also specifically recommend against using Ubuntu.)

    Then I’ll open a different app, sometimes it might open, sometimes it won’t.

    Or an app will freeze for no obvious reason, and I’ll get a popup asking to wait or quit.

    Check journalctl --user, and also htop, specifically the process state, for the last one (you mention a NAS, is it perhaps stuck on IO? I’m in a fucked network where that regularly happens with my NAS.)




  • I’m primarily talking about Win32 API when I talk about Windows, and for Mac primarily Foundation/AppKit (Cocoa) and other system frameworks. What third-party libraries do or don’t do is their own thing.

    There’s also nothing wrong with bundling specialized dependencies in principle if you provide precompiled binaries. If it’s shipped via the system package manager, that can manage the library versions and in fact it should do that as far as possible. Where this does become a problem is when you start shipping stuff like entire GUI toolkits (hello bundled Qt which breaks Plasma’s style plugins every time because those are not ABI-compatible either).

    The amount of time that I had to get out of .dll-hell on Windows on the other hand. The Linux way is better and way more stable.

    Try running an old precompiled Linux game (say Unreal Tournament 2004 for example). They can be a pain to get working. This is not just some “ooooh gotcha” case, this is an important thing that’s missing for software preservation and cross-compatibility, because not everything can be compiled from source by distro packagers, and not every unmaintained open-source software can be compiled on modern systems (and porting it might not be easy because of the same problem).

    I suppose what Linux is severely lacking is a comprehensive upwards-compatible system API (such as Win32 or Cocoa) which reduces the churn between distros and between version releases. Something that is more than just libc.

    We could maybe have had this with GNUstep, for example (and it would have solved a bunch of other stuff too). But it looks like nobody cares about GNUstep and instead it seems like people are more interested in sidestepping the problem with questionably designed systems like Flatpak.



  • Distributions are not the problem. Most just package upstream libraries as-is (plus/minus some security patches). Hence why programs built for another distro will a lot of the time just run as is on a contemporary distro given the necessary dependencies are installed, perhaps with some patching of the library paths (plenty of packages in nixpkgs which just use precompiled deb packages as a source, as an extreme example because nixpkgs has a very different file layout).

    Try a binary built for an old enough Ubuntu version on a new Ubuntu version however…






  • Yes, that is true. And yet, there are C++ LGPL libraries which as you say do in principle have the same problem. It should be safe if you’re careful about not using generics in the library’s public interface, or at least only generic code that is essentially just stubs calling the real logic. (I haven’t actually tried this myself tbh.)

    In general any kind of inlined code is always a problem when doing this, even C can have this with macros, or “static final” integer constants in Java.

    I should have definitely mentioned this and Rust’s ABI stability though, yeah. As for that, keeping the same compiler version is generally not a problem since all of them are available.