Way back when the personal computer was first introduced, there was a machine called the "Altair." It was a big box with some switches and lights. You were supposed to know what the switches did, and what the lights told you. It was basically a fancy number cruncher. Except, the numbers were in binary, and up to 8 places. Eight switches could be up or down, representing the eight digits allowed in a binary number. Think back to your school math days, and you may recall that binary means 1s and 0s only. That's because the electronic computer was based on -- suprise! -- electricity. With electricity, it's a simple matter of on or off. If you couldn't think in binary numbers, the Altair was pretty hard to use.
Things have changed a lot since then. While your computer is still at heart a fancy number cruncher, we get a lot more from those numbers. Oddly, the 8-place binary code is still there, underneath it all. We call that "8 bits," and together they form a byte. Computers still store information as bytes. Everything is in multiples of 8. If you go up the scale you find: 16, 32, 64, 128, 256, 512, 1024, etc. Thus, while the prefix "kilo-" usually means "1000x", in computers it means "1024x". "Mega-" is 1024 times kilo-, and "giga-" means 1024 times mega-. By getting up in the higher ranges away from the original bytes, we have the power to do lots more with computers. Hardware and software both have changed that way.
Now we have screens to look at, keyboards to type on, a mouse to move, and several other ways to communicate -- or interface -- with our computers. Some may recall their first use of a computer with a screen that glowed one single color, and displayed simple text and numbers. Then came a few colors, then letters with lots of colors. Eventually, someone came up with the idea of a fully graphical display, even with images that appear in 3 dimensions. We call this fancy display a GUI -- short for "Graphical User Interface."
As the hardware and software for displaying all this becomes more complicated, it increases the chances for problems. If we eliminate for the moment the factor that some hardware is cheap junk, we still have to worry about whether the kernel can talk to the display hardware properly, as we learned in the last lesson. Most of the hardware on your system requires a piece of software called a driver that the kernel uses to speak with it.
Since the operating system bundled with your PC is so very dominant in homes and businesses around the world, it's usually the first system to get drivers for the newest hardware. People who make the hardware are businesses, and business arrangements are the reason drivers for that system are so quickly made, often before the hardware makes it to the stores. The folks who write FOSS operating systems can't afford to work that way. If the hardware makers don't clue them in on how things work, they have to play with a copy of the hardware and figure it out as best they can. Admittedly, your bundled operating system is more likely to offer all the fancy features for every new piece of hardware that comes out.
When it comes to display hardware, that's about as far as the advantage goes. Bundled systems still have that problem with losing memory addresses, but they also have a very odd method for keeping them in the first place. The system itself puts limits on the method, and that contributes to crashes.
You must understand that the oldest commercial and academic computer systems didn't rely much on fancy graphical displays, because it was never important. When the GUIs were finally developed, they were built for the same kind of multi-user design, and ran as a separate process. One part of the system could run the GUI, and serve it up for every other machine connected to it. If the GUI had a problem, users just went back to the old way of doing things if they couldn't restart it. The heart of the system still ran fine without the GUI. When you work without a GUI, it's called a terminal or console or command line interface (CLI).
Your bundled system, in its early days, was also a CLI. They added a GUI on top, later. However, they chose to eventually make the GUI too much a part of the system. Today, they claim that the GUI is the system. You can still open a terminal window for the old command line, but there is some debate whether that old CLI is really there, or the system is just pretending. Either way, when any part of the GUI has a problem, it affects the whole system.
FOSS systems seldom crash that way. First of all, the GUI tends to keep working when some program goes crazy. You can usually kill the program by itself. Even when the GUI system crashes, the heart of the operating system is seldom affected. In fact, a very large portion of folks who run FOSS are prepared to get along without the GUI, and many never use it at all.
In FOSS, you have to setup the GUI separate from the system. While your keyboard and mouse both work in the CLI, the GUI uses them differently, and they don't work exactly the same. You have to be ready to tell the GUI what kind of each you have, as well as the name of your graphics card and your monitor. You may never see the CLI, but you should be aware it's there, and plan on learning how to use it someday. For the time being, the most common GUI you will find in FOSS is called XFree86, or simply X. It's been around a lot longer than the GUI that comes with your bundled system, and -- while less fancy -- is less likely to crash.
Even better, it comes in so many different flavors you'll have a hard time believing it, at first. Some flavors can be made to look and work exactly like your bundled PC system GUI. Others are so radically different, you'll have to learn from scratch all over again. Some are so simple, they are almost not there, just a step above the console. Others are so fancy and beautiful it's breathtaking. A few can be adjusted between very plain and very fancy. If you have older hardware, you'll have a tough time getting the GUI to work, and it is likely to be slow. However, all the fancy power of the system underneath is available without the GUI.
What you can do with Free and Open Source Software depends on how much you are willing to learn.
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 ehurst@ofb.biz.