So now we’re going to look at kind of an extreme example of timing-dependent input being difficult to deal with. In the 1980s, there was a machine called a Therac-25. And what the Therac-25 was was a radiation therapy machine, and it was used to deliver a highly concentrated beam of radiation to a part of a human body where that beam could be used to destroy cancerous tissue without harming tissue that’s nearby. And as you can see, this is not, obviously, an inherently safe technology. It’s going to depend on skilled operators and also highly safe software in order to safely dose patients at the cancer site without harming the patients. So what happened with the Therac-25 was a tragic series of mistakes where 6 people were subjected to massive radiation overdoses and several of these people died. I’ll make sure to include a link about these occurrences in the supplementary material for this course. If you actually take a look at it, you’ll find that it’s really quite terrifying reading. It’s really a very scary series of accidents. The Therac-25 had a number of serious issues with its software, and we’re just going to talk about 1 of them here. The Therac-25 was a largely software-controlled device, and it had, at the time, a fairly sophisticated controller. It turned out that the people developing the software put a number of bugs into it. The particular bug that I’m talking about here was a software bug called a race condition. And what a race condition is is a scenario where different threads of execution fail to be properly synchronized, with the result being that the software containing the race conditions can actually make mistakes. This particular race condition in the Therac-25 software involved the keyboard input to the radiation therapy machine, which is what the person operating the machine used to tell the machine how to treat the patient. And what happened was if the operator of the machine typed slowly, the bug was very unlikely to be triggered. And of course while the machine was being tested, the people testing the machine weren’t very good at using it. They hadn’t used it a lot, and so they didn’t type very fast. But unfortunately, as operators in hospitals became more and more familiar with this machine, as they treated hundreds and hundreds of patients, what happened was these people got very good at operating the machine, they typed faster and faster, and eventually they started triggering this bug. And the effect of this bug, unfortunately, was to deliver massive radiation overdoses to patients. And, as I said, this led to several fatalities. And so the kind of quandary that this scenario raises for us as software testers is do we have to care about the time at which inputs arrive at our software under test, or can we not worry about that? And so obviously, for the Therac-25 and obviously, also for something like a Linux kernel, the time at which inputs arrive is relevant. On the other hand, unless we’ve been extremely sloppy, the square root function that we’ve been talking about won’t care about the time at which its inputs arrive.