Originally Posted by Wombat Pete
But isn't backwards compatibility a Linux principle?
No. Where did you get that idea? That is an old MS principle.
The linux principle is to be the latest and hottest and most versatile possible.
We don't have to code for backwards compatibility because everything is in the open. No secrets - so you can, in principle, build to your conditions.
This is not to say that devs just update and to hell with everyone else - programmers need to be aware of who they are hurting when they make a change ... in open source, we are painfully aware of this.
Imagine - all programs have bugs, so all programs have to be updated as the bugs get fixed. A compiler is a program. It has bugs - so it has to be updated. But - too much of an update will mean that old source code may not compile on the new compiler. The answer is usually to support older methods for a while, but give the programmer a warning when they use it that the method is obsolete and will not be supported after x date.
Certainly, drivers compiled for one kernel have to be recompiled for the next one - which makes maintaining proprietary drivers a serious pain.
Which raises another question - I often see it written that a given distribution comes with later releases of certain programs.
Does the threat of 'dependency hell' mean that you couldn't just go to the developers' sites & download the latest versions?
It means you need to be more aware of the possible consequences when you use a managed distro. You can
do this, you can do whatever you want. It's just more work, that's all.
One of the side effects of free software distribution is that programmers just reuse each others code. One way to do this is to use each others whole programs, another is to dynamically link each others libraries. This adds efficiencies in sharing resources etc. However, every gain has it's cost: a particular program may depend on some others being present in order to run, so you get the 3-6 dependencies for the one program you want only to find that half of them also have 3-6 dependencies. For large complicated programs this can go on for a while, depending on how complete your original install to start with.
An alternative would be to package all the dependencies with the core program. This is what happens in the proprietary world. This is why the Windows version of firefox is bigger than the linux version - mozilla have to supply all the dependencies that go with it while linux already has them (warning: over-simplified for clarity).
Dependency hell is usually only a big problem when you start out. This is because, after you've installed the dependencies for one program, you find these same programs are also needed by the next program you install. As you install software, the number of dependencies you need to install drops to nil and your computer has been evolved/customized to what you like to do with it.
eg. To install one KDE game in a gnome system, I have to install all the Qt related things. This can add megabytes to download for just a simple game. But - once done, the next KDE game is just kilobytes.
Another symptom is in security updates - a vulnerability in firefox will require half-a-dozen or so patches because it is not just one program.
By comparison, the proprietary world would make me download all the Qt stuff for each game (though it is more likely that they'd adopt some strategy to minimise the royalties they have to pay.)
The main thing to be aware of when installing from a non-standard source is that the program may not be entered in the distro package-manager database. It doesn't know its there - so it won't be counted as a satisfied dependency for package installation, and it may get erased next upgrade. Though there are ways around this too - remember, you can do anything.
The upshot is: pick a distro that suits your needs.
If you like lots of bleeding edge stuff, pick a distro that also likes this. Then, almost all that you want ill be its repos, it will be tolerant of non-standard install methods, and there will be a community around it which is skilled at running along that edge.
The differences between distros can run quite deep. Have a look at this: