diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\200\347\253\240\357\274\232\350\256\241\347\256\227\346\234\272\347\232\204\345\216\206\345\217\262.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\200\347\253\240\357\274\232\350\256\241\347\256\227\346\234\272\347\232\204\345\216\206\345\217\262.md"
index 59f6c851..c9fd732f 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\200\347\253\240\357\274\232\350\256\241\347\256\227\346\234\272\347\232\204\345\216\206\345\217\262.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\200\347\253\240\357\274\232\350\256\241\347\256\227\346\234\272\347\232\204\345\216\206\345\217\262.md"
@@ -22,7 +22,7 @@
 
 　　不过，这话说起来轻巧。人类为了“偷这个懒”，其实摸索了几千年。
 
-![](https://raw.githubusercontent.com/TinySnow/computer-science-guide-resources/master/computer-science-guide/content/为什么需要计算机.svg)
+![](https://raw.githubusercontent.com/TinySnow/computer-science-guide-resources/master/computer-science-guide/content/为什么需要计算机.png)
 
 ### 最早的算工具：算盘
 
@@ -57,7 +57,7 @@
 
 > 　　巴贝奇的分析机和 ENIAC 都能“自动计算”，但“存储程序”这个想法为什么如此关键？它到底解决了什么老问题？
 
-![](https://raw.githubusercontent.com/TinySnow/computer-science-guide-resources/master/computer-science-guide/content/懒是人类进步的第一动力.svg)
+![](https://raw.githubusercontent.com/TinySnow/computer-science-guide-resources/master/computer-science-guide/content/懒是人类进步的第一动力.png)
 
 ## 小结
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\211\345\215\201\345\205\255\347\253\240\357\274\232\347\250\213\345\272\217\344\270\216\347\250\213\345\272\217\350\256\241\346\225\260\345\231\250.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\211\345\215\201\345\205\255\347\253\240\357\274\232\347\250\213\345\272\217\344\270\216\347\250\213\345\272\217\350\256\241\346\225\260\345\231\250.md"
index 4df252f6..f0ab9244 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\211\345\215\201\345\205\255\347\253\240\357\274\232\347\250\213\345\272\217\344\270\216\347\250\213\345\272\217\350\256\241\346\225\260\345\231\250.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\211\345\215\201\345\205\255\347\253\240\357\274\232\347\250\213\345\272\217\344\270\216\347\250\213\345\272\217\350\256\241\346\225\260\345\231\250.md"
@@ -103,13 +103,13 @@ END:
 
 　　这就要靠**指令译码器（Decoder）**：它把操作码翻译成一组具体的控制信号——让 ALU 做什么运算、读哪几个寄存器、结果写回哪里、PC 要不要跳转。
 
-　　还记得造 ALU 时，用一个译码器把操作码翻译成“选中哪一种运算”吗？指令译码是同样的套路，只不过被翻译的东西，从“一个运算”变成了“一整套动作”。
+　　还记得造 ALU 时，用一个译码器把 ALU 控制码翻译成“选中哪一种运算”吗？指令译码是同样的套路，只不过它要把指令操作码翻译成控制整条数据通路的“一整套动作”。
 
 　　于是，一条指令的执行被拆成清晰的几步：**取指 → 译码 → 执行 → 写回**。这也是后面流水线的基础。
 
  **思考题** 
 
-> 　　上面算 1 到 N 和的程序，如果还想顺便算出平均值（和 ÷ N），应该怎么改？注意 N 在循环里已经被改动过了。
+> 　　上面算 1 到 N 和的程序，如果还想顺便算出平均值（和 ÷ N），应该怎么改？注意区分保存 N 的 R1 和在循环中不断自增的 R3。
 >
 > 　　另外想一想：如果 PC 只会无脑加 4，它怎么处理长度不固定的指令？
 
@@ -131,14 +131,13 @@ END:
 
 ### 思考题答案（仅供参考）
 
-1. 循环结束后 R3 已经变成 N+1，要先把它减回 N，再做除法：
+1. 循环只修改了 R3，保存 N 的 R1 没有改变，所以可以直接用 R2 除以 R1：
 
 ```assembly
-    SUB R3, R3, #1   ; R3 = N
-    DIV R4, R2, R3   ; R4 = sum / N，即平均值
+    DIV R4, R2, R1   ; R4 = sum / N，即平均值
 ```
 
-　　这也提醒我们：使用寄存器时，要留意它是否被前面的指令改动过。
+　　循环结束时 R3 的确已经变成 N+1，但它只是循环变量 i。这个例子也提醒我们：使用寄存器时，要分清每个寄存器保存的含义，以及它是否被前面的指令改动过。
 
 2. 变长指令的 PC 不能无脑加 4，而要加“当前这条指令的实际长度”。译码阶段顺便算出指令长度，再让 PC 加上它。定长指令之所以受欢迎，就是因为 PC 更新特别简单、流水线也好设计。
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\270\200\347\253\240\357\274\232\344\270\216\346\210\226\351\235\236\351\227\250\351\246\226\345\260\276\347\233\270\350\277\236.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\270\200\347\253\240\357\274\232\344\270\216\346\210\226\351\235\236\351\227\250\351\246\226\345\260\276\347\233\270\350\277\236.md"
index 92404de0..65ddf821 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\270\200\347\253\240\357\274\232\344\270\216\346\210\226\351\235\236\351\227\250\351\246\226\345\260\276\347\233\270\350\277\236.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\270\200\347\253\240\357\274\232\344\270\216\346\210\226\351\235\236\351\227\250\351\246\226\345\260\276\347\233\270\350\277\236.md"
@@ -2,7 +2,7 @@
 
 ## 复习
 
-- 算术逻辑单元：ALU 把算术和逻辑运算集成起来，用操作码选择当前运算
+- 算术逻辑单元：ALU 把算术和逻辑运算集成起来，用 ALU 控制码选择当前运算
 - ALU 的状态标志：ALU 用零、符号、进位和溢出标志记录运算结果的特征
 - 运算器总装：把前面造好的零件组装成了能算加减乘除的运算器
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\270\203\347\253\240\357\274\232\345\260\235\350\257\225\345\212\240\346\263\225\350\207\252\345\212\250\345\214\226.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\270\203\347\253\240\357\274\232\345\260\235\350\257\225\345\212\240\346\263\225\350\207\252\345\212\250\345\214\226.md"
index 1eed0e68..f0767c1b 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\270\203\347\253\240\357\274\232\345\260\235\350\257\225\345\212\240\346\263\225\350\207\252\345\212\250\345\214\226.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\270\203\347\253\240\357\274\232\345\260\235\350\257\225\345\212\240\346\263\225\350\207\252\345\212\250\345\214\226.md"
@@ -3,13 +3,14 @@
 ## 复习
 
 - 如何读时序图：时序图记录信号随时间的高低电平变化
-- 触发器：触发器在时钟边沿保存一位数据，能避免噪声干扰
+- 触发器：触发器在指定时钟边沿保存一位数据，远离采样边沿的输入变化不会直接改变输出
 - 寄存器：多个触发器并排连接，形成能保存多位数据的寄存器
 
 ## TL;DR
 
-- 把加法器、寄存器、多路选择器接成一个回路，就能自动累加
-- 寄存器保存“目前的累加和”，多路选择器决定这一轮加的是新输入还是上一次的结果
+- 把加法器、寄存器和反馈线路接成一个回路，就能自动累加
+- 寄存器保存“目前的累加和”，外部输入提供每一轮要加的新数
+- 多路选择器可以在初始化时选择 0，之后选择寄存器反馈的当前和
 - 这个电路就叫累加器，是 CPU 运算部件的雏形
 
 ## 正文
@@ -29,33 +30,35 @@
 　　机器要自动化这件事，就得解决两个问题：
 
 1. 谁来记住“目前的和”？——用寄存器。
-2. 每一次相加，是拿“新来的数”加，还是拿“上次的结果”加？——用多路选择器来选。
+2. 怎样把“目前的和”与每轮“新来的数”同时送进加法器？——让它们分别连接加法器的两个输入。
 
 ### 搭出电路
 
-　　思路其实很朴素：让加法器的输出，经过寄存器保存下来，再绕回到加法器的输入，和自己加。
+　　思路其实很朴素：让加法器的输出经过寄存器保存下来，再绕回到加法器的一个输入；外部的新数则接到另一个输入。这样每一轮计算的都是“当前和 + 新数”，不是让当前和与自己相加。
 
 - 加法器：两个输入，一个来自外部的新数，一个来自寄存器里存着的“当前和”；输出新的和
 - 寄存器：把加法器算出来的新和存起来
-- 多路选择器：在“外部新数”和“寄存器里的当前和”之间二选一，送给加法器
+- 多路选择器：在初始化时为加法器的第一个输入选择 0，开始累加后改选寄存器反馈的当前和
 - 时钟：告诉寄存器什么时候把新结果存进去
 
 　　接好之后大概是这样一条回路：
 
 ```
-   外部输入 ──┐
-             ├──[多路选择器]──┬──[加法器]──┬──[寄存器]──> 输出
-   寄存器 ───┘               │           │
-                             └───────────┘（回送到加法器的另一个输入）
+   常数 0 ───┐
+             ├──[多路选择器]──────┐
+   寄存器 ───┘                    │
+                                 ├──[加法器]──[寄存器]──> 输出
+   外部新数 ──────────────────────┘                │
+                                                  └──反馈到多路选择器
 ```
 
 ### 它是怎么工作的
 
 　　假设初始时寄存器里是 0。我们依次送入 1、2、3、4：
 
-1. 送入 1：多路选择器把“当前和 0”和“新数 1”送给加法器，算出 1，存进寄存器
+1. 送入 1：多路选择器先选择 0，外部输入提供新数 1；加法器算出 1，存进寄存器
 2. 送入 2：把“当前和 1”和“新数 2”相加，得 3，存进寄存器
-3. 送入 3：1、3 相加得 6，存进寄存器
+3. 送入 3：把“当前和 3”和“新数 3”相加，得 6，存进寄存器
 4. 送入 4：6、4 相加得 10，存进寄存器
 
 　　每来一个数、每来一个时钟脉冲，寄存器就更新一次。四个数送完，寄存器里就躺着答案 10。
@@ -76,8 +79,8 @@
 
 ### 知识点
 
-- 用加法器 + 寄存器 + 多路选择器构造累加器
-- 多路选择器在回路中的作用：选择反馈值还是新输入
+- 用加法器 + 寄存器 + 反馈线路构造累加器
+- 多路选择器在回路中的作用：初始化时选择 0，之后选择反馈值
 - 时钟在其中的作用：决定何时写入
 - 累加器的意义：运算部件的雏形
 
@@ -93,7 +96,7 @@
 
 ### 思考题答案（仅供参考）
 
-　　让它“听命令”运算。具体做法是：在加法器之外，再放上减法器、乘法器等功能部件，然后用多路选择器在它们的输出之间选择，用一个信号告诉多路选择器“这一轮选哪个运算”。这个信号，我们已经在前面的 ALU 里见过，它就是“操作码”。把操作码、累加器和数据通路组合起来，就离真正的 CPU 很近了。
+　　让它“听命令”运算。具体做法是：在加法器之外，再放上减法器、乘法器等功能部件，然后用多路选择器在它们的输出之间选择，用一个信号告诉多路选择器“这一轮选哪个运算”。这个信号就是前面见过的 **ALU 控制码**。以后，完整指令中的操作码会由控制器译码，产生 ALU 控制码以及其他控制信号。把这些控制信号、累加器和数据通路组合起来，就离真正的 CPU 很近了。
 
 ## 协议
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\271\235\347\253\240\357\274\232\346\233\264\345\244\247\345\255\230\345\202\250.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\271\235\347\253\240\357\274\232\346\233\264\345\244\247\345\255\230\345\202\250.md"
index 5f60c0e3..93c2d902 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\271\235\347\253\240\357\274\232\346\233\264\345\244\247\345\255\230\345\202\250.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\271\235\347\253\240\357\274\232\346\233\264\345\244\247\345\255\230\345\202\250.md"
@@ -32,11 +32,11 @@
 - 8 根数据输出线
 - 1 根写入控制线
 
-　　一共 17 根。如果要存 1000 个 8 位数据，就是 17000 根线。晶体管才不在乎多几个，但**芯片上的引脚和走线是极其宝贵的资源**，这么多线根本排不下。这就是这种办法最大的问题——线太多了。
+　　一共 17 根。如果真的给 1000 个寄存器都保留一套彼此独立的外部接口，就会出现 17000 根信号线，还需要庞大的选择和连接电路。**芯片上的引脚和走线是极其宝贵的资源**，这种“每个寄存器单独接出全部信号”的办法并不现实。
 
 ### 换个角度想
 
-　　为什么我们觉得“每个寄存器都要有独立的输入输出线”？因为我们默认：任何时候都要能同时读写所有数据。
+　　为什么刚才会画出那么多线？因为那个最直接的方案默认每个寄存器都有独立接口，仿佛随时都要同时读写所有数据。
 
 　　可实际使用中，我们绝大多数时候**只需要读写其中一个数据**。比如查数组的某个元素、取一条指令，都只关心某一块，而不是全部。
 
@@ -69,7 +69,7 @@
 
  **思考题** 
 
-> 　　并排连接的方式线太多，矩阵方式省线。那为什么寄存器不干脆也排成矩阵、共用数据线，省下那些线？提示：想想寄存器最大的特点是什么。
+> 　　CPU 的寄存器文件其实也可以排成阵列并共用部分线路。既然如此，它为什么仍然不能像大容量存储器一样，只设计一个读写端口、每次只访问一个位置？提示：想想一条指令可能同时需要几个操作数和结果。
 
 ## 小结
 
@@ -88,7 +88,7 @@
 
 ### 思考题答案（仅供参考）
 
-　　寄存器最大的特点是**快**，而且是“随取随用”。CPU 每个时钟周期都可能同时用到好几个寄存器（比如两个操作数加一个结果），所以它必须让所有寄存器都能被并行、直接地访问，这正是靠“每人一条专用线”换来的。存储器要的是容量大、成本低，牺牲一点速度、改成“按地址一个一个取”完全值得。**速度和容量，本来就是一对矛盾，这正是存储层次结构要解决的问题。**
+　　CPU 的**寄存器文件通常本身就是一个小型阵列**，也会使用地址译码器、位线和多路选择器，并不是每个寄存器都直接拉一套线路到芯片外。它与大容量存储器的关键差别在于端口和设计目标：一条指令常常要同时读取两个寄存器并写回一个寄存器，所以寄存器文件会提供多个读写端口，并为低延迟付出更大的面积和功耗。大容量存储器更重视容量和成本，端口通常更少、访问也更慢。**速度、端口数、面积和容量需要彼此权衡，这正是存储层次结构存在的原因。**
 
 ## 协议
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\272\224\347\253\240\357\274\232\350\247\246\345\217\221\345\231\250.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\272\224\347\253\240\357\274\232\350\247\246\345\217\221\345\231\250.md"
index b69eb4bf..f81c7442 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\272\224\347\253\240\357\274\232\350\247\246\345\217\221\345\231\250.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\344\272\224\347\253\240\357\274\232\350\247\246\345\217\221\345\231\250.md"
@@ -10,7 +10,7 @@
 
 - 触发器是计算机中最基本的记忆单元
 - 触发器同锁存器一样，可以存储一位二进制数据（0 或 1）
-- 不同的是，触发器不容易被噪声信号（错误输入）干扰
+- 不同的是，边沿触发器只在指定时钟边沿采样输入，远离采样边沿的输入变化不会直接改变输出
 - 触发器是实现时序逻辑电路的基础
 - 触发器是构建寄存器和存储器的基本单元
 
@@ -65,9 +65,9 @@
 
 ### 边沿 D 触发器
 
-　　受机械锁存装置的分步操作（例如先“预存”再“锁定”）的影响。业界采用主从触发器的形式，实现边沿敏感触发器。第一个触发器称为“主触发器”，第二个触发器称为“从触发器”。
+　　实现边沿敏感触发器的一种经典方法，是把两个电平敏感锁存器串联起来。第一级称为“主锁存器”，第二级称为“从锁存器”，两级由相反的时钟电平控制。
 
-　　例如主触发器在 WE = 1 时接收输入并暂存，从触发器在 WE = 0 时复制主级状态。这种物理隔离确保输出仅在 WE 下降沿（或上升沿）更新。
+　　以图中的**上升沿触发**结构为例：主锁存器接反相后的 WE，因此在 WE = 0 时接收并暂存 D，从锁存器此时关闭；WE 从 0 变为 1 的瞬间，主锁存器关闭并锁住边沿前的 D，从锁存器同时打开，把主级保存的值送到 Q。WE 保持为 1 时，D 的后续变化进不了主级；WE 下降时，从级关闭，Q 也不会更新。因此这个结构只在 **WE 上升沿**采样。
 
 ![](https://img.tinysnow.cn/blog/computer-science-guide/content/上升沿敏感边沿D触发器.png)
 
@@ -75,11 +75,11 @@
 
 ![](https://img.tinysnow.cn/blog/computer-science-guide/content/添加Q_Middle.png)
 
-　　这是一个上升沿敏感边沿 D 触发器（因为主触发器，也即第一个触发器前面加了一个非门，所以 WE 为 0 时，主触发器才会更新 D 值），时序图长这样：
+　　这是一个上升沿敏感 D 触发器：第一个锁存器前的非门让它在 WE = 0 时跟随 D，而第二个锁存器在 WE = 1 时才接收主级锁住的值。时序图长这样：
 
 ![](https://img.tinysnow.cn/blog/computer-science-guide/content/上升沿敏感边沿D触发器时序图.png)
 
-　　可以看到 Q_Middle 达到了我们理想中的效果。如果忽略 Q_Middle 这个中间结果，直接观察最终结果 Q, WE 和 D，可以发现 Q 的每次更新都是在 WE 信号变化时才更新。
+　　可以看到 Q_Middle 达到了我们理想中的效果。如果忽略 Q_Middle 这个中间结果，直接观察最终结果 Q、WE 和 D，可以发现 Q 只会在 WE 上升沿采样并更新。
 
 　　注意观察图中的噪声信号：它发生在采样边沿之外，所以没有导致最终结果 Q 的更新。在 35μs 的时刻还有一次上升沿，D 信号为 0，触发器会把 0 写入 Q；图上看不到变化，只是因为 Q 此前已经是 0。
 
@@ -87,11 +87,11 @@
 
 | D | WE | Q(下一状态) | 说明 |
 |:-:|:-:|:----------:|:-----|
-| X(无关) | 其他情况 | Q(保持) | 保持当前状态 |
-| 0 | ↑(上升沿)或↓(下降沿) | 0 | 复位 |
-| 1 | ↑(上升沿)或↓(下降沿) | 1 | 置位 |
+| X(无关) | 非上升沿 | Q(保持) | 保持当前状态 |
+| 0 | ↑(上升沿) | 0 | 采样并保存 0 |
+| 1 | ↑(上升沿) | 1 | 采样并保存 1 |
 
-　　注意，↑(上升沿触发)和↓(下降沿触发)是两个不同的触发方式，画图时的表示也不一样。上面的真值表为合写，实际上一个边沿敏感 D 触发器只能有一个触发方式。
+　　把两级锁存器的时钟极性反过来，也可以做出下降沿触发器。↑（上升沿触发）和 ↓（下降沿触发）是两种不同器件行为，画图时的表示也不一样；一个具体的边沿 D 触发器只采用其中一种。
 
 ### 其他触发器
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\345\205\253\347\253\240\357\274\232\346\227\266\345\272\217\351\200\273\350\276\221\347\224\265\350\267\257.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\345\205\253\347\253\240\357\274\232\346\227\266\345\272\217\351\200\273\350\276\221\347\224\265\350\267\257.md"
index eb77faf6..9a57caae 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\345\205\253\347\253\240\357\274\232\346\227\266\345\272\217\351\200\273\350\276\221\347\224\265\350\267\257.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\345\205\253\347\253\240\357\274\232\346\227\266\345\272\217\351\200\273\350\276\221\347\224\265\350\267\257.md"
@@ -2,7 +2,7 @@
 
 ## 复习
 
-- 触发器：触发器在时钟边沿保存一位数据，能避免噪声干扰
+- 触发器：触发器在指定时钟边沿保存一位数据，远离采样边沿的输入变化不会直接改变输出
 - 寄存器：多个触发器并排连接，形成能保存多位数据的寄存器
 - 尝试加法自动化：加法器、寄存器和多路选择器接成回路，构成自动累加器
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\345\205\255\347\253\240\357\274\232\345\257\204\345\255\230\345\231\250.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\345\205\255\347\253\240\357\274\232\345\257\204\345\255\230\345\231\250.md"
index cd0adc39..48fb2ae5 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\345\205\255\347\253\240\357\274\232\345\257\204\345\255\230\345\231\250.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\345\205\255\347\253\240\357\274\232\345\257\204\345\255\230\345\231\250.md"
@@ -4,7 +4,7 @@
 
 - 时钟：时钟以周期性方波统一各部件更新的节拍
 - 如何读时序图：时序图记录信号随时间的高低电平变化
-- 触发器：触发器在时钟边沿保存一位数据，能避免噪声干扰
+- 触发器：触发器在指定时钟边沿保存一位数据，远离采样边沿的输入变化不会直接改变输出
 
 ## TL;DR
 
@@ -16,7 +16,7 @@
 
 　　还记得我们怎样做出 ALU（算数逻辑单元）吗？我们利用与或非基础三门，造出复杂逻辑门，进而造出加法器、减法器、乘法器、除法器，配上一些组合逻辑，让逻辑门识别我们需要做的特定运算，ALU 就完成了。
 
-　　寄存器也是如此，甚至更简单。我们造出了 1 位触发器，实现了锁存功能，还屏蔽了噪声信号干扰，完全可以把这个 1 位触发器当作新元件使用。
+　　寄存器也是如此，甚至更简单。我们造出了只在指定时钟边沿采样的 1 位触发器，完全可以把它当作新的存储元件使用。
 
 　　恭喜你！我们的抽象能力上升了一级。
 
@@ -42,7 +42,7 @@
 
 　　8 位或者 64 位的寄存器有什么用呢？
 
-　　回想一下，在前面造 ALU 时，我们初步接触了“指令”的概念。比如“0001”并不表示数字 1，而是表示“做加法”运算。
+　　回想一下，在前面造 ALU 时，我们初步接触了控制码的概念。比如按第十八章的约定，`0000` 不表示数字 0，而是告诉 ALU“做加法”运算。
 
 　　“指令”不能和“数据”混为一谈，所以我们需要更多的寄存器，分开保存信息。
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\347\253\240\357\274\232\350\277\220\347\256\227\345\231\250\346\200\273\350\243\205.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\347\253\240\357\274\232\350\277\220\347\256\227\345\231\250\346\200\273\350\243\205.md"
index 57f35538..4f7577f1 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\347\253\240\357\274\232\350\277\220\347\256\227\345\231\250\346\200\273\350\243\205.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\272\214\345\215\201\347\253\240\357\274\232\350\277\220\347\256\227\345\231\250\346\200\273\350\243\205.md"
@@ -3,7 +3,7 @@
 ## 复习
 
 - 乘除法的优化：Booth 算法、华莱士树和不恢复余数法能加快乘除法
-- 算术逻辑单元：ALU 把算术和逻辑运算集成起来，用操作码选择当前运算
+- 算术逻辑单元：ALU 把算术和逻辑运算集成起来，用 ALU 控制码选择当前运算
 - ALU 的状态标志：ALU 用零、符号、进位和溢出标志记录运算结果的特征
 
 ## TL;DR
@@ -45,7 +45,7 @@
 　　现在把这些零件接到一起。一个最简单的运算器，需要这些东西：
 
 - **ALU**：负责算，加、减、乘、除、与、或、非都在里面
-- **操作码输入**：告诉 ALU“这一步算什么”
+- **ALU 控制码输入**：告诉 ALU“这一步算什么”
 - **数据输入**：参与运算的两个数
 - **结果输出**：算出来的数
 - **状态标志输出**：零、符号、进位、溢出
@@ -53,7 +53,7 @@
 　　接好的样子：
 
 ```
-   操作码 ──┐
+ ALU 控制码 ──┐
             ▼
    数据 A ──▶[ 算术逻辑单元 ALU ]──▶ 结果
    数据 B ──▶        │
@@ -73,9 +73,9 @@
 
 　　ALU 不会一次算完，要一步步来：
 
-1. 操作码设为“加法”，数据 A 送 3、数据 B 送 5 → 输出 8
+1. ALU 控制码设为“加法”，数据 A 送 3、数据 B 送 5 → 输出 8
 2. **把 8 记下来**（怎么记？先按下不表）
-3. 操作码设为“乘法”，数据 A 送 8、数据 B 送 2 → 输出 16
+3. ALU 控制码设为“乘法”，数据 A 送 8、数据 B 送 2 → 输出 16
 
 　　结果是 16，正确。
 
@@ -104,7 +104,7 @@
 ### 知识点
 
 - 从晶体管到 ALU 的完整层级
-- 运算器的组成：ALU + 操作码 + 数据输入 + 结果/标志输出
+- 运算器的组成：ALU + ALU 控制码 + 数据输入 + 结果/标志输出
 - 运算器的局限：能算不能记
 
 ### 参考资料

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\344\270\203\347\253\240\357\274\232\344\271\230\351\231\244\346\263\225\347\232\204\344\274\230\345\214\226.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\344\270\203\347\253\240\357\274\232\344\271\230\351\231\244\346\263\225\347\232\204\344\274\230\345\214\226.md"
index db2827fa..368da8ef 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\344\270\203\347\253\240\357\274\232\344\271\230\351\231\244\346\263\225\347\232\204\344\274\230\345\214\226.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\344\270\203\347\253\240\357\274\232\344\271\230\351\231\244\346\263\225\347\232\204\344\274\230\345\214\226.md"
@@ -18,31 +18,31 @@
 
 ### 慢在哪里
 
-　　第十三、十四章里那套乘除法，原理都对，但都很“老实”：
+　　第十五、十六章里那套乘除法，原理都对，但都很“老实”：
 
-- 乘法：乘数每一位为 1，就要加一次。如果乘数是 `1111 1111`，64 位里全是 1，就得加 64 次
+- 乘法：乘数每一位为 1，就要加一次。如果一个 64 位乘数的 64 位全是 1，就得加 64 次
 - 除法：每次试商都要真减一次；不够减，还得把余数恢复回去
 
 　　位数一多，这些“老实”的做法就拖后腿了。这一章看看工程师们怎么优化它们。
 
 ### 乘法的优化一：Booth 算法
 
-　　Booth 算法的聪明之处在于：**把一串连续的 1，换成一次减法。**
+　　Booth 算法的聪明之处在于：**把一串连续的 1，换成发生在两端边界的加减法。**
 
-　　比如 `1111`（十进制 15），可以看成 `10000 - 1`（16 - 1）。这样，原本要加 4 次的连加，变成“加一次、减一次”，只动两步。
+　　比如正数 15 至少要写成 5 位补码 `01111`，它可以看成 `10000 - 1`（16 - 1）。这样，原本要加 4 次的连加，变成“加一次、减一次”，只动两步。不能直接把 4 位补码 `1111` 当成 15，因为它表示的是 -1。
 
-　　推广开来，对乘数里任意一段连续的 1，都可以只在它的**开始**处减一次、**结束**处加一次，中间那串 1 就全被“消化”掉了。
+　　推广开来，一段连续的 1 可以用“在低位边界减一次、在高位边界加一次”来表示，中间不必逐位相加。
 
-　　具体判断规则：从低到高扫描乘数的每一位，看它和前一位（相邻位）的关系：
+　　标准的基 2 Booth 算法会准备三个量：初始为 0 的累加器 A、乘数 Q，以及附加位 Q₋₁（初始为 0）。如果操作数是 n 位补码，为了覆盖“最小负数取反后无法用 n 位表示”的边界，A 和被乘数通常要增加一位保护位并进行符号扩展。每一轮检查乘数最低位 Q₀ 和 Q₋₁：
 
-| 当前位 Yₙ | 前一位 Yₙ₊₁ | 操作 |
+| Q₀ | Q₋₁ | 运算 |
 | :---: | :---: | :--- |
-| 0 | 0 | 部分积右移一位 |
-| 1 | 0 | 部分积 + 被乘数，再右移一位 |
-| 0 | 1 | 部分积 − 被乘数，再右移一位 |
-| 1 | 1 | 部分积右移一位 |
+| 0 | 0 | A 不变 |
+| 0 | 1 | A = A + 被乘数 |
+| 1 | 0 | A = A − 被乘数 |
+| 1 | 1 | A 不变 |
 
-　　为什么是“右移”？因为逐位相乘时，低位一旦算完就不受高位影响，可以右移“挤掉”，让部分积和被乘数对齐，直接参与运算。减被乘数时，用第十一、十二章的补码加法即可。
+　　完成表中的运算后，不是只移动“部分积”，而是把 `{A, Q, Q₋₁}` 当成一个整体做一次**算术右移**：最高位补符号位，A 的最低位移入 Q 的最高位，Q 的最低位移入 Q₋₁。重复 n 轮后，去掉多余的保护符号位，A 和 Q 的有效部分合在一起就是 2n 位乘积。减被乘数时，可以用前面学过的补码加法完成。
 
 　　Booth 算法对**补码**特别友好：它天然就能处理带符号数，不需要额外把操作数转成绝对值。
 
@@ -50,7 +50,7 @@
 
 　　普通做法是“一个部分积、一个部分积地累加”，加法器一级一级串起来，延迟很大。
 
-　　华莱士树换了个思路：把一大堆部分积用**进位保存加法器**成对地、并行地压缩，像锦标赛一样一层层把数量减半，最后再做一次普通加法。这样级联的深度大幅减小，速度更快。它比较复杂，本指南不展开。
+　　华莱士树换了个思路：把一大堆部分积用**进位保存加法器**并行压缩。每个 3:2 压缩器把三个同宽操作数压成“和”与“进位”两个操作数，其中进位要左移一位再参与下一层，即 `X + Y + Z = Sum + (Carry << 1)`。各层不断重复，直到只剩两个操作数，再做一次普通加法。这样压缩层数近似按对数增长，级联深度大幅减小。它比较复杂，本指南不展开。
 
 ### 除法的优化：恢复余数法 vs 不恢复余数法
 
@@ -68,7 +68,7 @@
 
  **思考题** 
 
-> 　　Booth 算法对乘数里的 `1111` 很有优势，那它对 `0101` 这样的乘数有优势吗？为什么？
+> 　　Booth 算法对乘数里的 `01111`（正数 15）很有优势，那它对 `00101`（正数 5）这样的乘数有优势吗？为什么？
 
 ## 小结
 
@@ -87,7 +87,7 @@
 
 ### 思考题答案（仅供参考）
 
-　　优势不大。Booth 算法擅长的是“连续 1”，而 `0101` 里的 1 是零散的，并没有可以合并的长串，所以加减次数和朴素做法差不多。它真正的收益出现在乘数里“连续 1 很多”的场合。这也说明：**没有万能的优化，工具要挑场合用。**
+　　没有优势，甚至可能更差。`00101` 中两个 1 彼此分开，基 2 Booth 重编码会在每个孤立 1 的两侧各做一次边界运算，共触发 4 次加减；朴素方法只需生成 2 个非零部分积。Booth 真正的收益出现在乘数里有较长连续 1 的场合。这也说明：**没有万能的优化，工具要挑场合用。**
 
 ## 协议
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\344\271\235\347\253\240\357\274\232ALU\347\212\266\346\200\201\346\240\207\345\277\227.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\344\271\235\347\253\240\357\274\232ALU\347\212\266\346\200\201\346\240\207\345\277\227.md"
index 461489c4..f885dbdd 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\344\271\235\347\253\240\357\274\232ALU\347\212\266\346\200\201\346\240\207\345\277\227.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\344\271\235\347\253\240\357\274\232ALU\347\212\266\346\200\201\346\240\207\345\277\227.md"
@@ -4,7 +4,7 @@
 
 - 除法器：除法器通过逐位试减、移位和控制电路实现二进制除法
 - 乘除法的优化：Booth 算法、华莱士树和不恢复余数法能加快乘除法
-- 算术逻辑单元：ALU 把算术和逻辑运算集成起来，用操作码选择当前运算
+- 算术逻辑单元：ALU 把算术和逻辑运算集成起来，用 ALU 控制码选择当前运算
 
 ## TL;DR
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\344\272\224\347\253\240\357\274\232\344\271\230\346\263\225\345\231\250.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\344\272\224\347\253\240\357\274\232\344\271\230\346\263\225\345\231\250.md"
index e638ac21..59358ffa 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\344\272\224\347\253\240\357\274\232\344\271\230\346\263\225\345\231\250.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\344\272\224\347\253\240\357\274\232\344\271\230\346\263\225\345\231\250.md"
@@ -61,7 +61,7 @@
 
 ### 移位
 
-　　上面逐位相乘的移位，最简单的方式就是在末位后面补零、同时丢掉最高位：`0011` 不补零，`0000` 补一个，`0011` 补两个。
+　　上面逐位相乘的左移，就是在低位一侧补零：`0011` 不补零，`0000` 补一个，`0011` 补两个。这里不能随意丢掉最高位：两个 n 位无符号数相乘，完整结果最多需要 2n 位，因此部分积和结果通常要放在足够宽的寄存器中。只有明确只保留固定宽度结果时，才截掉超出该宽度的高位。
 
 　　**而对有符号数进行移位时，特别是右移，最高位需要补上符号位**，不然负数就变成正数了。也就是说：对 `1010` 进行右移，结果应该为 `1101`。
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\345\205\253\347\253\240\357\274\232\347\256\227\346\234\257\351\200\273\350\276\221\345\215\225\345\205\203.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\345\205\253\347\253\240\357\274\232\347\256\227\346\234\257\351\200\273\350\276\221\345\215\225\345\205\203.md"
index 6e3956f1..01d0a348 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\345\205\253\347\253\240\357\274\232\347\256\227\346\234\257\351\200\273\350\276\221\345\215\225\345\205\203.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\215\201\345\205\253\347\253\240\357\274\232\347\256\227\346\234\257\351\200\273\350\276\221\345\215\225\345\205\203.md"
@@ -10,7 +10,7 @@
 
 - 算术逻辑单元（ALU）是计算机的核心运算部件
 - 它把加减乘除和与或非等运算都集成在一起
-- 用一组“操作码”选择当前要做哪种运算，再由译码器和多路选择器送出对应结果
+- 用一组 ALU 控制码选择当前要做哪种运算，再由译码器和多路选择器送出对应结果
 
 ## 正文
 
@@ -105,13 +105,13 @@
 |  1010  |   异或    |
 |  1011  |   同或    |
 
-　　恭喜你！我们已经在初步接触**“指令”**的概念了——上面这串控制信号，就是告诉 ALU“做什么运算”的指令。
+　　上面这串控制信号叫 **ALU 控制码**，它只负责告诉 ALU“做什么运算”，还不是一条完整的指令。真正的指令通常还要说明操作数来自哪里、结果写到哪里等；后面学习指令系统时会把这些字段组合起来。
 
-　　那么，怎么把指令翻译成“选中某一根线”呢？用一个**译码器（Decoder）**。它的作用，就是把输入的二进制码翻译成特定的信号。看图就懂：
+　　那么，怎么把 ALU 控制码翻译成“选中某一根线”呢？用一个**译码器（Decoder）**。它的作用，就是把输入的二进制码翻译成特定的信号。看图就懂：
 
 ![](https://img.tinysnow.cn/blog/computer-science-guide/content/decoder.gif)
 
-　　把操作码（op_code）送进译码器，译码器就选中多路选择器对应的那一路结果，其余结果不会送到输出。
+　　把 ALU 控制码送进译码器，译码器就选中多路选择器对应的那一路结果，其余结果不会送到输出。
 
 ![](https://img.tinysnow.cn/blog/computer-science-guide/content/alu.png)
 
@@ -119,13 +119,13 @@
 
 ### 验证 ALU
 
-　　来验证一下：设 A = 4(0100)，B = 2(0010)，按操作码依次计算结果（加法对应 0000，减法对应 0001……）：
+　　来验证一下：设 A = 4(0100)，B = 2(0010)，按 ALU 控制码依次计算结果（加法对应 0000，减法对应 0001……）：
 
 | 加法 | 减法 | 乘法 | 除法 | 取余 | 与 | 或 | 非 | 与非 | 或非 | 异或 | 同或 |
 | :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: |
 | 0110 | 0010 | 1000 | 0010 | 0000 | 0000 | 0110 | 1011 | 1111 | 1001 | 0110 | 1001 |
 
-　　把这个电路改造一下，让操作码自增，依次观察结果：
+　　把这个电路改造一下，让 ALU 控制码自增，依次观察结果：
 
 ![](https://img.tinysnow.cn/blog/computer-science-guide/content/alu-验证结果.gif)
 
@@ -133,7 +133,7 @@
 
  **思考题** 
 
-> 　　我们用“操作码 + 译码器”来选择运算。如果有一天 ALU 要支持的功能从 12 种增加到 20 种，操作码需要几根线？如果增加到 40 种呢？这说明了什么？
+> 　　我们用“ALU 控制码 + 译码器”来选择运算。如果有一天 ALU 要支持的功能从 12 种增加到 20 种，控制码需要几根线？如果增加到 40 种呢？这说明了什么？
 
 ## 小结
 
@@ -141,8 +141,8 @@
 
 - ALU 的组成
 - 用多路选择器从多个运算结果中选出一个输出
-- 用操作码 + 译码器选择运算
-- “指令”概念的初步接触
+- 用 ALU 控制码 + 译码器选择运算
+- ALU 控制码与完整指令的区别
 
 ### 参考资料
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\233\233\345\215\201\344\270\211\347\253\240\357\274\232\347\254\254\344\270\200\346\254\241\345\221\274\345\220\270.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\233\233\345\215\201\344\270\211\347\253\240\357\274\232\347\254\254\344\270\200\346\254\241\345\221\274\345\220\270.md"
index 98f1c706..82a66bfc 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\233\233\345\215\201\344\270\211\347\253\240\357\274\232\347\254\254\344\270\200\346\254\241\345\221\274\345\220\270.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\233\233\345\215\201\344\270\211\347\253\240\357\274\232\347\254\254\344\270\200\346\254\241\345\221\274\345\220\270.md"
@@ -44,7 +44,7 @@
 
 ### 放一段程序进去
 
-　　我们在内存里放一段很小的程序，它做一件事：把两个数加起来，再把结果输出到一个灯泡上。
+　　我们在内存里放一段很小的程序，它做一件事：把两个数加起来，再把结果输出到由 4 个 LED 组成的二进制显示灯组上。
 
 ```
 地址     指令
@@ -52,7 +52,7 @@
 104     LOAD R2, [201]   ; 把内存 201 处的数取到 R2
 108     ADD  R3, R1, R2  ; R3 = R1 + R2
 112     STORE [202], R3  ; 把 R3 写回内存 202
-116     OUT  [202]       ; 把内存 202 的内容输出到灯泡
+116     OUT  [202]       ; 把内存 202 的低 4 位输出到 LED 灯组
 ...
 200     3
 201     5
@@ -75,7 +75,7 @@
              执行：通过总线，把 8 送到输出设备
 ```
 
-　　灯泡亮了——它表示数字 8。
+　　4 个 LED 按照二进制 `1000` 的模式亮灭——这表示数字 8。单个灯只能表示 0 或 1，多个灯组合起来才能表示更大的数。
 
 　　整个过程，没有一只手拨开关，没有一个数被人抄写。机器自己取指令、自己译码、自己运算、自己输出。**它活了。**
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\233\233\345\215\201\344\272\214\347\253\240\357\274\232\344\270\255\346\226\255\347\263\273\347\273\237.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\233\233\345\215\201\344\272\214\347\253\240\357\274\232\344\270\255\346\226\255\347\263\273\347\273\237.md"
index 4316c2e4..f9ae3bb5 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\233\233\345\215\201\344\272\214\347\253\240\357\274\232\344\270\255\346\226\255\347\263\273\347\273\237.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\233\233\345\215\201\344\272\214\347\253\240\357\274\232\344\270\255\346\226\255\347\263\273\347\273\237.md"
@@ -52,10 +52,14 @@
 
 ### 中断从哪来
 
-　　按来源分，中断大致有两类：
+　　在不同体系结构和教材中，“中断”一词的分类略有差异。先按“是否由当前指令引起”来分，可以得到两大类：
 
-- **硬件中断**：外设或硬件事件触发，比如键盘按下、网卡收到数据、时钟到点
-- **软件中断**：程序自己触发，比如请求操作系统服务的系统调用、除零异常
+- **外部硬件中断**：由当前指令之外的硬件事件异步触发，比如键盘按下、网卡收到数据、时钟到点
+- **同步事件**：由当前指令触发，并且总能对应到这条指令。它还可以继续分成两种：
+  - **异常**：CPU 执行指令时检测到的情况，比如除零、非法指令或缺页
+  - **软件陷阱**：程序显式执行系统调用或 trap 指令，请求操作系统提供服务
+
+　　因此，除零是同步异常，不是程序主动发出的软件陷阱。具体名称和边界会因指令集与教材而异，但“外部异步到来”和“由当前指令同步引起”这一区别最重要。
 
 　　其中**时钟中断**特别重要。它每隔固定时间就响一次，操作系统借此“抢回”控制权，给不同程序分配运行时间——这就是进程调度的心跳。没有它，一个死循环程序就能把电脑卡死。
 
@@ -72,7 +76,7 @@
 - 保存现场与恢复现场
 - 中断向量表
 - 中断优先级与嵌套
-- 硬件中断与软件中断
+- 外部硬件中断，以及同步事件中的异常与软件陷阱
 
 ### 参考资料
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\233\233\345\215\201\345\233\233\347\253\240\357\274\232\346\234\257\350\257\255\350\241\250.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\233\233\345\215\201\345\233\233\347\253\240\357\274\232\346\234\257\350\257\255\350\241\250.md"
index cc78cf64..c956c9f6 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\233\233\345\215\201\345\233\233\347\253\240\357\274\232\346\234\257\350\257\255\350\241\250.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\345\233\233\345\215\201\345\233\233\347\253\240\357\274\232\346\234\257\350\257\255\350\241\250.md"
@@ -46,7 +46,7 @@
 | 半加器 / 全加器 | 算两个一位的和 / 再考虑低位进位的加法器 |
 | 进位 | 本位相加产生的、要送给高位的信号 |
 | 算术逻辑单元（ALU） | 集成了加减乘除和逻辑运算的运算部件 |
-| 操作码 | 告诉 ALU“做哪种运算”的编码 |
+| ALU 控制码 | 告诉 ALU“做哪种运算”的控制信号编码 |
 | 累加器 | 能保存“当前和”、不断累加的寄存器 |
 | 状态标志（ZF/SF/CF/OF） | 结果的特征位：零 / 负 / 进位 / 溢出 |
 
@@ -55,7 +55,7 @@
 | 术语 | 一句话解释 |
 | :--- | :--- |
 | 锁存器 | 最简单的 1 位记忆单元 |
-| 触发器 | 边沿触发的记忆单元，抗噪声更强 |
+| 触发器 | 在指定时钟边沿采样并保存一位数据的记忆单元 |
 | 时钟 | 全局节拍，规定各部件何时更新 |
 | 上升沿 / 下降沿 | 信号从 0 跳 1 / 从 1 跳 0 的瞬间 |
 | 寄存器 | 多个触发器并排，暂存一个字的数据 |
@@ -73,6 +73,7 @@
 | 术语 | 一句话解释 |
 | :--- | :--- |
 | 指令 | “做什么 + 对谁做”的一条命令 |
+| 操作码 | 指令中表示要执行哪类操作的字段 |
 | 操作数 | 指令里参与运算的数据或它的位置 |
 | 程序 | 一串按顺序排列的指令 |
 | 程序计数器（PC） | 保存下一条指令地址的寄存器 |

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\351\231\204\345\212\240\347\253\240/\345\271\266\350\241\214\350\256\241\347\256\227\345\237\272\347\241\200.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\351\231\204\345\212\240\347\253\240/\345\271\266\350\241\214\350\256\241\347\256\227\345\237\272\347\241\200.md"
index 42549de4..09159b32 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\351\231\204\345\212\240\347\253\240/\345\271\266\350\241\214\350\256\241\347\256\227\345\237\272\347\241\200.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\351\231\204\345\212\240\347\253\240/\345\271\266\350\241\214\350\256\241\347\256\227\345\237\272\347\241\200.md"
@@ -65,9 +65,9 @@
 
 ### 别忘了缓存一致性
 
-　　还记得前面提过的缓存一致性问题吗？在多核并行里，它变得更关键：核心 A 改了共享变量，核心 B 的缓存里还是旧值，程序就会出错。
+　　还记得前面提过的缓存一致性问题吗？在多核并行里，它变得更关键。缓存一致性协议负责协调同一内存位置在不同核心缓存中的副本，让各核心对这个位置的写入顺序形成一致认识。但这并不自动保证多次内存操作的先后关系，也不能把“读取、计算、写回”这样的复合操作变成不可分割的一步。
 
-　　所以并行程序除了“分任务”，还要处理**同步**——用锁、信号量等机制，保证同一时刻只有一个核心改动共享数据。同步用得好是保护，用不好就是性能杀手（甚至引发死锁，这在操作系统部分会细讲）。
+　　因此，并行程序除了“分任务”，还要处理**同步和内存顺序**。多个线程在没有同步的情况下同时读写同一变量，可能形成数据竞争；常见办法包括用互斥锁保护临界区、用原子操作更新简单状态、用屏障协调阶段。信号量主要用于计数或协调资源，只有二元信号量在特定用法下才类似互斥锁。同步用得好能保证正确性，用得不好则会拖慢程序，甚至引发死锁（这会在操作系统部分细讲）。
 
  **思考题** 
 

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\200\347\253\240\357\274\232\350\256\241\347\256\227\346\234\272\347\232\204\345\216\206\345\217\262.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\200\347\253\240\357\274\232\350\256\241\347\256\227\346\234\272\347\232\204\345\216\206\345\217\262.md"
index 6bd6fbac..59f6c851 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\200\347\253\240\357\274\232\350\256\241\347\256\227\346\234\272\347\232\204\345\216\206\345\217\262.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\200\347\253\240\357\274\232\350\256\241\347\256\227\346\234\272\347\232\204\345\216\206\345\217\262.md"
@@ -57,6 +57,8 @@
 
 > 　　巴贝奇的分析机和 ENIAC 都能“自动计算”，但“存储程序”这个想法为什么如此关键？它到底解决了什么老问题？
 
+![](https://raw.githubusercontent.com/TinySnow/computer-science-guide-resources/master/computer-science-guide/content/懒是人类进步的第一动力.svg)
+
 ## 小结
 
 ### 知识点

diff --git "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\200\347\253\240\357\274\232\350\256\241\347\256\227\346\234\272\347\232\204\345\216\206\345\217\262.md" "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\200\347\253\240\357\274\232\350\256\241\347\256\227\346\234\272\347\232\204\345\216\206\345\217\262.md"
index e1484228..6bd6fbac 100644
--- "a/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\200\347\253\240\357\274\232\350\256\241\347\256\227\346\234\272\347\232\204\345\216\206\345\217\262.md"
+++ "b/src/\345\255\246\344\271\240\344\270\216\350\277\233\346\255\245/\350\256\241\347\256\227\346\234\272\347\247\221\345\255\246\346\236\201\347\256\200\345\205\245\351\227\250\346\214\207\345\215\227/\350\256\241\347\256\227\346\234\272\347\273\204\346\210\220\345\216\237\347\220\206/\347\254\254\344\270\200\347\253\240\357\274\232\350\256\241\347\256\227\346\234\272\347\232\204\345\216\206\345\217\262.md"
@@ -22,6 +22,8 @@
 
 　　不过，这话说起来轻巧。人类为了“偷这个懒”，其实摸索了几千年。
 
+![](https://raw.githubusercontent.com/TinySnow/computer-science-guide-resources/master/computer-science-guide/content/为什么需要计算机.svg)
+
 ### 最早的算工具：算盘
 
 　　在古代，商会算账、官府收税，靠的都是人手一颗一颗拨珠子。中国的**算盘**，大概是“把计算交给工具”最早的成熟实践之一——它把抽象的加减乘除，变成了看得见、摸得着的动作。

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\345\215\225\347\257\207/\345\215\225\347\257\207.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\345\215\225\347\257\207/\345\215\225\347\257\207.md"
new file mode 100644
index 00000000..676705a1
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\345\215\225\347\257\207/\345\215\225\347\257\207.md"
@@ -0,0 +1 @@
+# 单篇 | Single Novels

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\345\260\217\347\263\273\345\210\227/\345\260\217\347\263\273\345\210\227.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\345\260\217\347\263\273\345\210\227/\345\260\217\347\263\273\345\210\227.md"
new file mode 100644
index 00000000..44b4d16a
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\345\260\217\347\263\273\345\210\227/\345\260\217\347\263\273\345\210\227.md"
@@ -0,0 +1 @@
+# 小系列 | Little Series

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\346\201\213\347\210\261\347\232\204\346\227\266\347\251\272\350\243\202\351\232\231/\346\201\213\347\210\261\347\232\204\346\227\266\347\251\272\350\243\202\351\232\231.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\346\201\213\347\210\261\347\232\204\346\227\266\347\251\272\350\243\202\351\232\231/\346\201\213\347\210\261\347\232\204\346\227\266\347\251\272\350\243\202\351\232\231.md"
new file mode 100644
index 00000000..eff08516
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\346\201\213\347\210\261\347\232\204\346\227\266\347\251\272\350\243\202\351\232\231/\346\201\213\347\210\261\347\232\204\346\227\266\347\251\272\350\243\202\351\232\231.md"
@@ -0,0 +1 @@
+# 恋爱的时空裂隙

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\346\254\242\346\201\213\345\256\207\345\256\231/\346\254\242\346\201\213\345\256\207\345\256\231.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\346\254\242\346\201\213\345\256\207\345\256\231/\346\254\242\346\201\213\345\256\207\345\256\231.md"
new file mode 100644
index 00000000..7ac9a5de
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\346\254\242\346\201\213\345\256\207\345\256\231/\346\254\242\346\201\213\345\256\207\345\256\231.md"
@@ -0,0 +1 @@
+# 欢恋宇宙 | Graceful Love Story Universe

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\346\262\203\346\234\227\345\276\267\344\270\216\347\247\213\350\225\276\351\233\205/\345\260\217\350\257\264\350\256\276\345\256\232.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\346\262\203\346\234\227\345\276\267\344\270\216\347\247\213\350\225\276\351\233\205/\345\260\217\350\257\264\350\256\276\345\256\232.md"
new file mode 100644
index 00000000..0c82225f
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\346\262\203\346\234\227\345\276\267\344\270\216\347\247\213\350\225\276\351\233\205/\345\260\217\350\257\264\350\256\276\345\256\232.md"
@@ -0,0 +1 @@
+# 小说设定

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\346\262\203\346\234\227\345\276\267\344\270\216\347\247\213\350\225\276\351\233\205/\346\262\203\346\234\227\345\276\267\344\270\216\347\247\213\350\225\276\351\233\205.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\346\262\203\346\234\227\345\276\267\344\270\216\347\247\213\350\225\276\351\233\205/\346\262\203\346\234\227\345\276\267\344\270\216\347\247\213\350\225\276\351\233\205.md"
new file mode 100644
index 00000000..f6f61c1f
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\346\262\203\346\234\227\345\276\267\344\270\216\347\247\213\350\225\276\351\233\205/\346\262\203\346\234\227\345\276\267\344\270\216\347\247\213\350\225\276\351\233\205.md"
@@ -0,0 +1 @@
+# 沃朗德与秋蕾雅 | Walond and Curiya

diff --git "a/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\347\220\206\346\203\263\351\233\252/\347\220\206\346\203\263\351\233\252.md" "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\347\220\206\346\203\263\351\233\252/\347\220\206\346\203\263\351\233\252.md"
new file mode 100644
index 00000000..70cd884a
--- /dev/null
+++ "b/src/\347\224\237\346\264\273\347\242\216\347\254\224/\345\260\217\350\257\264/\347\220\206\346\203\263\351\233\252/\347\220\206\346\203\263\351\233\252.md"
@@ -0,0 +1 @@
+# 理想雪 | Ideal Snow