Basic Lesson #3: Talk to Me

By Ed Hurst | Posted at 12:25 AM
So far, we have discussed how Open Source technology is more secure because of how files are handled. Now we will examine stability issues.

What makes a computer crash? It can be compared nicely to a nervous breakdown in humans. When people, for whatever reason, lose their sense of control and nothing makes sense any more, people "crash." There is a sense of being so overloaded with demands that no response will serve any purpose, so one stops responding. Computers get that way when the heart of the system can't control the processes going on in the computer. The heart of a computer system is called the kernel.

When you first turn on a computer, there is a tiny process built into the hardware that checks what is there, and where it all is: mouse, keyboard, video card, etc. This thing is called the BIOS: Basic Input and Output System. This thing then tries to find the system installed to run it. Typically, it finds the system on the hard drive, but more modern computers can look for it on the floppy (as it was in the old days) or on the CD-ROM.

When it finds that system, BIOS passes off all the information about the hardware and goes away. Then the kernel grabs that information, tries to make sense of it, and starts the system. This system makes it possible for you to use your computer for all the things that we buy computers to do. Without a system running on the computer, your hardware would be a pile of junk. The kernel keeps track of all the hardware and software, and makes everything work together.

If something in this process gets out of control, the system can crash. If the hardware is not working right, the system could crash every time the hardware fails to react as expected. That's actually rather rare. Most of the time, your bundled operating system crashes because it simply fails to keep track of how the software uses the hardware. The biggest problem is memory use. Allowing two different processes to put stuff in the same part of the memory will make the system crash. The software needs a chunk of memory to keep ready all the different actions you might want to take. For example, a game loads lots of different responses based on what the joystick can do, so that it can respond to all the moves you make, without taking a long time to think about what you mean when you twist the handle to the left.

All this preparation is loaded into the memory chips in your computer. The memory is divided into sections, and the whole thing has a rather simple numbering system that works like street addresses. The game, when it is started, claims it needs X amount of memory addresses, and the kernel marks out a range for the game's use. During the process of playing the game, if the kernel fails to keep track of those addresses, it might allow some other process to move it's stuff into the same addresses. When the game comes back for some of it's stuff, it's gone but the game doesn't know it. It grabs something where it left it, but the information doesn't fit what it's doing, and the system gets confused and crashes.

It's all very complicated, indeed. Sometimes it's a problem with software that isn't written properly, and playing fast and loose with memory. However, since the kernel is in control of these things, it should be the last line of defense and try to limit that sort of problem. FOSS kernels usually handle this sort of thing much better. That's because it's based on much older commercial and academic software, which came about in the days when computers cost millions of dollars. When one part of the system crashed, the heart of the thing had to keep working, because too many people depended on it.

Another part of the problem is that the companies that make the bundled operating systems are a business first and foremost. As long as things work okay most of the time, for most of the people using it, that's good enough. Further, part of making that money means not telling anyone else much about how their stuff works -- it's a "trade secret." They don't want anyone to copy their ideas. So while people writing software for the system have to know something about it, they will never be allowed to know everything. All the more so if the big companies are already trying to sell software that does the same thing, along with the system to run that software.

So if there's a fellow out there who really does a good job of writing game software, he still might have trouble making it work properly, because he isn't allowed to know enough about the operating system. On the other hand, FOSS operating systems get that name from allowing anyone in the world to look at the way the operating system is made. Most of those working on the system are not getting paid for it. It's not just a hobby, but more like an art. They do it because they love it. It has to be done right.

Of course, not every crash is the fault of the operating system or the software. If the kernel doesn't understand the hardware, it can't talk to it properly. When you install an operating system, part of the process is checking to see what the hardware is, and where it is. As good as they may be, people who program that search process can't always get it perfectly for every piece of hardware that exists. Most modern hardware does a fair job of telling the system what it is and maybe what it can do. Many pieces don't do that very well, and some not at all. If the hardware is capable of doing too many things, you'll have to make the decision which set of things you want it to do.

When you install a bundled system, it's not likely to ask you about the hardware, but will guess on lots of things. It will always get some things wrong, but you may not ever know that. Keeping you ignorant keeps a lot of other people rich. It also makes for computer crashes. Since FOSS is not about making money that way, you as a user need to know more about your computer, and what the hardware can do. During installation, you'll need to be ready to answer some questions. Some versions of Linux are so easy to set up, it's easier than the bundled operating systems. Some are not so easy. The operating systems called Unix are usually more difficult. But along with this is the promise that, if your hardware isn't too weird, and you know how to tell the system about it, it's less likely to ever crash.

Can you imagine a system so stable it doesn't crash until the hardware breaks down? That's Free and Open Source Software.

Ed Hurst is Associate Editor of Open for Business. Ed is also the Music Director for Grace Baptist Church of Kickapoo Creek, Texas. He loves computers, runs GNU/Linux and reads all sorts of things. You can reach Ed at