In the Beginning...Was the Command Line (8 page)

The only parts of this that are readable, for normal people, are the error messages and warnings. And yet it’s noteworthy that Linux doesn’t stop, or crash, when it encounters an error; it spits out a pithy complaint, gives up on whatever processes were damaged, and keeps on rolling. This was decidedly not true of the early versions of Apple and Microsoft OSes, for the simple reason that an OS that is not capable of walking and chewing gum at the same time cannot possibly recover from errors. Looking for, and dealing with, errors requires a separate process running in parallel with the one that has erred. A kind of superego, if you will, that keeps an eye on all of the others and jumps in when one goes astray. Now that MacOS and Windows can do more than one thing at a time, they are much better at dealing with errors than they used to be, but they are not even close to Linux or other Unices in this respect, and their greater complexity has made them vulnerable to new types of errors.

Linux is not capable of having any centrally organized policies dictating how to write error messages and documentation, and so each programmer writes his own. Usually they are in English, even though tons of Linux programmers are Europeans. Frequently they are funny. Always they are honest. If something bad has happened because the software simply isn’t finished yet, or because the user screwed something up, this will be stated forth-rightly. The command line interface makes it easy for programs to dribble out little comments, warnings, and messages here and there. Even if the application is imploding like a damaged submarine, it can still usually eke out a little S.O.S. message. Sometimes when you finish working with a program and shut it down, you find
that it has left behind a series of mild warnings and low-grade error messages in the command line interface window from which you launched it—as if the software were chatting to you about how it was doing the whole time you were working with it.

Documentation, under Linux, comes in the form of man (short for manual) pages. You can access these either through a GUI (xman) or from the command line (man). Here is a sample from the man page for a program called rsh:

Stop signals stop the local rsh process only; this is arguably wrong, but currently hard to fix for reasons too complicated to explain here.

The man pages contain a lot of such material, which reads like the terse mutterings of pilots wrestling with the controls of damaged airplanes. The general feel is of a thousand monumental but obscure struggles seen in the stop-action light of a strobe. Each programmer is dealing with his own obstacles and bugs; he is too busy fixing them, and improving the software, to explain things at great length or to maintain elaborate pretensions.

In practice you hardly ever encounter a serious bug while running Linux. When you do, it is almost always with commercial software (several vendors sell software that runs under Linux, and there is more available each month). The operating system and its fundamental utility programs are too important to contain serious bugs. I
have been running Linux every day since late 1995 and have seen many application programs go down in flames, but I have never seen the operating system crash. Never. Not once. There are quite a few Linux systems that have been running continuously and working hard for months or years without needing to be rebooted.

Commercial OSes have to adopt the same official stance toward errors as Communist countries had toward poverty. For doctrinal reasons it was not possible to admit that poverty was a serious problem in Communist countries, because the whole point of Communism was to eradicate poverty. Likewise, commercial OS companies such as Apple and Microsoft can’t go around admitting that their software has bugs and that it crashes all the time, any more than Disney can issue press releases stating that Mickey Mouse is an actor in a suit.

This is a problem, because errors do exist and bugs do happen. Every few months Bill Gates tries to demo a new Microsoft product in front of a large audience only to have it blow up in his face. Commercial OS vendors, as a direct consequence of being commercial, are forced to adopt the grossly disingenuous position that bugs are rare aberrations, usually someone else’s fault, and therefore not really worth talking about in any detail. This posture, which everyone knows to be absurd, is not limited to press releases and ad campaigns. It informs the whole way these companies do business and relate to their customers. If the documentation were properly written, it would mention bugs, errors, and crashes on every single page. If the on-line help systems that come
with these OSes reflected the experiences and concerns of their users, they would largely be devoted to instructions on how to cope with crashes and errors.

But this does not happen. Joint stock corporations are wonderful inventions that have given us many excellent goods and services. They are good at many things. Admitting failure is not one of them. Hell, they can’t even admit minor shortcomings.

Of course, this behavior is not as pathological in a corporation as it would be in a human being. Most people, nowadays, understand that corporate press releases are issued for the benefit of the corporation’s shareholders and not for the enlightenment of the public. Sometimes the results of this institutional dishonesty can be dreadful, as with tobacco and asbestos. In the case of commercial OS vendors it is nothing of the kind, of course; it is merely annoying.

Some might argue that consumer annoyance, over time, builds up into a kind of hardened plaque that can conceal serious decay, and that honesty might therefore be the best policy in the long run; the jury is still out on this in the operating system market. The business is expanding fast enough that it’s still much better to have billions of chronically annoyed customers than millions of happy ones.

Most system administrators I know who work with Windows NT all the time agree that when it hits a snag, it has to be rebooted, and when it gets seriously messed up, the only way to fix it is to reinstall the operating system from scratch. Or at least this is the only way that
they know of to fix it, which amounts to the same thing. It is quite possible that the engineers at Microsoft have all sorts of insider knowledge on how to fix the system when it goes awry, but if they do, they do not seem to be getting the message out to any of the actual system administrators I know.

Because Linux is not commercial—because it is, in fact, free, as well as rather difficult to obtain, install, and operate—it does not have to maintain any pretensions as to its reliability. Consequently, it is much more reliable. When something goes wrong with Linux, the error is noticed and loudly discussed right away. Anyone with the requisite technical knowledge can go straight to the source code and point out the source of the error, which is then rapidly fixed by whichever hacker has carved out responsibility for that particular program.

As far as I know, Debian is the only Linux distribution that has its own constitution (http://www.debian.org/devel/constitution), but what really sold me on it was its phenomenal bug database (http://www.debian.org/Bugs), which is a sort of interactive Doomsday Book of error, fallibility, and redemption. It is simplicity itself. When I had a problem with Debian in early January of 1997, I sent in a message describing the problem to [email protected]. My problem was promptly assigned a bug report number (#6518) and a severity level (the available choices being critical, grave, important, normal, fixed, and wishlist) and forwarded to mailing lists where Debian people hang out. Within twenty-four hours I had received five e-mails telling me how to fix the problem:
two from North America, two from Europe, and one from Australia. All of these e-mails gave me the same suggestion, which worked, and made my problem go away. But at the same time, a transcript of this exchange was posted to Debian’s bug database, so that if other users had the same problem later, they would be able to search through and find the solution without having to enter a redundant bug report.

Contrast this with the experience that I had when I tried to install Windows NT 4.0 on the very same machine about ten months later, in late 1997. The installation program simply stopped in the middle with no error messages. I went to the Microsoft Support website and tried to perform a search for existing help documents that would address my problem. The search engine was completely nonfunctional; it did nothing at all. It did not even give me a message telling me that it was not working.

Eventually I decided that my motherboard must be at fault; it was of a slightly unusual make and model, and NT did not support as many different motherboards as Linux. I am always looking for excuses, no matter how feeble, to buy new hardware, so I bought a new motherboard that was Windows NT logo-compatible, meaning that the Windows NT logo was printed right on the box. I installed this into my computer and got Linux running right away, then attempted to install Windows NT again. Again, the installation died without any error message or explanation. By this time a couple of weeks had gone by and I thought that perhaps the search engine on the
Microsoft Support website might be up and running. I gave that a try, but it still didn’t work.

So I created a new Microsoft support account, then logged on to submit the incident. I supplied my product ID number when asked, and began to follow the instructions on a series of help screens. In other words, I was submitting a bug report just as with the Debian bug tracking system. It’s just that the interface was slicker—I was typing my complaint into little text-editing boxes on web forms, doing it all through the GUI, whereas with Debian you send in a simple e-mail “telegram”. I knew that when I was finished submitting the bug report, it would become proprietary Microsoft information, and other users wouldn’t be able to see it. Many Linux users would refuse to participate in such a scheme on ethical grounds, but I was willing to give it a shot as an experiment. In the end, though I was never able to submit my bug report, because the series of linked web pages that I was filling out eventually led me to a completely blank page: a dead end.

So I went back and clicked on the buttons for “phone support” and eventually was given a Microsoft telephone number. When I dialed this number, I got a series of piercing beeps and a recorded message from the phone company saying, “We’re sorry, your call cannot be completed as dialed.”

I tried the search page again—it was still completely nonfunctional. Then I tried choosing PPI support (Pay Per Incident) again. This led me through another series
of web pages until I dead-ended at one reading: “Notice—there is no Web page matching your request.”

I tried it again, and eventually got to a Pay Per Incident screen reading: “OUT OF INCIDENTS. There are no unused incidents left in your account. If you would like to purchase a support incident, click OK—you will then be able to prepay for an incident….” The cost per incident was $95.

The experiment was beginning to seem rather expensive, so I gave up on the PPI approach and decided to have a go at the FAQs posted on Microsoft’s website. None of the available FAQs had anything to do with my problem except for one entitled, “I am having some problems installing NT,” which appeared to have been written by flacks, not engineers.

So I gave up and still, to this day, have never gotten Windows NT installed on that particular machine. For me, the path of least resistance was simply to use Debian Linux.

In the world of open source software, bug reports are useful information. Making them public is a service to other users, and improves the OS. Making them public systematically is so important that highly intelligent people voluntarily put time and money into running bug databases. In the commercial OS world, however, reporting a bug is a privilege that you have to pay lots of money for. But if you pay for it, it follows that the bug report must be kept confidential—otherwise anyone could get the benefit of your ninety-five bucks!

This is, in other words, another feature of the OS mar
ket that simply makes no sense unless you view it in the context of culture. What Microsoft is selling through Pay Per Incident isn’t technical support so much as the continued illusion that its customers are engaging in some kind of rational business transaction. It is a sort of routine maintenance fee for the upkeep of the fantasy. If people really wanted a solid OS they would use Linux, and if they really wanted tech support they would find a way to get it; Microsoft’s customers must want something else.

As of this writing (January 1999), something like 32,000 bugs have been reported to the Debian Linux bug database. Almost all of them have been fixed a long time ago. There are twelve “critical” bugs still outstanding, of which the oldest was posted seventy-nine days ago. There are twenty outstanding “grave” bugs, of which the oldest is 1166 days old. There are forty-eight “important” bugs, and hundreds of “normal” and less important ones.

Likewise, BeOS (which I’ll get to in a minute) has its own bug database (http://www.be.com/developers/bugs) with its own classification system, including such categories as “Not a Bug,” “Acknowledged Feature,” and “Will Not Fix.” Some of the “bugs” here are nothing more than Be hackers blowing off steam, and are classified as “Input Acknowledged.” For example, I found one that was posted on December 30, 1998. It’s in the middle of a long list of bugs, wedged between one entitled “Mouse working in very strange fashion” and another
called “Change of BView frame does not affect, if BView not attached to a BWindow.” This one is entitled:

R4: BeOS missing megalomaniacal figurehead to harness and focus developer rage

and it goes like this:

Unfortunately, the Be bug reporting system strips off the names of the people who report the bugs (to protect them from retribution!?) therefore I don’t know who wrote this.