I’ve been journaling more and this is something that was percolating in my head the last bit of time and I finally dumped to there. It seemed adequate enough to then further dump to my blog, so it’s presented more as thoughts in progress than a strong argument

C never had a package manager, and it’s always been a bit hard to include packages, usually need to get the precompiled and supplied library (dll, so) and a header file with defs, link against it etc. On windows and MacOs that also meant shipping all your dep libs with your app. In practice we saw a pretty low ceiling on the amount of libraries C apps would depend on, and they’d also skew to OS supplied support libraries like widgets and audio and etc.

There was where Linux distros shined with their package managers, and in part why I loved them. Every library you could imagine and it’s dev parts was just a package manager command away, your whole Linus OS + package manager WAS the C library package manager. And everything was managed and worked together, you didn’t even have to worry about version management.

Newer languages tho started inventing their own package managers. Java, more awkwardly, and then newer ones since, Python, JS, Go, Rust, etc, now they all have their own package managers. I suspect this was motivated by two factors: devs on non Linux operating systems wanting this, and in some cases second, by wanting to have updates incorporated faster than Linux distros would update, wanting to “go fast”, which, I can kind of understand if you’re on Debian stable and it’s updates every 2 years.

This results in different tensions, app developers are now more used to being able to use all the latest packages, stable or not, and weather they are writing user applications or server side things. The reasons Debian stable is so fixed and “slow” is exactly to provide a rock solid and stable server experience. Writing stable server apps with all the latest barely checked deps still makes me a bit itchy and uncomfortable, but we’re seeing more of it.

As a result of all of this, languages now all having their own package managers, we’re seeing a tension with Linux distros and their package maintainers. Standard language community advice is always ignore and by pass distro packages and use the langauge package manager to get deps. And that’s when there’s a choice at all. Languages like Go with no library support don’t even offer the choice. As a result I think I’ve seen chatter that more package maintainers are getting tired of even trying to offer an in disto set of libraries if no one wants that, and the community perpetually wants to apply pressure on them to update faster than they’d be comfortable with.

Following from this, I think we’re seeing a bit of a loss of value to some extent of the Linux distro package manager. In it’s peak days, for me, my whole distro moved lock step as a single development environment and it felt glorious. Now we’re increasingly moving away from that and it provides a base, and each project now has it’s own package manager the manages all it’s deps, and one can work on multiple projects at the same time all with different versions of even shared dependency libraries. The dev environments are each swelling in size and the host OS is shrinking.

This is also walking side by side with the increasing push to containerize apps with their dependencies and not depend on the host OS for anything, build the entire app on your machine once and ship it as is, a bit more like app installs on Windows and MacOS have always been.

The efficiency optimizing part of my brain that worked out a lot in the 90s and 2000s when resources felt more scarce was really proud of Linux distros on this front. One copy of all needed dependancy share libraries system installed and shared by all apps should def get memory usage to an optimal low, while Windows and MacOS apps all carrying potentially many duplicate copies of the same libraries around taking more space on disk and more space in memory just seemed, inefficent and less optimal.

And yet we’ve been steadily moving away for that coordination on Linux now for decades and very much a part of me mourns that and feels nostalgic for it and misses it.

Weather or not in the big picture that is fair or “correct” tho even I’m undecided. Some of the arguments that could fall on the line of “we have more Ram and harddrive space now” just feel like echos of Moore’s law excusses for inefficency, and now that Moore’s law has kind of run its course and we’re starting to hit more limits and rate of growth of resources has slowed, that feels not just invalid but wrong. If we’re gonna want to get more out of our systems going forward, it may increasingly come from reclaiming various efficiency gains we’ve been ignoring increasingly for the last 2 decades.

There’s some arguments about wanting to use the latest stuff, I’m not a huge fan of those. There’s some arguments that containerization and etc can provide more security, also not entirely sold on those. Some of those arguments from certain crowds have tried to also then argue as far as “since we want to containerize apps so far, we must also give up unified customizable desktop themeing” and that’s just not an argument I’m going to concede. Whimsy and flexibility must always be a part of computing and user choice matters.

There’s a part of me too that appreciates that having to be aware of supporting not always the newest libraries but the most widely shipped versions does potentially create a little more burden for developers, but more so ones currently not doing that and transitioning to it than those already trying. But it gets to a gnarly argument. I do like coordination between works. I like that apps on Linux for instance can work in multiple Desktop Environments. We’re seeing some break down now with Wayland and modern GTK and QT, Gnome apps increasingly insisting on drawing their own and different window decorations. I’m not against apps having the option to do that, I was a fan of winamp back in the day, but at the same time, broadly, I like the option myself to have uniformity now, and with Gnome apps refusing that, they stick out, and I’m increasily migrating off them. Personal choice. Which is all kind of swirling around, I do like coordination and cooperation, and I think as out lined above real gains can come from that but I’m not quite sure I’m willing to too strongly say we should have distro managed deps for all things. Just that I with perhaps it was not a continuingly less chosen option? I’d love to see more apps maybe play a bit more towards stability and shared resources, but, it is potentially some kind of OS archetecural taste aesthetic on my part more than any strongly backed technical and social argument. I have my opinions as outlined above but I’m not super confident in their strength.