The Mount Rushmore Programmers of the Computing WorldFour Programmers and the Digital Civilization Beneath Their Feet

(0) An Old Man and a Raspberry Pi

According to colleagues who worked alongside him at Google, there was a white-haired old man who, with a top-of-the-line company workstation at his disposal, preferred to write code on a $35 Raspberry Pi.

In his later years he even gave up macOS, switching to Raspbian — a Linux distribution that runs on the Raspberry Pi. The father of Unix, in the end, returned to the very lineage of operating systems he had founded with his own hands.

This old man was named Ken Thompson.

He is a member of the National Academy of Engineering (elected 1980) and a member of the National Academy of Sciences (elected 1985).

What do these two credentials mean? The National Academy of Engineering and the National Academy of Sciences, together known as "the two academies," form the highest system of honor in American science. To be admitted to one is already to stand at the summit; those admitted to both are called "dual academicians." Mapped onto China's frame of reference, it is roughly equivalent to being elected simultaneously to both the Chinese Academy of Sciences and the Chinese Academy of Engineering — and in modern Chinese history, the only people to reach that tier belong to the echelon of Qian Xuesen, Qian Sanqiang, and Deng Jiaxian. And Ken Thompson wears one more crown on top of it: the Turing Award of 1983, the Nobel Prize of computer science.

A man like this, 83 years old, is reportedly still writing code on a $35 machine.

But what I want to talk about today is not only him.

I want to talk about four people. Four programmers. Between them runs a hidden thread that spans half a century and stitches together nearly every technology you are using at this very moment.

(1) Ken Thompson — Three Weeks and a Discarded Computer

1969, New Jersey, Bell Labs.

At the time, Bell Labs was in the most legendary golden age in the history of human technology — the transistor was invented here, information theory was born here, radio astronomy began here. The people you brushed past in the hallways were future Nobel laureates.

In this place teeming with geniuses, Ken Thompson was just a young engineer.

The lab was then taking part in a large operating-system project called Multics. Multics, short for Multiplexed Information and Computing Service — a system of enormous ambition, whose goal was to let many people share a single mainframe simultaneously. But the project grew ever more bloated, and Bell Labs eventually pulled out.

Ken was not resigned to it. The lab had a discarded PDP-7 sitting in a corner gathering dust. He picked it up. His wife had taken the children home to visit family, and he shut himself alone in the office.

According to the account that later spread widely, he spent about three to four weeks — one week each for the operating-system kernel, the shell command line, the editor, and the assembler. His later partner Dennis Ritchie called this stretch "three weeks," and the tech world grew accustomed to that more legendary version.

Whether three weeks or four, he wrote a new system. His colleagues gave it a name: Unics — Uniplexed Information and Computing Service. It was a play on words: Multics was "multiplexed," too complicated; Ken's system did the opposite, so simple it did only one thing but did it to perfection, hence "uniplexed." Later Unics was abbreviated to Unix.

At the time almost no one paid attention to this. Unix at first didn't even have an official project number. Bell Labs management thought it was nothing more than a young man's little toy.

But it was precisely this "little toy" that would later give rise to the underlying logic of BSD, macOS, iOS, and Android. According to W3Techs' ongoing monitoring, Linux (Unix's direct descendant) has long held over 96% of the world's top web servers. The moment you unlock your phone, the code logic Ken Thompson typed out more than half a century ago is running in the palm of your hand.

Of course, Unix was not Ken's achievement alone. His colleague Dennis Ritchie (who shared the 1983 Turing Award with him) later rewrote Unix in the C language he himself had invented, turning it from a prototype on a single machine into a general-purpose system portable to any hardware. Without Ritchie's C language, Unix could never have left Bell Labs. The collaboration of the two — Thompson's systems intuition plus Ritchie's genius for language — was the complete Genesis.

Ken's contributions go far beyond Unix.

One day in 1992 — as Robert Pike himself has recalled many times in public talks — while he and Ken were having dinner at a restaurant in New Jersey, the two of them doodled back and forth on a napkin (or a paper tablecloth; accounts differ slightly across versions) and designed an encoding scheme called UTF-8. That design on that piece of paper is what lets Chinese, Arabic, Japanese, and emoji coexist peacefully on the same web page. Every Chinese character you see right now runs, underneath, on the scheme drawn on that dinner table.

In his seventies, together with Robert Pike and Robert Griesemer, he designed the Go language at Google. A programming language made by a man in his eighties runs today across the world's cloud-computing infrastructure.

But what still sends chills down the spines of security researchers to this day is his Turing Award lecture. Ken Thompson received the Turing Award in 1983 and, the following year (1984), formally delivered that lecture, titled "Reflections on Trusting Trust," published in the Association for Computing Machinery's authoritative journal Communications of the ACM.

On stage he demonstrated one thing: you can plant a backdoor in a compiler so that, when it compiles a particular program, it automatically inserts malicious code — and this backdoor can replicate itself, so that even if you obtain the compiler's source code and review it line by line, you find nothing amiss. Because the backdoor hides in the compiler's binary, and every time a new version of the compiler is built it quietly passes itself down.

In 1984, the term "supply chain attack" did not yet exist. But Ken Thompson, from the podium of the Turing Award, showed this specter to the whole world in the most elegant way, nearly forty years ahead of its time.

Forty years on, has this problem been solved?

The answer is: partly solved, but never cured.

Later security researchers invented a method called "Reproducible Builds" — put simply: if you compile with the same source code, the same toolchain, and the same environment, you should get exactly the same binary, bit for bit. If it differs, something fishy happened in between. This idea began to spread in operating-system communities like Debian and Arch Linux in the 2010s, and today it has become standard equipment in security infrastructure.

But the truly terrifying part Ken Thompson revealed lies one layer deeper: if the compiler itself is contaminated, what do you use to compile that "clean" compiler? It is a chicken-and-egg problem. To truly break the cycle, you must start from a point you completely trust — and "complete trust" is itself a philosophical question.

This may be the only case in computer science where a technical problem is elevated into a philosophical one. A bottomless pit about trust. Ken Thompson threw a stone into it in 1984, and no echo has been heard yet.

That is this man. He built the foundation of a civilization, and while he was at it, pointed out that a bomb might be buried within that foundation.

Then he signed off with Love, ken, and went back to writing code.

(2) Linus Torvalds — A Chain Reaction in a Dorm Room

August 25, 1991, University of Helsinki, Finland.

A 21-year-old student posted an email on Usenet:

"I'm doing a (free) operating system (just a hobby, won't be big and professional like gnu)."

This student was named Linus Torvalds.

At the time he just wanted to get a usable operating system for his own 386 computer. He couldn't afford a Unix license, and the Minix from his textbook was too restrictive, so he might as well write one himself.

He named his system Linux. The origin of the name is straightforward: Linus + Unix = Linux. An operating system written by a Finnish university student, inspired by Unix. The name is both a tribute and a declaration — I stand on the shoulders of giants, but I mean to walk my own road.

"Just a hobby."

Thirty-four years later, this "hobby" underpins over 96% of the world's top web servers, over 70% of smartphones (Android), nearly all supercomputers, and the underpinnings of the cloud-computing infrastructure you use every day.

Linus stood on Ken Thompson's shoulders, but walked an entirely different road. Ken was in the golden age of Bell Labs, with the best hardware and colleagues; Linus was in a dorm room, relying on volunteers who were strangers to him on the internet.

Ken built the foundation; Linus built on that foundation the largest collaborative engineering project in the world.

His weapon was not a flash of genius, but an extreme sense of taste — he knew what code belonged in the kernel and what code should get lost. And the way he expressed "get lost" was written into history in the tech world.

(3) F**k You and the Man Who Doesn't Get Angry

June 2012, Aalto University, Finland.

Linus stood on the stage, the seats filled with students. Someone raised a hand and asked: what do you think of NVIDIA's support for Linux drivers?

Linus's answer was captured in full by the camera.

He first calmly said a few words, calling NVIDIA "the single worst company we've ever dealt with." Then he faced the camera and raised his middle finger.

"So, NVIDIA — fuck you."

The video went up on YouTube. The original video alone racked up over twenty million views. And that was just one source on YouTube — over fourteen years, this clip has been re-recorded, cut, screenshotted, and turned into GIF memes countless times, spreading again and again across Reddit, Twitter, Instagram, Bilibili, and all manner of tech blogs and short-video platforms. That freeze-frame of Linus flipping the bird became one of the most widely circulated memes in the global developer community. Conservatively estimated, its cumulative cross-platform reach runs into the tens of millions to hundreds of millions.

But the truly interesting part of this story is not the man giving the finger — it's the party on the receiving end.

Jensen Huang.

Founder and CEO of NVIDIA. An immigrant boy who came out of Tainan, bullied in his early teens at a boarding school in the American Midwest, who later built the most valuable chip company in the world by market capitalization.

His reaction?

No reaction.

No statement, no counterattack, no legal letter. When later asked about it in public settings, he smiled and acknowledged that NVIDIA could indeed do better.

Linus flipped the bird at the camera, and the entire tech world applauded.

Jensen Huang didn't get angry, and the entire tech world admired him all the more for it.

Two men, two postures, and in a certain sense both winners.

But the real ending is a hundred times more fascinating than a contrast of personalities. Because this is not a story about temper. This is a story about the free market.

When Linus flipped the bird in 2012, NVIDIA's core revenue came from gaming graphics cards. Gamers use Windows, not Linux. So NVIDIA was careless about Linux driver support — the market gave it no reason to take the matter seriously.

Then AI arrived.

In 2022, ChatGPT set off a global AI arms race. Training large language models requires tens of thousands of GPUs. And where do these GPUs run? On Linux clusters. All of the world's AI training infrastructure — OpenAI, Google, Meta, Anthropic, xAI — runs, without exception, on Linux as the underlying operating system. There is no Windows option.

NVIDIA's revenue structure underwent a tectonic shift:

(Note: the above are NVIDIA's official financial figures; the fiscal year ends in January of the following year.)

In four years, the data center went from four-tenths of revenue to nearly nine-tenths. Gaming — once the core business — became a rounding error.

And these data center customers — AWS, Google Cloud, Azure, Alibaba Cloud — all run Linux. They need NVIDIA's GPU drivers to be deeply integrated with the Linux kernel, they need to be able to audit the security of driver source code, they need the flexibility to customize the kernel. A closed-source binary driver blob cannot meet these needs.

In May 2022 — precisely the quarter in which data center revenue first surpassed gaming revenue — NVIDIA announced it would open-source its GPU kernel modules.

In 2024, NVIDIA went a step further: its new-generation data center chips, the Grace Hopper and Blackwell architectures, support only open-source kernel modules, with the closed-source kernel driver path cut off entirely. Not a multiple-choice question, but a mandatory one. (It should be noted: what NVIDIA open-sourced is the GPU's kernel modules — the layer that deals directly with the Linux kernel; while user-space components like CUDA, OpenGL, and Vulkan remain closed-source. This is not full open source, but it is the biggest concession NVIDIA has made in thirty years.)

That September, at the Open Source Summit, Linus Torvalds was asked what he thought of NVIDIA. This time he did not flip the bird. He said: NVIDIA is now "doing really good work."

From 2012 to 2024, from "fuck you" to "really good work."

This was not Jensen Huang's magnanimity winning Linus over, nor Linus's middle finger scaring NVIDIA. What changed NVIDIA was not morality, not community pressure, not Linus's temper — it was the fact that 88% of $194 billion in annual revenue runs on Linux.

The free market accomplished what twenty years of community complaints could not.

Adam Smith, were he alive, would probably nod with a smile: it is not from the benevolence of NVIDIA that we get good Linux drivers; it is because NVIDIA needs to sell GPUs to Linux users that we get good Linux drivers.

This is one of the most perfect cases in the textbooks of free-market economics: when all your biggest customers run open-source systems, you are forced to embrace open source. Not a choice, but survival. The man who gave the finger and the man who didn't get angry were, in the end, pushed by the market into the same boat.

And Linus's temper was far from a one-time affair.

On C++:

"C++ is a horrible language... even if the choice of C were to do nothing but keep the C++ programmers out, that in itself would be a huge reason to use C."

On the GNOME desktop environment:

"I think the GNOME people are on drugs."

After saying so he switched to KDE. KDE had a bug, so he cursed KDE too. Then he switched back to GNOME. The community turned this back-and-forth into a meme.

The Tanenbaum-Torvalds debate (1992):

Andrew Tanenbaum, an authoritative professor in the field of operating systems, publicly said that Linux's monolithic-kernel design was "obsolete." The 22-year-old Linus rebutted him point by point on the mailing list. This debate was written into operating-systems courses around the world as a classic case, and the microkernel-vs-monolithic-kernel dispute has run on for thirty years. Thirty years later, Linux runs on 96% of servers. The textbook's "correct answer" lost, in the server market, to a college student's "obsolete design" — although the idea of the microkernel never truly died; it lives on in hybrid-kernel form beneath macOS and iOS (the XNU kernel, Mach + BSD), and also influenced later experimental systems like Fuchsia.

But after more than twenty years of cursing, in September 2018, Linus suddenly posted an open letter.

"I am not an idealized, emotionless person... I need to change some of my behavior, and I want to apologize to the people that my personal behavior hurt and possibly drove away from kernel development entirely."

The entire tech world was shaken.

A man who had cursed his whole life suddenly apologized. Not because he was forced to — there was no lawsuit, no PR crisis. He simply looked in the mirror one day and felt something was wrong.

He announced he was temporarily stepping away from kernel maintenance to seek help with emotional management. He came back a few weeks later, his temper noticeably reined in. But his standard for code review — meticulous, uncompromising — never dropped.

By the way, although Linus is Finnish, he emigrated to the United States back in 1997. First in Silicon Valley, later settling in Portland, Oregon, and he took American citizenship in 2010. Every day he maintains the Linux kernel from home — a Finn sitting in a house in the northwest corner of America, guarding the world's digital infrastructure.

In February 2026, Linus signed a commit. Not a bug fix, nor a new feature.

What he signed was the Linux kernel's first succession plan in thirty-four years.

The most likely successor is Greg Kroah-Hartman, maintainer of the Linux stable branch. A man who, like Linus, holds code quality as his highest article of faith.

Linus is 56 this year, and still writing code. But he has clearly begun to ponder one thing:

When he is gone, can this machine keep turning?

And what most endures across time is not any of the famous cursing moments, but the line printed on programmers' T-shirts around the world:

"Talk is cheap. Show me the code."

(4) Avi Kivity — The Quietest Gatecrasher

If Ken Thompson and Linus Torvalds are figures in the spotlight, then Avi Kivity is the kind of person you may never have heard of, yet whose creation you use every single day.

Israel. A background in aerospace engineering. Switched to software.

In 2006, at the small company he founded, Qumranet, he wrote something called KVM — Kernel-based Virtual Machine.

Translated into plain words: he wrote a piece of code that lets a single physical computer pretend to be many computers.

This sounds utterly unremarkable. But think about it: AWS, Alibaba Cloud, Tencent Cloud, Azure — the "cloud servers" that every cloud provider in the world sells you all need this kind of virtualization technology underneath. That "cloud server" you paid for is, in essence, a small slice virtualized out of one big computer. And the underlying technology doing this work is, in all likelihood, KVM.

Worth noting on the timeline: on October 19, 2006, Avi formally submitted the KVM code to the Linux kernel mailing list. That same year, on the other side of the planet at Google's headquarters, Jeff Dean's BigTable paper had just been published in November. Two men made their most important contributions in the same year — one doing virtualization at the very bottom of the operating system, the other doing distributed storage at the very top. Strangers to each other, unconnected, yet their work would later be reunited in every data center on earth: Jeff Dean's systems run on machines virtualized by KVM.

What's interesting is the way Avi submitted his code.

The Linux kernel's code review is one of the strictest code reviews in the world. Linus himself is the pickiest gatekeeper — he has cursed away countless submitters who fell short.

Avi did not charge in head-on.

Before he formally submitted, he first lurked on the Linux kernel mailing list for a long time. He carefully observed the review standards of Linus and the other maintainers, studying what kind of code passed and what kind got cursed. Only once he had grasped the rules did he make his move.

The result: on February 4, 2007, Linux 2.6.20 was released, and KVM was formally merged into the kernel mainline. From submission to merge, less than four months.

The mailing list for the entire review process remains publicly available to this day — and in those emails, you will not find any record of Linus losing his temper over Avi's code. In the world of the Linux kernel, that in itself is a medal.

The pickiest gatekeeper met the gatecrasher who best understood the rules.

In September 2008, Red Hat acquired Qumranet for $107 million. Avi's code became one of the foundations of global cloud computing.

But he did not stop.

After leaving Red Hat, he founded ScyllaDB, rewriting Apache Cassandra (a widely used NoSQL database) from scratch in C++. The performance improvement was not a matter of tens of percent — it was on the order of tenfold.

Twice. Twice a textbook-level act of technical creation. And you may be hearing this name for the very first time today.

(5) Jeff Dean — Building a Skyscraper on the Grandmaster's Foundation

Jeff Dean's childhood reads less like a programmer's and more like the lead of a documentary.

His father was a researcher of tropical diseases, his mother a medical anthropologist. His childhood shuttled between multiple developing countries such as Somalia and Uganda. At the age when other American kids were playing baseball, he was writing statistical software for the WHO's (World Health Organization) global AIDS program.

Later he was admitted to the University of Minnesota, earning a double degree in computer science and economics and graduating with the highest honors, summa cum laude. A PhD in computer science from the University of Washington.

He joined Google in 1999.

That year Google was still a startup of a few dozen people. Larry Page and Sergey Brin had just secured their first large round of funding. No one knew what this company would become.

After Jeff Dean walked in, he did the following:

MapReduce (December 2004). A computing model that lets tens of thousands of ordinary computers cooperatively process massive amounts of data. This paper directly gave rise to the Hadoop ecosystem and laid the foundation of the entire big-data era.

BigTable (November 2006). A distributed storage system. Later databases — HBase, Cassandra (the very one Avi Kivity would later rewrite in C++), and others of that generation — were all built only after their creators read this paper.

Spanner. A globally distributed database. The underpinning of Google Search and Google Ads.

Google Brain (2011). The AI research lab he co-founded with Andrew Ng. This lab later merged with DeepMind and became the core weapon in Google's AI arms race today.

TensorFlow (open-sourced November 2015). A deep-learning framework. It propelled the entire era of AI engineering.

Google's engineering levels run from L3 to L10, and L10 is the ceiling. Jeff Dean reached L10.

Then he declined to move into management.

Google thought it over and created a level specifically for him — L11. The one level created as an exception for an individual in all of Google's history.

And like Ken Thompson, Jeff Dean is also a dual American academician — elected to the National Academy of Engineering in 2009 (NAE, for contributions in the field of large-scale distributed systems), and to the National Academy of Sciences (NAS) in 2021. In addition, he is an ACM Fellow (2009, the same year he received the ACM Prize in Computing, shared with Sanjay Ghemawat) and a member of the American Academy of Arts and Sciences (2016). Four crowns — exceedingly rare among computer scientists.

Of the four legends, both Ken Thompson and Jeff Dean are dual academicians. One earlier, one later, spanning nearly thirty years. When Ken was elected in 1980 and 1985, Jeff Dean was still a teenage boy, shuttling around Africa with his tropical-disease-researching parents; by the time Jeff Dean was elected in 2009 and 2021, Ken was already an old man in his seventies. Two generations carved their names onto the same plaque of highest honor.

Inside Google he became a legend. Engineers made up a set of "Jeff Dean Facts," the same in nature as "Chuck Norris Facts" — using absurd exaggeration to express genuine awe:

"Knuth checked out a library book about Jeff Dean's life. It was 'The Art of Computer Programming'."

"Compilers don't warn Jeff Dean. Jeff Dean warns compilers."

This is programmer-style idol worship — deification accomplished through deadpan jokes.

And all of his work, underneath, runs on Linux. Linux traces its bloodline back to Ken Thompson's Unix.

Jeff Dean built the skyscrapers of the Google empire on the foundation laid by the grandmaster.

(6) The Coordinate Where Four Lines Intersect

2006.

This year, Ken Thompson joined Google. The grandmaster who wrote Unix in the sixties walked into the most important technology company of the twenty-first century.

That same November, Jeff Dean published the BigTable paper inside Google, laying out the next generation of distributed systems.

That same October, on the other side of the earth in Israel, Avi Kivity formally submitted the KVM code to the Linux kernel mailing list.

And guarding the kernel's entrance was Linus Torvalds — a Finn, sitting in his home in Portland, Oregon.

Four lines, converging around 2006.

Ken built Unix; Linus, upon Unix's ideas, built Linux (the name itself is Linus + Unix); Avi's code passed Linus's review and entered the Linux kernel; Jeff Dean's entire empire runs on Linux; and Jeff Dean and Ken Thompson ended up as colleagues at the same company.

Four people. Spanning half a century. Each one's work was the foundation for the next.

The most interesting is the relationship between Jeff Dean and Linus — or rather, the absence of a relationship.

Jeff Dean was born in 1968, Linus in 1969. Contemporaries. One built distributed systems at Google's Mountain View headquarters, the other maintained the Linux kernel from his home in Portland, Oregon. The straight-line distance between them is under a thousand kilometers. Google is one of the largest corporate contributors to the Linux kernel. Every system Jeff Dean built runs, underneath, on the code Linus maintains.

Yet in the public record, there is almost no trace of them ever appearing together, conversing, or commenting on each other directly.

The foundation-layer worker and the architect of the same building may never once have run into each other in the elevator.

(7) How a Genius Is Forged

Having told the stories of four people, one question hangs in the air:

Are these people's minds the same as ours?

The honest answer is: we don't know.

Neuroscience has indeed found that the brain structures of certain long-term, high-intensity trainees show differences. But the causality may be reversed — it is the extremely focused training that made the brain different, not an innately different brain that made the genius. There are no certain conclusions in this field, and anyone claiming otherwise is lying.

But if you lay the early experiences of the four people side by side, there is a common pattern:

Ken Thompson did arithmetic in binary in his head back in elementary school. Not because anyone taught him, not because it would be on a test. He just found it interesting.

Linus Torvalds wrote a kernel in a dorm room. Not to start a company, not for his résumé. He just couldn't afford Unix, so he wrote one himself.

Jeff Dean wrote statistical software for the WHO before college. Not to apply to a university, not for an internship. He was simply there, and the problem was there.

Avi Kivity switched from aerospace engineering to software, lurking first and striking later. Not anxious to prove himself, but first grasping the rules thoroughly before saying anything.

Four people, four starting points, one common trait: extreme intrinsic drive.

Not pushed forward, but charging ahead of their own accord. Not because they saw where the finish line was, but because they didn't care about the finish line at all — there were too many interesting things along the way to ever stop.

So if a formula must be given:

Some initial predisposition × extreme intrinsic drive × the environment happened to encounter × decades of deliberate accumulation.

Not one of the four factors can be missing. This is not chicken soup for the soul — it is the only common structure you can extract after taking apart the experiences of the four people.

(8) The Last Blank Page

In Ken Thompson's era, computer science was strewn with untrodden land.

An operating system? None. Write it yourself.

A programming language? Not good enough. Build one yourself.

Character encoding? Not unified. Draw one at the dinner table.

That was an era where "three weeks changed the world." One genius, one discarded computer, three weeks — and humanity had one more operating system.

Such windows no longer exist in mature disciplines.

You will not again see one person write an operating system in three weeks — because a modern operating system is the product of tens of thousands of people over decades. You will not again see one person design a globally universal encoding scheme at the dinner table — because today's standardization process takes a three-year committee.

But there is one exception.

Right now, in 2026, humanity faces a truly blank page: AI alignment, AGI architecture.

We do not know how to ensure that a system smarter than humans still benefits humanity. We do not even know what "benefit" means in this context.

This is the feeling Ken Thompson had facing that PDP-7 in 1969 — everything is new, there is no textbook, no correct answer from predecessors to copy.

Perhaps right now, in some dorm room, in some startup's little office, in some inconspicuous corner of a big company, someone is doing something that, looked back upon thirty years from now, will have changed everything.

Just like Ken in 1969.

Just like Linus in 1991.

Just like Avi in 2006.

Just like Jeff Dean in 1999.

None of them knew, at the time, how big the thing they were doing was.

(9) The Timestamp of a Commit

On a certain day in February 2026, one more commit appeared in the Linux kernel's Git repository.

Not a bug fixed. Not a driver added.

It was a succession plan. Signed personally by Linus Torvalds.

For the first time in thirty-four years.

Something one man had maintained for thirty-four years finally had a plan for "what to do if I'm gone."

And somewhere — maybe in a Google office, maybe at a desk at home — Ken Thompson may be sitting in front of a humble machine. A cursor blinking on the screen. 83 years old.

Do you know where the difference lies between the greatest programmers and ordinary ones?

Not in the speed of writing code. Not in how many algorithms they know. Not in how many awards they've won.

It's that they can't stop.

Ken Thompson is 83 and still writing code — not because he still needs to prove anything to anyone, but because not writing would make him miserable.

Linus Torvalds has maintained the kernel for 34 years — not because his employer demands it, but because if a single line in the code isn't written well enough, he simply can't sleep.

Jeff Dean is already a Google myth — but he's still writing papers, still pushing new architectures, still chasing that "next 10x."

Avi Kivity sold his company and took the money — and then started another one, and wrote another database from scratch.

Four people. Four life trajectories. One shared symptom:

They can't stop.

This may be the true fuel of digital civilization. Not capital, not institutions, not algorithms.

It is that switch inside certain people's minds that can't be turned off.