The Marvel That Became a Menace

The Therac-25, conceived in the early 1980s, was a groundbreaking advancement in medical technology. It ingeniously integrated two radiation therapies into one efficient machine, promising high precision in treatment. Yet, beneath its polished surface, a catastrophic flaw resided within its programming.

The software was not an advanced artificial intelligence; rather, it consisted of a straightforward series of commands written in assembly language. Within this programming lay a small yet dangerous error known as a race condition. This scenario can be likened to two athletes competing for the finish line, with the final outcome hinging on who crosses it first. In terms of software, it describes a situation where two components of the program attempt to access the same resource simultaneously, leading to erratic results.

In the case of the Therac-25, this race condition was triggered when operators input commands too swiftly. This confusion in the software resulted in the machine delivering exorbitant doses of radiation—sometimes hundreds of times more than intended.

Silent Suffering

The initial victims of the Therac-25 endured their suffering quietly. They faced burns, excruciating pain, and symptoms of radiation sickness, with physicians misattributing these effects to pre-existing health issues. The software defect remained hidden, a silent menace within the machine.

The Investigation Reveals the Truth

As additional cases came to light, a discernible pattern emerged. The issue lay not with the patients, but with the machine itself. Investigators meticulously examined the software line by line and eventually uncovered both the race condition and another critical problem: an integer overflow.

An integer overflow can be compared to attempting to pour a large volume of water into a tiny glass; it simply doesn’t work. In computing, integers have predefined limits, and exceeding those limits can lead to bizarre outcomes. In the Therac-25, the integer overflow caused significant miscalculations in the radiation dosage.

While I can't provide the specific code that failed, it is widely recognized that the following issues were responsible:

Due to a race condition (a timing error in software) and an integer overflow (where a variable surpasses its maximum capacity), the machine could inadvertently administer dangerous overdoses of radiation. This resulted in serious injuries and even fatalities.

Example Code:

#include <stdio.h>

#define MAX_DOSE 500

unsigned char dose_counter = 0;

unsigned int total_dose = 0;

void set_dose(unsigned int dose) {

dose_counter = (unsigned char)dose; // Potential integer overflow

total_dose = dose_counter * 100; // Incorrect dose calculation

}

int main() {

// ... User interface code ...

// User enters a dose (e.g., 540)

unsigned int user_dose = 540;

set_dose(user_dose);

// ... Code to control radiation machine ...

// Problem: total_dose will be incorrect due to the overflow and bad calculation

printf("Total dose: %un", total_dose);

return 0;

}

Explanation:

Integer Overflow: The variable dose_counter is defined as an unsigned char, which can only accommodate values from 0 to 255. When a user inputs a dose of 540, it overflows, wrapping around to 36 (540 - 255 * 2).

Incorrect Calculation: The total_dose is calculated by multiplying the erroneous dose_counter value (36) by 100, resulting in a drastically incorrect dose of 3600 instead of the intended 54000.

The Simple Fix:

1. Data Type Adjustment: Modify dose_counter to a larger type (such as unsigned int) to prevent overflow.
2. Revised Calculation: Correct the calculation of total_dose.
3. Software Testing: Implement comprehensive testing to identify and rectify race conditions.

Lessons Learned:

1. Importance of Data Types: Selecting appropriate data types is essential to prevent overflows and related errors.
2. Concurrency Issues: Race conditions can be subtle yet perilous, particularly in systems where safety is paramount.
3. Software Testing: Thorough testing is critical to detect bugs before they lead to catastrophic consequences.