An ISA, short for Instruction Set Architecture, is the convention that allows programmers to talk to computers. The programmer can write a string of bits, give it to a CPU, and the CPU will do something. It is the most basic form of programming language. In fact, all programming languages are eventually turned into a series of bits based off of the ISA. 9The series of bits is sometimes called Assembly Language, but that isn't important here.)

ISAs that are practically used are generally brittle. This means that if a random bit flips in an instruction, the results will likely be catastrophic (for the execution of the program, that is). Although this isn't a purposeful choice on the parts of the designers of these ISAs, it isn't necessarily a bad thing. Consider, for example, an ATM. if a “cosmic ray” hits the CPU, and an instruction has a bit flip, we (or, at least, the bankers) don't want it to continue running as if nothing had happened, as this could lead to a loss of money. Instead, they would rather the program fail, and just be rebooted.

Brittleness is caused by two main factors.

• The first factor is what I call structural fragility. The most important aspect of an ISA is control flow. This is because a program is really only useful when it can make decisions. Since programs are written as a 1D string of commands, decisions are made by jumping to certain locations in the program. This is no problem for normal programs written by normal people, but when mutation occurs, the changes can be drastic.
• The second factor is what I call fault intolerance. In a normal computer, errors do happen. Someone will open up calc.exe and divide 5 by 0. For modern computers, this is no problem. When an error, or fault, occurs, the operating system will step in and deal with it, and give the program a slap on the wrist. This means that mutations to source code occur, they are quickly stopped if they happen to cause a fault.