Title: Why I Don't Have the Patience for Scale Models Anymore

There's an almost archaeological pleasure in rummaging through the shelves of old model kits in a small hobby shop. My home is piled with these boxes, and they all have one thing in common: they're almost never opened.

The problem isn't desire. The desire is there, peaking the moment you pay. The problem is patience—or rather, how we redefine "patience" as adults. People often say it's because we're "busy" or "lazy." That's a superficial take. The real reason goes deeper, into the underlying logic of how we manage our time, projects, and mental energy.

1. The Craving for Contiguous Blocks of Memory

Our "free time" is an illusion. A modern person's schedule is like a heavily fragmented disk. You have 15 minutes here, half an hour there, but none of it is contiguous.

Building a moderately complex model is like launching a process that requires a large, contiguous block of memory. It demands that you load a huge amount of context into your "mental RAM" and run it for 5-8 hours straight. If you only have fragmented time, you'll spend most of your energy on constant "context switching": trying to remember where you left off, getting back into the zone, and just as you do, a "high-priority interrupt" from your boss or family arrives.

The cost of this switching is extremely high. So our brain, like an efficient resource manager, makes a rational decision: if it can't foresee a large enough block of contiguous resources, it won't start the process at all.

2. The "Kernel Panic" of Interruption

There's another critical point: the fear of interruption is far greater than the fear of the project itself. This explains Ken Thompson's UNIX origin story. He had three weeks to create an operating system—one for the editor, one for the compiler, and one for the shell. But what he needed wasn't just "three weeks" of absolute time; he needed three uninterrupted weeks, free from interruptions by his wife and one-year-old son.

A half-finished model, or a half-written OS kernel, if forcefully interrupted, can cause a state in your mind akin to a "Kernel Panic." The project's state is corrupted. The cost of restoring it is incredibly high, and sometimes, it's impossible. After experiencing this "panic" a few times, your internal risk assessment system flags all such "deep work" projects with a high-risk coefficient.

The result is you'd rather spend your time on "short tasks" that can be safely interrupted, like scrolling social media. Every refresh is an independent, stateless request. It doesn't create any long-term "mental context" that needs to be maintained. It's safe, but for that reason, it's also cheap.

3. API vs. Implementation: We're Buying the "Possibility"

For a model builder, there are two moments of peak happiness: imagining the model before you own it, and the moment you unbox it to inspect the sprues.

In software engineering terms, this is like admiring a well-designed API. The box art, the instruction manual, the neatly arranged parts on the sprues—together, they form a perfect API. It promises an elegant, achievable result.

But the building process is diving into the messy implementation details behind that API. You have flash, seam lines, and endless sanding and painting. This process is painful. It's a test of willpower, not creativity.

As kids, we had infinite time to enjoy the "implementation." As adults, our time is expensive. We're only willing to pay for a clean API. When we buy a model kit, what we're really buying is the possibility that "I could build this." We're buying the promise of an ideal state of leisure. We get most of our satisfaction from toying with the promise itself. Whether we actually "implement" it is another transaction entirely.

4. The Priority Queue and Starving Dreams

Imagine your brain is an OS scheduler, maintaining a priority queue of tasks.

• P0 (Highest Priority): Work, family responsibilities, health issues. These are system-level tasks that demand an immediate response.
• P1: Side hustles, learning new skills, important social events. These are "investment" tasks for future returns.
• P2: Traveling with family, trying new things. These tasks maintain the system's "well-being" and long-term stability.
• P3 (Lowest Priority): Building a model, finishing an old video game. These are "background tasks" that purely consume resources with no external reward.

In a busy system, P3 tasks are perpetually in a state of "starvation." They're always in the queue, but the scheduler never allocates CPU time to them. Unless, one day, the system load drops dramatically—say, you become financially independent or retire.

So, those piles of unbuilt models are the perpetually starved tasks in our dream queue. They aren't forgotten. They are rationally and continuously deprioritized by our internal scheduling algorithm. We look at them the way a sysadmin looks at a list of low-priority processes that will never run, with a kind of gentle resignation.

We haven't lost our passion for building models. We've just upgraded our operating system. And in this new OS, pure, unadulterated, deep-focus fun has become the first luxury to be sacrificed.

为什么我现在没有耐心拼模型了

在街边小店的货架间翻寻旧模型，有一种近乎考古学的乐趣。我家里堆着很多这样的模型盒子，它们的共同点是——几乎从来没有被开启。

问题不在于欲望。欲望是存在的，它在你付款的瞬间达到顶峰。问题在于耐心，或者说，是我们成年后对“耐心”这个词的重新定义。人们普遍认为，不拼模型是因为“忙”或“懒”，这是一种对现象的肤浅观察，真正的原因要深入到我们管理时间、项目和心智能耗的底层逻辑中去。

1. 对“连续内存块”的渴求

我们的“空闲时间”是一种幻觉。一个典型的现代人，他的时间表就像一块被打满了碎片的磁盘。这里有15分钟，那里有半小时，但它们是不连续的。

拼一个中等复杂度的模型，就像是启动一个需要大量连续内存的进程。它要求你加载大量的上下文到你的“心智内存”里并连续运行5-8个小时。如果你只有碎片化的时间，你将把大多数精力耗费在不断地“上下文切换”上：回忆你上次做到了哪里，重新进入状态，然后刚进入状态，一个来自上司或家庭的“高优先级中断”就来了。

这种切换的成本是极其高昂的。因此，我们的大脑，作为一个高效的资源管理器，会做出一个理性的决策：如果预见到无法分配到足够的连续资源，那么这个进程从一开始就不应该被启动。

2. 中断的“内核恐慌”

还有一个问题非常关键：对中断的恐惧，远大于对项目本身的畏惧。这解释了Ken Thompson的UNIX创世故事。他当时离创造一个操作系统只有三个礼拜的时间，一个礼拜用来写编辑器，一个礼拜 写编译器，另外一个礼拜写系统管线，但他需要的不是“三个礼拜”的绝对时间，他需要的是一个不会被他妻子和一岁儿子触发中断的、连续的三个礼拜。

一个进行到一半的模型，或一个写到一半的操作系统内核，如果被强行中断，它在你的精神世界里会造成一种类似“内核恐慌”（Kernel Panic）的状态。项目状态被破坏了，重新恢复它的成本极高，甚至可能永远无法恢复。多次经历这种“恐慌”之后，你的内部风险评估系统会给所有这类“深工作”项目标记上一个极高的风险系数。

结果就是，你宁愿把时间花在那些可以被安全中断的“短任务”上，比如刷社交媒体。每一次刷新都是一个独立的、无状态的请求，它不产生任何需要长期维持的“心智上下文”。它很安全，但也因此廉价。

3. API vs. 实现：我们购买的是“可能性”

对于模型玩家来说，最快乐的时刻有两个：尚未拥有它时对它的想象，以及刚刚拆开包装审视板件的时刻。

用软件工程的术语来说，这是在欣赏一个设计精良的API（应用程序接口）。盒子封面、说明书、排列整齐的板件——它们共同构成了一个完美的API。它向你承诺了一个优雅的、可达成的结果。

而拼装过程，则是深入到API背后的、混乱的实现细节中去。这里有毛边、合模线、需要反复打磨的上色。这个过程是痛苦的，它考验的是意志力，而非创造力。

童年时，我们有无限的时间去享受这个“实现”的过程。成年后，我们的时间变得昂贵，我们只愿意为清晰的API付费。我们购买模型，实际上是在购买一个“我能够完成它”的可能性，一个关于理想休闲状态的承诺。我们把玩这个承诺本身，就已经获得了大部分满足感。至于是否去“实现”它，那则是另一笔完全不同的交易。

4. 优先级队列与梦想的饥饿

想象你的大脑是一个操作系统调度器，它维护着一个任务的优先级队列。

• P0 (最高优): 工作、家庭责任、健康问题。这些是必须立即响应的系统级任务。
• P1: 副业、学习、重要社交。这些是为了未来获得更大回报的“投资型”任务。
• P2: 与家人旅行、体验新事物。这些是维持系统“幸福感”和长期稳定性的任务。
• P3 (最低优): 拼模型、打通一个老游戏。这些是纯粹消耗资源、不产生任何外部回报的“后台任务”。

在一个繁忙的系统中，P3任务会持续性地处于“饥饿”状态。它们永远在队列里，但调度器永远不会把CPU时间分配给它们。除非有一天，系统负载急剧下降——比如你财富自由了，或者退休了。

所以，那些堆积的模型，是我们梦想队列里长期饥饿的任务。它们不是被我们遗忘了，而是被我们的内部调度算法理性地、持续地推后了。我们看着它们，就像系统管理员看着任务列表里那些永远不会被执行的低优先级进程一样，带着一丝无奈的温情。

我们没有失去拼模型的热情，我们只是升级了我们的操作系统。而在这个新系统里，纯粹的、无功利的、需要深度专注的快乐，成了最先被牺牲掉的奢侈品。