Fixing Driver Hell
Linux is one of the absolute worst OSes in existence for a consumer. The reason is pretty much entirely due to installation of "stuff." Installing an application is hell. Installing a driver is hell.
Autopackage is working on the application installation front. I wish them luck; they'll need it to deal with all of the incompetent library developers that are making it near damn impossible to deal with Linux without a degree in computer science and a seedy, intimate relationship with a compiler.
On the driver front, however, there is no solution in near site. The Linux developers themselves are actually moving in a direction that will screw users in the rectum even more, with this new kernel development model discussion. "What, you mean actually make it possible to use a driver that's not part of tree? Hahaha, screw users, we're too lazy to make our OS usable by real people." Right, binary only modules are bad. Sure. I agree. I hate being subject to the whim of NVIDIA's driver developers, who are often quite slow at fixing bugs or breakages. But then, maybe if they weren't so busy tracking the API/ABI change of the week...
The thing is, it's not just binary modules that are screwed. Let's look at a scenario. Company X is releasing a new piece of hardware in a month. They write a Linux driver, release it under the GPL, and send patches to Andrew/Linus to get it into the kernel. This whole process even manages to occur before the hardware comes out, so in fact Linux 2.6.20 supports the hardware and is released a week before the hardware hits the shelves. Awesome, right? Well, it would be, if 2.6.20 was actually installed on anyone's machines.
See, users have already installed their OS. They are running Fedora or SUSE or whatever. Maybe the latest release; in many real world cases, probably several releases old. The kernel they have is maybe 2.6.10. They go buy this new hardware, install it (or plug in the USB cable, whatever), and... no go. No driver. Assuming we have an incredibly rare kind of person, the user might go look on Google and find out that 2.6.20 supports the hardware. (Admit it, people, the vast vast majority of users would just get upset and/or confused, blame the hardware manufacturer and/or Linux, and never even figure out how to fix the problem, much less actually fix it.) Anyways, so they need 2.6.20. Of course, there is no kernel update for their OS. Red Hat and Novell are focusing on the latest versions of the distributions. Even though they might support errata for the OS version the user has, they aren't going to do something like just release 2.6.20 for that version. *Especially* not with the new kernel development model. I mean, they aren't just going to get new drivers. They're going to a whole new fucking ABI; new module tools probably needed, a whole bunch of QA and testing for each distro version they want to releae the kernel upgrade for, probably all sorts of updates to tons of userland stuff like hotplug, remerging of any custom patches they use... it just isn't going to happen. It takes a long time to stabilize a kernel (especially now that the kernel development model says that it is in fact distribution makers' jobs to stabilize the kernel). The user is pretty much stuck with 2.6.10, maybe with an occassional security patch or backported fix for a serious bug. That's it.
Now, the user can't really upgrade to 2.6.20 easily either. Again, of course, pretending we have a total nerd as our user who actually knows how to upgrade kernels, and has so little of a life that they can spend all that time doing a kernel upgrade. They won't be able to, at least not easily at all, for many of the same reasons Red Hat and SUSE didn't do it for them - they need new user land tools, need to test the kernel to make sure its stable, port any distribution patches that they like or need to use their machine, make sure they get the kernel configuration correct, etc. Sure, 2.6.20 is just a small handful of "minor revisions" from 2.6.10... but in the kernel, the different between 10 minor revisions is the amount of different between several major revisions of the popular desktop environments! Worse, actually, since both KDE and GNOME understand reality and support backwards compatibility.
The user is pretty much forced to upgrade their OS. This, of course, isn't all that great. They need to download or buy upgrade media. They need to go through the upgrade process. Half their applications break (see beginning of this post as to how incompetent developers cause this to happen), many components of their entire system change (new menu layouts, wildly different application behaviour from major upgrades, all new sets of bugs and problems), and they in general go through a lot of pain.
Just to get a single periphial device working.
Again, note, this was a (theoretical) GPLd driver that was included in the kernel itself. This is what Linux causes us to have to do. The user couldn't grab a precompiled driver, drop it in, and get on with his life. Nobody makes binaries for the 10 errata kernel each version of each architecture of each distribution of Linux around. And (again assuming our user is a nerd with no life and lots of time to waste on what should be unnecessary crap) compilation won't even help, because the bloody kernel API has managed to wildly morph in 10 minor revisions as well.
A worse scenario even is when a device driver is needed for the computer itself to even operate. Say, a disk controller driver. You *should* be able to stick in the OS installer and have it ask for additional drivers (say, from a floppy, USB drive, or second CD drive), but you can't, because nobody has the bloody binary for the installer. You can't make one yourself, 'cause you don't have a working computer yet! In this scenario, Linux is completely and absolutely unusable, and the user has no choice other than to use a different OS.
All because the kernel developers are too apathetic to make the kernel usable as the basis of a non-nerd OS.
Now, the proper fix for this scenario is to get it into the kernel developers' heads as to *why* they need a stable ABI, or at least a stable API (so that installers which compile and install GPL drivers automatically for a user would actually be possible). Doesn't look likely at the moment.
The next best fix would be to make an unofficial Linux Driver API. This would itself be a module that simply exported a well defined unchanging API. Drivers that wanted compatibility and portability between kernels and don't mind taking a (slight) performance hit from going through an extra layer could target this API. The module would also likely need its own module loading code as well, so it can do smart things like read drivers from /lib/linux/drivers/[api version]/[driver].ko (so you don't need to reinstall drivers for each kernel revision) and also be immune to all those module interface changes Linux is subject to. Yet, it's "bloat," and should be absolutely unnecessary, but Linux makes it necessary. With this module, both GPL and proprietary drivers could be installed at any time and Just Work(tm) independent of the kernel revision. In fact, this API could even be backported to older 2.4 or even 2.2 kernels; some features might not work, but the core driver should still work.
This Driver API wouldn't need to be a complete replacement for the internal kernel API. The purpose of this API would be to support common user-changable devices; basic periphials, disk controllers, etc. Things like whole new bus types and such are things that can safely remain in the core kernel. It's also understandable that the API would need to be versioned and new versions would be needed occassionally to support new features of the Linux kernel (and the new buses it might support). Drivers using the older API should still work, though, of course.
The problem with this solution is getting it done. Someone very familiar with the kernel and ready to develop and maintain such a complex interface layer would need to do the work; I doubt there are many people like that around .
The last fix is to make a new sort of package repository. We already have several popular RPM repositories that package various popular third party software for several versions of several distros. We need something like that, but catering only to kernel modules. At first, supporting just the major players (Red Hat, Fedora, SUSE, Mandrake) would probably be enough. All the packagers would do is package kernel modules, so it would hopefully be easier to manage all the various kernel errata for many versions of each distro. Autobuilds could occur such that as long as the drivers don't need modification (usually the case for errate kernel updates on distros), the packagers need do nothing; the autobuild system finds a new kernel update is available, downloads it, rebuilds all the kernel modules, pushes out the new packages.
The site would have a fairly simple interface. Select distro, select version, select driver, get a list of RPMs. A YUM and/or apt repository would be availabel. There would also be an interface for searching for hardware by things like the PCI ID and vendor/product name which would return the appropriate driver package. An XML-RPC interface would also be available along with a tool/library for doing the searching. Imagine having hotplug on your OS detect new hardware for which there is no installed driver popping up a dialog, "I have detected hardware that I do not know how to handle. I can search the Linux Driver Database for an appropriate driver. [Cancel] [Find Driver]" It queries the site, finds an appropriate driver, then grabs the correct RPM(s) for the user's installed kernel(s) and installs them.
This solution is likely the only one that's feasible, because of all the solutions it is the only one that doesn't require big changes on developers. Unfortunately, it's the worst possible solution because it doesn't actually fix the problem itself and will actually require more work overall. (It will just be work that is capable of being done by a larger segment of people than a solution that requires talented and experienced kernel developers.) There will still be gaps; for example, the user needs a driver for his networking hardware... how does he get the driver off the site? How does he get the driver for his disk controller during OS install? The first two solutions make it possible for drivers to be shipped on a CD or other media right along with the hardware itself.
Linux is great for developers. After all, we *are* the nerds with seedy, intimate relationships with compilers and no life resulting in tons of time to sit around compiling shit and tweaking source code. Well, most of us are. Some of us, perhaps, are sick of that crap, and just want our computer to work. If we *are* going to sit around tweaking and compiling stuff, we'd rather it be our own projects and not have to waste many hours to get some other bit of something working that some other developer should have already gotten working. But, alas, no - we're going to be stuck wasting our time away doing ultimately pointless excercises to get things working that should've been working from the start.