The kernel is doing its job. Userspace, not so much. Though it's not nearly as bad as you think. In general, any desktop application compiled in the last 5 years will run unmodified on any modern distro. Really, it will, and I'd challenge you to find a counterexample.
But I suspect you're talking about the dependency issue. Installing something with a bunch of dependencies (because modern software has a dependency graph that looks a lot like seaweed) requires finding and installing all that stuff on your modern distro. And package names have changed, and some have been dropped from the core distro, etc... And yes, this is a mess.
But seriously: if you have a binary that works alone on, say, Ubuntu Dapper, it almost certainly will run on Fedora 16 or RHEL 6.2
$ fgrep DNOTIFY /boot/config-3.2.9-1.fc16.x86_64
CONFIG_DNOTIFY=y
Obviously it's true that dnotify is the old junk and inotify the new hotness. But it hasn't been abandoned, by either the kernel or the distros. Again, they take stuff like this very seriously. Old junk runs. Really, it does.It is the result of having no unified platform and library release coordination, no long term plans, nothing, just chaos. Everybody just releases when he is in the mood for it. And since nothing is complete when released, devs further down the chain always go for the latest and greatest to get additional functionality. And to upgrade app1, you have to upgrade lib1 which triggers the updates of app2, app3, app4, lib3, etc. Sometimes you cant update a simple app without updating the whole desktop. The Linux dependency net appears nightmarish to everyone coming from Windows, where you have a reliable, stable base system which doesnt change for a decade and every app targets the same base system.
Linux, the kernel, is only running that great because it has a dictator. But Linus' dictatorship ends at the kernel borders, he has little influence outside. The Linux desktop also needs a dictator to massively slow down the rate of uncoordinated changes and force-stabilize the ecosystem. I hoped that Mark Shuttleworth could be that man, but he then introduced Unity... but even with unity, Ubuntu is the only chance for the Linux desktop for having a single defined set of libs attractive and influential enough for app devs as a primary target so they can safely go with the library versions in Ubuntu, instead of constantly chasing the latest and greatest versions from the upstream.
Now, you are being plain funny. Haven't you heard of 'DLL Hell' in Windows platform?.
You never had 'windows update' break your software for no reason?
On 16-bit Windows there was a single address space and only a single version of a DLL could be loaded by all processes: the first one to load would "win", and the others would get screwed with the old copy. This was due to 16-bit Windows not having memory protection: it was more of a GUI over DOS, and thereby had cooperative multi-tasking.
Even with that fixed, many developers would require a slightly newer version of a library, and rather than ask the user to upgrade their system (an irritating consequence of not having packages or dependencies; APT FTW ;P) would just include the DLL in their installer and unconditionally overwrite any existing copy.
After the dynamic loader started supporting "local" versions of libraries (installed to the same folder as the application), a similar problem happened with COM objects, which are centrally registered: someone would install their own version of a shared GUI component, register it with the shared name, overwriting possibly-installed newer copies.
Both of these problems were actually solved, but way too many developers simply gave up on Microsoft and Windows beforehand, and then refuse to spend the time to learn about the improvements. In essence, Windows now has reasonable-ish package management, with dependencies: Windows Installer.
In addition to dependencies and versioning of packages (which can then be correctly tracked by Windows, much like APT on a Debian/Ubuntu box), Windows Installer supports the notion of "unified installer program" with "merge modules": in essence, you can include someone else's package inside of your package; that way the dependencies can correctly be checked, and old versions won't get overwritten.
There are still a few cases that are quite difficult to manage (involving libraries that require a modified ABI over time, but still receive updates), and Microsoft's solution to those is WinSxS. Honestly, while I'm much less familiar with it than on Unix, it only seems a constant multiple more crazy than .la files, which I believe solve a similar problem.
These technologies and improvements were all introduced at or before Windows XP, an operating system that was released just over a decade ago. Of course, these are all solutions that developers sometimes ignore, but if you download software for Linux that comes with a .sh installer that scribbles into /lib, you are in for similar "hell".
On Linux, having to upgrade the distro (including getting a new desktop environment force-installed) to get a new version of any random app is established practice. Example: http://esr.ibiblio.org/?p=3822
See the various opinions on MSFT intentionally removing the binary compatibility which already existed in their libraries here:
By default you can't but you can adjust the build settings and it works fine.
When you are dealing with different distributions that provide different versions of core libraries, different sound architectures , package managers and put things like executables and config files into different parts of the filesystem.
I thought that the Linux standard base would be the way to solve this.
After two sentences i thought "he probably works for microsoft or another big corporation", not because it's flame, but because of the attitude to regard this as pure chaos (and having no big plan as bad). I even looked up the profile.
There is kind of a release-plan, not for the whole eco-system, but that's what stable distros are for. So the remark to Ubuntu is right. But it's wrong to mix library-stability with perceived frontend-issues with Unity. Ubuntu still fulfills that role for some apps. And besides that, it isn't necessarily wrong to write new programs against new libraries. They have new features and new bugfixes.
I wouldn't want the ecosystem to stagnate right now. Or ever.
The problem is that no app dev targets stable distros, but always goes for the latest and greatest from the upstream so distros are constantly forced to update libs and change the base system.
So with a stable distro, you cant get a new version of an app, because the libs of your distro are too old, and you need to upgrade the whole distro just to be able to get that new app you want.
The Linux ecosystem needs one distro (say Ubuntu) to become so influential, that app devs start to primarily target it instead of the upstream. Only then will the library space stop being a moving target for end users, and only then it will be possible to upgrade app1 without triggering an automatic update of app2, which both happen to depend on the same lib. Only then will these useless practices of "packaging" and "backporting" finally stop, and devs will be simply make packages themselves, like they do on windows or osx. Only then will users be able to install a distro once, and then be able to install new apps for 5-10 years without having to upgrade the whole distro every 6 months.
> I wouldn't want the ecosystem to stagnate right now. Or ever.
But with an ecosystem as unstable as the current one you wont get more than 1% of the market right now. Or ever.
Normal users and especially businesses simply dont want to constantly update their systems. Force them to do that, and they simply walk away.
What happens in Windows is not what you're describing; developers are simply forced to distribute their own copies of the libraries (as DLLs or statically compiled) since there is no package manager. What then happens is that there are dozens of copies of the same libraries, most of them lacking bugfixes and even security patches.
The dependency system used by Linux distros may have its problems, but it surely beats ad-hoc dependency management, even if it requires backporting.
Normal users and especially businesses simply dont want to constantly update their systems. Force them to do that, and they simply walk away.
Right. If you use Windows, have you tried counting the number of update managers running in the background, the number of applications that ask you on launch to "verify updates", the number of times Windows Update alerts you, etc?
Windows machines are constantly updating. Unlike Ubuntu, they just do it incrementally instead of once every six months (except for security patches). But that's better fixed by moving to a rolling release scheme.
It's just not commonly done (with exceptions like http://sta.li/), and as a user, I'm thankful for that.
The bigger development teams don't focus on a single distro, as their development base is probably diverse enough to demand a certain degree of platform compatibility.
However, many of the smaller development teams will focus almost exclusively on Ubuntu, as it is the distro they will most likely have.
I know, from my own limited experience, that I have only ever attempted to make my systems work on Ubuntu and just allowed others to push their changes into the main development if they have specific platform that they prefer to use.
In fact, usually when we run into problems, it's a new version, not an old one.
This used to be RedHat: software for Linux would often come as either 1) source code (if open), 2) a crazy .sh install script, and 3) an RPM package for RedHat 5.
See how jwz shows you how to run a binary of Nestcape from 1995 (17 years old) on the latest Linuxen:
http://www.jwz.org/blog/2008/03/happy-run-some-old-web-brows...
Your major problem if you want to make a closed source application is that the user space dynamic libraries are mostly (L)GPL licensed, so you have to avoid (L)GPL libraries to have a legally fully-library-independent closed source application. LGPL license allows closed source linking only if you link dynamically to the LGPL library (meaning: your application must depend on the externally present library which can be replaced at any time). Which is really fair, IMHO.
http://en.wikipedia.org/wiki/GNU_Lesser_General_Public_Licen...
I did have to fish around a bit for an old version of curses and create a symlink. It only took a few moments though.
Just a data point to consider.
Speaking of that, I wonder if there's some point at which dynamic libraries don't really help you that much. These days, even shared libraries don't seem to stop a GNOME desktop running a browser from sucking down a gig of memory; would it really kill them to have a couple more megs of static library in each program? With copy-on-write, I think things like Chrome which spawn many children would come out pretty well.
Even using an SSD I suspect the difference would be noticable for most applications.
I run older binaries on Linux all the time.
Good luck.
If you still have the specific version of every shared library that it loaded you might be able to get it to work.
This isn't the fault of the kernel team though.
It is probably to be expected on platforms in which distributing source code is the default option, but it makes the platform very hostile to closed source applications, particularly games.