第4讲 · 大语言模型、Agents 与 Scaling Law

2026 南京大学《操作系统原理》第四讲（Hacking Day）· 课堂实录重构


主讲	蒋炎岩（Yanyan Jiang）
视频	https://www.bilibili.com/video/BV1gEcmzzE4P/
课程主页	https://jyywiki.cn/OS/2026/
本讲讲义	https://jyywiki.cn/OS/2026/lect4.md
讲义 / 幻灯片作者	蒋炎岩，https://jyywiki.cn/
讲义 / 幻灯片许可	CC BY-NC 4.0
图片来源	书中插图为课堂演示与讲义渲染图；演示类截图为视频画面

对应讲次：第4讲（南京大学操作系统原理）

制作模型：deepseek-flash（coding-agent / pi；据 ~/.pi/agent/settings.json）

编者说明：本书由课堂录像的语音字幕重构而成，术语、章节骨架与参考链接已按课程官方讲义（lect4.md）校准。讲师的口语风格、类比与案例被尽量保留；编辑性的补充一律以「编者说明」标出。

引子：一次「不讲考点」的 Hacking Day

(参考时间: 00:00)

这是本学期的第一次 Hacking Day。课程向 3 学分调整后，每四次课（约每两周）会安排一次 补充选讲：不讲与考试直接相关的内容，而是聊一些和操作系统课、和你们的实验都有关系的扩展话题，不作为考试内容。

今天有两条线索：

讲一讲 Scaling Law——你们可能听过这个词，它来自一篇非常有名的论文；讲师会谈谈自己对 Scaling Law 和 Agentic AI 的理解；
一个小彩蛋：现场让 AI 帮忙写一个最小的操作系统。讲师坦言「我什么也没准备，随时可能翻车」——但正因为如此，大家可以看到今天的 AI 到底长什么样、犯了错我们该怎么应对、如果它一遍做对了我们又能做什么。

编者说明：这门课的一个反复出现的主线，是「智能变得很便宜」之后，人的价值在哪里。这一讲几乎每个故事最终都落回这句话。

下一次 Hacking Day 会由助教来讲命令行接口（Command Line Interface）——它从哪来、今天长什么样，都值得期待。另外，每周四下午 16:30–17:30 是 Office Hour，地点在计算机楼 809，欢迎来聊天。

一、大语言模型：大、语言、模型

1.1 从 ChatGPT 的第一次震撼说起

(参考时间: 00:01)

讲师回忆自己第一次在课堂上用上大语言模型，是 ChatGPT 刚爆火的时候。当时他还在讲一门「非常硬核」、要讲内核的操作系统课。正值 GPT-3.5 发布约两个月，在大家还忙着微调 BERT 这类语言模型时，世界好像突然变了。

编者拓展｜BERT 与 GPT 的区别：BERT 是 2018 年 Google 提出的模型，擅长「理解」——它同时看左右两边（双向），常用于分类、抽取、翻译等任务，当年大家常拿它做微调。GPT 系列则擅长「生成」——只看左边（自回归），一个字一个字往后写，Scale 之后展现出通用能力。ChatGPT 的震撼，本质上就是「生成式 + 大规模」这条路碾压了「理解式 + 微调」的老路线。

一个让他印象深刻的例子：问 ChatGPT「编译器会对这段代码做出怎样的优化？」——代码里含有一小段内联汇编（inline assembly）：

int return_1() {
  int x;
  for (int i = 0; i < 100; i++) {
    // Compiler will assign [%0] an assembly operand
    asm("movl $1, %0" : "=g"(x));  // "x = 1;"
  }
  return x;
}

内联汇编在训练语料里其实并不多，模型大概只「见过几遍」。但它不仅看懂了这段 C 代码，还回答得非常好，对编程本身展现出很强的直觉。就在那一刻，讲师感到世界真的变了。

于是问题变成了：大语言模型为什么能这么厉害？他的答案是三个字——大、语言、模型。

编者拓展｜这段内联汇编为什么是个好例子：它同时考了模型三件事。其一，asm("movl $1, %0" : "=g"(x)) 用了一个输出约束 "=g"，把常量 1 写进变量 x，属于相当冷门的语法；其二，循环体每次都在重复同一个 x = 1，一个合格的编译器会看出整个循环可以折叠——这个函数几乎一定被优化成 return 1（这正是提问者想听到的「编译器优化」）；其三，它要求模型把 C 语义、内联汇编约束、编译器行为三者在脑子里同时对齐。语料稀少却能答对，说明模型学到的不只是「模式」，而是某种可迁移的编程直觉。

1.2 「大」：应对宏观复杂性的必要条件

(参考时间: 00:03)

物理学家薛定谔在《生命是什么》开篇抛出一个看似好笑的问题：我们为什么这么大？换个角度就是：原子为什么这么小？

这其实是个非常深刻的问题，它的逻辑是：

在经典原子理论或量子力学里，每一个原子携带的信息量都非常少——外层有几个电子、两两之间如何反应，都是一套相当精确而「经典」的模型；
那么由极少数原子组成的一个极小的系统，就不应该涌现出生命这样复杂的行为。

所以，「大」是应对宏观世界复杂性的一个必要条件。人的身体大、生物的行为复杂，都是因为它必须大到足以承载这种复杂性。大语言模型第一个「大」字，说的正是这件事。

编者拓展｜薛定谔到底在问什么：这个问题出自薛定谔的《生命是什么？》（What is Life?, 1944）。书中论证的大意是：物理定律在微观上是统计性的——原子太少时，「秩序」会被热运动随机抹平（涨落幅度约为 $1/\sqrt{N}$，$N$ 是粒子数）。因此，若一个系统只由少数原子构成，它的宏观行为就无法稳定地承载复杂信息。生命之所以能维持高度有序，恰恰因为它由海量原子构成，是「以量取胜」换来了抵御随机性的稳定性。讲师把它类比到大模型：参数（连同训练数据）就是那个「数量」——只有足够大，复杂的世界模型才放得下、也才稳得住。

1.3 「语言」：人类沉淀千年的世界模型

(参考时间: 00:05)

第二个有意思的问题是：为什么选的是语言？在此之前，深度学习最爆炸性的成功案例是图像分类（AlexNet）和围棋（AlphaGo），为什么最终产生质变的是语言模型？

讲师的理解是：语言是人类沉淀了几千年的一套「世界模型」，一个在人与人之间可以对齐的、描述物理世界的抽象。

举一个例子：「我昨天看到一只猫。」——这句话很短，但它背后压着的是你从小到大见过的无数只猫、你对「猫」这个概念的私人理解，以及整个共享的文化环境。你闭眼在脑子里还原一只猫，每个人还原出来的都不一样，但又在结构上相似——因为大家共享同一个物理世界，上的是同一套教材，拥有一个既相同又略有差异的 grounding。

正因如此，语言成了人类世界里那种可以被传承下去的抽象。也正因如此：

用（多模态）大模型可以在很大程度上表达这个世界；
但你无法和外星人对齐——除非借助别的、不依赖人类语言的方式。

编者说明：讲师顺带提到 1970 年代发射的旅行者号——它带着镀金唱片和刻有图案的金属板，希望外星文明能认出「这是智慧生物的作品」。而今天，或许只要把一个多模态模型固化在南极某处，未来被挖出来后，就能从足够多的参数里复原出这个世界的样子。

编者拓展｜什么是 "grounding（接地）"：一个符号（比如「猫」这个词）本身没有意义，它的意义来自与非语言经验的绑定——你见过猫、摸过猫，这个符号才「落地」。这就是认知科学里的符号接地问题（symbol grounding problem）。语言之所以能在人之间对齐，是因为说这门语言的人共享同一个物理世界：各自经验不同，却被这个共同世界「锚定」到大致相同的位置。多模态模型的思路也是替语言找回接地——把图像、声音这些感官信号与文字配对训练，语言符号就重新连回了感知。反过来说，若两个智能体没有共同的经验世界，「对齐」就无从谈起，这就是为什么「和外星人对齐」是个真问题。

顺带一提，维特根斯坦那句话——「即使一头狮子会说话，我们也听不懂它」——说的正是这种困境。

1.4 「模型」与 next token prediction

(参考时间: 00:08)

那么语言模型的工作原理是什么？它有一个上下文（context）（你们最熟悉的问题大概就是 context 溢出、不够用），然后从这个上下文出发，不断向外补全文本。

这带来两个阶段的训练：

graph LR
    A["海量文本<br>（先教它「会说话」）"] -->|预训练 Pre-training| B["基础模型<br>学会写人类世界里看起来正常的话"]
    B -->|后训练 Post-training<br>对齐成对话助手| C["对话模型<br>人: ... 机器: ... 人: ..."]
    C -->|根据全部历史<br>定义下一个 token 的概率分布| D["Next Token Prediction"]
    D -->|采样/取最大概率| C

预训练（pre-training）：直接拿海量文本训练，相当于先教它「学会说话」；
后训练（post-training）：把它调成一个能与你对话的助手——用一个特殊符号区分「人说了什么」「机器说了什么」，把整段对话写进去，让模型根据过去的全部内容，定义一个「下一个字是什么」的概率分布。

所以 GPT 里的 G 是 Generative（生成式），P 是 Pre-trained。哪怕是一个巨大的神经网络，它本质上就是一个概率分布：给定过去看到的所有文字，为「好的」「大的」乃至任意 Unicode 字符（包括各种表情）分别给出概率，再挑一个最可能的继续往后写。这就是 next token prediction。

编者拓展｜神经网络、模型与「参数」：神经网络是一大堆简单运算单元（「神经元」）堆叠、连接而成的函数，输入一串数、输出一串数。连接处的权重、每个单元的偏置加在一起，就叫参数（parameters / weights）——「7B」「70B」说的是参数个数（B = billion，十亿）。所谓「训练」，就是不断调整这些参数，让网络在大量样本上的输出越来越符合预期；训练结束后固定的这组参数，就是一个「模型」。所以「模型本质上是一个概率分布」，指的就是：给定输入，这个巨大的函数会输出各个可能的「下一个 token」的概率。

编者拓展｜从上下文到概率分布：模型每一步做的事，是把「下一个 token 的条件概率」参数化出来——整段文本的概率被分解为逐项条件概率之积：

$$ p(x_1,\dots,x_T)=\prod_{t=1}^{T}p(x_t\mid x_{<t}) $$

文本先被切成 token（常见的是 BPE 之类的子词单元，粒度既不是「字」也不是「词」）；上下文窗口（context window）则是能进入 $x_{temperature、top-p 等调节随机性，取最大值就是贪心解码）。预训练只要求「补全文本」，后训练（如 SFT、RLHF）才把它「矫正」成一个听话的对话助手——GPT 里的 G / P 两个字母（Generative / Pre-trained）说的就是这个先后。

本学期的某个实验，就是让大家实现一个并行的大语言模型推理。

编者拓展｜训练与推理（inference）：训练（training）是调整参数、让模型变聪明的过程（昂贵，往往要成千上万张 GPU 跑数周）；推理（inference）是参数固定后，用模型来回答问题 / 生成文本的过程（就是你和 ChatGPT 对话时它在做的事）。本学期实验里让大家「并行化」的，正是推理——因为它要反复做大量矩阵乘法，天生适合并行（这也是第 20 讲 SIMD/SIMT 的用武之地）。

1.5 为什么机器能「顺序」写代码

(参考时间: 00:10)

讲师讲了一段「古法编程」的往事。2022 年 ChatGPT 还没出来时，Google 发布过一个爆炸性产品 AlphaCode：它用 Transformer 类模型，声称能在 Codeforces 上拿到 2000 多分的 rating——在当时看来不可思议。

让人惊讶的是它写代码的方式。人类写代码用的是结构化程序设计：

先想好分几步（读数据 → 建图 → 跑算法 → 加工输出）；
先把 main 写出来，留好空白，标注「这里做 A、那里做 B、再做 C」；
再逐个填空。

而机器是一个字符一个字符顺着往下写：int → 空格 → main → ( → )……它输出的每个字符，都是前面所有内容的一个概率分布。可它竟然就这么顺序地把代码写对了。

后来大家想通了：人类在草稿纸上写伪代码，把「先做 A、再做 B、C 分别干什么」推导清楚之后，写代码就变成了一次机器翻译——从一个语言翻译到另一个语言，几乎可以不过大脑。

编者说明：讲师从前是程序设计竞赛选手，他形容自己在竞赛中受过的最重要的「预训练」，就是能够非常自如地顺序写代码。当时比赛三个人一台机器，为了不和队友抢机器，他练就了「在纸上写代码」的能力：写完整整三页 A4 纸的代码，检查一遍、修掉小错，敲进电脑就能编译通过并且是对的。人会做，机器翻译又已经做得很好（BERT 系列在翻译上表现相当好），那么只要模型足够大、短期记忆足够容纳推导步骤，它就没有道理不能顺序地把代码写出来。

编者拓展｜AlphaCode 分数的一个细节：AlphaCode 论文（Li et al., Science, 2022）给出的估算 Codeforces 分数约为 1238（大致处于人类选手的中位数水平）；它的做法是大量采样候选程序、再用示例测试过滤、最后按输出行为聚类去重，把有限的提交次数花在互不相同的解法上。讲师记忆中的「2000 多分」，更应理解为对「模型已能在竞技编程上达到相当高水平」的整体印象——后来更强的系统（以及面向推理的模型）在这类竞赛任务上的分数还要高得多。

1.6 大语言模型的进化：眼睛、草稿纸、计算器

(参考时间: 00:20)

编者说明：讲到这里，讲师发现自己漏放了一页幻灯片，于是顺手给大家看了一眼自己上课用的工具链——每一讲的讲义其实都是一份代码，播放一张幻灯片就是调用一个函数，生成 lecture notes 也是另一个函数。这与他后面要讲的「用文件系统/协议解耦子系统」是同一个设计思路（见 §4.3）。

📷 讲师的课堂讲义即代码：调用函数播放幻灯片
回到原视频 (00:18:35)

在这个「next token prediction」的框架上，人们很自然地开始往模型上加各种能力。

① 眼睛：把感官对齐到语言空间

每个 token 其实都是一个向量（0.35, 0.01, ...）。要想让模型「看到」图片，只要把一个 $16\times16$ 的小图块也变成一个向量、对齐到同一空间即可——这就是 ViT 的思路。

编者拓展｜词向量（embedding）与「向量空间」：模型内部并不直接处理文字，而是先把每个 token 映射成一串实数（一个向量），这叫 embedding（嵌入）。向量的「方向 / 距离」可以表示语义相似度——意思相近的词，向量也相近。多模态的关键就在这里：只要把图片、声音也编码成同一空间的向量，它们就能和文字一起被同一个模型处理。这也呼应了第 01 讲的主题——把语言问题翻译成数学问题。GPT-4o 把声音、图像等人类的多种感官都对齐到同一个语言空间，于是 AI 有了眼睛和耳朵。

编者拓展｜ViT 具体是怎么「看」图的：它把一张图切成固定大小的图块（例如 $16\times16$ 像素），把每个图块拉平后线性投影成一个向量——于是每个图块就变成了一个「视觉 token」，可以直接送进 Transformer，和文字 token 用同一套自注意力机制处理。这就是「把感官对齐到语言系统」的具体机制：只要都能变成向量，就都能放进同一个注意力空间。

② 草稿纸：把有限状态机变成图灵机

讲师分享了一句给研究生的建议：

如果你把所有东西都放在脑子里，你就是一个有限状态机；但如果你有了 paper 和 pencil，你就成了一个图灵机——你有了无限的 working memory。

一台有限内存的计算机和一台无限内存的计算机，能算的东西完全不同。所以哪怕模型不是无限的，只要它的 context 越来越长，我们也可以让它一步一步地把问题解决。

编者拓展｜有限状态机 vs 图灵机：有限状态机（FSM）只有有限个状态，能处理的问题类（正则语言）很窄；给它一条可无限读写的纸带，就升级为图灵机，能力跨入「可计算」的边界。脑子里的短期记忆有限，所以纯靠空想只能做有限状态机的事；把推导写到纸上（或写进 context）就相当于获得了那条纸带。这正是 reasoning model 的底层直觉：推理不是一次算完，而是「写出中间结果」再回看。

以 123 + 456 为例（早期 ChatGPT 连这个加法都做不对）：

$$123 + 456 = 100 + 20 + 3 + 400 + 50 + 6 = (100+400) + (20+50) + (3+6)$$

看起来绕了远路，但这降低了心算的难度：你不再需要逼着模型去「硬算」，而是把它展开成竖式，再让注意力依次集中到相邻的两项上——这就是今天 thinking / reasoning model（如 DeepSeek）做的事：先试一个想法，发现错了，再从头来。在 GPT-4 时代，只要加一句 "think step by step"，复杂任务上的表现就能提升一大截。

③ 计算器：AI 的手和脚

但如果你看到的是 123 × 456 呢？你不会展开来算，而是本能地去拿计算器。ReAct 和 Toolformer 教的正是这件事：让模型输出一个特殊 token，比如

<|python3 -c "123 * 456"|>

把执行结果再拼回上下文——就像你按完计算器，把数字抄回来一样。这就是 AI 的手和脚。

编者拓展｜ReAct 与 Toolformer 各解决了什么：ReAct 让模型把推理（reason）与行动（act）交替进行：想一步 → 调一个工具 → 看结果 → 再想下一步，形成闭环；Toolformer 则用自监督的方式，让模型自己学会「什么时候该插入一次工具调用、以及怎么用」。两者共同点是：把「不会算」的部分外包给一个可靠的执行器——这与人类拿计算器，本质上是同一件事。

有了眼睛、耳朵（多模态），有了草稿纸（reasoning），有了计算器（tools），LLM 根本就是一个活生生的人：能推理、能犯错、能纠正自己、能尝试新的可能性，最终把事情做对。

📷 大语言模型的进化：语言、模型、眼睛、草稿纸、计算器
回到原视频 (00:19:05)

编者说明：在 ChatGPT 之前，人们靠 thefuck 这样的工具，根据你过去命令的历史，帮你修掉打错的命令、补上缺失的权限（讲师还带过一个同学专门做它的增强）。大模型出现之后，这类工具几乎全部被「杀死」了——现在只要在 Claude Code 里说「我要做什么」，它会自己去写命令、犯错、再修复。

二、LLM Agents：把能力用到极致

(参考时间: 00:29)

既然有了一个「智力极高、随时为你服务」的东西，怎么把它的能力发挥到极致？

讲师给了一个很有画面感的比喻：假设你突然转生到一个奇怪的世界，你的导师变成了你的宠物——你说什么 instruction 它都 follow，那你该怎样用好这个导师？

答案是：给他一个工作区（workspace）。因为他是一个活生生的人，能尝试、会犯错，只要不断尝试就能推进进度；而你需要给他一个大的 working memory。在计算机世界里，这就是一个目录：

graph TD
    W["工作区（一个目录）"] --> R["README<br>你要做什么"]
    W --> P["plan.md<br>分解后的计划（做完打勾）"]
    W --> D["docs / 设计文档"]
    W --> S["源代码"]
    W --> T["tests / 测试"]

软件工程师这么多年积累的 best practice，恰好给 AI 搭好了一个完美的舞台。

2.1 Agentic Loop：像人一样地循环

(参考时间: 00:33)

大模型接收一个任务后，很自然地会提出规划：为了实现一个操作系统，先做 A、B、C、D、E。它能用逻辑推理先把粗的 plan 列出来，再把每一步细化，并把计划写进文件系统（比如 plan.md），用 Markdown 列出「第一件事、第二件事……」，做完一件就打个勾。

graph TD
    T["收到任务"] --> P["提出计划 / 分解任务"]
    P --> F["把计划写进 plan.md"]
    F --> E["逐项执行：写代码、跑测试、调工具"]
    E --> C{"检查结果<br>（lint / 单元测试 / printf 调试）"}
    C -->|不符合预期| X["修复错误"]
    X --> E
    C -->|符合预期| N["推进到下一项"]
    N --> P

而人类在开源社区也是这么做的：一个团队要做一个项目，会规划近期与远期的 milestone（要加什么功能、再加什么功能），然后一个一个去完成。写代码时我们会写测试、用 lint 这样的工具检查低级错误、用单元测试发现不符合预期的地方，出错了甚至会加个 printf 来调试——这些和「计算器」在理论上都是等价的，都是模型可以调用的工具。

于是，「小龙虾」（Agentic AI）的爆火，简直是历史的必然。

编者拓展｜今天的 Agent 由哪些零件拼成：这套「规划—执行—检查」的循环，今天已被工程化为一组通用机制：工具调用 / function calling（模型把「调用哪个函数、参数是什么」写成结构化输出）、子智能体（sub-agents）（把子任务分派出去、各自带自己的上下文）、技能（skills / 可复用的提示与脚本包）。讲义在这里并列提到了 OpenClaw 与 Agent Skills 这类生态——它们要做的，都是一个能被反复插拔、承载复杂性的平台（呼应 §3.7 的 Mechanism is King）。transcript 里把流行的 coding agent 戏称为「小龙虾」，也正是这类产品的昵称化叫法。

2.2 Git 与「死亡循环」

(参考时间: 00:31)

为什么说 Git 就是为 AI 量身定制的？（讲师吐槽：保研面试时问「什么是 Git」，很多人答「用来从互联网下载代码的软件」，让他一时语塞。）Git 是一个分布式版本控制软件，更重要的是——它管理的是目录的快照。

graph LR
    S0["快照 0"] --> S1["快照 1"] --> S2["快照 2"]
    S2 -.->|可以随时退回| S0
    S2 -.->|cherry-pick| S1

它有点像一个 persistent data structure：你可以在当前工作区上随便改，改完可以提交；但无论你把它变成什么样，你永远可以退回到过去的某个快照，把不要的东西扔掉，甚至只 cherry-pick 你要的那一点，然后在另一条世界线上继续工作。Git 给了这个世界无数个平行宇宙。

编者拓展｜Git 内部真的就是一棵「持久化数据结构」：Git 把内容按哈希寻址存成一棵 Merkle DAG——每个文件是 blob、每个目录是 tree、每次提交是 commit，后者的哈希由前者算出。于是「快照」几乎不额外占空间（没变的子树直接复用），内容也无法被悄悄篡改（一改哈希就变）。git switch --detach、git cherry-pick、git reset 之所以能在你说的「平行世界」之间瞬间跳转，正是因为它们只是在移动一个指向某个 commit 的指针。这台「时间机器」，正是 AI 工作的理想底座。

这就引出一个有趣的观察：大模型每次启动时只有参数（训练好的样子）和一句 system prompt，它没有记忆。而你的整个项目又太大，没办法一次全塞给它（历史、日志就更长了）。所以：

大模型就像被困在一场死亡循环（DEATHLOOP）里：每次醒来都是空的，转生到异世界重新开始，面对一个「看起来全新」的仓库，再根据任务改、改、改……

对策就是前面说的：把计划、进度、状态落到文件系统里。这样它「下一次醒来」时，看一眼 plan.md 就知道上次做到哪、下一步该做什么。

2.3 不止程序员：用目录管理一切

(参考时间: 00:36)

讲师强调：这可不是程序员专属的工作方式。任何一个学生都可以这样做：

把每一讲的 lecture、知识点、作业放进目录，做完的勾掉；
建一个错题本：哪个题做错了就记下来；
打开 Claude Code 问它：我下一步该做什么？帮我复习之前薄弱的地方？快期末了，给我出一套模拟题？
让它去网上、去群里搜罗往年真题，找到了就放进目录。

讲师自己也早就这么做了：把所有个人文档放进一个目录，用仓库的方式组织，需要时打开 Claude Code 让它帮忙填表；再在前面接一个 Telegram 前端（Telegram 官方支持 bot 接口），就可以在手机上对话；还可以定义一个 cron 定时任务，比如每天早上 7 点自动爬取当天天气预报，结果也写进这个「记忆」目录。

编者拓展｜cron 长什么样：crontab 的一行由五段「时间字段」加一条命令构成——分时日月周命令。例如 0 7 * * * /path/fetch_weather.sh 表示「每天 07:00 执行一次」（* 表示「每」）。它由系统常驻的 cron 守护进程按表触发：一个「让机器按时替你做事」的通用机制，正好可以配上上面这套「目录即记忆」的用法。

编者说明：「今天你看到火爆的东西，在历史上都存在一定的必然性，不需要特别惊讶。」——这是从大模型一路讲到 Agent 之后，本讲反复出现的判断。

三、量变引起质变：Scaling Law 的历史

3.1 The Bitter Lesson：通用方法的力量

(参考时间: 00:38)

这一节算是「灌点鸡汤」。先看 Rich Sutton 写的那篇著名短文 The Bitter Lesson（《苦涩的教训》）——Sutton 正是因为强化学习拿了图灵奖。讲师强烈建议全文阅读，可以开个 AI 帮你翻译、做总结。

📷 The Bitter Lesson：通用方法的巨大力量
回到原视频 (00:39:00)

文章的核心，讲师概括为：要相信通用方法的巨大力量——不要试图把人类总结的「简洁规律」硬塞进系统，而应该只内置那些能够找到并承载任意复杂性的元方法（meta-methods）。

讲师用自己的一句话来翻译它：量变引起质变。

3.2 故事一：网页增长慢于存储，所以 Google 是必然的

📷 网页增长与存储容量的增长曲线（对数坐标）
回到原视频 (00:40:10)

1980 年代，人们发现一个规律：互联网上所有内容的增长速度，慢于存储系统容量的增长速度（图的对数纵轴是存储容量，横轴是时间）。这意味着有一天，一台计算机（或一小组计算机）就能存下世界上所有的网页。

一旦能全存下来，配合一些好的算法——比如你们可能学过的后缀数组/后缀排序，可以在（近）线性时间内对极长的文本做带匹配、做检索——那么一个搜索引擎就是必然的。存储技术在一点一点发展，看似只是量变，但一旦越过某个临界点，就会产生超乎想象的效果。在 AI 到来之前，互联网检索几乎是我们获取信息的唯一入口。

编者拓展｜从「存得下」到「搜得到」：索引的魔力：把全世界的网页存下来只是第一步，关键是要能又快又准地检索。后缀数组把一个字符串的所有后缀按字典序排好，于是「某个模式串是否出现／出现几次」就变成一次二分查找，复杂度约 $O(m\log n)$（$m$ 为模式串长度）；更进一步的 FM-index 还能把索引压缩到接近文本本身的大小。再叠加倒排索引（词 → 文档列表），就是搜索引擎的地基。回看讲师的论证：存储技术的量变，加上索引算法，才一起跨过了「搜索引擎」这个质变点。

3.3 故事二：龙芯 GS132 的「烂代码」

(参考时间: 00:39)

还有一个励志故事：龙芯 GS132 里有一段看起来非常「烂」的代码，但它竟然可以运行，而且后来越来越快。讲师借此说明：很多伟大的东西是从零开始一点点做出来的，一开始难看不要紧，只要它在真实世界里跑起来、能被持续改进。

3.4 故事三：DeepBlue 的 Scaling Law

(参考时间: 00:42)

象棋、围棋，乃至你们打的《王者荣耀》，背后都有一套 Elo 评分系统。它的数学模型用正态分布给每个人建模：

均值 $\mu$ 代表这个人的战斗力；
标准差 $\sigma$ 代表他的稳定性。

两个人比赛，就是各自从自己的分布里取一个值比大小——$\mu$ 高的人取胜概率极大。整个 rating system 要做的，就是用胜负不断调整每个人的 $\mu$ 与 $\sigma$，比赛足够多之后，大家就收敛到各自在世界上的正确排位。

编者说明：若把两人实力分别记为 $\mu_A, \mu_B$，Elo 常用下式估计 A 的胜率：

$$ P(A \text{ 胜}) = \frac{1}{1 + 10^{-(\mu_A - \mu_B)/400}} $$

这只是一个简化模型，用于说明「实力被建模成一个可比较的数值」这一直觉。

1980 年代，Ken Thompson（UNIX 的发明者、图灵奖得主）也参与在用计算机下象棋的竞赛中。那时象棋主要还是暴力搜索 + alpha-beta 剪枝。他们发现一个非常有趣的规律：搜索深度每增加一层，棋力（积分）就稳定地提升一截。

也就是说，他们第一次看到了一个惊人的事实：所谓人类的智能，本质上不过是算力。

那么，如果要尽快让机器打败最强的人类，最该做什么？——造加速器。

从算法角度，每多搜一层，时间是指数级增长的；
想快速加深搜索，最好的办法就是做硬件加速。

编者拓展｜alpha-beta 剪枝与 DeepBlue 的硬件：alpha-beta 剪枝是极小化极大搜索的优化——一旦发现某条分支已经不可能优于已知选择，就直接剪掉，从而把有效搜索深度推得更深，且不改变最优解。DeepBlue 则把这件事做到了极致：一台 IBM RS/6000 主机，插上 480 颗专用下棋芯片，每秒能评估约 2 亿个局面，用硬件换搜索深度。这就是「造加速器」的量化版本。

讲师读研时读过许峰雄（Feng-hsiung Hsu）的回忆录：为了击败加里·卡斯帕罗夫（Garry Kasparov），他们做的是下棋专用电路——8×8 棋盘上判断一步棋是否合法，在顺序 CPU 上要走很多分支、很慢；而用电路实现，几个周期就能判断状态迁移。最后，他们在超级计算机之上又加了加速器。

这，是不是和今天的大模型时代如出一辙？1997 年，DeepBlue 击败人类世界冠军，登上了报纸头版——那大概是讲师第一次正式听说「人工智能」这个名字。

📷 DeepBlue 与加里·卡斯帕罗夫
回到原视频 (00:44:30)

3.5 故事四：AlphaGo 的 Scaling Law

(参考时间: 00:47)

2016 年，AlphaGo 再次证明了这条规律：人类的智能不过是算力。它借用卷积神经网络去「阅读」棋盘（就像阅读图片一样），搜索算法也从 alpha-beta 剪枝换成了蒙特卡洛树搜索（MCTS）。

编者拓展｜蒙特卡洛树搜索（MCTS）在做什么：它不去穷举整棵博弈树，而是反复采样：每一步依次做「选择 → 扩展 → 模拟 → 回传」，把更多的计算预算分配给「看起来有希望」的分支。AlphaGo 用策略网络缩小候选落子、用价值网络评估局面，再让 MCTS 把两者结合起来——搜索的对象从「所有可能」变成了「值得算的那些」。

讲师回忆自己 2016 年在美国熬夜看直播——虽然高端的棋局他也看不明白，但当时他想到的，正是从 DeepBlue 时代就知道的那句话。而今天，大模型已经开始横扫各种程序设计竞赛和数学竞赛。

📷 AlphaGo 与李世石
回到原视频 (00:47:30)

3.6 今天的 Scaling Law：Kaplan 与 Chinchilla

(参考时间: 00:48)

开启大语言模型时代的两篇论文，正是今天的主题：

Kaplan's Scaling Law（OpenAI）；
Chinchilla（DeepMind）。

它们给出了同样的经验规律：算力（compute）越大，就需要越多的数据、越大的模型；而当三者按合适比例一起放大时，training loss 会稳定下降——也就是模型预测 next token 的能力越来越好。

📷 Scaling Law：算力、数据与模型一起放大，loss 稳定下降
回到原视频 (00:49:15)

graph LR
    C["算力 Compute ↑"] --> D["数据 Data ↑"]
    C --> M["模型参数 Model ↑"]
    D --> L["Training Loss ↓（智能 ↑）"]
    M --> L

编者拓展｜Kaplan 与 Chinchilla 到底差在哪：两篇论文都在拟合同一条经验幂律，形如 $L(C)\approx (C_c/C)^{\alpha}$（loss 随算力 $C$ 以幂次下降），但结论不同。Kaplan 认为「模型越大越好」，于是大家拼命堆参数；Chinchilla 在更充分的数据下发现：给定算力预算，参数量与训练 token 数应按大致固定的比例一起放大（最优约为每个参数配 20 个 token）。据此，1750 亿参数的 GPT-3 其实是「饿着」训练的——要喂饱它大约需要 3.5 万亿 token，而它实际只见过约 3000 亿。这也解释了此后 LLaMA 一类模型「更小的模型 + 更多的数据」为何成为主流。

这让 OpenAI 当年敢去训练 1750 亿参数的 GPT-3。其实没有人知道它能不能成功：他们只是做了一些小规模实验，然后相信这个规律可以外推——「我们的数据还没把模型喂饱，所以在有更多数据时，应该训练一个更大的模型」。

甚至像「激活函数用哪一个更好」这种细节，当时也没人知道。可人类就这么一路试着试着，造出了智能的机器。

讲师由此感慨：

一方面，人类运气不错；
另一方面，这也是历史的必然——既然象棋、围棋、语言模型都反复证明了「智能就是算力」，那么这件事是情理之中的；
但也许还存在一个用更少参数就能得到更强智能的模型，只是我们还不知道。

这很像生物进化：人类也许就是 highly suboptimal 的——我们从藻类、海洋生物、老鼠一路带下来，身上带着大量中间物种的基因。如果能从零开始重新设计人类，也许能得到一个高效得多的人类。所以，未来制造更强模型这件事，也许也可以交给机器：给它一个工作区，让它去试各种各样的网络设计，直到设计出更好的模型。

3.7 世界变了：Heuristics is dead

(参考时间: 00:52)

讲师借 Jim Gray 在 2006 年那句极具号召力的话来类比今天。Jim Gray 讲的是存储系统：

Tape is Dead, Disk is Tape, Flash is Disk, RAM Locality is King.

讲师仿照它说：

Heuristics is dead, Policy is Heuristics, LLM is Policy, Mechanism is King.

编者拓展｜Jim Gray 那句话在说什么：它讲的是存储层级演进的连锁反应——磁带被磁盘取代，磁盘（在 SSD 出现后）又扮演了旧磁带的角色，闪存再取代磁盘成为主力；而当存储越来越快、越来越大之后，性能瓶颈就转移到了「数据是否已经在内存 / 缓存里」——数据的局部性（locality）成了王者。讲师把它「翻译」到算法世界：手调的启发式（heuristics）正在被通用方法取代，而机制（mechanism）才决定了上限。

你们在科研实践课里可能见过这样的研究范式：用启发式算法，把一个本来就不太好的方案，改成一个稍微好一点但仍然不怎么好的方案。这种范式今天已经死掉了，因为智能变得很便宜。
取而代之的，是做出一个可以无限扩展的机制/平台（比如 Agent 的生态），然后吸引人来往上面插东西，甚至吸引 AI 来往你的底座里插东西；插进去的越多，你能解决的问题就越多。这和 The Bitter Lesson 是同一个道理，也带着一点操作系统的味道：机制（mechanism）为王。

讲师给「量变引起质变」补了一句警告：很多人会说「你在任何地方做微小的东西都是有意义的」——这不对。你只有找到那个能引起质变的量变，量变才能引起质变，否则只是在原地踏步：在高铁时代，把马车造得再快一点，对高铁没有任何帮助。

「Code is cheap」的时代，那些过去不具备 scalability 的高级智能，现在可以 scale 了。讲师半开玩笑地举例——如果你「想毁掉全世界」，可以把所有学位论文都扒下来：

让 AI 去读，先挑出那些逻辑明显错误、结论根本不成立的论文，它们先死；剩下的一部分，再让 AI 去复现实验结果，复现不出来的，也死了。

在这个巨变的时代，要把视野放得足够大：找到那条能「走量」的路（Agentic AI、Agent Skills……），然后大胆去做以前觉得疯狂的事。

四、打开 Agentic AI：如何用好大模型

(参考时间: 00:58)

接下来进入技术部分：怎样用好大模型的能力。

4.1 注意力即一切：prompt engineering = attention engineering

前面已经科普过模型如何工作：它为了吐出下一个 token，内部有一个非常关键的机制叫 self-attention（自注意力）。

编者拓展｜Transformer 与 self-attention：今天的大模型几乎都由 Transformer 结构堆叠而成，其核心是 self-attention（自注意力）：处理某个位置的 token 时，会把序列中其它位置的信息按相关程度「加权求和」进来。正因为每一处都能「看到」前后文，模型才能利用长距离的依赖。所谓「注意力工程」，就是通过组织上下文，让模型的注意力落到你希望它关注的地方。这和人也很像——你做难题时，往往靠的是注意到某个关键处，然后题就解出来了；而你之所以能注意到，是因为题目结构里有某个「钩子」。

由此，讲师给出一句精辟的概括：提示词工程（prompt engineering）本质上就是 attention engineering。你要做的，是让模型注意到你想让它注意的东西，并引导它做出正确的事。

举例：让 AI 写一篇小说总是不尽如人意，因为它所有的 attention 都集中在「写一个小说」这几个字上——而作为一个「看过世界上所有书」的存在，它会非常乐意地用一个中庸、平庸的平均方式，写出一篇「非常好、但可能不是你要的」小说。这时你就需要在上下文里注入个性化的信息：你是什么样的人、你希望它是什么样。给出足够的信息，它才能注意到，才能写好。

编者说明：这也是为什么早期 GPT 的提示词常常非常长——信息越具体，注意力越容易落到正确的地方。今天的模型虽然更强，但这条原则没有变。

4.2 分解问题 = 构建合适的抽象

(参考时间: 01:00)

今天，AI 已经能在 plan mode 里自己做规划；但「分解问题」依然是极其重要的能力。讲师甚至说：

分解问题的能力，是 AI 时代你们最需要的能力。

一个疯狂的想法，如果直接丢给 AI，它只会给你一个平庸的答案；但如果你能用你独特的视角把问题分解，你就可能直接得到一个可用的、甚至产品级的结果。

而所谓的分解，其实就是构建一个合适的抽象。这在操作系统/计算机系统领域有非常经典的例子：

graph TD
    subgraph L1["抽象一：系统调用"]
        A1["巨大的应用生态<br>（原神、Steam……）"] --- A2["系统调用 syscall<br>（非常小的一层）"] --- A3["操作系统实现<br>（千万行级的高性能代码）"]
    end
    subgraph L2["抽象二：指令集"]
        B1["操作系统 / 软件生态"] --- B2["指令集 ISA（RISC-V）"] --- B3["硬件实现"]
    end

syscall：上面是巨大无比的应用生态，下面是千万行级的操作系统实现，中间那层接口却非常小——这就是它优雅的地方；
ISA（指令集）：上面是整个计算机世界，下面是硬件，接口同样极简（如 RISC-V）。

编者拓展｜「中间接口要窄」——窄腰架构：这种「上下都复杂、中间接口很窄」的结构，在网络里叫 narrow waist（窄腰）：互联网的沙漏模型中间是 IP 层，上面能长出 HTTP、SMTP 等无数协议，下面能跑以太网、Wi-Fi、光纤等各种链路。操作系统的 syscall、硬件的 ISA 也是同一个形状。窄腰之所以重要，是因为它稳定、通用、可组合——只要接口不变，两侧就能各自独立地狂野生长。这也正是「好的抽象」的判准。

在一个应用程序内部，也可以做同样的复杂性分解。 讲师举例：你想做一个校园服务（送外卖、洗衣服……），第一个功能是注册用户，于是写一个 register_user(name=…, gender=…) 函数。很多地方会调用它，这带来维护负担——比如有一天性别要支持「多元」，你一改参数，就可能break 掉跨模块的调用。

编者说明：重点不是「不该把 register_user 实现成函数」，而是——系统设计与实现时，子系统与子系统之间的交互才是最有意思、也最需要人的判断的地方。让 AI 去做一个「平均」的方案，未必是对你最合适的。

4.3 案例：用文件系统解耦子系统

(参考时间: 01:05)

讲师分享了自己在上课系统里做的一个相当反常规的设计。

如果让 AI 去实现一个「上课的系统」，它大概率会做成一个前端网页：左边栏、右边栏，点一个按钮就把事件传递给另一个地方，内部是一堆函数调用、内存里的数据结构。这对「导出 lecture notes」之类的事情会带来麻烦。

讲师没有用函数调用，而是把子系统之间的接口变成了文件系统：

当他切换到某一张幻灯片时，他做的事是写一个文件；
一个独立的播放器程序去读取这个日志文件，约定好格式（协议），就能正确显示幻灯片。

编者拓展｜这就是 UNIX Philosophy：顺着「用文件当接口」，就能理解被讲了五十年的 UNIX 哲学——每个程序只做一件事并做好，再用文本流 / 文件把它们组合起来（| 管道就是最典型的组合）。Linux 把设备、内核状态都暴露成文件（/dev、/proc、/sys），于是 cat、echo、重定向这些最朴素的工具就能操作几乎一切。讲师用「写一个日志文件」代替「调一个函数」，正是这套「一切皆文件、以约定解耦」的思想在应用层的复现。

graph LR
    U["讲师操作<br>（切换幻灯片）"] --> F["目录 / 日志文件<br>（约定的协议）"]
    F --> V1["网页播放器"]
    F --> V2["终端播放器"]
    F --> V3["其它任意程序"]

好处是：

前端与后端彻底解耦，中间接口只是一个目录和一个日志；
幻灯片播放器本身可能只是 300 行 AI 生成的代码，但它是一个独立运行的程序，不会污染系统的其它部分；
可以让多个 AI 并行地实现好几个工具——如果是一个 monolithic 的库、到处函数调用调来调去，两个 agent 同时改同一个文件就会有冲突风险。

讲师坦言，这种「为子系统制定协议」的能力，是现在 AI 还不够擅长的地方。但他也相信：算力就是智能，所以 AI 没有道理做不了这件事——「当 AI 真正能做这件事的时候，我们的末日就真正来了」。

五、Hacking Day：用 AI Vibe-Code 一个最小 OS 内核

(参考时间: 01:09)

接下来是今天的彩蛋：把「写一个操作系统内核」全部交给 AI，测试一下（国产）模型的能力。讲师强调自己没有任何准备，随时可能翻车——但正因如此，大家能看到最真实的 AI。

5.1 任务分解：让 GPT-5.4 写一份 CLAUDE.md

(参考时间: 01:09)

为了公平地「测试国产模型」，讲师先自己说了一句话，让 GPT-5.4 生成一个小的任务分解，因为他暂时觉得国产模型在做「分解」这件事上可能还需要一点时间。

编者说明：讲师特意「把和操作系统相关的知识全部清空」，假装自己完全不懂 RISC-V 和操作系统，完全不用自己的 OS 知识，全部交给模型——这才是真正的「vibe coding」。

GPT-5.4 给出的分解看起来还不错：

他要启动内核，初始化一个最小的运行环境（minimal runtime environment）；
创建多个内核线程；
做线程切换；
并展示调度。

它甚至煞有介事地写了工作风格（working style）与 "think step by step" 的提示，要求每一步都解释清楚、并说明怎么测试；还从讲师的自然语言提示里提炼出诸如 "keep the design tiny and explicit" 之类的原则，以及 What to avoid、Next、preferred mindset 等小节。

目标是一个 最小的「操作系统」：不依赖任何外部库函数和代码，在 coding agent 的协助下实现一个最小的 OS。思路、架构、流程都写在 CLAUDE.md（类似 AGENTS.md）里；对于真实项目，这些文档还需要进一步分解。目标还包括设计一些有用的 skills / subagents，体验「一个人就是产品经理」的感觉。

5.2 现场演示：真·翻车准备

(参考时间: 01:12)

模型开始工作了（用的是豆包系的模型）。可以看到它的 self-attention 在起作用：它先得到一个 plan list，然后开始创建必要的文件结构——写 Makefile、写链接编译脚本、建 source 和 include 目录。

graph TD
    A["读 CLAUDE.md"] --> B["列出 plan list"]
    B --> C["创建目录结构<br>source/ include/"]
    C --> D["写 Makefile / 链接脚本"]
    D --> E["写 kernel.h / thread.h"]
    E --> F["写上下文切换汇编"]
    F --> G["make 编译"]
    G -->|报错| H["读错误信息并修复"]
    H --> G
    G -->|成功| I["QEMU 中运行<br>切换两个线程"]

讲师一边看一边点评：

📷 Claude Code 生成的目录结构与源码
回到原视频 (01:13:15)

它写出的代码工工整整，有一种「回到计算机系统基础课」的感觉；
它知道编程里的 best practice，会先写注释，再做设计；
它甚至写了一段汇编——只要一个东西是 well-known、别人做过的，它就可以用「记忆里对操作系统的理解」把它写出来。

📷 编译报错：cast a pointer from integer of different size
回到原视频 (01:16:05)

编译时出现了一个典型错误："cast a pointer from integer of different size"。讲师感慨：如果是自己遇到这个问题，唯一能做的就是查手册——在大语言模型之前，我们拥有的只有互联网和无数手册，人只能充当人肉索引。而现在，模型自己读完错误信息就去修复。

最后，结果有点出乎讲师的预期：成功了。它构建出了一个最小的 RISC-V 操作系统，能在 QEMU 中运行，并成功切换了两个线程。讲师手动 make、运行、检查输出（50 51 52 53 …，以十六进制打印）——没有问题。

📷 AI 生成的最小 RISC-V 内核在 QEMU 中切换两个线程
回到原视频 (01:17:05)

编者拓展｜一个「最小内核」到底在干什么：RISC-V 是一套开放的指令集（ISA），任何人都可以免费实现它；QEMU 则用软件模拟一台 RISC-V 机器，让内核不必有真硬件也能跑起来。一个最小内核要做的几件事，恰好就是本讲反复讲的「状态机」：① 设置好栈与运行环境；② 准备一个陷入（trap）处理入口；③ 实现上下文切换——用一小段汇编把当前线程的寄存器保存到它的栈上、再恢复另一个线程的寄存器；④ 用一个最朴素的调度器在两条线程间来回切。屏幕上那串 50 51 52 …，就是两个线程各自打印自己的计数器、交替输出的证据——线程切换真的跑起来了。

5.3 观察与反思：AI 与人到底哪里不一样

(参考时间: 01:17)

讲师抛出一个问题：这个过程哪里让你觉得不太对？如果由人来构建，会在哪里不同？

他的观察是：AI 所做的是 "Attention is all you need"——当你对它说 "do it" 时，它所有的 attention 都集中在你过去做的事情上，于是它不由自主地倾向于「你说什么就做什么」：跑 make，看到 error message，就去修，一步一步线性推进。

而如果是人来「给同学们构建一个操作系统」，会更倾向于：

先构建基础设施、先做抽象，而不是一口气把代码写完再逐个修错；
实现一个 skill（比如用来运行/测试的框架），主动要求它打印 trace / log；
做一个最小的测试框架（哪怕只有一两行），这样每次 build 完都能自动运行一次、立刻拿到反馈。

📷 人类会为系统设计可验证的测试抽象
回到原视频 (01:21:20)

讲师特别强调日志污染上下文的问题：运行时刷屏的打印信息，会占用大量上下文；人类会凭直觉及时中断，而 AI 往往要等到一个默认 timeout（比如一分钟）之后才停，这一长串日志都会留进上下文——即使之后 compact，也多少有损失。而一个合适的「测试抽象」，能把这类噪音挡在上下文之外。

他还提到，将来希望把整门课程全部开源、再也不需要自己维护。为此，作为一个系统研究者，他会显式地告诉 AI：你需要这样一个工具——不仅仅是 unit test，甚至还有验证工具（比如在计算机系统实验里引入的 differential testing）。这些「合适的抽象」，正是人类智慧中最值得保留、也最值得在这门课上学到的东西。

编者拓展｜differential testing（差分测试）是什么：它的思路是「同一份输入，交给两个（或多个）应当等价的实现，比较输出」。计算机系统基础实验里常用它来自动批改：参考实现与学生实现跑同一批测试，结果不一致就定位到差异。相比写死几个期望值的单元测试，它能用大量随机输入去覆盖边角情况。对 AI 写的代码尤其有用：可以让模型同时给出一个「直觉上更可能对」的参照实现，再用差分测试自动找出两边分歧的地方。

编者说明：本讲并没有给出「AI 到底行不行」的结论。它更像一次公开的实验与示范：模型已经能独立写出可运行的内核雏形，而人的价值，越来越体现在分解问题、设计抽象、制定协议、以及为 AI 搭好可验证的舞台这些事上。

总结

大语言模型的三个字：「大」是承载复杂性的必要条件；「语言」是人类沉淀千年、可对齐的世界模型；「模型」是一个 next token prediction 的概率分布。
大模型 = 一个活生生的人：加上眼睛（多模态）、草稿纸（reasoning）、计算器（tools）之后，它能推理、会犯错、能自我纠正。
Agent 的本质是一个工作区：用目录 + Git 充当 working memory，让「每次醒来都失忆」的模型能够持续推进一个大项目；这套软件工程的 best practice，恰好是为 Agent 量身定制的舞台。
Scaling Law 是一条反复被验证的历史规律：从网络存储到 DeepBlue、AlphaGo，再到今天的 Kaplan / Chinchilla——所谓智能，很大程度就是算力，量变引起质变。
量变引起质变的前提，是找对了「量变」：在高铁时代造更快的马车没有意义；要找到那条能「走量」的路，而机制/平台往往是承载复杂性的关键（Mechanism is King）。
用好大模型的两个抓手：一是注意力工程（把你想让它注意的信息放进上下文）；二是分解问题 = 构建合适的抽象（syscall、ISA、子系统之间的协议）。
AI 与人当下的差异：AI 擅长「do it」式的线性执行，人在先搭抽象、先做基础设施、为系统设计可验证的接口上仍占优势——而这些「合适的抽象」，正是系统课真正要教的东西。

附：官方参考与延伸阅读

本讲的讲义见课程主页，以下链接按书中出现顺序整理：

主题	链接
BERT 论文	https://arxiv.org/abs/1810.04805
ViT：一张图等于 16×16 个词	https://arxiv.org/abs/2010.11929
ReAct：让语言模型「推理 + 行动」	https://arxiv.org/abs/2210.03629
Toolformer：让模型学会调用工具	https://arxiv.org/abs/2302.04761
thefuck：命令行的「自动纠错」（大模型之前）	https://github.com/nvbn/thefuck
DEATHLOOP（死亡循环，游戏）	https://store.steampowered.com/app/1252330/DEATHLOOP/
Rich Sutton, The Bitter Lesson	https://www.cs.utexas.edu/~eunsol/courses/data/bitter_lesson.pdf
Elo 评分系统简介	https://www.attackingchess.com/understanding-the-elo-rating-system-in-chess/
Kaplan et al., Scaling Laws for Neural Language Models	https://arxiv.org/pdf/2001.08361
Hoffmann et al., Training Compute-Optimal LLMs（Chinchilla）	https://arxiv.org/abs/2203.15556
AlphaCode（Li et al., Science, 2022）	https://www.science.org/doi/10.1126/science.abq1158
符号接地问题（Harnad, 1990）	https://en.wikipedia.org/wiki/Symbol_grounding_problem
蒙特卡洛树搜索 MCTS	https://en.wikipedia.org/wiki/Monte_Carlo_tree_search
Deep Blue（IBM）	https://www.ibm.com/history/deep-blue
Merkle tree（Git 底层结构）	https://en.wikipedia.org/wiki/Merkle_tree
差分测试（differential testing）	https://en.wikipedia.org/wiki/Differential_testing
最小「操作系统」Demo	https://jyywiki.cn/OS/demos/intro/os-minimal
AGENTS.md（OpenClaw）	https://github.com/openclaw/openclaw/blob/main/AGENTS.md
QEMU	https://www.qemu.org/
RISC-V 指令集	https://riscv.org/
DeepSeek	https://www.deepseek.com/
Claude Code	https://www.anthropic.com/claude-code
Codeforces（编程竞赛平台）	https://codeforces.com/

阅读材料：建议在 AI 的帮助下全文阅读 The Bitter Lesson，并对照 Kaplan 与 Chinchilla 两篇论文，理解「算力—数据—模型」三者的经验规律；也可以动手体验 os-minimal，看一个最小的 RISC-V 内核是如何在 QEMU 中跑起来的。

版权说明：本讲讲义与幻灯片作者为蒋炎岩，采用 Creative Commons BY-NC 4.0 许可，来源于 https://jyywiki.cn/OS/2026/。视频画面与字幕版权归原作者所有。本书为课堂内容的学习性重构。