Slashdot Mirror
Why Was Linux the Kernel That Succeeded?
jones_supa writes: "One of the most puzzling questions about the history of free and open source software is this: Why did Linux succeed so spectacularly, whereas similar attempts to build a free or open source, Unix-like operating system kernel met with considerably less success?" Christopher Tozzi has rounded up some theories, focusing specifically on kernels, not complete operating systems. These theories take a detailed look at the decentralized development structure, pragmatic approach to things, and the rich developer community, all of which worked in favor of Linux.
That and the Unix philosophy.
| wonder what finally made the c-levels unafraid of linux?
time and nobody important being sued
It's not a big mystery. Linus released a primitive kernel that worked, at the right time, with the right license, and then diligently kept rolling up contributions and releasing the result.
Expanding a bit:
While the first release of Linux was primitive, it worked. People hungry for a free *NIX were able to grab it and run it. At the same time, HURD was a big research project; if you just wanted to run *NIX on your own computer, HURD was not at all ready.
Linus released it at the right time. It was just becoming possible for large numbers of people to get the kernel from him, and to send contributions back to him. Something like Linux might not have worked at all before the Internet and/or BBSs; it would have been too difficult to send releases out and collect contributions of code.
Linus used the right license. He has said that the choice of releasing under GPLv2 was the best decision he ever made. Arguably a BSD license could have worked as well, but many people have a fear that if they contribute to BSD projects, that evil companies might benefit from their work; with GPL they are comfortable contributing. Also, IBM contributed some code that uses IBM patents; because of the GPL, IBM knew that commercial entities wanting to use the patents would still need to license the patents from IBM. So Linux got the largest possible pool of contributors.
And then there is the fact that Linus worked hard managing Linux. He collected patches sent by people and rolled them in. These days he writes very little code himself; almost all he does is manage patches. I'm not sure how much code he wrote in the early days, but I think his diligent application of patches sent to him helped Linux to become stable and useful.
Given all of the above, Linux was a success, and success bred more success (the "Snowball effect"). People who just wanted something that worked could grab Linux as it worked better and better all the time; people who wanted to join an active project joined it as it was the most active project.
If Linus hadn't released when he did, another project might have gotten the snowball momentum thing going and become the big popular project. But he did, and he worked hard to keep it going, and the result is the kernel that changed the world.
lf(1): it's like ls(1) but sorts filenames by extension, tersely
Not sure I see your point. While the phrasing is perhaps a bit uncommon, there's nothing grammatically wrong with the headline.
Overallocations, OoM Killer, hangs and freezes all because the kernel can't be bothered to keep track of every last bit of it's memory make the Linux kernel a piss-poor substitute for a real UNIX kernel.
There are other problems in the memory subsystem as well. For example, if you are not using swap and the system begins to run out of memory, it starts throwing out pages of active programs from memory. Very soon they are loaded again from disk when those parts are needed. This causes a disk-grinding circus that feels like swapping.
BSD did not in any sense fail or fizzle, it is ubiquitous in printers, network gear and other appliances. Funny Apple could take the Mach that GNU HURD mishandled and make a working core for their BSD variant. Stallman really does suck at leadership/management/implementation, idea man only.
The reason why Linux eclipsed Minix is obvious, since Minix was never more than an educational tool. But why did Linux triumph over BSD? In the early 1990s, FreeBSD was considerably better, more stable, and had a more liberal license. Here are my theories:
1. FreeBSD required a hardware FPU, at a time when many computers didn't have them.
2. The AT&T lawsuit put a lot of uncertainty over BSD.
3. The user communities were very different. Linux users were very open and helpful to newbies. BSD forums were hostile to anyone that didn't already know everything.
The "more liberal" license might be the problem. While the license for the actual code you get is quite liberal, it doesn't propagate. The GPL ensures that there is always more GPLed code, once you start out from a GPL base. The BSD license is in some way an evolutionary dead end, because it is so liberal that it does not guarantee its own propagation. If I want to contribute to a project and want a guarantee that in turn, I have access to the contributions of people who are using my code, I can't rely on the BSD license. A BSD license means that the only development you are guaranteed to get is your own development. Anything else is just by chance. Your code might be useful for lots of other people, but you stand empty. There is no ROI for your development work if you publish something under BSD license. If you publish the same code under GPL, and even a single other developer shows some interest and adds something to your work, you are guaranteed to get rewarded by additional functionality.
Consider the following anecdote:
Around 1994 or 1995 I was starting an applied research project that needed an oddball sort of network widget. I e-mailed Alan Cox, whose group was handling most of the Linux network staff at the time, describing what I was trying to do. I got an e-mail back the next day that was basically: "Sounds cool! Ethernet sockets might be able to do the job (draft documentation attached). If not, let me know and we can discuss the best place for you to add a hook to the IP stack." Ethernet sockets were sufficient; I had a basic version of the widget up and running after a couple of long weeks; it was impressive enough that mgmt let me run with.
No way any of the other kernel projects were going to treat me that well.
He built a teaching OS, a cool ass distributed OS (Amoeba), a good WAN solution on top of it (Globe), and much later the self-healing UNIX-comcompatible Minix 3. That was all while he taught thousands of students how to build shit right. Andy is anything but lazy.
Tozzi overthinks it in the article. The kernel succeeded by being in the right place in the right time and then continuously being good enough that there was insufficient reason for change.
Linux, the OS not the kernel, was the first mostly complete Unix available on a college student's budget that would install on hardware the college student mostly already had. Right place, right time. Hurd didn't exist in any usable form, Minix and Solaris were $$ and the *BSD's didn't start to release for a year or two later.
Fast forward four years and when those graduating college students met the Internet bubble, Linux was the server OS they knew. Right place, right time.
Byeond that it was a game of, "don't eff it up." That's where Torvalds' pragmatism came in to play.
Moderating "-1, Disagree" is simple censorship. Have the guts to post your opinion.