技术史 · M zheng · 1964—2026

一台机器,一种方言

五十年前,两台计算机的语言并不相通。Unix、C、Linux、Windows NT、Intel 与 ARM —— 它们不在同一个维度上,所以才会看起来混乱。

这份报告把它们拆成三条可以各自追踪的线索:代码如何变得可搬运,硅如何收敛到两种,以及那几张合同如何决定了三十年的格局。

十一幕六份附录关键事实逐条核对

目录

  1. 序 · 一台机器,一种方言
  2. 第一幕 · 失败者的遗产(1964—1973)
  3. 第二幕 · 两条平行线(1971—1985)
  4. 第三幕 · 伯克利的意外(1974—1983)
  5. 第四幕 · 分裂(1983—1994)
  6. 第五幕 · 另一条血脉(1981—1993)
  7. 第六幕 · 一个人的周末(1983—1994)
  8. 第七幕 · 穷出来的架构(1983—1998)
  9. 第八幕 · 把系统搬回家(1985—2001)
  10. 第九幕 · 四次换芯(1994—2023)
  11. 第十幕 · 只剩两种(2001—2026)
  12. 第十一幕 · Unix 到底给你留下了什么
  13. 终章 · 三层世界
  14. 附录 · 年表 / 人物 / 名词 / 常见误传 / 书目 / 拍摄建议

序一台机器,一种方言

1964 年,你想让两台计算机交换一份文件。做不到。

不是因为网络还没发明。是因为"文件"这个词,在两台机器上不是同一个意思。

CDC 6600 的字长是 60 位,一个字符占 6 位。PDP-10 是 36 位字长、9 位字节。IBM System/360 刚刚把字节定成 8 位——今天"一字节等于 8 比特"这条常识,就是它定下来的——可它用的 EBCDIC 编码里,字母根本不按顺序排,A 到 I 的码位跳着走。据说这样能让打孔卡的排序电路便宜一点。

把一段文字从一台机器搬到另一台,不是"格式不兼容",是彻底读不出来。更麻烦的是程序。那时候连"操作系统"都不是一个能搬运的东西:监控程序本身是用那台机器的汇编写的,硬件一换,全部重来。

FORTRAN(1957)和 COBOL(1959)让源码可以跨机器,但编译器还是每台机器一套;而且它们只管"计算",不管"机器怎么管自己"——内存、设备、文件、进程、权限,没有任何标准可言。

术语

操作系统是什么。它是站在程序和硬件之间的一层翻译。程序说"把这个字节显示出来",操作系统负责翻译成这台机器认识的电信号。在没有操作系统的年代,每个程序都得自己干这件事,所以换台机器就得重写。今天的操作系统还多管一件事:分配——谁先用 CPU、谁能读写哪块内存、谁的权限更高。

那个时代真正稀缺的不是算力,是约定。谁先定义出一套别人愿意遵守的约定,谁就定义了后面六十年的形状。

画面建议 开场不要放电脑。放三样东西:一张 80 列打孔卡、一段 6 位编码的纸带、一台 IBM 360 的控制面板。旁白只说一句:"这三样东西,互相看不懂对方写的是什么。"

第一幕失败者的遗产 · 1964—1973

1964 年,MIT、贝尔实验室和通用电气三家联手,决定造那个约定。项目叫 Multics——MULTiplexed Information and Computing Service,多路信息与计算服务。

它的野心今天看都过分:一台机器同时给几十个人用;文件系统是树形的、分层的;连打印机和磁带机也当成文件;权限用硬件"环"来隔离,一共八级。它是第一个认真对待这个念头的工程——操作系统应该是一套抽象,不是一堆硬件补丁。

今天你在用的东西,几乎每一样都能在 Multics 的设计里找到原型:分层目录、设备文件、权限位、用户与组。

然后它失败了。1969 年,贝尔实验室退出。理由很实在:进度太慢,PL/I 编译器难写,GE-645 那台机器不好用。一个想给全世界造通用语言的项目,死在了自己的通用性上。

为了玩游戏,他写了个操作系统

肯·汤普森(Ken Thompson,1943— )是留下来收拾残局的人之一。他手里有一台没人用的 PDP-7——视觉与声学研究部门淘汰下来的。他想在这台机器上继续玩自己写的游戏《太空旅行》(Space Travel)。

为了玩游戏,他需要工具;为了写工具,他需要一个系统。Unix 是这么长出来的。不是谁的战略规划,是一个程序员的消遣。

那年夏天他妻子去度假,他有一个月完整的时间。分层文件系统、编辑器、汇编器、命令解释器——全在这一个月里长出来。

名字是后来才有的。1970 年,布莱恩·柯林汉(Brian Kernighan)给它起了个玩笑名:Unics,Uniplexed Information and Computing Service,单路信息与计算服务——对着 Multics 的"多路"来一个"单路"。这词念起来像 eunuchs(阉人),所以拼写最后改成了 Unix。

1970 年,他们拿到一台 PDP-11/20。1971 年 11 月 3 日,《UNIX 程序员手册》第一版出版,man page 的格式从那时用到现在。

1973:分水岭

1973 年,Unix 第四版被用 C 语言重写了一遍。这在当时是异端——所有人都认为操作系统这么复杂的东西必须用汇编写。

C 是丹尼斯·里奇(Dennis Ritchie,1941—2011)在 B 语言基础上做出来的。B 来自 BCPL,BCPL 来自 CPL。这条谱系一路在砍东西,最后留下的是"能直接对应机器指令、但不绑定任何一台机器"的那一小块。里奇自己管它叫"可移植的汇编"。

这一行字值得停下来看清楚:

1973 年之前,操作系统是硬件的附属品。
1973 年之后,操作系统是一份可以编译的文本。

但要说实话:1973 年那次重写并没有立刻让 Unix 变得可移植。第四版里还塞满了 PDP-11 的假设,换个机器根本跑不起来。真正的证明要到 1977 年——贝尔实验室特意买了一台和 PDP-11 尽可能不同的机器(Interdata 8/32),把它当考题。Unix 过了。

从那一刻起,"换一台机器"这件事,从重写变成了重编译。整个软件史的速度,是在这里变的。

它为什么能传开:因为不能卖

这一段最容易被讲漏,但它是 Unix 扩散的真正引擎。

AT&T 当时被 1956 年一纸反垄断和解协议捆着:除了"公共通信服务",它不准做任何别的生意。这意味着Unix 不能当商品卖。

于是贝尔实验室只收磁带的钱和运费。谁写信来要,汤普森就寄一盘磁带过去。1973 年,第五版授权给大学;1975 年,第六版开始授权给公司,两万美元——但大学几乎是白拿。1974 年,Unix 第一次在操作系统原理研讨会上公开,论文第二年发在 CACM 上,全世界的计算机系都开始要这盘磁带。

一个不能卖的东西,被免费送进了全世界最好的大学。这是 Unix 赢了 Unix 战争之前那场仗的唯一原因。

1983 年,司法部拆分 AT&T,那纸禁令解除。AT&T 立刻把 Unix 变成商品,System V 上市。同一年,理查德·斯托曼宣布 GNU 计划。

这两件事发生在同一年,不是巧合。一个是"终于可以卖了",一个是"那就别卖了"。

画面建议 这一幕的核心道具是一盘磁带。旁白讲"它为什么能传开",画面是汤普森在桌上贴标签、装箱、寄出去。快递单上收件人写着"加州大学伯克利分校 计算机系"。

第二幕两条平行线 · 1971—1985

很多人以为 Unix 和 Intel 是一起长大的。不是。它们很长时间里根本不在一个工地。

Unix 的代码大厦建在一串非 Intel 的芯片上:PDP-11 → VAX → 摩托罗拉 68000 → SPARC → MIPS。而 Intel 在另一条线上,从计算器芯片开始,一路爬到个人电脑。

术语

指令集(ISA)。CPU 只认识一张词汇表。 "把这两个数加起来"是一条指令,"如果相等就跳到第 40 行"也是一条。你写的代码编译到最后,就是这张词汇表里的一串词。这张表就叫指令集。

兼容。新一代 CPU 必须认识老一代的全部词汇。这不是技术选择,是商业铁律:如果新芯片跑不了旧软件,没人会买。所以 x86 不是被"设计"出来的,是被一层层叠出来的。

一颗芯片的爬升:4004 到 8088

1971 年 11 月 15 日,Intel 发布 4004——2300 个晶体管,本来是给日本一家计算器公司(Busicom)做的。它被公认为第一颗商用微处理器。

1974 年,8080。1975 年,一台叫 Altair 8800 的机器用它做成套装件卖,卖得很好。加里·基尔代尔(Gary Kildall,1942—1994)为 8080 写了 CP/M,成了早期微型计算机的事实标准操作系统。

1978 年 6 月,8086——16 位。1979 年,8088:和 8086 几乎一样,只是把外部数据总线从 16 位砍到 8 位,为了能用更便宜、更少的外围芯片。

这颗"阉了一刀"的芯片,改变了历史。

术语

x86 这个名字哪来的。8086、80186、80286、80386、80486——型号全都以 86 结尾,所以这一族被叫做 x86。名字本身就是一部兼容史:它不是一个设计,是一串必须互相认识的芯片。

1981 年 8 月 12 日:一台机器的三个决定

IBM 决定做个人电脑,项目代号"象棋"。它要快,要一年内出货。三个决定,塑造了后面四十年。

第一,芯片选了 8088,不是 68000。 68000 更好——16/32 位、平坦地址空间,后来的 Macintosh 就用它——但 IBM 要的是"马上能出货"。8088 有现成的外设生态,8 位总线能复用旧零件,还便宜。

第二,要"第二供应商"。 IBM 不接受独家供货。1982 年,Intel 把 8086/8088 授权给 AMD。x86 从此不是一家公司的私产,而是一个谁都能造的公共标准。这条纸面上的条款,是二十年后 AMD 能做出 64 位 x86、把 Intel 逼到墙角的法理起点。

第三,操作系统是"买来的",而且合同里留了个洞。 这是最值得慢慢讲的一段。

PC-DOS 是怎么来的:一场没谈成的生意

1980 年 7 月,IBM 的人飞到西雅图找微软。他们要的其实不是操作系统,是语言:BASIC、FORTRAN、COBOL、Pascal。操作系统另找——盖茨把他们指向了加里·基尔代尔。

基尔代尔是 CP/M 的作者,那是当时 8 位机器上的标准系统。IBM 的人去了加州太平洋格罗夫。谈崩了。

流传最广的版本说,基尔代尔那天在开自己的飞机,把 IBM 晾在门口。这个版本不准确——他当天晚些时候见了 IBM。真正的分歧在条款:IBM 要一次性买断、不再按份付钱;DRI 要保留按份分成。谁也不让。

盖茨转身找了另一家:西雅图计算机产品公司(Seattle Computer Products)。那里有个 24 岁的程序员蒂姆·帕特森(Tim Paterson,1956— ),四月份刚用六周时间给 8086 写了个操作系统,叫 QDOS——Quick and Dirty Operating System,"快而脏"。它干的事很朴素:照着 CP/M 的接口实现一遍,让为 CP/M 写的程序以为自己在 CP/M 上。

1980 年 12 月,微软花 2.5 万美元拿到授权;1981 年 7 月 27 日,再花 5 万彻底买断。总共 7.5 万美元。帕特森本人 1981 年 5 月进了微软,员工号 80。

1981 年 8 月 12 日,IBM PC 出货。1565 美元起,8088 跑 4.77 兆赫,16 KB 内存,没有硬盘。

操作系统单卖:PC-DOS 40 美元。同时 IBM 也提供 CP/M-86,240 美元——因为 DRI 威胁要打官司,IBM 只好把它摆上货架。

后来一份调查显示:96.3% 的机器配的是 40 美元的 PC-DOS,3.4% 配的是 240 美元的 CP/M-86。

六倍的价格差,决定了之后四十年的桌面。

但真正致命的不是价格,是合同里那一条:微软只给了 IBM 非独占授权,保留把同一份系统卖给别人的权利。IBM 以为自己买的是独家。于是当康柏们开始造兼容机,微软可以把 MS-DOS 卖给每一家。

IBM 造了 PC,却没能拥有 PC 的软件。
行业标准从 IBM 手上,滑到了"IBM 兼容"这个词上。

而 Unix 这时在哪儿

在 PDP-11 上,在 VAX 上,在 68000 上。跟 Intel 一点关系都没有。

微软 1980 年从 AT&T 拿到 Unix 授权,改出 Xenix,交给一家叫 SCO 的小公司去移植到 8086。那是 Intel 世界里唯一像样的 Unix,但它始终是配角——因为 8086 跑不动真正的 Unix:只有 1MB 寻址,没有真正的内存保护。

合流点是 1985 年的 386。32 位平坦地址空间、分页、保护模式,还有 VM86(能在保护模式里跑实模式的 DOS 程序)。275,000 个晶体管。

这颗芯片第一次让"一台便宜的 Intel 机器跑真正的 Unix"在技术上成立。两年后 Tanenbaum 写了 Minix 当教材,四年后一个赫尔辛基的学生买了台 386 兼容机。

准确的时序是:Unix 建了三十年的代码大厦,Intel 建了十五年的硅大厦,两者在 1990 年代才对接。对接之后,Intel 芯片上跑得最重要的系统,既不是 Intel 的,也不是当年那家 Unix 公司的。

画面建议 这一幕的高潮是两个价格标签:40 和 240。可以让画面停在这两个数字上三秒,旁白只说"六倍"。不要急着解释,让观众自己算。

第三幕伯克利的意外 · 1974—1983

你提到的那件事是真的,而且比一般人讲的更关键:互联网的雏形,是被装进 Unix 才活下来的。

但故事得从一次会议讲起。

一盘磁带怎么到了伯克利

1973 年 10 月,Unix 第一次在操作系统原理研讨会(SOSP)上公开。台下坐着伯克利的教授鲍勃·法布里(Bob Fabry),他是那场会议的程序委员。他听完,回去就要了一台机器。

1974 年,Unix 到了伯克利,装在一台 PDP-11/45 上。因为预算不够,这台机器还得跟数学系和统计系合用——Unix 每天只能分到八小时,白天或者晚上,二选一。

1975 年,汤普森休学术假,到伯克利做客座教授。他把第六版装上,开始写 Pascal 编译器。两个研究生接着改:查克·黑利和比尔·乔伊(Bill Joy,1954— )。乔伊后来写了 vi,写了 csh,1982 年参与创办 Sun。

1977 年,乔伊把这些散装软件打成一个包,寄给其他想要的人。1978 年 3 月 9 日,1BSD 发布,大约 30 份。1979 年 5 月,2BSD,75 份,里面第一次有 vi 和 csh。

到这时候,BSD 还只是个"软件包",不是操作系统。

另一条线:国防部想要一张网

1969 年,美国国防部高级研究计划局(ARPA,后来叫 DARPA)资助的 ARPANET 连上了第一批四个节点。1971 年投入运行,用的协议叫 NCP。

1973 年,鲍勃·卡恩和温特·瑟夫开始琢磨一个问题:怎么让不同的网络互相连起来——卫星网、无线电包交换网、地面网。1974 年 5 月,他们发表论文,提出一个协议,叫 TCP。同年 12 月,瑟夫和两个学生在斯坦福写出规范(RFC 675)。

1978 年,这个协议被拆成两层:TCP 管可靠传输,IP 管寻址和路由。1980 年,美国国防部规定 TCP/IP 是军用标准。1983 年 1 月 1 日,ARPANET 全网切换,这一天在圈内叫 flag day。

现在问题来了:协议有了,谁来写代码?

BBN 写了,跑在特定机器上。但全美几十所大学用的机器五花八门,跑的东西却大多是 Unix。如果有一个 Unix 版的 TCP/IP,所有学校就都能连上这张网。

1979 年,DARPA 找到伯克利,给了法布里一份合同。资助一直持续到 1988 年。任务写得很清楚:让 Unix 支持 ARPANET 的协议。

1983 年 8 月:TCP/IP 进了内核

4.2BSD 发布了。它第一次把一个完整的 TCP/IP 实现放进了 Unix 内核,还带来一个新东西:socket。

这一步的技术意义,比它的名气大得多。socket 做的事是:把一条网络连接,变成一个文件描述符。

从这一刻起,"读写网络"和"读写磁盘"用的是同一对函数。Unix 那句"一切皆文件",第一次伸到了机器之外。

联网从此不再是一件需要专门知识的事,而是一件"打开、读、写、关闭"的事。这是互联网能长成今天这样的技术前提之一。

TCP/IP 之所以能赢,不是因为它被写进了标准,是因为它被免费装进了每一台 Unix。
协议靠操作系统传播,不靠委员会。

顺便说两个反讽。

第一,Windows NT 3.1(1993)里的 TCP/IP,也是从 BSD 的代码来的。微软早期的协议栈是从别处买的 STREAMS 实现,后来自己重写,但那个生态的源头在伯克利。今天你手机上跑的一切,协议栈的血统在 4.2BSD。

第二,BSD 的许可证太宽松,宽松到谁都可以拿去闭源——这既是它能渗透进 Windows、Solaris、PlayStation 的原因,也是它没能长成一个"运动"的原因。这一点,后面会跟 GPL 形成对照。

画面建议 这一段可以画一张 1979 年的美国地图:几十个大学节点用线连起来,每个节点旁边标注它跑什么机器。然后所有线同时变成同一种颜色——因为"它们都跑 Unix 了"。

第四幕分裂 · 1983—1994

1983 年之后,Unix 开始互相不认识。

AT&T 把 System V 当正统卖;伯克利的 BSD 在大学里疯长;中间夹着 SunOS、AIX、HP-UX、IRIX、Ultrix、Xenix 一堆厂商方言。到 1990 年代初,市面上一度有两百多个变种。一个数据库厂商为了覆盖所有变种,维护了一千多个 SKU。

标准委员会开始救火。1984 年欧洲厂商搞了 X/Open;1985 年 AT&T 出了 SVID;1988 年 AT&T 拉上 Sun 搞 UNIX International,其他厂商立刻组了个 Open Software Foundation 对着干。这场混战叫 Unix 战争。

真正活下来的那份标准,是 1988 年的 POSIX。

术语

POSIX 是什么。它不指定实现,只指定接口。它不说"你必须有 fork 这个函数",它说"如果你有进程创建,那它必须是这个样子"。这样 BSD 和 System V 都能通过认证。

冷知识:这个更好念的名字,是理查德·斯托曼建议给 IEEE 的——原来叫 IEEE-IX。委员会觉得 POSIX 更好记,就用了。

然后是官司。1991 年,几个伯克利的人出来开了家公司 BSDi,卖"不含 AT&T 代码"的 BSD。1992 年,AT&T 的 Unix 子公司 USL 起诉他们。法院下了禁令,Net/2 不能继续分发。

这场官司打了近两年,1994 年 1 月和解,基本是伯克利赢:一万八千个文件里,只需要删掉三个、改七十个。但那两年的法律真空已经造成了后果——谁都不敢碰 BSD 的代码。

而这两年,正好够一个芬兰学生把东西做出来。

第五幕另一条血脉 · 1981—1993

微软那边同时握着两条互不相干的血脉。这是最多人绕晕的地方。

第一条:DOS 血脉。1981 年的 MS-DOS 是单用户、单任务、16 位实模式、没有内存保护。Windows 1.0(1985)、2.0、3.0(1990)、3.1(1992)都只是加在它上面的一层壳。1995 年的 Windows 95 号称 32 位,底下仍然是 DOS,靠一堆虚拟设备驱动和"兼容性债务"硬撑到 ME(2000)。这条线 2001 年断了。

术语

实模式 / 保护模式。实模式是 1978 年的世界:内存最多 1MB,程序能直接碰任何地址,一个程序崩了整台机器就崩。保护模式是 1985 年之后的世界:每个程序活在自己的虚拟地址空间里,越界就被杀掉,操作系统说了算。

1982 年的 286 有个著名的坑:进了保护模式就回不去实模式,只能复位。386 才用 VM86 补上这个洞——顺便让 DOS 程序能在保护模式里跑,这也是 Windows 3.0 增强模式和 Windows 95 的技术基础。

第二条:NT 血脉。1988 年 10 月,微软决定做一个可移植的系统,兼容 OS/2 和 POSIX,支持多处理器。1989 年 11 月开工。

带队的人叫戴夫·卡特勒(Dave Cutler,1942— ),从 DEC 挖来的。他做过 RSX-11M、VMS、VAXELN,还有一个没发布的对象式系统 MICA——NT 的目录结构和文件名,据说跟 MICA 对得上。

NT 有几个刻意的设计:

先用非 x86 开发。初版目标是 Intel 的 i860(代号 N10,"NT"这个名字可能就从这儿来),1989 年底转到 MIPS R3000,1990 年才转 i386。这么做是为了防止 x86 的坏习惯渗进内核。

把硬件差异全塞进一层。那层叫 HAL,硬件抽象层。上面是内核和执行体,再上面是"子系统":Win32、OS/2、POSIX 各是一个。这个结构受卡内基梅隆的 Mach 微内核影响,但不是纯微内核——内核和执行体最后链接成同一个模块,ntoskrnl.exe。

内部一律用 Unicode。NT 是最早一批内部用 UCS-2/UTF-16 的操作系统。这一点后面还会用到。

1993 年 7 月 27 日,Windows NT 3.1 上市,同时支持 x86、DEC Alpha、MIPS R4000 三种指令集。这在 PC 操作系统里是第一次。

还有个不太光彩的插曲:DEC 的工程师很快就发现 NT 的内部结构和 VMS 太像了——有人拿 VMS 的内核手册对着 NT 讲,居然讲得通。最后没打官司,微软赔了 DEC 六千五百万到一亿美元,外加答应帮忙卖 VMS、培训 DEC 的人、继续支持 Alpha。

NT 只学了一半

NT 学走了 Unix 的方法论:用 C 写、把硬件差异塞进一层薄薄的 HAL、用子系统兼容别人的 API。所以它能在三种指令集上跑,能同时跑 Win32 和 POSIX 程序。

但它没学走 Unix 的交付方式。Unix 世界给你源码,Windows 世界给你编译好的二进制。

Unix / Linux 世界Windows 世界
交付物源码,用户自己编译编译好的 .exe / .dll
换架构重新编译一次旧程序全部作废,得靠模拟层
稳定契约源码级:接口不变即可二进制级:机器码行为不能变
代价生态碎片化被 ABI 焊死在 x86 上二十年
收益可搬运性极强企业软件生态牢不可破
术语

API 和 ABI 差在哪。API 是给人看的说明书:这个函数叫什么、要几个参数。ABI 是给编译器看的物理约定:参数放哪个寄存器、结构体怎么对齐、函数名怎么修饰、谁负责清理栈。

API 变了,重编译一次就行。ABI 变了,已经编译好的程序直接跑不起来——而企业买的软件,往往只有 exe,没有源码。

这笔债,二十年后会变成一道墙:Windows 想换到 ARM,必须靠一层 x86 模拟器兜底,因为搬不动那几百万个只有二进制的程序。

第六幕一个人的周末 · 1983—1994

1983 年 9 月 27 日,理查德·斯托曼(1953— )在网络上发了一封公开信,宣布要做一套完全自由的操作系统,叫 GNU——"GNU's Not Unix",一个递归的玩笑。

他的判断是伦理性的:软件应该可以被使用者修改。实现方式却很技术:用版权法反过来锁住开放。这就是 copyleft。你可以用、可以改、可以卖,但你不能把改过的东西闭起来。

1985 年成立自由软件基金会,1989 年发布 GPL 第一版。

到 1991 年,GNU 除了内核什么都齐了:编辑器(Emacs)、编译器(GCC,1987)、shell(bash,1989)、一整套 Unix 工具。缺的那个内核叫 Hurd,卡住了——因为它选了 Mach 微内核路线,而微内核在 1990 年代的硬件上性能很难看。

1991 年 8 月 25 日,一个 21 岁的芬兰学生在 comp.os.minix 新闻组发了个帖子:

"我在做一个(免费的)操作系统(只是个爱好,不会像 GNU 那么大那么专业)……"

—— 利纳斯·托瓦兹(Linus Torvalds,1969— ),1991 年 8 月 25 日

他在 386 上开始,用 GCC 编译,参照 Minix 的文档,一行 AT&T 的代码都没抄。9 月 17 日,0.01 版上传。1992 年 12 月,换成 GPL。1994 年 3 月,1.0。

它赢的方式,和 Unix 一模一样

Linux 不是一个更好的系统,它是一个更容易被搬走、被改、被塞进任何盒子的系统。

单体内核是"落后"的选择。同时代的学术潮流是微内核,Tanenbaum 为此跟托瓦兹公开吵过一架。但单体内核快、简单、驱动好写。工程上赢的是它。

内核内部接口不稳定,但有一条铁律叫"我们绝不破坏用户态"。内核随便改,用户程序的行为不能变。这是 Linux 的 ABI 契约,也是它二十年没散架的原因。

容器不是新发明。2000 年代中后期,内核陆续加进 namespaces 和 cgroups。十几年后有人拿这两个东西拼出了 Docker(2013)。它们是内核里躺了十年的两个特性,被人重新组合。

真正的分水岭是 2008 年的 Android:Linux 内核 + 一整套非 GNU 的用户空间。它证明了一件事——"内核"和"操作系统"是两个可以拆开的层。而这正是 Unix 血统最深层的那份遗产。

顺带说清一个常见误解:Linux 不是 Unix。Unix 是 AT&T 那条血脉和它的商标;Linux 是照着 POSIX(1988 年那份"共同语法")重写的方言。两者像,是因为都遵守同一份语法书,不是因为血缘。

第七幕穷出来的架构 · 1983—1998

ARM 的起点跟 Unix、Intel 都没有关系。它在英国剑桥,一家叫 Acorn 的小公司。

Acorn 1978 年成立,1981 年拿下英国广播公司"每间教室一台电脑"的项目,做出 BBC Micro,卖了上百万台,用的是 MOS 6502(8 位)。

到 1983 年,他们想做 32 位机器,去市场上看芯片。摩托罗拉 68000 性能好但太贵、太热;National Semiconductor 的 32016 又慢得离谱——他们实测了几颗芯片,发现都卡在 4 Mbit/s 的内存带宽上。

所以他们决定自己做。

这个决定今天看很疯狂:一家几十人的小公司,要设计一颗 32 位 CPU。促成它的其实是个很小的观察——苏菲·威尔逊(Sophie Wilson,1957— )和史蒂夫·弗伯(Steve Furber,1953— )去拜访 Bill Mensch 的 Western Design Center,发现"设计 CPU"这件事的团队规模,是他们能想象的那种小。俩人回来就想:那我们也能做。

1983 年 10 月立项。18 个月后,1985 年 4 月 26 日,第一批样片一次点亮。25,000 个晶体管,3 微米工艺,6 兆赫,4 毫米见方。同期的 68000 是 68,000 个晶体管。

低功耗不是目标,是穷出来的

这里有三个偶然,凑成了后来整个移动时代的地基。

第一,没有工具。当年没人能估算功耗,他们没法验证,只能保守地"过度设计"。

第二,买不起陶瓷封装。只能用便宜的塑料封装,塑料散热差,功耗就必须压到极低。

第三,第一次上电是个事故。芯片插上开发板,串在电源上的电流表读数是零——因为板子有故障,CPU 根本没接电。它靠周围逻辑芯片的漏电流就跑起来了。

实测功耗大约 0.1 瓦。三十年后,这个"穷出来的副产品"变成了移动时代的入场券。

全部围绕"少"

设计取舍换来什么
不要微码CISC 芯片内部有一层微码把复杂指令翻译成微操作,ARM 直接删掉,指令硬连线执行
定长 32 位指令 + 3 级流水解码简单,多数指令一个周期完成
每条指令都可条件执行条件判断不用跳转,省掉大量分支开销
桶形移位器免费一条指令同时完成移位与运算
LDM / STM 批量搬寄存器函数调用保存现场、内存拷贝,一条指令搞定
16 个寄存器,PC 就是 r15没有额外寄存器堆,上下文切换极快

真正的发明不是芯片,是卖法

1990 年,Acorn 把设计团队拆出去,成立新公司 Advanced RISC Machines Ltd.,苹果和 VLSI 参与进来。动机很具体:苹果要做 Newton,需要 ARM 芯片,但不想向竞争对手 Acorn 买。

解决办法是把它变成一个中立的公司,只卖设计授权(IP),不卖芯片。

这个决定改变了一切。因为 ARM 不造芯片,所以高通、德州仪器、三星、苹果全都是它的客户而不是对手;因为没有工厂,它的成本结构跟 Intel 完全不同;因为授权可以深度定制(苹果可以在指令集许可下自己设计微架构),客户愿意为它做长线投入。

1992 年 ARM6;1993 年 Newton 用 ARM610(卖得不好)。真正的引爆点是德州仪器把 ARM7TDMI 塞进给诺基亚的基带芯片——一颗芯片里同时有应用处理器和基带处理器。1997 年的诺基亚 6110 成了爆款,ARM7TDMI 后来成了历史上最畅销的处理器核心。

顺带一个反讽:Intel 唯一一次认真做 ARM,是 1998 年从 DEC 手里买下 StrongARM 改成 XScale,然后在 2006 年把它卖给了 Marvell——正好是 iPhone 发布前一年。

第八幕把系统搬回家 · 1985—2001

1985 年,乔布斯被自己创办的公司赶出去,创办了 NeXT。

NeXT 的硬件卖不动——1990 年那台机器要 9999 美元。但它的软件 NeXTSTEP(1988)攒了一身奇怪的本事:内核是卡内基梅隆的 Mach 3.0 加 BSD 4.3,语言是 Objective-C,图形层用 Display PostScript。1993 年 NeXT 放弃硬件,专做这套软件。

1996 年 12 月,苹果宣布收购 NeXT。1997 年完成,大约 4.27 亿美元。乔布斯回归。

那套系统被改名 Darwin,内核叫 XNU——Mach 加 BSD 加 I/O Kit。2001 年 3 月 24 日,Mac OS X 10.0 发布。

Unix 绕了三十年,绕回了个人电脑。

这件事的分量要看它后来的样子:Darwin 不只是 macOS 的内核,它是 iPhone、iPad、Apple Watch、Vision Pro 的共同底座。2007 年那台 iPhone 跑的,就是这条血脉。

第九幕四次换芯 · 1994—2023

Mac 是理解这一切最好的标本,因为它把"换架构"这件事做了四次,每次都留下完整证据。

时期架构为什么换怎么过渡
1984—1994摩托罗拉 68000起点:图形界面要便宜够用的 32 位芯片—
1994—2006PowerPCAIM 联盟(1991.10 成立),摆脱单一供应商68k 模拟器
2006—2020Intel x86G5 功耗太高,笔记本做不出来Rosetta(运行时翻译)
2020—自研 ARM同样性能下功耗约为三分之一Rosetta 2 + 双架构二进制

1984 年 1 月 24 日,第一台 Macintosh:128 KB 内存,68000,图形界面来自施乐 PARC 的 Alto(1973)和 Smalltalk。它没有内存保护,多任务是"协作式"的——程序得自己主动让出 CPU。技术上比同期 Unix 落后一代,体验领先一代。

1994 年 3 月,第一台 Power Macintosh。PowerPC 601 是 IBM POWER1 的单芯片版。过渡靠 68k 模拟器,旧程序照跑。

2005 年 6 月 6 日,WWDC,乔布斯宣布转向 Intel。理由是路线图:G5 的功耗让"G5 笔记本"永远做不出来。2006 年 1 月,第一批 Intel Mac 出货(Mac OS X 10.4.4)。2006 年 8 月 Mac Pro,2007 年完成过渡。

这里有个诚实的细节:Rosetta 不是免费的。当年的测试说,翻译后的程序性能只有原生的 50% 到 80%。而且 Classic 环境(跑 Mac OS 9 程序的虚拟机)根本没搬到 x86——Intel Mac 跑不了老 Mac 程序。

2020 年 6 月 22 日,WWDC,宣布转向自研芯片。11 月 10 日,M1。2023 年 6 月,Mac Pro 完成全线过渡。

为什么 Mac 能换四次,Windows 换一次都难

因为 Mac 的基因里同时有两样东西:

Unix 的可移植性(Mach + BSD + C,换架构基本只需重编译),和一家公司的垂直整合能力(能用商业手段强推开发者和用户:提前两年发开发机、两套二进制并行、翻译层垫底、上层 API 一行不改)。

Windows 只有前者的"半份"。它能移植内核——NT 本来就跑过四种指令集——但搬不动那几百万个只有二进制、没有源码的企业程序。所以同样是换到 ARM:苹果几年就完成,微软走了十几年,到今天仍有一批程序跑不顺。

画面建议 四次迁移可以做成一条横轴,每次迁移的"桥"用不同的材质:68k→PPC 是一座石桥(模拟器),PPC→x86 是一座木桥(Rosetta,会晃),x86→ARM 是一座钢桥(Rosetta 2,提前把路修好)。桥下写着同一个词:兼容。

第十幕只剩两种 · 2001—2026

到 2000 年代,曾经热闹的架构全死了。

DEC Alpha 1998 年被康柏买走(康柏 2001 年又被 HP 买走);MIPS 退到嵌入式;SPARC 在甲骨文手里停摆;PA-RISC 随 HP 一起消失;PowerPC 只剩 IBM 的服务器;Intel 自己押的 Itanium 惨败。

不是因为 x86 和 ARM 技术最好,是因为芯片是规模生意:编译器只为最大的两个后端认真优化,操作系统只为最大的两个维护移植,开发者只为最大的两个写代码。第三名不是被打败的,是被"没人替你写工具链"耗死的。

两种性格,两种 64 位

x86 是带着镣铐跳舞。2001 年 Intel 推出 Itanium,想借一个全新架构甩掉历史包袱:让编译器在编译时就把指令排好,硬件做得简单些。技术上很优雅,市场拒绝——因为它不兼容 x86。真正赢的是 2003 年 AMD 的做法:在 x86 上原地扩出 64 位(AMD64),保住全部旧代码。

向后兼容的引力,比技术优雅强。

ARM 是干净断代。设计 ARMv8 时,它直接开了一套全新的 64 位指令集 AArch64,26 位时代的包袱一律不带。因为它没有"必须跑 1993 年二进制"的历史债务——这笔债是微软的,不是它的。

2013 年,苹果 A7 成为第一个 64 位 ARMv8 的消费级芯片。从那一年起,手机芯片的性能曲线和桌面芯片开始交叉。

第十一幕Unix 到底给你留下了什么

你那个判断,对了一半。而且是对的那一半最关键,错的那一半需要改一个词。

你说 Unix 是"一套所有编程语言的定义语义",Python、Java 都是从它上面长出来的。

不准确的地方在于:语言的定义语义不是 Unix 给的。类型系统、求值顺序、作用域、闭包、垃圾回收——这些是语言规范自己定的,跟 Unix 没关系。Haskell 的纯函数、Erlang 的 actor、Lisp 的宏,都不是 Unix 长出来的。

准确的说法是:Unix 定义了"程序在世界上怎么活"的那套语义。我给它一个名字,叫宿主语义(host semantics)。语言可以自由地设计自己怎么想,但只要它要落地运行,就必须向宿主收敛。

这套宿主语义有四件事,加一个小到不能再小的第五件。

一 · 进程:程序不是函数调用,是一个有生命的东西

Unix 把"运行中的程序"变成了一个独立对象:有 PID,有父进程,有退出码,能被信号打断,能 fork 出另一个自己,能 exec 换成另一个程序。

今天你写的每一行并发代码,底下都是这个模型:

语言它给你的接口底下是什么
Pythonsubprocess.run() / os.fork()fork + exec + wait
Node.jschild_process.spawn()fork + exec + 管道
Goos/exec.Commandfork + exec + 管道
JavaProcessBuilderfork + exec(Unix)/ CreateProcess(Windows)
Ruststd::process::Commandfork + exec

这些 API 长得不一样,但语义是同一个:创建一个子进程,接管它的三个通道,等它结束,拿它的退出码。这套语义是 1970 年代在 PDP-11 上定下来的。

二 · 文件描述符:所有资源都是"一个能读能写的编号"

Unix 把文件、设备、管道、socket 全部抽象成同一个东西:一个整数,叫文件描述符。0 是输入,1 是输出,2 是错误。

这一个设计,决定了后来所有语言的 I/O 长什么样。print、console.log、fmt.Println、System.out.println——它们全都是"往 1 号描述符写一串字节"。

也决定了"重定向"这件事为什么这么简单:> 只是把 1 号换成另一个文件。管道 | 只是把前一个程序的 1 号接到后一个程序的 0 号。

三 · 路径与权限:软件住在哪,谁能动它

斜杠分层的目录、. 和 ..、$PATH 里按顺序找可执行文件、0755 这样的权限位——这些不是"文件系统实现细节",它们是所有包管理器的形状。

pip 装到 /usr/lib/python3/site-packages,npm 装到 node_modules/.bin,gem 装到 /usr/local/bin,cargo 装到 ~/.cargo/bin——每一个都在模仿 Unix 的目录布局。你在 Windows 上装 Python,它也会造一个 Scripts\ 目录,里面放 .exe 的包装器,因为生态假设了"可执行文件住在一个在 PATH 里的目录"。

四 · 文本流与退出码:程序要能被组合

Unix 的第四个约定是:程序应该能当过滤器用。读标准输入,写标准输出,成功返回 0,失败返回非 0。

这一条塑造了语言被使用的方式:几乎所有语言的第一课都是"读一个文件、打印几行"。也塑造了工具链:grep、sed、awk 能跟任何语言的输出拼在一起,因为大家遵守同一个格式约定。CI 系统判断"这一步成不成功",看的就是退出码。

五 · 那个小到不能再小的东西:#!

1980 年前后,Unix 加了一个特性:如果一个文本文件的第一行是 #! 加上一个解释器的路径,内核就会用那个解释器来执行它。

两个字符。它让"脚本"成了一种程序。#!/usr/bin/env python3、#!/bin/bash、#!/usr/bin/perl——今天你写的每一个脚本的第一行,都是 Unix 在 1980 年留下的一个约定。

证据:POSIX 的第一版目录就是这四件事

1988 年 POSIX.1 定案时,核心服务那一章列的清单是:进程创建与控制、信号、文件与目录操作、管道、C 标准库、终端接口。

不是"语法",不是"类型系统",是进程、文件、管道、终端。标准委员会非常清楚自己在标准化什么。

但边界要说清楚

反例一:Java。JVM 的设计动机之一,恰恰是逃离 Unix 的碎片化——"一次编写,到处运行"是对"每个 Unix 都不一样"的反弹。但 JVM 落地时,仍然要映射到 POSIX 或 Win32;ProcessBuilder 在 Linux 上仍然调 fork/exec。

反例二:.NET、Erlang、Haskell。它们的语言语义跟 Unix 毫无关系。但它们的运行时(GC 怎么申请内存、线程怎么调度、文件怎么打开)仍然要向宿主低头。

所以准确的结论是这四句:

Unix 没有规定语言怎么想。
它规定了语言怎么活。
语言的语法可以自由,语言的运行时要向宿主收敛。
而今天几乎所有宿主,都是 Unix 的形状。

顺便说一个反证:Windows 上的语言生态,一直在补这门课。Cygwin 用一层 DLL 模拟 POSIX;MSYS2 是它的后代;WSL(2016)干脆把真正的 Linux 内核装进 Windows;WSL 2(2019)换成了轻量虚拟机里的真内核。微软花了二十年,最后承认:要让 Unix 生态的软件跑起来,最好的办法是把 Unix 装进来。

画面建议 这一章最好用"同一件事的四种写法":屏幕上并排四个窗口,Python、Node、Go、Java 各写一行"跑一个子进程"。四行代码完全不同,然后画面拉远,四条线都指向同一个系统调用 fork。这就是"宿主语义"的可视化。

终章三层世界

把五十年压扁,今天的世界只有三层。

三层世界的结构 从下到上依次是指令集层、内核层、接口层,越往上越容易更换。 第三层 · 接口 Win32 · POSIX · Cocoa · 浏览器与 WebAssembly · JVM 与 .NET —— 决定「程序长什么样」 第二层 · 内核 NT · Linux · XNU —— 决定「资源怎么分配」,全世界只剩三个 第一层 · 指令集 x86-64 与 ARM64 —— 决定「硅怎么动」,全世界只剩两个 越往上越容易换,越往下越难换。五十年里,第一层收敛到两个,第二层收敛到三个,第三层反而在爆炸。
三层世界。一个常见的误判是把它们混着比——"Linux 和 Intel 谁更强"这类问题之所以无解,是因为它们根本不在同一层。

一个常见的误判是把它们混着比。"Linux 和 Intel 谁更强"这类问题之所以无解,是因为它们不在同一层。准确的说法是:Linux 跑在 Intel 上,也跑在 ARM 上;Intel 上跑 Linux,也跑 Windows。

越往下越难换,因为越往下要背的历史越长。这就是为什么五十年过去,第一层只剩两个,第二层只剩三个,而第三层还在爆炸——WebAssembly、容器、JVM、Electron,都在往上堆新的接口层。

那个问题其实被解决了两次

你开头问的那个"一台机器一种编码"的世界,答案有两条,形状惊人地一样。

第一条是编程语言:C 用"贴近机器但不绑定机器"的最小公约数,让同一份代码能编译到任何 CPU 上。1973 年 Unix 用它重写,操作系统从此变成可搬运的软件。

第二条是字符编码。这条线几乎没人讲,但它和 C 是同一个故事。

年代状态后果
1960sEBCDIC、Fieldata、各家私码,6 位或 9 位字符数据跨机器即废纸
1963ASCII 定案(7 位)有了第一个共同子集,但只有英文
1964System/360 把字节定成 8 位"一字节等于 8 比特"沿用至今
1980s代码页地狱:CP437、GB2312、Big5、Shift-JIS、KOI8-R同一串字节在不同机器上是不同文字
1991Unicode 1.0(联盟 1 月成立,标准 10 月出版)给全世界每个字符一个唯一编号
1992UTF-8:9 月 2 日,汤普森和罗布·派克在新泽西一家餐馆的餐巾纸上画出设计变长字节流兼容 ASCII,成了互联网的实际标准
1993NT 内部一律 UCS-2;UTF-8 在 USENIX 正式发表一个操作系统第一次"从内核开始就是 Unicode"
今天UTF-8 占网页九成以上这件事结束了

先定一个最小公约数,然后让所有东西向它收敛。

C 对机器如此,UTF-8 对文字如此,POSIX 对操作系统如此,TCP/IP 对网络如此。这五十年真正被发明的东西,不是某一台机器、某一种芯片,而是"定公约数"这个方法本身。

所以你困惑的那些名字,其实是同一栋楼的不同楼层:Unix 是一种思想传统,C 是让它能被搬运的语言,Linux 是一次具体实现,NT 是一次彻底的重写,Intel 与 ARM 是两种硅,Mac 是把这些都换过一遍的活标本。

而 1973 年那段用 C 重写的代码逻辑,今天仍然在你手机里跑——只是换了五次外壳。

附录 A年表

年份事件
1956AT&T 反垄断和解:被禁止进入"普通通信"以外的生意——这是 Unix 后来只能"送"不能"卖"的法律原因
1964Multics 立项;IBM System/360 确立 8 位字节与 EBCDIC
1969贝尔实验室退出 Multics;Unix 在 PDP-7 上诞生;ARPANET 连上第一批四个节点
1970Unics 得名(柯林汉的玩笑);Unix 拿到 PDP-11/20
1971《UNIX 程序员手册》第一版(11 月 3 日);Intel 4004(11 月 15 日);ARPANET 投入运行
1972C 语言成形;Unix 加入管道
1973Unix 第四版用 C 重写;Unix 在 SOSP 首次公开;第五版授权给大学;基尔代尔写出 CP/M
1974CACM 发表《The UNIX Time-Sharing System》;Unix 到达伯克利(法布里要来的);卡恩与瑟夫提出 TCP
1975汤普森到伯克利做客座教授;第六版开始授权给公司
1977Unix 移植到 Interdata 8/32,可移植性首次被证明;乔伊开始打包 BSD;VMS 问世
19781BSD 发布(3 月 9 日,约 30 份);《K&R C》出版;8086(6 月);TCP 拆成 TCP/IP
19792BSD(5 月,带来 vi 与 csh);3BSD(虚拟内存);第七版;8088;DARPA 开始资助伯克利(至 1988)
19804BSD;微软买下 86-DOS(合计 7.5 万美元);美国国防部规定 TCP/IP 为军用标准
1981IBM PC(8 月 12 日,1565 美元);PC-DOS 40 美元 vs CP/M-86 240 美元;Acorn 的 BBC Micro
198280286;Intel 授权 AMD 做第二供应商——x86 成为公共标准
1983System V 上市;4.2BSD(8 月)内置 TCP/IP 与 socket;GNU 宣言(9 月 27 日);ARM 项目立项;AT&T 被拆分
1984Macintosh(1 月 24 日);X/Open 成立;POSIX 项目启动
1985Intel 386;Windows 1.0;ARM1 点亮(4 月 26 日);FSF 成立;SVID
1987Minix;Acorn Archimedes;OS/2;GCC 1.0
1988POSIX 1003.1 定案;NeXTSTEP;NT 立项(10 月);UI 与 OSF 对峙
1990ARM Ltd 成立;Windows 3.0(5 月);NeXT 放弃硬件(1993)
1991Linux 0.01(9 月 17 日,8 月 25 日发帖);Unicode 1.0;AIM 联盟(10 月 2 日);USL 起诉 BSDi(次年)
1992386BSD;Linux 改用 GPL(12 月);Windows 3.1;ARM6;UTF-8 设计成形(9 月 2 日)
1993Windows NT 3.1(7 月 27 日);4.4BSD;Debian;Newton 用 ARM610;Novell 买下 USL
1994USL 与 BSDi 和解(1 月);Linux 1.0;首台 Power Macintosh;4.4BSD-Lite
1995Windows 95(8 月 24 日);ARM7TDMI;Java 发布;Novell 把 Unix 卖给 SCO
1996苹果收购 NeXT(12 月宣布,1997 完成,约 4.27 亿美元);NT 4.0
1997诺基亚 6110(ARM7TDMI);苹果发布 Mac OS 8
1998Arm Holdings 在伦敦与纳斯达克上市;Intel 买下 StrongARM
2000Windows 2000 与 ME;ME 是 DOS 血脉最后一款
2001Mac OS X 10.0(3 月 24 日);Windows XP(10 月 25 日)——两条血脉合一;Itanium
2003AMD64 / Opteron(4 月);SCO 起诉 IBM;Linux 2.6
2005苹果宣布转向 Intel(6 月 6 日)
2006首台 Intel Mac(1 月);Intel 卖掉 XScale;Core 2
2007iPhone(Darwin + ARM);Windows Vista
2008Android 1.0;App Store
2010iPad;Apple A4
2012Windows RT(10 月 26 日)——NT 内核第一次正式上 ARM
2013A7:首个 64 位 ARMv8 消费级芯片;Docker 发布
2016Windows 的 Linux 子系统(8 月);软银 320 亿美元收购 ARM
2019WSL 2 改用真正的 Linux 内核(跑在轻量虚拟机里)
2020苹果宣布自研芯片(6 月 22 日);M1(11 月 10 日);NVIDIA 宣布收购 ARM
2022NVIDIA 收购 ARM 失败(2 月)
2023Mac 全线完成自研芯片过渡(6 月);Arm 在纳斯达克上市(9 月)
2024—Windows on ARM 借高通 X 系列重新推进;ARMv9 进入数据中心

附录 B人物

人物生卒在这段历史里的位置
肯·汤普森1943—Unix 与 B 语言作者;1983 年图灵奖
丹尼斯·里奇1941—2011C 语言与 Unix;1983 年图灵奖
道格·麦克罗伊1932—提出管道与 Unix 工具哲学
鲍勃·法布里—伯克利教授,1974 年把 Unix 要到伯克利,后来拿下 DARPA 合同
比尔·乔伊1954—BSD 早期主力;vi 与 csh 作者;Sun 联合创始人
加里·基尔代尔1942—1994CP/M 作者,Digital Research 创始人
蒂姆·帕特森1956—六周写出 86-DOS,后被微软买下变成 MS-DOS
戴夫·卡特勒1942—RSX-11M、VMS、MICA 作者;Windows NT 之父
理查德·斯托曼1953—GNU 与 GPL;POSIX 这个名字是他起的
利纳斯·托瓦兹1969—Linux 内核;Git
苏菲·威尔逊1957—ARM 指令集设计者;BBC BASIC 作者
史蒂夫·弗伯1953—ARM 微架构设计者;后转向异步电路与神经形态计算
温特·瑟夫 / 鲍勃·卡恩1943— / 1938—TCP/IP 的设计者
罗布·派克1956—与汤普森一起在餐巾纸上画出 UTF-8;Go 语言

附录 C名词对照

名词它到底是什么容易搞错的地方
Unix一套设计传统 + 一个商标不是某个具体系统;Linux 不算 Unix
C让操作系统可搬运的语言不是"Unix 的语言",是 Unix 恰好用它写
POSIX1988 年定案的操作系统接口标准是"语法书",不是实现;Linux 遵守它但不等于它
BSD伯克利那条 Unix 分支macOS 内核里有它,但 macOS 不是 BSD
Linux1991 年的一个具体内核实现,GPL 授权只是内核;完整系统叫 GNU/Linux 或 Android
x86一种 CISC 指令集(因型号都以 86 结尾得名)不是 Intel 的私产,AMD 也造
ARM一种 RISC 指令集 + 一家只卖授权的公司它不生产芯片;你手机里的 ARM 是高通或苹果造的
PC-DOS / MS-DOS同一份代码的两个牌子:IBM 卖的叫 PC-DOS,微软卖的叫 MS-DOS都不是微软原创,源头是 86-DOS
Windows一条产品线名9x 那条血统 2001 年就断了
Windows NT1993 年重写的那个内核Win10 / 11 用的还是它,只是版本号藏起来了
ABI二进制层面的调用约定跟 API 不是一回事;ABI 一变,旧程序直接跑不起来
HALNT 里隔离硬件差异的那层薄壳不是虚拟机,只是把"这台机器特有的操作"收在一个地方
Darwin / XNUmacOS、iOS 的共同内核内核开源,上层闭源

附录 D常见误传

常听到的说法实际是什么
"Unix 是 Linux 的爸爸"Linux 是照着 POSIX 标准从零重写的,没有抄 AT&T 一行代码。是"同一份语法书的两种方言",不是父子。
"基尔代尔那天在开飞机,所以丢了 IBM 的单子"他当天晚些时候见了 IBM。真正的分歧是 IBM 要一次性买断,DRI 要按份分成。
"微软写了一个操作系统卖给 IBM"微软买了一家小公司的 86-DOS(合计 7.5 万美元),改造成 PC-DOS。
"NT 就是 New Technology"微软 1991 年的宣传片是这么说的。两位早期开发者说名字来自 i860 的代号 N10;盖茨 1998 年说这几个字母已经没有具体含义。
"WNT 是把 VMS 每个字母往后挪一位"圈内流传的玩笑,Cutler 本人否认过。但这说法能传开,是因为 NT 确实有 VMS 的基因——DEC 为此拿到了赔偿。
"ARM 从一开始就追求低功耗"1983 年没人在乎功耗。低功耗是买不起陶瓷封装、又没有功耗估算工具的结果。
"Mac 是第一台图形界面电脑"施乐 PARC 的 Alto(1973)早得多;苹果自己的 Lisa(1983)也早于 Macintosh(1984)。
"TCP/IP 是 Unix 自带的"是伯克利 1983 年在 4.2BSD 里加进去的,钱来自 DARPA。AT&T 的 System V 直到 1980 年代末才补上网络。
"Linux 是第一个自由 Unix"386BSD 在 1992 年就出来了。但 BSD 当时陷在官司里,Linux 没有法律包袱,所以先流行起来。

附录 E延伸阅读

附录 F如果要拍成视频

这份稿子是按"能念出来"写的。几个具体建议:

一、不要按时间正序讲。观众对"1964 年"没有感觉。用"一台机器一种编码"这个具体困境开场,让人先感到不方便,再回到 1964。

二、每幕留一个实物。磁带、40 与 240 两个价签、一张 25,000 个晶体管的版图、一块亮着零的电流表、一张餐巾纸。历史片的说服力在实物上,不在旁白里。

三、把"两条血脉"做成视觉母题。一条紫色(Unix),一条琥珀色(微软/PC),一条青绿(ARM/苹果)。全片反复出现同一张谱系图,每次多长出一枝。观众记住的是图,不是年份。

四、第十一幕是全片的价值所在。前面十幕是故事,这一幕是"所以呢"。用四行代码指向同一个 fork,是全片最有冲击力的一个镜头。

五、控制数字密度。一集里超过五个年份,观众就放弃了。宁可把"1973 年用 C 重写"讲透,也不要一年一年报菜名。

六、结尾不要升华。用那句"1973 年那段代码逻辑,今天还在你手机里跑"就够了。停在具体的东西上,比停在"人类的伟大"上更有力。