Why Code Is Important

Modern Industrialized nations have based their societies on technology run by software. This code compiles into digital computer instructions. Digital is made of binary switches (or bits) of ones and zeros.

Code, if not written to respond safely to all possible contingencies, may produce a zero when the computer expects a one, or vice versa. This simple error may halt the computer—or worse.

Digital, due to its binary nature, is inherently brittle: it either works or not—there is no sort-of-works. Unlike analog, which degrades gradually over time, digital (if not programmed for all contingencies) may suddenly and unexpectedly stop.

Compare VCRs to DVDs. Tape stretches but it isn’t very noticeable. Tape breaks but can be easily spliced with very little loss of signal. Merely scratching a DVD can make it unplayable. Everything may appear intact, but it just takes one lost bit.

The programs we depend on daily are also brittle but unlikely to lose bits. Or so we think. A sufficient electromagnetic pulse or EMP (think small nuclear device) will destroy those bits unless your machine is “hardened” as are many military computers.

Once upon a time, dividing by zero would stop a computer cold. Since there were too many ways this could occur, the solution was to have the hardware check every division to make sure the divisor was not zero. If it was, the program—not the computer—was halted and an error message displayed.

A program and its data on our hard drives is inaccessible to other programs that write to hard drives. Those programs are constrained by system software, prevented from writing where they shouldn’t.

This solution depends on correct system software. It is not as safe as hardware trapping division by zero. Programs that write where they shouldn’t, are classed as viruses; they know how to get around system software protection.

These are simple examples of potential problems for programmers. Above, I used the word “contingencies” twice. To grasp the extent of possible contingencies, a programmer must be aware of the total environment in which the code must run.

There will be many different computers, each with a unique hardware configuration. Different CPUs means different instruction sets. Many computers have multiple processors (e.g., quad) requiring multi-threaded code.

Code must run on many different operating systems. Even the same operating system is configured differently according to installed updates, hardware drivers, customization, etc.

Then there’s the problem of many unknown programs running simultaneously or interrupting according to their own needs. Or crashing and interfering with the code. Or the intentional disruption of hackers.

It’s easy to see that code running successfully under all these contingencies is far more valuable to society than code that chooses cleverness over safety. Since digital is inherently brittle, code must be robust. Simpler code is easier to secure than complex.

No Exit

Despite the title, this is not about the play of that name by Jean-Paul Sartre. Yet this post is, to a large extent, existential. It asks the question, if our machines ignore us, do we exist? I know this may look like a joke. It’s not.

First, we must expand our definition of a machine. Hardware, while the most conspicuous part, is not the whole. The controls of a machine are equally essential. They can be analog (steering wheel), or automatic (computer regulating the car’s engine), or interactive (infotainment system). Without controls, a machine is a useless lump of metal (or plastic or both).

If we can’t control a machine to do our bidding—assuming what we want is within its capabilities—then one might say (as a philosopher might) that the machine is ignoring us. Of course, you could choose, as most of us would, to say you exist regardless of the machine’s behavior. You do, but in a universe apart from that machine.

Does it matter? On a less philosophical level, yes. If we can’t control our machines, if we permit them to ignore us—and our wishes—then clearly they do not serve us. If they are not servants in this relationship, how can we claim to be masters?

Dropping down into practical mode, I offer some personal experience. Back in the early days of owning your own computer, the first thing I did with anything new, hardware or software, was learn how to stop it. I wanted to be sure I could minimize the damage should things go awry.

These days, on my latest device (Kindle tablet), I find most programs (now called apps) have . . . wait for it . . . No Exit. What the hell? Not only can’t you exit this software, you can’t get it off your machine. Their uninstall doesn’t really do it; you need special apps to do a thorough job.

And worse. These devices never really shut down. They pretend to sleep, but really they’re lurking, waiting to serve their real masters. For the Kindle, that means Amazon and the Apps (not a rock band). Today’s machines are primarily a medium to expedite our servitude.