Can Writing Rust Code Provide the Same Brain Protection as Taxi Driving? A Thought Experiment

In 2024 researchers examined about 9 million U.S. death certificates across 443 occupations and discovered that taxi and ambulance drivers have the lowest proportion of deaths from Alzheimer’s disease—roughly 1 % after adjusting for age, gender, race and education, compared with an average of 1/60 for all occupations.

The authors attribute this protective effect not to driving itself but to the drivers’ need for continuous, real‑time, non‑GPS spatial navigation, which forces them to keep an ever‑updating mental map of their location, destination and route changes.

Inspired by this finding, the article draws a parallel to programmers who write Rust code. Rust’s ownership, borrowing and lifetime rules compel developers to maintain a dynamic mental map of which piece of memory belongs to whom, who is borrowing it, and how long the borrow remains valid. In contrast, languages with garbage collection (Java, Python, JavaScript, Go) offload that bookkeeping to the runtime, similar to a navigation app handling route planning.

Example code illustrates the point:

fn main() {
    let city_map = String::from("上海"); // city_map owns this memory
    let route = describe(&city_map);          // temporarily borrow "city_map"
    println!("{}: {}", city_map, route);   // city_map is still valid because it was only borrowed
}

fn describe(name: &String) -> String {
    format!("目的地是 {}", name)
}

The compiler will reject any code that violates these ownership relationships, forcing the programmer to constantly visualize a "resource‑ownership → borrow‑chain → lifetime" graph and correct it when the compiler reports an error.

This mental‑map activity mirrors the taxi driver’s need to constantly update a spatial map: both require continuous, non‑outsourced relational reasoning.

However, the analogy has clear limitations. There is currently no sample of Rust programmers to test Alzheimer’s incidence, and high cognitive load does not automatically translate into neuroprotective effects; long‑hours of coding, stress and poor ergonomics may offset any benefit. Moreover, other programming domains (e.g., distributed Java systems, functional Haskell code) also demand complex mental modeling, so attributing protection solely to Rust is a survivorship bias.

Additional research cited includes a 2023 machine‑learning study that predicted Alzheimer’s risk from the spatial complexity of a neighborhood’s street network with 84 % accuracy, and the broader concept of "cognitive reserve"—the brain’s ability to withstand pathology through sustained mental activity.

The real protective factor is likely the sustained cognitive complexity itself, not any particular profession or language.

Consequently, while writing Rust forces a high level of mental bookkeeping and may serve as a form of cognitive exercise, there is no empirical evidence that it reduces Alzheimer’s risk. The more robust inference is that any work requiring continuous, non‑automated mental modeling could provide similar "cognitive‑training" benefits.