Computing for Heretics


Vision 11


Computing for Heretics


Bob Billing

Copyright © 2002, Bob Billing, All Rights Reserved

I spent two years writing and then editing Run from the Stars. The manuscript is well over six hundred pages, or one hundred and twenty thousand words. In twenty-four months and around a million keystrokes I didn't have a single crash or loss of data.

In this article I'd like to tell you how I did it.

I've been around computers for something like thirty years and in that time I've seen a lot of changes, many of them for the worse. When I started programming a computer was a room full of simmering electronics; now it'll slip in my pocket.

Most people who use computers today are unaware of how they work or even what the major parts are. This is why they are not only frustrated by what happens, but also fall victim to some really dreadful scams.

The first thing to remember is:




In this case TOMCAT stands for "Totally Obedient Moron, Can't Actually Think." A computer is a machine that obeys instructions. It has memory in which it can store both instructions and information - that's what the Megabytes of RAM in the advert means. A byte is a unit of information, it can hold one character of text or a small number, or part of a larger thing such as an image. A megabyte is a million bytes - in fact slightly over a million.

Instructions are stored as numbers. They tell the computer to do really simple things, like add two numbers together, read a keystroke from the keyboard or send a character to the printer. Some instructions do what's known as changing the "flow of control." They tell the computer where to look in memory for its next instruction.

Programs such as games and word processors are made by joining together lots of simple instructions so that the computer can do complex things. The word "software" simply means "big dollops of joined-up instructions that do something pretty impressive."

The problem with this is that the computer wants its instructions in the form of blocks of numbers. These are almost unreadable to humans. I have programmed by writing the numbers directly, but it's a miserable, thankless business.

The craft of writing software, or programming as it's called, isn't done that way. If someone wants to create a word processor or a web browser they write what's called source code in a programming language. The current fashionable language is called C for reasons that make a kind of sense for other programmers.

Source code looks something like this:


/* Block loop */

      for ( K = 0;; K++ )


          /* Read file in buffer-sized lumps */

          R = fread ( Main_Buffer, 1, Buffer_Size, In ) ;


          if ( R )


                if ( K )


                  /* Not start of file, write the saved char */

                  putchar ( Last ) ;

                  Base = 0 ;



Not perhaps the most comprehensible thing in the world, but easy enough to learn to write.

The source code is then translated into instructions by a program called a compiler.

Companies that sell software usually keep the source code to themselves and only give you the actual instructions, or what's called the binary.

There are two sorts of programs. System programs, such as windows or MacOS, directly communicate with the hardware. They do things like working the disk drive and drawing on the screen. Applications are games, web browsers, word processors and any other programs that you use. When an application wants to access the disk, for example, it issues a request to a system program which then does the operation.

This is where it all began to go wrong. When I started programming computers were big, expensive and shared between many users. The system software was designed to keep the users apart. It wouldn't allow one user access to another user's files, and only the people controlling the machine could make changes to the system software. In this way a user couldn't either accidentally -- or on purpose -- hurt another user, or damage the system.

Then the PC came along. Because it didn't make a real distinction between users, or between user and system, any program could change anything. This didn't matter until people started connecting PCs to the internet. Then it only took a few days for someone to work out how to write a program that would send a copy of itself to another computer, and when it arrived, it would build itself in to that machine and send itself on. Because any program could change anything the virus problem was born.

The older machines which ran operating systems such as Unix, RSX or VMS, and which did impose distinctions between users weren't affected. The main reason for this is that a virus on one of these systems would be running as a user program so it couldn't affect the system or another user.

Occasional exploits against these systems do happen, but they're very rare and getting rarer. Basically an exploit is something that makes use of an error in the system software to get a privilege that the program shouldn't have. But it's making use of an error that can be fixed without stopping the applications working. If all the errors are one day fixed the exploits will finally stop.

Not so with viruses - they work because of design decisions, such as choosing to give all programs equal ability to access the hardware. These decisions can't be changed without stopping old application software from working. Some applications, such as scandisk, legitimately make use of this sort of access.

So why can't we have an operating system with a distinction between system and applications that runs on a PC? If we did we could kill the virus problem stone dead overnight, and we could protect the system software from the results of an application doing something absurd.

We have. In fact there are several systems on the market that will do this.

The one I use is called Linux. The word is formed from the name of Linus Torvalds, the creator of the kernel of the operating system, and Unix, the older system it resembles. He wrote the original code and began swapping it with a few friends over the internet. Linux is copyright but it's released under a different kind of software license called the General Public License  which permits the user to do almost anything as long as they don't try to interfere with someone else's freedom.

Linux is a huge collection of software from a large number of software authors. It consists of the kernel itself (the core of the system software), various system tools, and lots of applications.

It's effectively free. The GPL requires that anyone who has GPL software is entitled to copy it and use it on any number of computers. In fact it insists that nobody is allowed to stop them.

This includes copying the source code. On the rare occasions I've had problems I've been able to look at the original source as written by the programmers and figure out what's wrong, and then fix it. Of course not everyone has the skill to do this, but plenty of people have ,and they can bought with consultancy fees, chocolate or beer.

In fact it's been a standing joke for some years: When someone's come to me with a problem I've put on the Obi-Wan voice and said, "Use the source, Luke."

In the early days Linux was a bit chaotic. It was difficult to keep track of which versions of what programs existed, and what was compatible with what.

Now we have distributions. There are companies such as RedHat and SUSE who will sell you a complete packaged build of Linux complete with applications. Once you've got the distribution you can install it on as many machines as you like and even make copies of the disks.

These companies make their money not from the actual software - which is effectively given away - but from selling consultancy, telephone support and printed handbooks.

Because the underlying system is essentially the same as Unix, it can run the X-window system. This is a foundation on which a graphical user interface can be built. There is a choice of GUIs which you can run with X, the two commonest being KDE and Gnome. Both give you a desktop, a task bar at the bottom of the screen, a start menu and more or less everything you are used to.

The difference with X is that it does some rather wonderful tricks. It can run multiple desktops, you can have a lot of applications open then click on a button and effectively start again with a new computer and run some more programs, then switch back to the old one. As I type I've got eight desktops running on this machine. Once you connect X-windows to a network something magical happens. You can run a program on one computer and have its windows displayed on another. This is spectacularly useful if you want to do remote administration, or if you want to run a program that's installed on another machine.

Linux also offers you the command line interface. Not everyone wants this, and if you aren't interested you can ignore it. However it's very useful if you want to do anything that involves running the machine unattended. It's very easy to use the CLI to do something after a delay, or only if the previous operation worked.

There's plenty of application software. The StarOffice, Applix and Corel office suites all run on Linux. There's a free program called Gimp that's almost a clone of Photoshop. I used a planetarium program called xephem to see the night sky hundreds of years ahead for one scene in the book.

The network and internet support on Linux is very good and includes a lot of setup and troubleshooting tools.

You may want to go on running MS Office - now you can do that as well. There's an emulator at  which will let you run it on Linux. Alternatively you can go to  and get a virtual machine emulator which will run the whole of windows, including all the applications, in one window under Linux. If the captive copy of windows then crashes vmware has the rather disconcerting ability to wind time backwards to the beginning of the session, before your files got trashed, and let you try again.

Linux isn't the ultimate solution.  It still has some problems, but it does work, and I found that once I had it running it was a cheaper and more reliable alternative.