Linux

Linux is actually kinda designed to be less fragmented than windows really.

The reason you don't pick an install directory is because the standard is that binaries live where binaries live, dependencies live where dependencies live, logs live where logs live, etc.

All the user should worry about is where the media or whatever your program works with is.

Always try to find the apt install instructions for whatever program you want, and it's easy to uninstall with apt remove.

Apart from a few deb packages, almost everything that can't be managed via apt should be considered incomplete or experimental. If it was ready for you to just use it without issue, it would be in an apt repository.

It may seem a bit daunting to have to use command line at first, but once you're used to it, you'll realise how absolutely broken and archaic managing software on windows is. (Like seriously, it's 2024 and you're still having to fish through slow or sketchy websites to find installers for tools and drivers.)

First of all, in Linux everyone should only use software from distribution repositories (eg. via apt command in Debian, Ubuntu, Mint, dnf/yum command in Fedora etc...). Package managers will install software in controlled way and it is really easy to remove them too. And, there is usually gui app for installing apps from distribution repositories.

Second way is to use flatpak / snap. They are pretty much similar and will keep things easy.

Do not install sh packages or tar.gz if you really do not know what you are doing. These are only for expert cases.

One fundamental change coming from Windows is that in Linux, you should never worry about location where software is installed (except for those expert cases, which you should not use). They will be put in correct places always. In Linux, apps are sorted so that executables go to /usr/bin, library files to /usr/lib64 and /usr/lib, applicatoin other non-modifiable stuff to /usr/share etc. It gets quite a lot to get used to, but in long term it feels more natural than Windows way to dump everything in app directory.

My recommendation will be to install some user friendly distribution (Ubuntu, Fedora, Mint) and just go ahead with default package management things what it offers. If you see Android way handling software good, Fedora Silverblue is kind of like that - System upgrades are handled same way, and applications are installed as flatpaks.

My strategy is to always install program with flatpak, SDKs are also installed as flatpak, find graphical alternatives to command line programs. I don't use command line a lot, so I don't need fancy tools for it.

I only have one system package installed for inputting unicode math symbols. So that I have a clean and easily migratable system.

there's different ways to install things because they each have their use cases in which they're better than others (or used to have use cases)

• binary package managers (e.g. apt): fast and lightweight because it only downloads/installs the necessary binaries

• flatpak: can be installed on any distro, but takes up more storage space because they're installed in a sandbox and all the dependencies are also installed with it, for every application

• snap: same thing as flatpak but a bit worse, but some applications are only packaged for snap because canonical paid a lot of big companies to package for snap (rhey didn't incentivise against flatpak, they just didn't fund flatpak)

• appimage: the 'windows exe' kinda thing and has all the dependencies bundled so distro agnostic, but you have to manage the appimage files yourself unless you get a manager for it and you can't update them centrally like you can do with other stuff

• source code repos (e.g. aur): have to compile every new version yourself on your machine, so is slow to update, but often offers things not in the binary package manager

• .sh files for installation: idk why these are used, they're just annoying. a lot of proprietary software from corpos use them (probably so they can verify dependencies themselves and not trust the system)

• binariy files (e.g. .deb): same thing as with appimage except they're not distro agnostic

• tar.gz: is just a compressed file format like zip

What you're seeing is the result of decades of new ways to install stuff being added at different times. As a new way is added all the old ways still need to work because getting everyone to switch to the new way is impossible. There is no central authority making these decisions, it's more of a marketplace of ideas with different 'sellers' competing for attention.

Linux doesn't really have stand alone programs like Windows. A package is a series of files that get placed in the proper places plus some optional scripting. Packages have dependencies so you can't just run a binary from a package. The closest thing Linux as is AppImage but it lost a lot of steam.

In Linux there are two general types of package managers. The first one is native packages. Native packages install to the root filesystem and are part if the core system.

The second type of package manager is the portable format like Flatpak. Flatpaks can either be installed system wide or as a local user. The big difference is that they run in there own environment and have limited permissions. This is done by creating a sandbox that has its own filesystem so that it is independent of the system. This is also what makes them portable as that environment is the same no matter what.

Technically snap packages are portable but you aren't going to see much use outside of Ubuntu since the underlying architecture has so many flaws.

Why not consolidate all this?

https://xkcd.com/927/

But, there is actually a location standard: https://en.wikipedia.org/wiki/Filesystem_Hierarchy_Standard

This is part of why these days I just stick to flatpaks. No fragmentation, same on any distro, I know where all the programs are going as well as all their config files.

If I want to back up my flatpaks I can do so trivially.

It's a godsend. Way better than having a bunch of different formats everywhere, or the windows-style some programs installed in XYZ directory, some in program files, some in program files (x86), with config files saved literally anywhere. Maybe it's in one of the dozens of poorly laid out appdata folders, maybe it's where the exe is, maybe it's in documents, maybe it's in C:, maybe it's hidden in my user directory, etc. I've even seen config files saved to bloody onedrive by default, leading to some funky app behaviour when I wasn't connected to the internet, or when I ran out of onedrive space.

The idea is to not manage programs by hand to avoid messes.

The multiple solutions come from various needs, but it's more of an underlying complexity of installation than a real intent to have so many.

Ideally we would need one clean package manager that handles everything without ever having to tinker with installation paths and various methods.

I don't see the issue, since you rarely have to run a program by going to the location of the binary (AppImage and others excluded).

I think that, while, yes, fragmentation hinders a system, it is also its saving grace, as it also stops a given family of systems from growing into what made the competition problematic.

Taking the Program Files folders as example, they have limited read/write permissions on Windows, so whenever possible, I try to install them onto a folder I make in the root of C:. But more and more, since at the very least Windows XP from what I could observe, Microsoft is training users into using only the users folder, and less and less programs give an option to install elsewhere, installing only on the Program Files folder instead. Meanwhile, on Linux Mint (my distro of choice), if AppImage (my to go medium of programs) isn't working well, I can always fallback to other means, such APT directly or downloading its .deb files then extracting them, getting from flatpak, compiling it myself, building a custom AppImage, running on a VM or emulator, or in the worst possibility, I make a dual boot between Mint and some other distro.

Also, although there are many package managers, from my experience, they usually work similarly. Some changes in syntax, options and names, but nothing outlandish. It would be, I think, like someone learning a close language to his/her mother tongue. And from experience, you can even organize installations in a more standardized way, although it will take some effort from your part to figure out how, since some adaptations may be needed (java 8 and sdl ptsd intensify).

And lastly, from what I can observe, stuff in Linux more often than not share logic or even methods with a lot other stuff in the system. Dunno if it's a bit of a bias of someone that's using Linux for a few years already, but the fragmentation usually feels superficial to me, with distros being more tweaks of the ones they stem from, and major changes being better observable when distros are sufficiently far apart.