Somnium Vanum

The whole 70s - 90s developers were something else, creating humanity changing software, while here I am fixing TypeScript errors.

Last night, I spent another two hours wrestling with a baffling TypeScript error: Property 'xxx' does not exist on type 'never'. In the end, it turned out that a generic inference had taken an unexpected path through nested conditional types.

Once it was fixed, I just stared at my screen in a daze for a while.

A thought suddenly popped into my head: the generation of developers in the 70s, 80s, and 90s—the ones who built Unix, wrote C compilers, and designed the TCP/IP stack—what they wrote in a single night might have altered the course of human civilization. And me? I’m making sure a button’s color displays correctly in dark mode.

What troubles me isn’t the realization of “I’m not as good as they were”—there is really no comparison there. What leaves me in a daze is this: is any of this that I’m doing actually real?

For example, when you request a block of memory in a user-space C program, you must go through at least three layers of abstraction:

First, malloc uses a complex set of heuristics to allocate an address range within a virtual, contiguous address space. When you access this address, it may trigger a page fault. Next, the operating system employs another set of complex policies to find an available physical memory page, and updates your page table to map the virtual address to the physical address. Finally, when your instructions reach the CPU, the MMU translates the address within the instruction into a physical address based on the page table to actually access the memory.

Despite generations of optimization, this overhead can still easily account for over 10% of the entire runtime. What is perhaps more problematic is the unpredictability of this overhead.

Why introduce such complexity? It is to provide isolated address spaces for each process in a multiprogramming environment, ensuring that no matter how one program misbehaves, it will not crash others. The requirement for a contiguous address space stems from legacy languages like FORTRAN, which assumed contiguous memory; in many early environments, concepts like dynamic memory allocation did not even exist. Yet today, even when writing C, our reliance on malloc’s contiguous space assumption is often less strict (though the stack still requires it, and out-of-bounds access remains dangerous). Furthermore, we frequently run a virtual machine on top of all these layers of abstraction, using languages that feature built-in memory safety.

“If all is an illusion, the concept of ‘I feel this is an illusion’ could never arise. Within a completely simulated system, you cannot generate suspicion toward its simulation. The act of doubting is, in fact, proof of the real.

Much like when you occasionally wonder mid-dream, ‘Am I dreaming?’—in that precise instant, you have already awoken, ever so slightly.

Therefore, that feeling of dissociation, that hollow sensation when you close your IDE after a grueling workday and think, ‘Did I really do anything just now?’—perhaps it is not a bug. It is a feature. It is there to remind you that you are engaged in a grand, collective fabrication.

A fabrication known as ’the technology industry.’ Complete with its own currency (PRs, story points, KPIs), its own rituals (stand-ups, retros, on-calls), and its own myths (changing the world, disrupting industries).”

…And if we pull back the lens of history, blurring the lines of time, this grand, collective weaving of ours is no different from the California Gold Rush of 1849.

It was a massive, years-long hallucination staged in the Sierra Nevada. Countless souls sold everything they owned, chasing the intoxicating myth of “striking it rich,” and threw themselves into the merciless wilderness. Today, we no longer swing iron pickaxes; we strike mechanical keyboards. We no longer sift through the gravel of rushing streams; we wash through endless logs and data streams, panning for the flecks of gold we call “data” and “user growth.”

Yet, history enjoys a cruel sort of irony. In the frenzy of the Gold Rush, the ones who amassed true, lasting wealth were never the mud-drenched prospectors, but the merchants standing at the foot of the mountain selling shovels, water, and Levi’s jeans. Just as in today’s tech euphoria, the ultimate spoils are quietly reaped by the giants who rent out cloud compute and peddle infrastructure.

Meanwhile, we, the modern-day prospectors, burn through our youth and eyesight only to snap awake and realize that what we hold in our hands is nothing more than a few lines of legacy code waiting to be refactored. When the fever finally breaks, the streams of fortune run dry, leaving behind a scarred, barren landscape of tech debt—and us, staring into the dark screen with hollow eyes.

Yet, I am not entirely cynical. History, while cruel, is rarely entirely futile.

Though ninety-nine percent of those 1849 prospectors went home empty-handed, their collective madness laid down the railroads that stitched America together, and transformed a sleepy harbor named San Francisco into a booming metropolis.

The same was true for the Dot-Com crash. The bubble burst, fortunes vanished overnight, and the hype evaporated. Yet, when the dust settled, it left behind thousands of miles of dark fiber and a global digital infrastructure that laid the bedrock for a new era. We may be chasing a mirage, but the monuments we build along the way are undeniably real.