「计算机百年史」系列 · 第 4 篇 / 共 10 篇
按《从铜线到智能——计算机两百年》原书卷次连载。本篇:语言与表达(1952—2012),共 16 章,约 16.0 万字符。
卷四 · 语言与表达(1952—2012)卷首语
编程语言史最常见的写法,是一部"进步史":汇编太难,所以有了 Fortran;Fortran 太专,所以有了 ALGOL;一步步走向今天的完美。本卷拒绝这种写法。没有一门语言是因为"更先进"而胜利的——COBOL 赢在五角大楼的采购条款,C 赢在 PDP-11 上买不起边界检查的那 24KB,Java 赢在企业级工程规模变迁的那个当口,JavaScript 赢在离零分发成本最近的位置。每一门语言都是它所处约束下的局部最优解,约束一变,最优即成历史包袱。
本卷的主导物理约束只有一条,却贯穿十六章:人类工作记忆容量的上限,与硬件资源表达精细度之间的永恒妥协。BASIC 把门槛削到文科新生能跨过,Pascal 把纪律立到编译器能强制执行,C 把全部认知负荷压给程序员换硬件零损耗,Python 反过来用运行时的慢买人类认知的快,Rust 则让编译器替人记住所有权——每一次取舍都是一次重新议价,议价的对手从来不是别的语言,而是人脑一次能把握的复杂度,和机器必须兑现的物理现实。
照例声明:本卷没有注定的赢家。PL/I 想讨好所有人而无人问津,Itanium 想让编译器全知而崩塌,ALGOL 60 赢走了所有后世语言的语法却输掉了市场——每一个选择在当时都有充分的理由,本卷要还原的正是这些理由。Multics 的教训在语言世界同样成立:委员会的成活率,关键看它就什么达成了拒绝。
阅读指引。 本卷每章讲一门语言,章节之间相对独立,可以按兴趣跳读。程序员读者建议按自己会的语言对号入座:写 C 的读 039,写 Java 的读 045,写 Python 的读 044,写 JS 的读 046,写 C++ 的读 041,写 Rust/Go 的读 048。非程序员读者建议只读 037(BASIC 与 Pascal)和 043(Haskell 与 ML)——这两章的故事性最强,技术门槛被压到了最低。骨架章是第 030(编译器诞生)、037(BASIC 与 Pascal)与 044(Python):它们分别代表"语言的发明""语言的教育"与"语言的民主化"三个阶段。
第 033 章 Fortran:科学计算从算子重载中破土
1954 年 9 月 20 日,纽约,IBM 的一间机房里,一台 704 计算机完成了一次不寻常的运行:它读入了一份用接近数学的记号写成的程序,吐出了一串可以执行的机器码。这是历史上第一个成功编译的 FORTRAN 小程序——一段由人类用公式语言书写、由机器自己翻译成指令的代码。在场工程师的忐忑可以理解:此前所有关于“机器替人写程序”的尝试,要么慢得没法用,要么干脆没人信。这一次的翻译品质,将在三年后接受全世界科学家的检验。而检验的结果超出所有人的预期:这门为“把公式变成计算”而生的语言,从此再没有离开过数值计算的舞台——从它诞生到今天,已经七十年,它仍是核工程、气候预测与材料科学等领域的首选语言,仍是全世界超级计算机上负载最重的编程语言之一。一门诞生于穿孔卡时代的语言,凭什么统治数值计算七十年?答案不在情怀,在形状。
公式进,机器码出:一张卡片的宪法
先看这门语言长什么样,因为它每一处“怪癖”都是那个时代的忠实化石。FORTRAN——名字就是它的使命宣言,Formula Translation,公式翻译——的程序写在一行行八十列的穿孔卡片上,于是语言把卡片的物理格式直接吸收成了语法:第 1 列写字母 C,整行就是注释;第 1 到第 5 列留给语句标号;真正的语句必须从第 7 列开始写——词前那六个空格不是美学,是卡片分栏的产物。符号名最长六个字符,因为早期编译器的符号表就这么大;写字符串要用水打孔机时代的记法,五个字符的 hello 要写成 5Hhello——以打孔机的发明人霍勒里斯命名的“霍勒里斯常量”;而且彼时根本没有字符串变量这种类型,文字在 FORTRAN 的世界里只是可以打印的数字序列。分支语句更是教科书级的时代印记:算术 IF 长成 IF(表达式) 标号一,标号二,标号三——表达式为负跳去第一处,为零跳第二处,为正跳第三处;三个去处全靠行号指定,程序员在卡片间跳来跳去。这些设计没有一处经得起后世语言美学的审视,但没有一处是随意的:每一条都把穿孔卡的物理约束、早期机器的字符表与编译器的处理能力,原封不动地翻译成了语法。卡片的余下栏目同样各有其主:第 6 列是续行标记,长语句接一张卡继续写;第 73 至 80 列被编译器直接忽略——那原本是给卡片编号的手工区,程序员习惯在那里签上自己的名字或卡组序号,后来的一些编译器事故恰恰因为没忽略这一区而把签名当代码报错。这个签名区还有一项救命的用途:一盒几百张的卡片一旦摔散,全靠这几列的序号才能重新排序——程序即卡片,卡片即程序,物理世界的秩序就是程序世界的秩序。变量命名还埋着一条影响深远的潜规则:凡以 I、J、K、L、M、N 开头的名字自动是整数,其余自动是实数——这条“隐式类型”法则是为了让 FORTRAN 里的整数默认对齐数学家的习惯(i、j、k、l、m、n 正是数学里下标与循环变量的御用字母),代价是拼错一个变量名不会报错,机器只会安静地为你新造一个变量。语言永远带着它出生那天的介质印记——FORTRAN 是这条定律最清晰的标本——标本价值连城,因为它保存的是计算史上最早、也最完整的一套语言化石。沿时间轴看它的版本谱系,同样是一部介质进化史:FORTRAN I 到 IV 如今被视为过时——它们带着大量机器相关特性,换一台机器就得改代码;其中的 FORTRAN III 甚至从未正式发布,成了这门语言唯一的未出生者;1966 年的 FORTRAN 66 是第一个正式标准,把方言收拢成共同文本;此后版本干脆以标准发布的年份命名;今天仍在服役的主力是 FORTRAN 77 与 Fortran 90 及其后代。命名中另有微妙的一处变化:早期全大写的 FORTRAN 是注册商标式的写法,1991 年后的标准把它改为首字母大写的 Fortran——一个字母的大小写,划分了这门语言的古典与现代。
真正的骨架只有两样:DO 循环与数组。FORTRAN 的 DO 循环把“重复计算”压缩成一行结构——从初值走到终值,每次跨一步,循环体套在中间;一层套一层,就能遍历任意维的数据。数组则在声明时就定下大小与维度,编译器据此一次性分配连续的内存。两者的组合恰好覆盖了当时科学计算的全部工作形状:把物理问题离散成网格,把方程组排成矩阵,然后用循环把数组中的每个元素按公式算一遍。数值世界的三大件——网格、矩阵、循环——从这里起就成了 FORTRAN 的全部疆土,也成了此后所有科学程序的通用骨架。值得单独记录的是 FORTRAN 数组的存储顺序:多维数组按列优先排列在内存里——第一列存完存第二列。这个今天看来只是“约定”的细节,实为性能的种子:按列连续访问内存,机器的读取顺序与存储顺序一致,循环写得规矩就能让内存访问如流水线般顺畅;几十年后缓存体系的诞生,让这个 1957 年的无心布局变成了天生的性能优势——列优先的 FORTRAN 数组与逐列扫描的算法,天然就是缓存友好的。而 C 语言后来选择了行优先,两种约定的分野至今仍是跨语言调用数值库时最容易踩中的陷阱;连数组下标的起点都各执一词——FORTRAN 沿数学惯例从 1 计数,C 沿指针惯例从 0 计数——迁移代码时,这“差一”足以让每个边界都错一位。同一个二维数组,FORTRAN 在内存里是 1 列 1 行、1 列 2 行这样逐列排布,C 则是 1 行 1 列、1 行 2 列逐行排布——把 FORTRAN 的矩阵直接递给 C 函数,或者反过来,程序不会报错,只会把矩阵当成它的转置来算;结果错得规整而隐蔽,数值上看着“像那么回事”,物理意义全错。数值计算的老手都背过这条铁律:跨语言传矩阵,先问存储顺序。一个五十年代的存储约定,至今仍在给每一次跨语言调用设卡,这是语言化石最顽固的形态。语言的存储顺序一旦定下,它擅长的计算形状也就随之定下:FORTRAN 天生是为“整列整列地算矩阵”而生的。
这套设计的深层逻辑,是把“科学家脑中的公式”与“机器执行的结构”之间的距离,压缩到一门语言的全部能力极限。DO 循环与数组的配合写出来只有寥寥数行——遍历一个数组的全部元素,按公式逐个换算,是科学计算里出现频率最高的三行:
DO 10 I = 1, N
A(I) = B(I) * C + D
10 CONTINUE
三行卡片,一条循环,N 个元素的批量计算;循环变量、起止与步长写在 DO 之后的括号外——1957 年的写法里循环体靠行号 10 收尾,后来的标准才把它换成结构化的 END DO。把这些循环再叠一层,就是矩阵运算的完整形态:外层扫行、内层扫列,一次矩阵乘法不过是几十次这样的遍历;数值计算的全部宏伟大厦——解方程、算本征值、模拟流体——都是这三行代码以不同层数与次序的组合。这些代码细节在今天的教程里已成古董,但它们的组合逻辑与七十年来所有科学程序一脉相承。科学家写 DO 循环时,心里想的是“对这个矩阵的每一行做变换”;机器执行时,做的是“把这段地址上的数据按指令流过一遍”。公式、循环与数组在 FORTRAN 里是同一个计算的三种投影——这种对齐不是巧合,是设计的原点:FORTRAN 从立项起就只为一种负载服务,即公式驱动的数组计算;它为此放弃字符串、放弃通用性、放弃一切与数值无关的表达需求。一门语言的形状与一个问题域的形状严丝合缝时,语言就不再是工具,而是问题域本身的书写系统。
数组的暴政与自由:语言形状匹配问题形状
把镜头拉远看科学计算这个行当,会发现它的负载画像几十年来惊人地稳定。天气预报把大气切成三维网格,逐格解流体方程;结构工程师把机翼切成有限单元,解应力矩阵;计算化学家把分子轨道展开成基函数,解本征值问题;核工程算中子输运,气候学界耦合海洋与大气模型——每一行的底层都是同一件事:大规模的数组,加上作用在数组上的密集算术循环。数值计算的世界里,数据是规整的(矩阵与网格)、访问是可预判的(按行列扫过)、运算是密集的(每个元素都要算);这恰好是“声明定长的数组加 DO 循环”这套极简设计能够完全覆盖的形状。FORTRAN 的统治因此有一半是运气:它1957年选定的抽象,恰好就是科学计算的永恒抽象——七十年代出现了向量机,数组运算天然映射到向量指令;八九十年代出现了并行机,独立迭代的循环天然可以切给多处理器;二十一世纪出现了 GPU,密集的阵列运算又一次顺着数组的形状铺开。每一波硬件浪潮里,FORTRAN 编译器都只需回答同一个问题:这段循环里的各次迭代互不干扰吗?数组语义的规整让回答变得有章可循——不共享内存写入的迭代就是并行安全的,编译器与程序员都据此放心地切分数据。向量化、共享内存并行、分布式并行、图形处理器加速,四代并行技术全都在 FORTRAN 的循环模型上落地生根;如今超级计算机上跑的科学程序,几乎都是“FORTRAN 的骨架加上并行指令的肌肉”。这种跨硬件时代的适应力,来自语言形状与计算形状的深层重合:数组计算的本质就是“对大量数据做同样的运算”,而硬件进化的方向恰恰就是“把同样的运算做得更快更多”——两边朝着彼此走了七十年。每一代新硬件的优化路径,都自动流向了 FORTRAN 的领地,因为它三十年前就把自己写成了硬件喜欢的形状。
另一半则是刻意的设计。FORTRAN 对数组语义的规定出奇地严格:数组是一整块连续的、按列排布的内存,元素类型统一,没有指针指着到处乱跑。这个“单调”的语义给了编译器一张清晰的地图——分析一段循环时,编译器可以确定哪些数组在内存里互不重叠、哪些访问可以安全地重排、哪些中间量可以驻留寄存器,于是优化可以放开手脚:循环变换、向量化、分块,一层层压榨硬件。与 C 对比,差距的根源就在语义的松紧:C 的指针可以指向任何地方,两个看似无关的指针可能指向同一块内存(别名问题),编译器为了安全只能保守地少做优化;FORTRAN 的数组语义天然排除了大部分别名可能,编译器的每一步激进优化都有语法作保;C 阵营后来意识到这块短板,专门补了一个提醒编译器“此指针不与其他指针重叠”的关键字——借来的补丁,恰好反证了原生长者的优势。同样的矩阵乘法,FORTRAN 编译器生成的代码常常胜过朴素的 C 实现、匹敌手工调优的版本——这不是编译器写得更好,是语言把“可以放心优化”的信息提前交了出来。九十年代之后,FORTRAN 干脆把数组运算提升为一等语法:整段数组可以直接参与运算与赋值——写 A 等于 B 加 C,编译器负责把它展开成遍历每个元素的循环;数组从“被循环遍历的对象”升格为“可以直接运算的量”,语言形状与数学形状的贴合又进了一步。数学家的线性代数直觉从此可以近乎直译:整行整列的矩阵变换、成片的边界条件更新,都按数学书上的写法直接落在代码里。这门语言也没有随旧世纪一同老去:开源编译器让任何人在任何机器上零成本使用它,社区在 2020 年代建起了新的门户与包生态,2026 年,全世界的 FORTRAN 使用者还专门为它庆祝了七十岁生日——一个经常被宣告死亡的语言,办了一场自己的庆典。
六十年的统治:沉默的底层
长寿的第二个支柱,是一座几乎与 FORTRAN 同龄的代码金字塔。几十年间,全世界的数值分析学家把最精妙的算法写成 FORTRAN 子程序,层层沉淀:最底层是 BLAS——一组基础线性代数子程序,负责向量内积、矩阵向量乘这些最原子的运算;中间层与上层垒起了 LAPACK——线性方程组、本征值问题、最小二乘,数值线性代数的全部重武器。这两座库经过几十年、几代硬件的持续适配,性能被调优到了极限:机器换了多少代,库就跟着重写过多轮缓存优化与并行化,每一轮都在同一份接口之下。今天的现实是:你在 Python 里调用 NumPy 做一次矩阵运算,底层大概率在跑几十年前就开始优化的 FORTRAN 代码——Python 的优雅只是一层包装,真正的算术在 FORTRAN 里完成。大模型时代也一样:训练中的线性代数瓶颈,在 FORTRAN 层优化的收益可能高于上层框架的任何改动。
把这座代码金字塔拆开看,层级清晰得像一座精铸的塔:塔基是 BLAS——基础线性代数子程序,只做最原子的运算:向量的加减与内积、矩阵乘向量、矩阵乘矩阵;塔身是 LAPACK——线性方程组求解、最小二乘、本征值问题,全部调用塔基的原子运算搭建。分层的好处是硬件红利沿塔自动上浮:新一代芯片只要重写塔基的少量原子例程,塔身上几十年验证过的算法立刻整体提速——GPU 厂商、芯片厂商与超算中心竞相优化的第一件事,就是各自的 BLAS。塔中沉淀的还不只是速度:LAPACK 的每一个例程都对着几十年公开的数值测试校准过,误差界有数学文献背书——科学家信任它们,等于信任一整代数值分析学家。这就是科学计算生态的隐秘秩序:最顶层的编程语言换来换去,塔基的 FORTRAN 例程岿然不动。塔里存的还不只是代码,是信任的复利:一个气候模型的可信度,来自它对过去几十年气象数据的回算准确;一个结构求解器的可信度,来自它对真实桥梁应力的复测吻合。这些验证是拿真金白银的算力与几十年的现实观测换来的,全部寄存在 FORTRAN 代码与其配套数据里。重写代码易,重攒信任难——后者以十年为单位计价,这正是“重写即风险”的全部含义:你可以复刻代码的逻辑,复刻不了代码与世界对过答案的那段历史。科学计算的基础设施迁移成本极高,围绕这些库建立的验证体系、教科书与工程师经验,构成了一个自我强化的生态:越多人用,库越完善;库越完善,越多人用。挑战者年年都有:新一代的科学语言许诺把易用与高速合二为一,语法更现代、类型系统更聪明,在基准测试上也可圈可点;但它们每次都要面对同一道考题——你打算怎么对待那几十年的 FORTRAN 遗产?重写,就要重验几十年积累的科学结论;兼容,就要在底层调用同一批 FORTRAN 库。绝大多数挑战者的终局,是变成这座金字塔的又一层包装。对后发国家而言,这道考题还有另一层现实意义:想在科学计算基础设施上自主可控,绕不开重写或兼容这些 FORTRAN 遗产——塔可以重新粉刷,塔基的几十年验证无法速成。
第三个支柱最不起眼却最致命:稳定性。FORTRAN 的标准化从 1966 年开始,此后每一个标准都严格向后兼容——半个多世纪前的循环写在今天的编译器里,大概率还能跑。这不是小事:一个气候模型或结构求解器,其数值行为已经对照真实世界验证了十几年——卫星数据校过、实验测量对过、几十年的天气预报回头看准过;模型里的每一个系数、每一处近似,都承载着无法速成的领域知识。把它用一门时髦语言重写,得到的是同样的公式配上全新的错误——对科学计算而言,重写不是升级,是把已经校准的仪器拆掉重铸;几十年的验证数据也随之作废,谁也赔不起这段等待真实验证的时间。于是行业形成了稳定的分工:新语言负责界面与胶水,FORTRAN 负责重活。天气预报的求解器、飞机的流体仿真、核工程的中子计算、材料科学的能带模拟——世界上相当份额的超算机时,至今在跑 FORTRAN。逐个看这些战场的分量:计算流体力学里,机翼表面的气流仿真要解的是百万格点上的耦合方程,几十年的求解器代码与验证数据全在 FORTRAN 里;有限元分析把桥梁与机身切成几十万个小单元逐个解应力,是土木与航空工业的日常主食;天气与气候模型是人类写过的最大科学代码之列——全球网格、多层大气、海洋耦合,一次模拟跑数周,代码的每一行都对着历史气象数据校准过。这些系统共享一个特征:它们回答的问题重要到不容出错,又复杂到无法推倒重来——FORTRAN 的存量与稳定,恰好是它们唯一能接受的语言策略。更深的不朽是隐形的:新一代科学家在 Python 里调用矩阵运算时,多数人并不知道脚下的数值库是用什么写的——看不见的地基才是最深的不朽。它不在技术新闻里,因为稳定运行的系统不会上新闻;它在每一台超级计算机的负载统计里,因为重活总得有人干。对今天的工程师而言,学 FORTRAN 的意义与其说是怀旧,不如说是门票:航空航天、高性能计算、气候科学、计算物理的从业路上总会遇到它,能读懂并扩展这些代码库是真实且稀缺的技能;更深一层,它训练一种在别的语言里学不到的思维方式——数据排成什么样、循环朝哪个方向扫、每一步访存离上一步多远,性能的真相永远藏在内存布局里,这门老语言逼你直面它。
支撑这条兼容链的,是 FORTRAN 严谨到刻板的版本纪律。1966 年,FORTRAN 66 成为这门语言第一个正式标准,把各方方言收拢成共同文本;1978 年的 FORTRAN 77 补上了字符串类型——此时距语言诞生已二十一年,字符处理才不再是霍勒里斯常量的黑魔法;1991 年的 Fortran 90 是一次大步进化:自由格式源代码终于挣脱了卡片分栏,变量名放宽到三十一个字符,数组整体运算成为语法,模块机制取代了零散的公共区,动态内存也让“数组大小必须在编译期写死”的祖训作废;2003 年的标准加入了面向对象机制;此后标准大约每数年一版,并行能力、与现代 C 的互操作陆续入册。每一版都在扩容,每一版都向后兼容——1977 年写的循环,放进 2023 年的编译器依然合法。这条兼容链的成本同样真实:为了不破坏任何存量程序,语言背着一整套过时特性的包袱前行,新特性不得不与旧写法长期共处,教科书与存量代码讲着不同世代的故事——这份兼容的债务清单,与它在科学计算里七十年的统治地位,是同一份合同的正文与附则。
化石的清单
清算这门语言的账目,化石要一件件登记。第一批是格式化石:固定列的卡片语法在穿孔卡死后又延续了几十年,六字符的名字让变量名变成猜谜,5Hhello 式的字符串记法是打孔机时代的活化石——每一代新手都要先学一套与编程无关的“考古学”才能下笔。隐式类型则是最阴的一枚:它意味着 TEMP 与 TEMP1 可以是不相干的两类变量,一个手滑的拼写错误不会得到任何报错,机器只会安静地新造一个变量、继续用错误的零参与计算——科学计算史上不知有多少“离奇的结果”可以追到这里。后来的标准补上了显式声明的开关,谨慎的团队把它写进了编码纪律;但开关默认是关的,而科学计算的世界里,大量代码从不打开它。语言同样不检查数组边界:下标越出数组不会当场报错,程序会去读相邻位置的内存,把垃圾当作数据继续演算——对一个结果要拿去预报台风、设计机翼的行当,这种静默的错误比崩溃可怕得多。第二批是控制流化石:算术 IF 的三分跳转配合行号,写出的程序像一盘散落的跳棋——执行流在卡片间飞来飞去,读代码的人要自己记住哪个标号对应哪个条件。算术 IF 还埋着一个语义暗礁:表达式恰好等于零时走中间那个标号——浮点运算里“恰好为零”几乎从不发生,三分支里有一支常年是死代码,程序员却仍要为它准备去处。FORTRAN 对 GO TO 的纵容更进一步:语句间的转移全靠行号,几百行程序里的跳转可以用一张蛛网来形容;这门语言因此成了六十年代末结构化编程运动最醒目的批判靶子——迪杰斯特拉那篇著名的檄文所指认的混乱,在 FORTRAN 的存量代码里俯拾皆是。需要为它说一句公道话的是:行号跳转的真正源头是穿孔卡——卡片可以插拔重排,行号是让机器在重排后仍能找到目标的手段;语言的“罪”,一半是介质的遗传。第三批是类型化石:没有字符串类型、迟到的逻辑类型、一路到 FORTRAN IV 才补齐的复数——语言对数值的偏爱与对其他数据形式的冷漠同样彻底,这让它在科学计算之外几乎无处立足:写个文本处理、搭个数据库、画个界面,FORTRAN 都不是候选。第四笔账是方言:标准化之前各厂商自行扩展,IBM 与 DEC 的扩展集几乎相同已是万幸,更多厂商的方言让“可移植”三字在纸面上挣扎多年;1966 年的标准与后续修订,算是为方言分裂补上了一张迟到的药方。付款人是几代科学程序员:他们中的每一代都要同时精通两套语言——FORTRAN 写计算,另一门语言(从汇编到 C 再到 Python)写 FORTRAN 不擅长的一切;这个“双语言生存”的行规,至今仍是科学计算工程师的标准配置。学习成本也在一代代转手:物理系与工程系的学生要修的不再是“程序设计”,而是半门考古加半门数值方法——先考古断代分辨新旧写法,再学循环与矩阵的正宗用法;FORTRAN 把编程的门槛降到了科学家够得着的高度,又用四十年的存量把这个高度焊死在了原地。此外还有一笔最隐蔽的账:优化的自由是有物理后果的——编译器重排浮点加法的顺序,结果就会在最后几位小数上抖动;不同编译器、不同优化等级、不同代数的芯片,跑同一个程序会给出略微不同的数值。对精确到小数点后十几位的科学结论而言,这不是噪声而是复现性的裂缝:论文里的数字,换一台机器可能对不上最后几位。数值界的应对是把“可复现”重新定义为“在误差界内一致”,而那句“同一个程序永远给出同一个数”的古老直觉,就此成为编译器时代的第一个祭品。
而把账本翻到收益栏,这一章对卷四主线的回答最为直白。认知带宽与硬件精细度的妥协,在大多数语言里是此消彼长的拉锯——更接近人的抽象必然远离机器,更贴近机器的语法必然折磨人。FORTRAN 的做法是先精确测量自己的用户需要什么认知:科学家的认知带宽里装的是公式、矩阵与网格,而不是寄存器与地址;于是它把全部语言预算投向“让公式直书”这一件事,用公式到机器码的直接翻译,把认知的损耗压到接近零——科学家几乎不需要学习新的思维方式,数学怎么写,程序就怎么写。这个选择的代价是语言永远告别了通用性,收益则是七十年不曾松动的问题域统治。拿它与后来者各自的合同对照,取舍更清楚:Python 递给科学家的是即写即得的交互体验,代价是把性能外包给底层的 FORTRAN 与 C;C++ 递给工程师的是全部控制权,代价是把正确性的责任一并压到个人肩上;FORTRAN 的合同条款最少——它只承诺一件事,数组上的公式计算,快、稳、可验证,七十年不涨价。合同越窄,越难被推翻;这是专用语言与通用语言在时间尺度上胜负分明的根源。它的启示不在于“专用语言好过通用语言”这种简单结论,而在于一个更锋利的判断:语言的寿命,取决于它选中的那个问题域的寿命。科学计算不是一门会过时的生意——只要人类还需要解方程,数组与循环的形状就不会过时;FORTRAN 选中的问题形状从未过时——只要人类还在解方程,数组与循环的形状就不会过时,于是它自己也活成了长久的形状。认知带宽与硬件精细度这对永恒的矛盾,在它这里不是被“平衡”解决的,而是被“分工”解决的——语言只管公式到机器码的翻译精度,数学只管公式本身的对错;七十年里双方各守一边,再未重开谈判。巴克斯当年在提案里承诺的“让程序员摆脱手工编程的痛苦”,以一种他未必设计过的方式全部兑现:他没能让 FORTRAN 适应一切,却让一切需要计算的科学,适应了 FORTRAN。上一章的编译器之战,在这一章有了最终的回声——当年那场“编译器能否匹敌手工汇编”的赌局,用七十年的科学计算成果完成了终审。而在 FORTRAN 问世的次年,另一群人选择了截然相反的方向:他们不打算让语言迁就机器的形状,而是要造一门语言,让机器迁就人类的思维结构——那门语言叫 Lisp,它的故事与 FORTRAN 像光谱的两端。
第 034 章 1958:Lisp
1958 年秋天,麻省理工学院(MIT)一间堆满穿孔卡片的实验室里,IBM 704 占据了房间中央,操作员把卡片盒推进读卡机,机器按秒吞掉预算。研究生史蒂夫·拉塞尔(Steve Russell)盯着约翰·麦卡锡(John McCarthy)写在黑板上的一页数学推导看了很久,忽然开口:“为什么我不把这个求值器编出来?”麦卡锡几乎没有抬头,飞快地答了一句:“Ho,ho——你把理论和实践搞混了。”在麦卡锡看来,黑板上那个叫 eval 的东西是一个数学定义,描述任何符号表达式应当如何被求值,它属于论文,不属于机器。拉塞尔把这句话当成了耳旁风。他坐到 704 的控制台前,花了一个周末,把黑板上的数学翻译成机器码。周一早上,实验室里多了一样此前不存在的东西:一个能运行的 Lisp 解释器。麦卡锡多年以后对着录音机回忆这段往事,承认“这个进展让我吃惊”(This development was a surprise to me)。一个被写出来只为在纸面上自洽的定义,一夜之间变成了一个可以实际运行的语言。此后三十年,美国几乎所有重要的人工智能系统都在这个周末的产物里运行。上面这段对话与麦卡锡的晚年自述,此处对话与自述,转引自麦卡锡晚年口述历史的公开整理,原文如此,不做修饰。
公式算不出推理
麦卡锡想要一门新语言,起因是一次失望。1956 年夏天,十余名研究者在达特茅斯学院聚会,麦卡锡在会上造出了“人工智能”(artificial intelligence)这个词。会上,艾伦·纽厄尔(Allen Newell)与赫伯特·西蒙(Herbert Simon)展示了他们为“逻辑理论家”(Logic Theorist)写的表处理语言 IPL。IPL 能操作符号,能做推理演示,在当时是独一份的实现。IPL 本身来头不小:它是 1955 至 1956 年间出现的人工智能语言,比 Lisp 早两岁,列表处理与递归这些后来归于 Lisp 名下的概念,IPL 先用过一遍。麦卡锡承认它能用,但私下里觉得它在代数品位上令人不快:IPL 是贴着 IBM 汇编写出来的,指令形状处处迁就机器的寄存器与字长,组合程序像在拼装机器零件,算子之间没有数学上干净的复合规则。他想要的是一门根植于阿隆佐·丘奇(Alonzo Church)λ演算的语言:函数在其中是一等公民,可以像数字参与算术那样被传递、被组合、被作用于自身。后来的史述常把这段写成“麦卡锡发明了一切”,公允的说法是:IPL 证明了表处理这条路走得通,λ演算给了这条路数学的形状,麦卡锡的工作是把两者焊在一起,再用一篇论文把焊点变成所有人都能踩的地基。
这个念头在 1956 年显得奢侈,有两个具体原因。第一,市面上有语言,而且刚够用。约翰·巴克斯(John Backus)的 Fortran 在 1957 年交付,编译出的代码效率让汇编老手闭嘴,科学家排着队学它。对一台按秒计费的机器而言,“够快”是硬通货,任何不能承诺效率的新语言都要先回答一个问题:凭什么让我为你的漂亮付出机器时间。第二,符号处理本身在当时不算一门正经负载。Fortran 的形状是公式,输入输出都是数字;麦卡锡要处理的却是定理、棋局、英语句子——输入是一堆符号,输出是另一堆符号,中间没有数值计算可言。机房管理者看到这种需求,反应与今天看到有人申请超算画画一样:机器是用来算数的,不是用来“推理”的。符号在 1958 年的计算机房里没有合法身份,麦卡锡等于要为一群尚不存在的用户,向一群不相信符号计算的人要机器时间。
符号负载与数值负载的差异,可以用两行代码看清。Fortran 程序员写的是公式到数字的映射:给出一组数,算出另一组数。Lisp 程序员写的则是关系与规则:用一张表(father John Mary)表示“约翰是玛丽的父亲”,用关联表存放人物属性,再写规则从关系里推导新的关系。公式计算里,数据的形状是预先定死的数组;符号推理里,数据的形状在运行中生长——新的事实推出来,就拼成新的表挂到旧表上。Fortran 的编译器可以提前规划好每一块内存的住户,因为数组的大小在声明时已经写死;符号程序的内存需求在程序跑起来之前根本算不清,表要生多少、活多久,全看推理走到哪一步。两种负载对机器提出的要求几乎处处相反:一个要规整、要预知、要一次算完;一个要生长、要即兴、要边算边造。麦卡锡坚持另起炉灶的理由就藏在这里:IPL 已经证明表处理走得通,但 IPL 的用户每写一段推理,都要顺手操心机器的寄存器与字长;他想要的 λ演算传统里,函数本身可以作为值被传递、被组合、被作用于自身,推理规则的复合在纸面上是什么形状,在机器里就该是什么形状,中间不应当横着一层汇编的方言。
反对者的位置站得住脚,还因为他们手里有 IPL 这个现成反例。纽厄尔与西蒙已经证明,沿着汇编思路可以造出表处理语言,逻辑理论家确实证明了定理。既然路已有人走通,麦卡锡坚持另起炉灶,在同行眼里近乎品位之争:IPL 丑是丑了点,可它在机器上跑得起来;λ演算美则美矣,它是写在纸上的逻辑学,从纸面到 IBM 704 之间隔着谁也不知道有多深的沟。品位之争的实质是风险分担之争:沿着 IPL 走,风险是已知的丑陋与局促;跟着 λ演算走,风险是未知的大到无法估计。工程共同体在有现成路可走时,几乎总是先走现成的路,等现成的路被证明走不通,再回头给美的东西一次机会。Lisp 的运气在于,它要去的地方现成的路根本到不了,品位成了唯一的向导。更实际的一层是,麦卡锡本人最初也没打算让他的记法上机。他设想的程序写法是一种叫 M-表达式的东西,外形接近数学惯例,函数作用写成 car[cons[A,B]] 这副模样;机器内部用的 S-表达式只是过渡性的编码。连设计者自己都把“优雅的写法”与“能跑的实现”放在两层,怀疑者自然有理由等一等,看这团数学雾气能不能凝成水。
1958 年 9 月 1 日,MIT 人工智能项目成立。麦卡锡带着一个值得实现的方案走进去,也带着上述全部质疑。他的回答分成两个赌注,每一个在当年都要冒机器时间的风险。赌注一:代码与数据应当长得完全一样。程序本身就是一张裹在括号里的表,程序检查、生成、改写另一个程序,与重排一列数字没有区别。赌注二:内存应当由机器自己管理,程序员不再手工追踪每一块存储的生死。两个赌注有一个共同点:它们都把本该由人承担的认知负担转交给机器,而 1958 年的机器恰恰是最不宽裕的甲方。把时间线一次排开:1958 年语言在 MIT 成形,同年秋天解释器在 704 上跑通,1960 年 4 月论文刊于《美国计算机学会通讯》,同年回收器随 LISP I 交付,1962 年自托管编译器问世。从黑板上的数学到可交付的工具链,只用了四年。反对者赢了每一次辩论,输掉了整条时间线。
一对括号里装下世界
Lisp 的名字是 List Processor 的缩写,直译是“表处理”。它的全部数据世界只用两种东西拼装:不可再分的原子,以及由括号围起来的 S-表达式。论辈分,它是现今仍在广泛使用的第二古老的高级语言,只比 Fortran 年轻一岁。这门第二古老的语言,做的却是当时最年轻的事:它的输入输出不走数字,走的是符号、规则、命题。S-表达式的经典定义只有两行:一个形如 x 的原子是 S-表达式;一个形如(x . y)的结构也是 S-表达式,其中 x 与 y 本身都是 S-表达式。第二行里的点号读作 cons,一次 cons 把两个 S-表达式粘成一个有序对。后来的 Fortran 程序员看到满屏括号会头晕,但这套记法有一个编译器视角下的优点:语法里没有优先级,没有中缀算子,没有需要查表的例外,读入程序就是读入一棵树。
树在内存里的样子,就是 Cons 单元串起来的链。一个 Cons 单元是存放两个指针的内存物件,左半叫 car,右半叫 cdr。把若干单元的右半依次相接,左半依次放元素,就得到一张表;把右半接向任意子树,就得到任意二叉树。写在纸上的(x y z)只是缩写,它在内存里的真实形态是(x . (y . (z . NIL))),NIL 是挂在链尾的特殊标记,意为“到此为止”。下图把纸面、内存、求值三者的对应画在一处:
纸面写法 内存里的 Cons 链 求值器的读法
( + 1 2 ) ┌─────┬─────┐ ┌─────┬─────┐ ┌─────┬─────┐
│ + │ ──────▶│ 1 │ ──────▶│ 2 │ NIL │
└─────┴─────┘ └─────┴─────┘ └─────┴─────┘
│ │ │
头一个是 后面全是 链尾 NIL
要调的函数 传给它的参数 表示“没有更多了”
一切 Lisp 程序都是这张图里的东西:操作符永远站在括号内的第一个位置,后面跟着参数。C 语言里写成 4 == (2 + 2)的判断,在这里写成(= 4 (+ 2 2))。这种前置记法取消了全部歧义,代价是把人类习惯的中缀顺序整个翻转。求值器的工作方式可以拿一行例子走一遍:(+ (* 2 3) (/ 8 4))。最外层是一张以 + 开头的表,求值器先求值内层两张表:(* 2 3)得 6,(/ 8 4)得 2,再把 + 作用于 6 与 2,交出 8。全程不需要优先级表,不需要查算子结合性,括号的嵌套本身就是求值顺序。条件、递归、高阶函数在这门语言里都是原生的:条件用分支原语表达,循环用递归代替,函数可以作为参数传给另一个函数,也可以作为结果被返回。Fortran 程序员用 DO 循环扫数组,Lisp 程序员用递归剥表,两种循环形状背后是两种世界观:前者相信计算是遍历一块已知大小的土地,后者相信计算是剥开一颗不知道有几层的心。人类为此付出的代价是阅读时的栈深度:每深入一层括号,就要记住一层尚未闭合的上下文,表达式嵌套五六层之后,多数人要靠手指着括号数。括号嘲讽持续半个世纪,根子在这里:机器最舒服的形状,恰好是人脑最不舒服的形状。后来的语言设计者花了几十年在这对矛盾里找中间道路:缩进代替括号,类型标注分担记忆,中缀外衣包裹前置内核。每一种缓和都是交易,用解析器的复杂度换阅读者的轻松。Lisp 把交易推到极端:解析器的复杂度降到接近零,阅读的负担全压在人眼上。这个极端位置让它永远小众,也让它永远清晰——任何想理解“程序的本质结构长什么样”的人,最终都要回到这满墙括号前站一会儿。麦卡锡实验室的 IBM 026 键控穿孔机还在语法上留了一道物理印记:那种穿孔机的键盘上没有方括号。麦卡锡原本设计过一套更干净的记法,设备短缺迫使语言长成满墙圆括号的模样。批评者抓住这一点,把 Lisp 的形状说成设备妥协的化石。这话对了一半:括号的泛滥确属偶然;但“程序即数据”的同像性(homoiconicity)与括号多少无关,即便换成方括号,代码可以被当作表来改写的性质也不会改变。
词汇里还埋着另一枚硬件化石。car 与 cdr 这两个让几代新手困惑的名字,来自 IBM 704 汇编的两条指令:取地址寄存器内容(Contents of Address Register)与取减量寄存器内容(Contents of Decrement Register),各自抓取 36 位指令字里一段 15 位字段。一个 Cons 单元的左右两半,当年在 704 上正好各占一个这样的字段。语言里最常用的两个动词,是机器指令集的直接翻版。后人学 Lisp 先背 car/cdr,背的其实是 1958 年一款机器的字长。S-表达式的递归定义还有一层很少被点破的含义:它与 Cons 链的表示能力完全对齐,两者都能表示任意二叉树。从纸面记法到内存布局,中间没有翻译损耗,这是 Lisp 解析器异常简单的原因,也是 S-表达式后来溢出 Lisp 本身的原因:通信协议、配置格式、WebAssembly 的文本表示,都借用过这套括号加前置的写法。人们嫌弃括号,却不断重新发明括号,因为用嵌套结构表示嵌套思想,目前仍没有更省的办法。
M-表达式的命运最能说明这门语言的性格。麦卡锡设想程序员写 M-表达式,机器把它转成 S-表达式执行;拉塞尔的解释器跑起来之后,程序员发现直接写 S-表达式更顺手,M-表达式那层数学外衣从此无人问津,只有霍勒斯·埃尼亚(Horace Enea)的 MLisp 与沃恩·普拉特(Vaughan Pratt)的 CGOL 短暂续过它的命。设计者规划的“人写优雅式、机跑括号式”两层结构,被使用者一票否决,合并成了一层。这里留下一份 M-表达式的标本:关联查询函数写成 assoc[x;y] = eq[caar[y];x] -> cadar[y];T -> assoc[x;cdr[y]],箭头分隔条件与分支,大写 T 表示“其余情况”。同一段逻辑的 S-表达式版本是一串嵌套括号,机器读起来毫不费力,人读起来需要数括号。程序员选择了后者,因为与求值器共用一套形状带来的便利,超过了数学外衣的可读性。同像性不是设计出来的,是程序员用脚投票投出来的:当代码与数据被迫共用一套括号,元编程就不再是特性,而是默认状态。一个 Lisp 程序检查另一个程序,如同检查一张表;生成一段新代码,如同拼接一张表。宏系统、自托管编译器、读取—求值—输出循环(REPL),后来都被追认为 Lisp 的开创,但它们的源头是同一个事故:过渡用的记法喧宾夺主,永久地住进了语言的心脏。
代码与数据的边界,在 Lisp 里只隔着一枚撇号。同一张表(+ 1 2),不加修饰地写下,求值器把它当作调用:请函数 + 消费 1 与 2,交出 3;前面加一枚撇号写成 '(+ 1 2),它就被冻结成纯数据,一张装着三个元素的表,不执行、不求值。eval 与 quote 是互逆的两个动作:quote 把代码冻成表,eval 把表解冻成代码。程序可以在运行中途用 cons 现拼一张表,再把它递给 eval 执行,等于在程序运行时现场写程序。麦卡锡最初假定的原子朴素到近乎简陋:无穷多个可区分的符号,每个是“大写拉丁字母与数字、夹带空格”的字符串。后来的方言往原子家族里添了字符串、浮点数、向量,定义不断放宽,撇号的语义从未改变。REPL 把这种能力交到每个终端用户手里:读入一行 S-表达式,求值,打印结果,循环往复。程序员与语言之间不再隔着编译、链接、装载的整套仪式,想到一段逻辑,敲进去立刻看到答案。交互式编程的全部传统,从这里起头。
一个最小的例子可以感受这种“代码即表”的质地。下面这段示意代码构造一张表、取出表头、并把一段数据当作代码求值,全程只用 cons、car 与 eval 三个原语:
;; 构造:(cons 'A '(B C)) 得到表 (A B C)
;; 取头:(car '(A B C)) 得到原子 A
;; 数据即代码:(eval (list '+ 1 2)) 得到 3
;; 程序把“(+ 1 2)”这张表递给求值器,
;; 求值器把它当作一次函数调用执行。
cons 家族很快长成一整套原生词汇:list 把多个元素装成新表,append 拼接两张表,member 在表里查找元素并交出命中的后半截,assoc 在键值对的关联表里按名字取值,symbolp 与 listp 分辨手里的东西是原子还是表。几个调用实例足以建立手感:(cons 1 '(2 3)) 得到(1 2 3),(car '(1 2 3)) 得到 1,(cdr '(1 2 3)) 得到(2 3)。用今天的眼光看,这是一套极简的容器库;用 1958 年的眼光看,它是第一套把“符号集合”当作一等公民的操作系统:家庭关系、语法规则、棋盘状态,都先变成表,再交由这十几个原语搬运。程序员不再为每种数据形状发明轮子,形状只有一种,操作形状的动词也只有一小把。Lisp 程序的短小常让初学者误以为它简单,熟手才知道短小的代价:所有的复杂性都被压进嵌套,读程序等于在脑内运行求值器,一层层剥开括号。
1960 年 4 月,麦卡锡把这套东西写成论文,刊于《美国计算机学会通讯》(Communications of the ACM),题为《符号表达式的递归函数及其机器计算,第一部分》。论文形式化了 S-表达式,给出了元循环求值器的写法,展示了只用少量简单算子加一套函数记法,就能建成图灵完备(Turing-complete)的算法语言。值得注意的是,这篇“第一部分”是它唯一的姐妹篇,第二部分从未发表。一个语言的完整理论地基,只用一篇论文就交了卷,此后六十年再没有人需要重写它的语义起点。
谁来倒垃圾
如果说括号只是改变了程序的外形,那么自动内存管理改变的是编程的责任划分。1958 年的规矩是:程序员申请一块内存,用完亲手归还,漏还一块,机器的可用空间就少一块,直到程序被不断增长的垃圾撑死。在符号处理的世界里,这条规矩近乎酷刑:表处理程序每秒制造大量临时表,推理一步,中间结果生灭一批,程序员若要手工追踪每一只 Cons 单元的生死,写程序的时间会大半花在记账上。MIT 研究生丹尼尔·爱德华兹(Daniel Edwards)在 1960 年的 LISP I 里写出了第一个垃圾回收器:程序员只管分配,不管归还,机器自己定期找出不再被引用的单元,收回重用。史述里有一句平淡的评价,值得把分量称足:这个回收器“使得在通用计算机上运行 Lisp 变得可行”。没有它,符号程序的内存需求是条没有封口的增长曲线,跑一会儿就把 704 的几千字内存吃光,Lisp 将只是一门纸面语言。爱德华兹的名字很少出现在流行史里,但 Lisp 从数学定义变成可用工具,拉塞尔的解释器是第一步,他的回收器是第二步。两步都发生在 1960 年之前,此后六十年的自动内存管理史,都是这两步的续写。
今天的读者很难体会这个举动在当年有多冒犯。机器时间按秒计费,内存按字计费,一个自动回收器意味着程序要为“整洁”支付双份开销:回收器运行时程序必须停下,堆里还要常年养着一堆尚未回收的死单元。对 Fortran 阵营的工程师来说,这近乎道德问题:他们的编译器为每一个寄存器的分配绞尽脑汁,目标是让机器少做一次多余动作;而 Lisp 阵营居然主动要求机器去干与计算无关的家务。机房管理者的账本摆在那里:704 的内存以千字计,回收器的标记位与空闲链表本身就要占掉一块,出一次回收全机停顿,交互用户在终端前干等。自动内存管理在 1960 年不是显而易见的进步,它是一项税,税率写在每一次停顿里。Lisp 愿意交这笔税,赌的是程序员的时间比机器的时间涨得快,而符号推理的程序员根本交不起手工记账的另一种税:他们的表在运行中生灭,中间结果的寿命以毫秒计,手工追踪等于让推理的每一步都背着一本账。两笔税摆在一起,Lisp 选了交给机器的那一笔。这个赌局的判决下达得很慢:Java 在 1995 年把自动回收带进工业主流,Python 把它带给科学家,中间隔了三十多年。Lisp 在 1960 年迫使业界第一次面对自动内存管理这个事实本身,就是它留给后世的债务凭证,至于回收算法具体怎么标记、怎么清除,那是卷五要讲的另一段故事。
反对的声音还有第二路,来自语言审美。ALGOL 阵营在 1960 年拿出块结构、词法作用域、递归过程的标准答案,语法有着数学论文般的体面;Lisp 的括号在他们眼里是未开化的记号,car/cdr 是方言,M-表达式的死亡被当作“连设计者自己都放弃体面”的证据。第三路批评最实际:Lisp 解释器慢。拉塞尔的 eval 是逐表解释,函数调用一层套一层地展开,速度与 Fortran 编译出的机器码不在一个量级。1962 年,蒂姆·哈特(Tim Hart)与迈克·莱文(Mike Levin)在 MIT 用 Lisp 自身写出第一个完整的 Lisp 编译器,编译出的函数与解释执行的函数可以在同一个会话里自由混用。这种增量编译模型在当年是新鲜事:程序员不必在“全解释”与“全编译”之间二选一,调通的函数逐个编译沉淀下来,正在调试的部分继续解释执行,两种形态在同一个堆上共存。它没有堵住批评者的嘴:编译后的 Lisp 依然比同等 Fortran 程序慢,符号程序跳跃式的访存模式本就不合 704 的胃口。但它把 Lisp 从“解释器玩具”变成了可以交付的工具,语言第一次有了方言生长的底气。
方言的分化几乎立刻开始。LISP 1.5 由麦卡锡等人在 MIT 推出,成为第一个广泛发行的版本;MIT 的 MAC 计划在此基础上做出 MACLISP,跑在 PDP-10 与 Multics 上(名字里的 MAC 另有所指,既无关后来的 Macintosh,也无关麦卡锡本人);BBN 为 TENEX 系统写的 Interlisp 被 Xerox 接过去,人称“西海岸 Lisp”,与东海岸的 Maclisp 分庭抗礼。1963 年,哈特提议给 LISP 1.5 增加宏,代码生成代码的能力第一次有了正式的语法入口。东西两岸的竞争持续了十几年:一方背靠 MIT 的分时系统与黑客文化,一方背靠施乐帕洛阿尔托研究中心(Xerox PARC)的图形与交互传统,函数定义、作用域规则、库函数在两边渐行渐远。1975 年,杰拉尔德·萨斯曼(Gerald Sussman)与盖伊·斯蒂尔(Guy Steele)推出 Scheme,第一个采用词法作用域并保证尾调用优化的方言,语言的理论血统在这里回流了一次 λ演算。1980 至 1990 年代,斯蒂尔、斯科特·法尔曼(Scott Fahlman)、理查德·加布里埃尔(Richard Gabriel)、大卫·穆恩(David Moon)等人把各家方言收拢成 Common Lisp,1994 年定为美国国家标准 ANSI X3.226-1994。收拢是有代价的:标准庞大到几乎没有实现能全盘吞下,Lisp 的统一以“统一成一个大到没人能完全实现的标准”告终。方言史在这里显出它的两面:同像性让每个人都能长出自己的语法,代价是谁也管不住语法的生长。
把三路批评并排放回 1958 至 1962 年的语境,会发现它们每一路都站得住。当时的机器内存以千字计,CPU 按秒租,程序员相对便宜,自动回收与解释执行是在最贵的生产资料上铺张;IPL 已经能用,λ演算的数学之美不能当机器时间花;Fortran 的效率神话如日中天,任何慢语言都要先证明自己有活下去的负载。Lisp 没有接这个辩题,它绑死了一个 Fortran 处理不了的负载:符号推理。定理证明、自然语言解析、棋类博弈,这些任务的输入输出天然是表,Fortran 的数组与循环在它们面前无处下手。到 20 世纪 60 年代中期,它取代所有竞争者,成为人工智能研究的通用工作语言:在它里面运行的,有证明定理的系统、解析句子的系统、下棋的系统。争议没有消失,只是被悬置:批评者在效率上依然正确,Lisp 在领地上已经无法替代。这种“正确但无关”的悬置,是技术史上反复出现的格局:一种设计在旧的记分牌上全输,在新的记分牌上全赢,而新的记分牌要很多年后才被承认是正式比赛。
括号的蔓延与清算
领地的扩张速度超出所有人预料。1970 年,特里·维诺格拉德(Terry Winograd)用 Lisp 写出 SHRDLU,把自然语言理解装进运行的程序;20 世纪 70 年代中期,爱德华·费根鲍姆(Edward Feigenbaum)在斯坦福的团队用 Lisp 写出专家系统 MYCIN。当专家系统热潮把符号推理变成一门生意,产业界为这门语言造了整台机器:Lisp 机器,一种只运行 Lisp 的专用计算机,占满一个房间,价格也占满一张预算表。三家 Lisp 机器公司加上数家 Lisp 编译器公司,一度构成完整的商业生态,通用机器的厂商只能在门外看着。这是符号主义商业化的顶峰,也是坠落前最后的光。
清算发生在硬件价格表里。1987 年前后,Sun 工作站与 DEC VAX 等通用机器的性能追上了专用 Lisp 机器,价格却只有后者的五分之一左右。买一台 Lisp 机器的钱可以买五台通用工作站,后者还能跑 C 与 Unix 生态的全部软件。Symbolics 的营收在 1987 年后断崖式下跌,1990 年申请破产保护,与之相伴的是押注人工智能专用计算机的公司一家家倒下,第二次人工智能寒冬拉开帷幕。Lisp 机器公司的倒下常被讲成“Lisp 输了”,这个讲法潦草了。输掉的是专用硬件的商业模式:通用芯片的规模效应碾过了为单一语言定制的体系结构。Lisp 机器上跑的 ZetaLisp 本就是 Maclisp 的直系后代,血缘最近的方言反而替通用阵营验证了一件事:语言的思想不需要专用的硅也能活。Lisp 作为语言没有随机器进坟墓,它的发明物开始向外扩散,清单很长:垃圾回收进了 Java 与 Python,REPL 进了几乎所有动态语言,高阶函数与闭包成了标配,动态类型让脚本语言得以轻装上阵,宏的思想在卫生与非卫生两个方向上被反复重新发明。说 Lisp“输了”的人数的是机器的销量,说 Lisp“扩散了”的人数的是思想的后代。两本账都成立,取决于数的是哪一栏。扩散的名单还可以拉得更长:编辑器 Emacs 里嵌着一整门 Emacs Lisp,几代程序员用它把编辑器改造成操作系统;各团队内部的小型领域语言,从测试描述到部署流水线,反复验证着同一个经验——凡是需要被工具检查、变换、生成的结构化表示,最后都会长成 S-表达式的样子。宏的思想也没有死,它只是换了名字住进各处:代码生成器、模板引擎、注解处理器,每一个都在做 Lisp 程序员 1963 年就用宏做的事:把写程序的程序,写成程序。1994 年,Common Lisp 被定为美国国家标准,距离拉塞尔在 704 前的那个周末过去了三十四年。括号没有消失,它只是搬进了每一门后来者的身体里。
回头看,Lisp 的形状是它所处约束的精确拓片,而约束有两头。一头是人类一侧:人脑的工作记忆装不下寄存器分配与内存记账,符号推理的程序员尤其装不下——他们的对象本就是流动的信念与规则,手工内存管理会把推理程序写成记账程序。Lisp 把这部分认知负担整个接过去:同像性让“谈论程序的程序”与“谈论数字的程序”用同一种语法,自动回收让程序员永远不必为 Cons 单元的生死停下思考,REPL 让试错的循环短到一次回车。另一头是硬件一侧:704 的字长、026 穿孔机的键盘、按秒计费的机时,每一处都在语言里留了疤——car/cdr 是字长的疤,括号是键盘的疤,三十年被嘲笑的缓慢是机时定价的疤。卷四的主题正是这样两头的拉扯:人类认知带宽装得下多少,硬件表达允许得多精细,语言就只能站在两者妥协的位置上。Lisp 的全部设计可以读成一句话:在硬件表达极其昂贵的年代,它选择把昂贵留给机器,把便宜留给人脑,而当时几乎所有同行都选了反方向。
这句话有一个可被反驳的对手盘:Fortran 的选择方向相反,它把昂贵留给人(科学家学穿孔卡、手排循环、背诵存储顺序),把便宜留给机器(编译器榨干每一分性能)。两种妥协都活了下来,各自守着不同的领地:数组计算归了 Fortran 一系,符号操作的思想归了 Lisp 一系。Lisp 用半个世纪的扩散证明,编程语言史上最长寿的创新不是某一套语法,而是第一次把“机器替人记账”当作天经地义——从那之后,每一代新语言都要回答它提出的问题:这一次,你打算替程序员记住什么。
第 035 章 1959:COBOL——商业账簿与英语语句的固执
五角大楼里的买家会议
1959 年 5 月 28 日,五角大楼。战后的商业繁荣把会计、工资、库存这些事务处理的需求推到了机器面前,企业发现账本的增长速度已经甩开了人手的极限。国防部数据系统研究处主任查尔斯·菲利普斯(Charles Phillips)坐在一排计算机制造商代表对面,听他们陈述同一个诉求:造一种大家共用的商业编程语言。菲利普斯有充分的理由认真听——国防部当时运营着两百二十五台计算机,订购单上还压着一百七十五台;这些机器来自不同厂商,每台说着自己的语言,每份新程序都要从头编写。就在一个多月前,宝来公司的计算机科学家玛丽·霍维斯(Mary K. Hawes)刚刚召集过一次预备会,讨论创建面向数据处理的通用语言;制造商代表团的陈述让她与菲利普斯达成了共识——这位主任当场认为,代表团“彻底理解”了国防部的问题。他答应出面赞助,还把起草议程的任务交还给代表团——让提需求的人自己写出需求清单,这份会议纪要因此成了行业痛点的第一手档案。会议之后是一条压缩到极限的时间线:短期小组起草规范,各方征询意见,次年四月 COBOL 60 报告正式提交——一年之内,从痛点清单到语言标准。参会的代表名单横跨整个行业:制造商、联邦机构、用户单位,每一家都带着自己的方言与账本来——这几乎是小半个计算机产业在一张桌子上点名。这次会议催生了一个名为 CODASYL 的委员会——全称展开是“数据系统语言会议”,一个由制造商、用户与政府代表共同组成的常设联合体,通用商业语言 COBOL 的全部制度框架在两天之内搭起了骨架。新语言的名字随后定下:COBOL,面向通用商业的语言——“通用”二字是它存在理由的全部:跨机器、跨厂商、跨行业,谁也不许把它变成自家的方言。委员会的产出机制也颇具时代特色:执行起草的是精干的短期小组,草案完成后向各厂商广泛征询意见,再汇总修订——语言第一次以准公共文件的方式被起草,而不是某家公司实验室里的内部产物。
推动这场会议的另有一组冰冷的数字。1959 年的一项调查发现:任何一个数据处理装置,编程的平均成本高达八十万美元,而把既有程序翻译到新硬件上的开销同样令人望而却步。在计算机行业,软件还不是一个可以买卖的产品——20 世纪 50 年代没有人想到软件能卖钱:硬件才是商品,程序是买了机器之后必须忍受的附属劳动,赠品没有报价,也就没有质量标准。买方的处境因此格外清楚:今天为 A 公司的机器写的整套账目系统,明天换 B 公司的机器就要全部重写;而机器的更新换代由技术进步决定,由不得财务部门。全世界最大的计算机买家终于受够了——国防部把“可维护、可移植”写进了对商业软件的采购要求,这不是技术倡议,是一纸采购条件:供应商想要国防部的订单,就得先联手解决语言割据。值得注意的是这份要求的时代重量:彼时“软件维护”甚至还不是一门有名字的学问,一份采购文件抢在学科前面,把十年后才被工程界普遍讨论的问题变成了付款前提。
在 COBOL 出现之前,商业世界的计算机在用什么写程序?答案令人尴尬:科学计算界好歹有了 1957 年问世的 FORTRAN,商业记账界的主力仍是各家机器的汇编语言。FORTRAN 提供定点与浮点运算,擅长数值公式,却不擅长处理文本与报表——账目世界里满是需要心思的东西:姓名地址要排版,金额要对位,报表要划线,批量记录要循环打印;FORTRAN 的武器在公式的世界里锋利,搬进账房立刻锈住。这些在当时的语言版图上没有位置。于是一个荒诞的行业形态延续着:银行与保险公司雇一屋子程序员,用最底层的汇编语言,逐条机器指令地手写对账、算薪、开票的程序;每家厂商的汇编互不相通,同一套工资逻辑在五台机器上就是五个平行世界。软件彼时还算不上一件商品——行业早期的共识是硬件才是产品,程序是你买了机器之后不得不忍受的附属劳动。没有软件市场,就没有软件质量的报价体系;八十万美元的编程成本,就是这样在无报价、无竞争、无标准的生态里自然长出来的。
割据还有第二重代价,落在买方的锁链上。每家厂商的专有语言都是一根缰绳:客户为 A 公司机器写的全部程序,构成了他更换 B 公司机器时的沉没成本——语言割据越久,锁定越深,厂商越没有动力统一。1959 年的那次调查把锁链的价码标了出来:平均八十万美元的编程成本之外,翻译成本同样高昂。打破锁链的力量不可能来自厂商内部的善意,只能来自一个大到不容拒绝的买家——国防部的采购条件,本质上是把锁链公开标价,再宣布不再支付。
让会计读懂程序:一场语言设计的豪赌
CODASYL 委员会里坐着各家的工程师,也有格蕾丝·霍珀(Grace Hopper)——她在第 030 章的故事里已经登场:她主持的 FLOW-MATIC 语言在几年前就验证了一个大胆的假设,程序可以写得让不懂机器的人大致读懂。委员会把这个假设推到了语言设计的正中央,定下了 COBOL 的第一设计准则:尽可能英语化,让没有计算机知识的老板也能看懂程序。把“可读性”列为显式设计目标,这在当时的语言版图上是首创——FORTRAN 面向写公式的人,Lisp 面向摆符号的人,只有 COBOL 面向看账本的人;三种语言的三种读者,划出了三种认知负荷的边界。这个假设并非空想——霍珀此前的编译器与面向数据的语言已经演示过,英语式的语句可以被机器执行,商业人员也确实读得懂;她作为技术顾问把这条经过验证的路线带进了委员会。加法不写加号,写 ADD;乘法不写星号,写 MULTIPLY;一条赋值语句读起来像一句祈使句——MOVE A TO B,把 A 送到 B。固执写进了语言的每一寸:语句必须完整、步骤必须显式、歧义必须消除——商业账本容不下任何一行需要猜的代码。在效率至上的工程师看来这近乎行为艺术:把加号写成四个字母的单词,机器没多算一步,人却多打了好几个键,程序篇幅翻着倍地膨胀。反对的声音完全合理——语言的第一个用户毕竟是人机之间的转录者,冗长的语法是对转录者时间的征税。委员会的回答同样冷静:商业程序的寿命以十年计,写它时的一次冗长,换它被读十年的顺畅,这笔账在账房里从来不难算。英语化是一张两面的契约:读的那一面是资产,写的那一面是负债;COBOL 的设计者把宝押在前者,赌的是商业程序一生中被读的次数远多于被写的次数——这个赌注后来被证明押对了,只是赢的方式与承诺的字面略有出入。
委员会把赌注押在了另一头。商业程序与科学程序的读者不同:科学计算读的是公式,数学符号天然高效;商业程序处理的是账簿、工资单、库存清单,它们的最终读者是会计、审计员与经理——这些人的语言是英语,不是运算符。COBOL 的第二个准则由此而来:数据是这个世界的真正主角。语言被明确划分成几个部(DIVISION):数据部(DATA DIVISION)专门描述数据的形状——记录怎么组织、文件怎么排布、每一位数字是字母还是数值、小数点在第几位;过程部(PROCEDURE DIVISION)则像一份操作手册,一步一步写明对这批数据做什么。程序的静态描述与动态步骤被制度性地分开——商业世界里“账本长什么样”与“账怎么记”本来就是两份文件,语言照着业务的形状切分自己。这套切分在今天仍能看到直系后裔:数据库的建表语句、接口的数据定义文件,延续的都是数据部的直觉——先把数据的形状写清楚,再谈怎么处理。这套结构在今天看来冗长笨重,在 1959 年,它是把程序当作正式商业文书来对待的第一份认真设计。四个部各自对应一种关注点——名字与作者、机器与环境、数据与格式、动作与流程——现代程序动辄分出的元数据、部署配置、数据模型与业务逻辑,不过是这四个部的孙辈。
委员会里的战争与和平
CODASYL 委员会的组成决定了它的气质:这不是几家友好厂商的技术沙龙,而是一场在买方压力下勉强同桌的谈判——每个制造商都带着自家的语言与自家的客户盘算。内部争吵不断,一则流传甚广的轶事说,某家公司对新语言的前身方案不满至极,代表做了一块刻着新语言名字的墓碑,径直寄到五角大楼为它“送葬”。委员会里也不乏为这门语言立传的人——设计者名单上后来被逐一记入史册:霍珀之外,还有琼·萨梅特(Jean E. Sammet)、威廉·塞尔登、格特鲁德·蒂尔尼、霍华德·布罗姆伯格、霍华德·迪斯康特、弗农·里夫斯们。萨梅特后来写出了领域内第一份全面的语言综述,把一门被嘲笑啰嗦的语言,连同它的同行们一起,写进了正史。轶事的细节无从逐一考证,但它能在工程师群体里流传几十年,恰恰因为所有人都见识过委员会里那种你死我活的方言之争——每种既有语言背后都站着一个商业帝国,让帝国们投票写字典,比让它们统一度量衡还难。但买方的重量压住了所有分歧:国防部是那个时代最大的计算机采购方,它要的从来不是一个优雅的语言,而是一个能让各家机器读同一种账本的语言。1960 年 4 月,委员会正式向 CODASYL 提交 COBOL 60 报告——从五角大楼会议到语言定稿,不足一年。语言由买方发起、多厂商共同签署、以公开报告的形式发布——语言标准化自此成为产业惯例,此后每一次语言标准之争,都在重复这套由 COBOL 首创的流程。此后这门语言进入少见的稳态修订节奏:六十年间陆续推出后续版本,最近的大修订已是新世纪之后的事;对一门商业语言而言,半个多世纪的规范连续性本身就是资历。报告本身也是一份公开文件——它不锁在哪家厂商的保险柜里,任何机构都可以照着它实现自己的编译器。语言规范先于实现而公开,这个在今天看似寻常的做法,在厂商各怀心思的 1959 年是一次制度创新:语言从此可以被检验、被比较、被竞相实现,而不必被某一家慢慢独占。此后美国各厂商与政府机构的机器陆续配上 COBOL 编译器,其他大型机构见状跟进采用,商业数据处理的巴别塔,被一份采购文件悄悄推平了。而巴别塔倒得这么快,恰恰因为它倒得这么早——语言生态的每一次重排,难度都随存量递增;1959 年的商业软件存量还薄得可怜,供应商们才付得起推平的价钱。至此,计算世界形成了三个各霸一方的语言王国:科学计算归 FORTRAN,商业账务归 COBOL,符号与智能探索归新生的 LISP——三足鼎立的格局各自沉淀,互不越界,而每个王国的疆界,都对应着各自用户承受得起的那种认知负荷。三个王国几乎从不交战——FORTRAN 与 COBOL 的读者不同、机器不同、问题不同,连竞争都显得多余;语言的疆域由认知负荷的分工划定,这条规律在 1959 年就已经写下了它的第一个案例。
CODASYL 委员会的内部谈判并不体面。各家带着各自的既有语言入场,都希望新语言尽量像自家那一套;分歧一度激烈到那则著名的轶事——对主席不满的某公司代表做了一块刻上新语言名字的墓碑,寄到五角大楼表达哀悼。买方的意志最终成了裁决者:国防部不在乎哪家的方言获胜,它只在乎结果统一。把 COBOL 的扩散模式与同时代其他语言摆在一起,两条路径的差异一目了然:FORTRAN 由 IBM 一家独力推行,实现快、落地快,但语言的主权始终属于一家公司;COBOL 由多家厂商在买方压力下联合制定,谈判拖了半年,换来的却是没有任何一家可以独占的语言——企业客户第一次拿到一份不构成锁定条件的程序载体。学术界的第三条路径此刻也已在路上,它选择了与两者都不同的航向:不属于任何公司,也不服务任何生意。委员会的技术裁决则呈现出一种务实的平庸主义:控制结构比 FORTRAN 还要简单——商业逻辑不需要精巧的循环嵌套,需要的是清晰;真正让它站住脚的是另一手:输入输出与报表。商业程序的大半时间都在读记录、打表格、分类归并,COBOL 把这些最枯燥的动作做到了开箱即用——工资支票、对账单、库存表,一条语句下去就是一份成品。数据描述却大大扩展——除了数组,引入了记录与文件,因为商业数据的天然形状就是“文件套着记录套着字段”。这个形状与当时的商业作业方式严丝合缝:账目按批处理,工资单按月打印,库存按日汇总——COBOL 对批量记录与循环打印的熟练,正中企业数据处理的核心场景。加减乘除写成英语单词,条件与循环写成短句,整份程序读起来像一份写给文员的操作手册。这套设计的每一处都在向两个读者群同时喊话:对机器说“你照着做”,对会计说“你看得懂”。
设计的边界同样划得清醒。英语化降低了读的门槛,却降低不了写的门槛——把一段业务逻辑准确翻译成程序,难度在逻辑本身而不在符号;指望会计亲手编程的愿景,在此后的半个世纪里被各种“自然语言编程”的尝试反复重温,也反复落空。COBOL 真正兑现的是一个缩水的版本:老板依然读不懂程序,会计与审计员却真的能审计程序——数据都在数据部里列得明明白白,每个字段的名字与格式都对得上账目科目。从“让人人编程”退守到“让业务可审计”,这一步退让反而成就了 COBOL 的全部生命力。
四个部:把程序写成账本
COBOL 程序的结构像一份正式的商业文件,从上到下分成几个部:标识部声明程序的名字与作者,环境部说明程序在哪类机器上运行,数据部登记所有账本的格式,过程部逐条写下记账动作。这种切分把商业程序的两个核心问题——账本长什么样、账要怎么记——强制写进了语言的骨架:
COBOL 程序的骨架(商业文书的语言化)
标识部 IDENTIFICATION DIVISION —— 这份程序叫什么、谁写的
环境部 ENVIRONMENT DIVISION —— 跑在什么机器、文件挂在哪里
数据部 DATA DIVISION —— 账本的格式
├─ 文件 ── 记录 ── 字段(类型、位数、小数点位)
└─ 工资单.记录: 工号 | 姓名 | 基本工资 | 扣款 ...
过程部 PROCEDURE DIVISION —— 记账的动作
├─ 打开工资文件
├─ 读一条记录
├─ ADD 基本工资 TO 应发合计
└─ 写回、下一条,直到读完
数据部是 COBOL 最有野心的一笔,它的遗产一直活到今天:字段要起名字、要声明类型与宽度、要写清小数点位置——这套“先签格式合同再动手处理”的纪律,正是此后数据库建表语句、通信协议字段定义、文件格式规范的共同祖先。数据先于过程,接口先于实现——COBOL 在 1959 年就替软件行业把这句话写进了语言的骨架。四个部的划分另有一层安静的贡献:它给商业程序的写作立了模板——先声明数据,再写过程。这个顺序被此后几乎所有商用开发沿用;数据定义先行,在今天叫模式先行、叫接口先行、叫契约先行,名字换了几轮,方法论的第一页仍是 1959 年写下的。在此前的语言里,数据是一堆匿名的数字格子;COBOL 把数据组织成记录与文件的层级——一条工资记录由工号、姓名、基本工资、扣款几个字段组成,字段有名字、有类型、有精确到位的宽度声明。一条工资记录的字段声明读起来像一张规格表:工号,五位数,数值;姓名,二十个字符,字母;基本工资,七位数,末两位隐含为小数——每一位都被写死,小数点甚至不占字符位,它是约定的一部分。商业计算对“分”的执念,被语言直接吸收进了数据定义:金额要精确到分,位数错了就是错账;COBOL 让程序员在数据部里就把这些格式写成合同,过程部只负责按合同搬运与运算。一段典型的过程部读起来近乎白话:打开文件,读一条记录,把数额加进合计,写回,关闭——每一步都是一句以动词开头的英语祈使句,打开、读取、写入、运算、执行,语言把商业流程会用到的那几十个动词做成了一整套词表,商业流程的每个动作都能在语句里找到一模一样的对应物。语句旁还常配着编号与注解,程序自身就是它的操作手册——商业文书的传统,从纸面一路延续进了代码。程序的第一读者因此变了:审计员可以只看数据部,核对账目的定义是否符合财务规则,而不必读懂一行过程——语言的读者被扩展到了程序员之外。
冗长的胜利:谁在为固执付账,谁在享用它
COBOL 的缺点从诞生第一天就被同行取笑:一个什么都不做的空程序,也要写出约五十个符号的架子;一句简单的算式写成英语从句,纸面上拖出半行;同行给它起了无数绰号,断言这种文牍气十足的语言很快会死。半个多世纪过去,它没有死。行业口径的估计是:全球金融系统底层仍运转着数千亿行 COBOL 代码——以每行几十个字符计,这是人类写下的最大规模单语言语料之一,规模大到没有任何一份文档能够完整描述它;约四成以上的银行系统仍在用它,绝大多数自动柜员机交易背后跑着 COBOL 程序。对大众而言,它是一门“从未见过、却每天都在用”的语言——每一次刷卡、转账、领薪水的动作,都在触发它的某一行语句;大众对它的无知,恰恰是它成功的证明:它把自己藏进了日常,藏得比任何一门明星语言都深。普通人认识 COBOL 的唯一渠道是故障新闻——媒体的每一次报道都伴随“竟然还有这么多系统在跑”的惊叹;大众对这门语言的认知负荷为零,这正是它的设计在反方向上的彻底胜利——它把全部负荷转移给了账本与值守者。工资单、保险理赔、信用卡清算、政府税务——商业世界最不能出错的那一层,至今压在这门被嘲笑冗长的语言上。
这门语言为什么换不掉?答案藏在它当年的取舍里。商业数据处理的第一要求是账目正确,第二要求是几十年如一日的稳定;COBOL 的冗长恰恰服务这两条——语句啰嗦但无歧义,每一步动作都摊在纸面上,数据格式写死在程序里——啰嗦的本质是把一切显式化,而显式正是可靠的另一种写法;几十年的正确运行本身就是最昂贵的测试报告。替换一套运转了几十年、历经无数次真实账目检验的系统,换来的只是一门更时髦语言里同样功能的重写版——金融业的风险收益账算得比谁都精,重写的风险由储户承担,收益归程序员的名声,这笔账没人签字——签字栏至今空着。监管的要求又在这本账上添了一行:金融系统的程序要能被审计、被追溯、被监管机构理解——一份写了六十年英语语句的程序,恰恰是审计者最不需要重新学习的东西。于是 COBOL 的维护成了新形态的长期工程:会写它的人逐年减少,银行高薪返聘退休程序员的消息隔几年就会出现一轮。一位 COBOL 维护工程师的日常自有其节律:读几十年前的过程部语句,对着一笔对不上的账翻数据部定义,补一个监管部门新要求的字段,跑一遍完整回归,确认那几百万行的账本分毫未错。他们与第 023 章里守着微控制器的工程师、与第 028 章里守着内核的工程师同属一个序列——现代世界的地面上,到处是这类无人知晓的值守者。而 COBOL 那些被嘲笑的冗长,反而成了它跨时代存活的可读性保险——新接手的工程师翻开几十年前写下的过程部,不需要为任何时髦概念查考古注脚,英语语句自己会说话。人才曲线的倒挂比代码的寿命更紧迫:学校不设课,新人不入行,存量工程师老一岁,断层就深一寸——代码还要活几十年,会写它的只剩屈指可数的几届毕业生。课程表的变迁记录了这一切:六七十年代,COBOL 是计算机系与商科共修的标准课;此后它从课表上悄悄淡出——课程表从来是产业重心转移的滞后指标,等它反映过来时,重心已经移走了——而账本的重心从未移动,这正是 COBOL 与它所有批评者之间错位的起点。隐匿在这门语言背后的,是另一批隐匿在视线之外的劳动者——维护账本的程序员,与第 023 章那些维护微控制器的人一样,在无人注视处守着现代金融的地面不塌。
对 COBOL 的评价因此注定分裂成两本账。工程美学的那本上,它是负资产:冗长、老派、无趣,半个世纪的批评者没有说错过一条——这些批评全部成立,今天依然成立。商业可靠性的那本上,它是正资产:在它最需要可靠的领域,它从未失守过。两本账都真实,只是记账的人不同——而这恰恰是本章留下的最后一个提示:评价一门语言,先要问清楚记账的是谁。为写它的人记的账,与为靠它吃饭的人记的账,从来不是同一本。
到了世纪之交,这门语言的身份变得前所未有地微妙。行业调查给出的数字持续令人咋舌:全球金融系统的底层仍运转着数千亿行 COBOL;行业口径显示,四成以上的银行核心系统仍以它为骨干,绝大多数自动柜员机交易要经过 COBOL 代码的处理。工资、保险理赔、信用卡清算、税务申报——商业世界最不允许出错的那一层,至今运行在这门诞生于 1959 年的语言上。围绕它形成一个奇特的人才市场:学校不再开设课程,工程师逐年退休,而银行在系统大修的季节不得不高薪返聘七十岁的老程序员——会写 COBOL 的人的手时价,偶尔超过任何一门时髦语言的从业者。
为什么不换?这是每一代技术评论的必答题,答案也是每一代都相同的三条。其一,正确性已被时间买断:一套跑了几十年、历经无数次真实对账检验的系统,本身就是行业里最昂贵的测试资产,任何重写版本都要从零开始重建这份信任。其二,风险与收益严重不对称:重写的收益是代码时髦,风险是错账——金融业的损益表上,前者可以忽略,后者不能存在。其三,业务逻辑与语言深度缠绕:几十年的规则修订、监管补丁、特殊分支全都织进了那几百万行过程部语句里,没有任何一份独立的文档记录着完整规则——代码即账本,账本即规则。进入云计算时代后,迁移终于开始加速,不少 COBOL 作业被搬上云端,或在外面包上现代系统的外壳;但被搬走的多数是运行环境,账本内核的语法鲜有动摇——环境在换,语言还在,账本继续。固执至此已不再是语言的性格,而是一个行业的性格:它宁可为老程序员付退休返聘的高薪,也不为重写风险开一张空白支票。此后每一波新技术浪潮都宣布过要终结遗留系统,遗留系统却一次次活过了宣布者——COBOL 是这场轮回的第一位主角,此后所有关于“老旧系统何时退役”的预测,都在拿它的寿命当参照系。
这段固执的哲学值得放在卷四的主线里掂量。编程语言的每一次设计,都是对某种认知负荷的反抗:Fortran 反抗的是把数学公式逐条译成指令的负荷,Lisp 反抗的是把思维塞进机器结构的负荷;COBOL 反抗的,是商业世界里程序与账本之间隔着一层行话的负荷——它坚持让程序的形状贴近账本的形状,让记账的人能在程序里认出自己的职业语言。这场反抗没能让老板亲手写程序——业务与编程之间的鸿沟没有因一门语言而填平——但它把鸿沟的宽度从“完全无法沟通”压缩到了“可以审计”。COBOL 的设计者承诺让老板读懂程序,五十年后老板们依然绕开它,可会计能审计它了——这门语言真正的胜利,是把程序的读者从程序员扩展到审计员与监管者;金融世界从不追求最好的语言,它只追求一份五十年没人敢换、也没人换得动的账本。固执在此处以胜利收场,而固执的赎金同样列得清楚:所有使用它的人都要先原谅它的啰嗦;世界答应用最保守的方式,供养这份啰嗦直到永远。永远很长,但账本的寿命更长;金融业对“永不”二字的理解,向来比任何行业都字面。
第 036 章 1960:ALGOL 60——学术纯洁性与后世基因
巴黎的六个冬天日夜
1960 年 1 月 11 日至 16 日,巴黎,一场软件会议的角落里挤进了当时语言学界几乎全部的巨头。一间会议室里坐着一群在各自国家都称得上招牌的科学家:主持者是艾伦·佩利(Alan Perlis),未来第一位图灵奖得主;FORTRAN 之父约翰·巴克斯(John Backus)在场,Lisp 之父约翰·麦卡锡(John McCarthy)在场——ALGOL 60 的报告里能看到 Lisp 的影子,Lisp 的设计里也回应着 ALGOL 的问题,两大传统在同一年代互为镜像;麦卡锡把递归的视角摆上了桌面——递归在符号语言里是天然品,要在算法语言里安家,则要解决存储的全部难题。荷兰人艾兹赫尔·迪杰斯特拉(Edsger Dijkstra)在场,报告的编辑工作落在丹麦人彼得·诺尔(Peter Naur)肩上——佩利主持讨论,诺尔执笔成文,一门语言规范第一次有了正式的“作者栏”。会议的国际性还带着冷战年代难得的体温:铁幕两侧的科学家照常坐在同一间会议室里争论语法的细节,学术合作保持着官方关系冰点以下的通道。他们聚在这里,是要为一种算法语言定稿——ALGOL 60。与会者的国籍横跨大西洋两岸,这个细节本身就是会议的资格证明:把这群人凑到一起的动因之一,恰恰是 ALGOL 58 的失控——各家实现彼此出入,同一个语言长出了好几个样子,再不定稿,规范就要名存实亡。此前的每一门重要语言都是一家公司的作品,而 ALGOL 从 1958 年起就是两个学术团体——美国计算机学会与联邦德国应用数学和力学协会——在苏黎世合作谈判的产物,初版定名 IAL(国际代数语言),旋即改称 ALGOL 58,并已立起几条规矩:赋值用冒号等号以示方向、数组可以有下标、复合语句可以嵌套。从苏黎世到巴黎的十四个月里,ALGOL 58 已被多家厂商着手实现——FORTRAN 的商业成功刺激了所有人,谁都不想在这个新战场上缺席。但它的局限同样写在纸面上:类型贫乏,没有块结构与递归,各家实现彼此出入。巴黎的六天,是要把这些遗憾一次清账。会议的产出将是一份公开发表的规范——一门尚未实现的语言,先拥有了自己的法典;法典的每一个条款都在争吵中表决,而表决记录的每一页,此后都被当成了史料。此前一年半,美国计算机学会与联邦德国应用数学和力学协会已在苏黎世合作产出了 ALGOL 58;巴黎会议的任务是把它修订成一份能传世的报告。六天唇枪舌战之后,报告成文;两年后罗马会议又做了勘误修订——一份语言规范自带一份修订报告,这在当时是学术严谨的象征:语言不是发布即完结的作品,而是可以被持续讨论的活的文本:一份不属于任何公司、不服务于任何商业利益、由国际委员会共同签署的语言规范。它的名字 ALGOL 是算法语言(ALGOrithmic Language)的缩写——命名本身就是宣言:这门语言描述的是算法,不是生意。
这六天谈判产出的语言,此后六十年再没有在哪台主流机器上大获成功过;可今天几乎每一行被写下的代码,语法里都流着它的血。这是那个巴黎一月里发生的事:一群拒绝向机器与市场低头的学者,写下了一份当时没人完整实现的规范——而这份规范,成了后世所有语言默引的祖先。
三件发明:块、作用域与递归
ALGOL 60 带来的第一件发明,是给程序装上了“房间”。块结构允许程序里出现嵌套的代码块——一个 begin 与 end 之间就是一个房间,房间里有自己的变量声明,走进房间变量才存在,离开房间它随之消失。房间可以套房间,内间的变量与外间互不打扰。在这之前,程序是平铺的一堆名字,谁都能改谁,变量名冲突靠程序员自己小心;块结构第一次把“这段逻辑使用的名字只在这段逻辑内有效”写成了语言规则——程序从此有了作用域,变量有了疆界,模块化有了语法地基。块的生灭还顺带解决了一个存储问题:变量随块的进出自动创建与释放,这块内存的自动化管理是此后果链上更庞大机制的最小样本。块与栈的联姻也顺理成章:块的进入就是压栈,块的退出就是弹栈,嵌套的房间就是嵌套的栈帧——编译器只需维护一个栈指针,就能让所有房间的生灭自动有序。设想一段统计报表的代码,外层声明着整张报表的合计变量,内层嵌着一个按列汇总的块,块里声明的临时累加器在离开块的那一刻自动消失——外层的同名变量安然无恙,谁也不曾污染谁。
第二件发明与第一件共生:词法作用域被首次标准化——名字属于哪个房间,由程序文本的结构静态决定,而不是由运行的路径临时决定。读一段嵌套的代码,每个名字的身份一目了然;冲突在结构上就不可能发生——内间与外间各说各话,谁也不必迁就谁的命名。这个词听上去抽象,意思却很朴素:想知道一个名字指的是谁,只要看代码写在哪个房间即可,不必模拟程序的运行轨迹。与它相对的是动态作用域——名字的含义由“谁调用了你”决定,同一段代码在不同调用路径下表现不同。词法作用域让程序可以被静态推理:读者与编译器都能只看文本就锁定每个名字的身份,名字冲突在结构上就不可能发生——内间的房间与外间的房间各说各话,谁也不必迁就谁的命名。它的对手动态作用域并非没有拥护者:在动态规则下,同一段代码今天与明天可以指向不同的对象,程序的行为要追着调用链跑才能确定——读代码的人等于被迫重演一遍执行。两种规则的胜负,本质上是一次认知负荷的分配:巴黎会议选择把负荷交给机器与文本,让读代码的人轻装上阵。这门规则此后成为绝大多数语言的默认,中间曾被动态作用域的方案绕行多年,直到后来的 Lisp 后裔们又把词法作用域请了回来——绕的那一圈弯路,反而验证了巴黎会议当年的直觉。第三件发明最大胆:递归例程被正式纳入语言——过程可以调用自身。今天的程序员对这三种东西熟视无睹,因为此后所有主流语言把它们做成了默认配置;但在 1960 年,它们每一种都要回答一个实现难题:一个允许“自己调用自己”的过程,它的局部变量在内存里该怎么摆?Fortran 干脆禁止递归,就是绕不开这个问题。为 ALGOL 60 编译器的实现,迪杰斯特拉第一次引入了栈——过程每次被调用,它的局部变量压入栈顶;调用返回,弹出作废;递归的深度不再受静态布局限制,只受栈的高度限制。栈这个概念的登场,一举解开了递归与块结构共同背后的存储之谜——此后它成了所有过程式语言的内存骨架,快照般简单,影响却深不见底。递归被标准化之后,教科书里出现了一类此前写不出来的程序——直接照着数学定义落笔的代码。阶乘的定义与实现从此一字对一句:
begin
integer procedure factorial(n);
integer n;
begin
if n = 0 then factorial := 1
else factorial := n × factorial(n - 1)
end
end
几行之内,数学定义与机器执行严丝合缝——这种表达力在禁止递归的语言里,只能靠循环与累加器的堆叠去笨拙地模拟。栈带来的还不只是递归:它让程序的每一次过程调用都拥有一块自己的活动记录,让“调用”这个动作第一次成为语言的一等公民——报告的样板程序本身就写着递归,规范与实现互相印证。
语言还规定了过程可以作为参数传递给另一个过程,参数的传递方式有两种:按值调用——把数值复制一份进去;按名调用——把实际参数的表达式文本,原样替换到过程体里每次出现该参数的地方。第二种方式有一个著名的巧用:写一个泛化的求和过程,把求和项与循环变量都按名传入,每引用一次循环变量,表达式就重新求值一次——求和的上下限、被加的项全由调用者注入。这套技巧后来被称作“Jensen 设备”,它是按名调用展示魔力的样板。
一份规范的另一半:BNF 与它的野心
ALGOL 60 报告的后半部,藏着一枚更深远的地雷:整份语言的语法,用一套形式化的记号逐条定义——这就是巴科斯-诺尔范式(BNF),思想源自乔姆斯基的文法体系、由巴克斯独立发现并用于 ALGOL。这是历史上第一次,一门编程语言的语法被数学式地精确描述:什么是合法的表达式、什么是合法的语句,不再依赖某本手册的行文,而由一组可以逐条核对的规则决定。诺尔还为报告写下了语义的描述——用归纳的方式说明每条语法结构将如何被执行,这是编程语言操作语义的第一个成规模范。此后几十年语言研究的整片疆域——解析器的构造与证明、LL 与 LR 文法的分类、抽象机器与操作语义——都是这份报告投进水里溅出的涟漪。一门语言被写成了可以被证明的对象,程序设计语言研究从此从技艺转向了科学。在巴黎的那六天里,委员会做的事情因此有了超出语言本身的分量:他们示范了一种书写方式——重要的东西,要用形式化的语言来定义。沿着这份报告长出来的研究很快自成一片森林:文法成为可以数学分析的对象,解析器被设计成可以被证明正确的程序;文法的子类被系统化——自顶向下构建解析树的 LL 文法与自底向上的 LR 文法,后者的分类出自克努特之手;IBM 维也纳实验室则把语义整理成抽象机器的形式,操作语义学由此得名。一门语言规范,养活了几十个博士论文的选题与一整个研究社群——这在 1960 年之前没有先例。它还顺手立下了此后语言标准化的全套流程模板:委员会起草、公开报告、多方实现、修订再版——从 C 到 JavaScript 的每一份语言标准,流程的骨架都能在那六天里找到原稿。BNF 则走进了每一本编译原理教科书的第一章,成了讲述语言的人与学习语言的人共同的第一课。
Jensen 设备:按名调用的魔力与深渊
按名调用值得单独拆开,因为它是 ALGOL 60 性格的浓缩样品。按它的规则,过程的形式参数不是值的占位,而是一段会被反复代入的表达式文本——过程体内每引用一次这个参数,调用者写下的那个表达式就重新求值一次。这门机制最漂亮的产物是一个小魔术:定义一个通用求和过程,把“被加的项”与“循环变量”都按名传入——项里引用着循环变量——于是同一个过程,既可以算整数的累加,也可以算函数在区间上的积分近似,只要调用者换一个表达式进去。一份代码,无限种求和。这个技巧日后以提出者约恩·延森(Jørn Jensen)命名,成了每个 ALGOL 教材里必讲的展品。
但展品的背面写着深渊。文本替换意味着表达式会在你意想不到的上下文里被反复求值:调用时写 sum(i, i*2, 1, 10),循环体内每一次对“项”的引用都会让 i 变化一次——求和的结果与你心算的完全不同;想避免意外,就得在调用前先把表达式的值算进临时变量,而这样又失去了机制的灵活性。效率同样成问题:每次引用都要求值,编译器再聪明也得为每次访问生成一段求值代码。魔力与深渊共用同一扇门——规则的表述只有一句话,规则的后果需要整整一章才能讲清。按名调用最终在后续语言里销声匿迹,它的教训却被编译器与语言设计者全部继承:任何“替换文本”式的机制,都要为无限的求值时机负责。许多年后,宏语言的默认方案里仍能看到它的影子,也仍能看到它留下的陷阱。按名调用本身在此后的主流语言里绝迹,它的能力被两条更安全的路径分别继承:宏与惰性求值各取一半。绝迹不代表失败——每一种被废除的机制,都把它的教训写进了下一代的规范。按名调用提出的真问题——参数该在何时求值——在后来的函数式语言里换了名字继续被讨论:按需求值的思路死而复生,只是这一次,求值时机被写进了语言的语义规范,而不是留给调用者踩坑。
纯洁性的代价:没有输入输出的语言
ALGOL 60 的委员会做出过一个让后世瞠目的决定:语言不定义输入输出。报告把这套东西留给了各个编译器与使用者自行处理——理由在委员会内部是充分的:I/O 与设备绑定、与机器相关,把它写进语言会玷污算法描述的纯粹性;况且各方对 I/O 该长什么样意见无法统一。这个决定在学术上无懈可击,在传播上是致命伤:一门不能读文件、不能打印结果的实用语言,每个实现者都得自造一套 I/O——于是同一个 ALGOL 60 程序,在这台机器上能跑,换一家编译器就要改写输入输出部分。为纯粹性放弃的部分,恰好是通用性赖以成立的那个部分;语言的规范越纯洁,实现之间的差异就越刺眼。刺眼是有实例的:FORTRAN 早已把读写语句做进了语言,一份 FORTRAN 程序的输出在任何机器上长相一致;而一份 ALGOL 60 论文附录里的程序,搬到另一家编译器上,第一件要改的就是那些各显神通的输入输出过程——科学论文的附赠代码因此常常只是伪代码,可移植性在最后一公里断掉。对照同年定稿的 COBOL,讽刺更加立体:COBOL 把报表与文件做成开箱即用的强项,靠采购文件强制推广,代价是语言被业务形状绑死;ALGOL 把一切与机器相关的部分扫地出门,换来算法表达的永恒正确,代价是没有任何一间机房能开箱即用。同一年定稿的两份规范,一个向报表低头,一个向数学献身——它们各自得到了自己选择的命运。商业与学术的两个极点,在 1960 年代初的两年里先后定稿;此后语言史的每一步,都是在这两极之间寻找自己的位置——位置这个词用得很准:每一种新语言发布时,都要自报家门说自己站在哪一极、或者离两极各有多远。
商业世界的冷落接踵而至,且步步都有道理。IBM 当时占据着世界四分之三的计算机市场份额,铁了心推行 FORTRAN,对 ALGOL 不予支持——没有最大厂商的背书,语言就失去了最有力的分发渠道。实现稀少:那份精美的报告长期找不到几个严肃的编译器,学者们忙着辩论语法的细节,愿意埋头写实现的人凤毛麟角。用户错位:FORTRAN 的用户是工程师与科学家,他们要的是“能跑”;ALGOL 的拥趸是计算机科学家,他们要的是“优雅”——两种要求本来就不在同一张谈判桌上。结果一边倒:ALGOL 60 在欧洲的大学与研究机构赢得尊重,在美洲的商业市场被 FORTRAN 压得抬不起头;IBM 的机器占据七成半的世界,也就占据了绝大多数程序员的日常。市面上并非没有为 ALGOL 押注的厂商——宝来公司造过带硬件栈的机器,让递归与块结构的运行效率直接由电路保证——但 IBM 凭着机器生态与销售网络的综合实力,把这些挑战者逐一压了下去。语言战争的胜负手常常不在语言之内:一份更好的规范,敌不过一台已经铺进千家公司的机器。一门不属于任何公司的语言,最终也没有任何一家公司有义务让它活下去。
账单的清算:谁在为纯洁性付款
纯洁性的账单分期送到了几处。第一批收款发生在学术界内部:研究者想用 ALGOL 60 教学或实验,就得先容忍各家编译器互不相通的输入输出,再忍受按名调用那些防不胜防的副作用——这些摩擦日复一日地提醒他们,规范与实现之间的鸿沟没有填平。第二批落在美国的商业市场上:FORTRAN 借着 IBM 的机器生态步步为营,ALGOL 的编译器事业在小规模与学术圈里徘徊,商业用户的名单始终凑不齐——没有用户就没有反馈,没有反馈就没有改进,没有改进就更没有用户。第三批最戏剧化,落在了 ALGOL 自己的继承仪式上:1968 年,委员会推出 ALGOL 68,试图让语言更上一层楼;报告一出,坚持 ALGOL 60 简洁品格的正统派公开否决,认为新设计过于复杂、野心过大——霍尔与沃斯提交的简化提案 ALGOL W 遭到拒绝,霍尔提交了少数派报告后拒绝继续与会——少数派报告并非孤本,它代表着一群坚持简洁的人的集体立场:语言的价值在于克制,而克制在委员会里永远是最难推销的提案。两派在学术期刊上互相发文攻讦,ALGOL 的商业生命在这场内斗中彻底终结。一门不属于任何公司的语言,连它的死都是学术性的——它死于自己人对“什么是正确方向”的分歧,而不是死于任何竞争对手。
但清算的另一栏同样要写满。那些为纯洁性付款的人,买到的是语言研究第一次成为科学的全部起点:BNF 让语法可以数学地讨论,归纳语义让含义可以严格地陈述,解析树、LL 与 LR 文法分类、操作语义学——这片研究疆域的每一条边界,都是 ALGOL 60 报告画下的。BNF 的后裔还散落在每一个程序员的日常工具里:配置格式的规范、接口定义的文法、协议文档的消息结构——凡是需要“把格式说死”的地方,都在用某种形式化文法说话。为它写编译器的人也各自结出了果实:迪杰斯特拉的编译器与栈、霍尔的编译器与快速排序、维也纳实验室的抽象机器——实现一门“被数学定义的语言”这件事本身,锻造出了一整代编译器工艺。这份工艺此后随编译器教材传遍世界,把一段段关于栈、关于作用域、关于翻译的共识,交到了一代代新工程师手里。ALGOL W 里诞生的 null 后来成了霍尔本人公开道歉的“数十亿美元的错误”,但道歉发生在 2009 年——一项设计决策的账单可以迟到半个世纪,这门语言催生的反省也如影随形地跟了半个世纪。
ALGOL 68 与正统派的叛乱
一门以纯洁为纲领的语言,死于一次不纯洁的继承。1966 年前后,霍尔与沃斯向 ALGOL 工作组提交了一份温和的改进提案——后来的 ALGOL W;委员会认为它太保守、改动太小,最终选择了另一份堆满新特性的雄心方案,定名 ALGOL 68。报告一出,ALGOL 60 的正统派公开决裂:霍尔提交了少数派报告,沃斯转身去做了自己的语言——先是把 ALGOL W 打磨成熟,继而在 1970 年前后演化出 Pascal,并为它设计了生成中间代码、可在不同机器上运行的编译器方案——这门以更简单方式继承 ALGOL 衣钵的语言,日后成了几代学生的第一门编程课;沃斯本人则在 1984 年因一系列创新语言获得图灵奖。它的一支后裔在八十年代初被一家公司打包成售价不到五十美元的编译器产品,编译速度惊人,把结构化编程一口气推平了整个微机市场——委员会拒绝的那份提案,以商业的形式完成了复仇。两派的论战搬上了学术期刊,你来我往的檄文把一个语言委员会的分裂公之于众;ALGOL 本就孱弱的商业生命,在这场自家人的内战中走到了终点。
这段结局常被当作“委员会设计”的终极注脚,但公平的读法要拆成两半:ALGOL 60 证明委员会可以定义出伟大的语言——当它的目标是简洁时;ALGOL 68 证明委员会也可以毁掉一门伟大的语言——当它的目标变成堆砌时。委员会不是问题,委员会没有概念完整性的守门人才是问题。这个教训后来以各种面目出现在每一个大型设计委员会的会议室里。被拒绝的 ALGOL W 也没有白写——提案本身在别处开枝散叶,它的直系后代不久后以新名字问世,成了教科书与课堂的经典;正统派的坚持同样结了果:对简洁的信仰此后在每一次语言设计的论战中都有人续写。
两本账:定义权与使用权
把 ALGOL 60 与同代的两位巨人对着看,张力才能称出重量。FORTRAN 背后是 IBM 的销售团队、文档、教科书与客户支持;COBOL 背后是国防部的采购命令与整个商业世界;ALGOL 60 背后只有一群大学教授和一份漂亮报告。商业语言的胜负由装机量与用户习惯投票决定,学术语言的胜负由教科书与谱系图投票决定——ALGOL 60 在后者的榜单上高居榜首:现代大多数编程语言的语法都是类 ALGOL 的:ALGOL 的直系与旁支合力织成了一张谱系网——剑桥与牛津一线的 CPL、BCPL、B 一路演化为 C,把 ALGOL 的结构化基因带进了此后的系统编程主流;Pascal 的结构化、Simula 在其骨架上扩展出的新物种——后两者沿着各自的路径走下去,一条通向系统编程的主流,一条孕育了以对象为中心的另一种传统。Scheme 继承了它的词法作用域与块结构,Java、C#、Python 的语法谱系都能一路追溯回 1960 年巴黎的那间会议室。它输掉了使用权,赢走了定义权。两本账的记账人也截然分开:定义权的账本由教科书作者与语言设计者记,每一堂讲块结构、作用域、递归与 BNF 的课都在为它续页;使用权的账本由 FORTRAN 与 COBOL 的用户记,他们从始至终没有想过要用它。两个记账群体互不相识,却共同写完了 ALGOL 60 的历史地位。使用权那本账则几乎无人翻阅——今天在生产环境里偶遇一段 ALGOL 60 的概率,趋近于考古。这门语言证明了语言可以像数学一样被精确定义、被公开辩论、被委员会共同拥有——也证明了学术的纯洁在商业世界必须付学费,学费的名目叫实现、叫分发、叫用户。
迪杰斯特拉对这份报告的评价在后世被反复引用:ALGOL 60 的出现,是计算机科学作为一个学科成立的重要时刻——一门手艺第一次拿出了自己可以被形式化讨论的对象。这个判断此后被一系列事实证明:为它写编译器的队伍催生了编译器工艺,为它定语法的范式催生了语言理论,为它实现递归而发明的栈撑起了此后所有过程式语言的运行时,甚至连它的失败都成了软件工程与语言设计课程的必修案例。一门商业上近乎缺席的语言,以教学、以规范、以血统的方式占领了几乎所有的课堂与几乎所有的后代语法——这不再是某一个设计的成败,而是一种知识传统在行业中的确立。此后几十年的算法教科书,几乎都用 ALGOL 风格的记号书写伪代码:那是一种不属于任何厂商的元语言,讲算法的人用它,就像数学家沿用同一套积分符号——巴黎会议定下的书写方式,成了整个学科的黑板体。
ALGOL 60 的谢幕自带一种罕见的体面:它死过两次——一次死在市场上,FORTRAN 与 COBOL 把它挤出了机房;一次死在委员会里,ALGOL 68 的内斗把它挤出了日程——可两次死亡都没有波及它的课堂生命与谱系生命。FORTRAN 用实现定义了语言的市场形态,ALGOL 60 用规范定义了语言的学术形态,两边的胜利都真实,两边的账单也都付讫——付讫的凭证,一张是市场,一张是书目。
回到卷四的主线上,ALGOL 60 是对另一种认知负荷的正面回答。FORTRAN 要卸掉的是“把公式翻译成指令”的负荷,COBOL 要卸掉的是“程序与账本之间隔着行话”的负荷;ALGOL 60 要卸掉的更深一层——它要把“算法该长什么样”从机器细节的绑架中解放出来,让算法的表达只服从数学与逻辑的秩序,块结构管理复杂性,作用域管理名字,递归管理结构,BNF 管理语言自身。半个世纪后回头看,这三大件换上了新装依旧站岗:begin 与 end 变成了花括号,作用域成了每门语言的默认,递归成了程序员的常识——巴黎会议定下的秩序,从来没有人真正离开过。它服务的读者也与众不同:不是工程师,不是会计,是此后所有语言的设计者。ALGOL 60 用一份几乎无人完整实现的报告,定义了此后所有被实现的语言——它把纯洁性当作生存策略,市场用冷落惩罚了它,历史用继承加冕了它;学术与商业在 1960 年完成的那场分家,让纯洁者获得永生,让实用者获得市场——此后每一个设计语言的人,都不得不选择自己想被哪一边记住。被两边的教科书同时记住,也算一种圆满。圆满的另一面,是它的王位从此虚悬——后世再没有一份报告,能同时让两边的阵营都低头学习。
第 037 章 1964—1970:BASIC 与 Pascal:平民启蒙与结构化学院派
1964 年 5 月 1 日凌晨,新罕布什尔州汉诺威小镇的达特茅斯学院机房,两台电传打字机几乎同时吐出了正确的结果彼时,分时实验在全美只有寥寥数处,达特茅斯是最不起眼的一家——最不起眼的地方做出了最普及的语言,这个反差本身就是故事的一半达特茅斯的选择在当年的高校版图里近乎异端:计算机课程的席位通常按系分配,文学院排在最后一档;把名额让给全体新生,意味着说服董事会相信编程与拉丁文同样重要——这两位教授说服了他们,用的是一台电传打字机和十行代码。机房之外的人第一次看清,编程不过是用另一种语言对机器说话——这条信息比任何课程大纲都更有说服力。:一条简单的算术程序,由两位数学教授亲手敲入,经由他们自建的 DTSS 分时系统运行、返回一切语言设计的底层争论,都可以还原成同一个问题:语言应该在多高的高度上俯瞰机器?太低,人沦为机器的誊写员;太高,机器变成不确定的黑箱。1964 年的三个答案分别选择了脚面、胸口与云端——十年之后的市场,给三种高度各开了一张不同的价单。托马斯·库尔茨(Thomas Kurtz)与约翰·凯梅尼(John Kemeny)盯着纸带上的输出——那是他们为新语言 BASIC 写下的第一批程序在场的没有外人,也没有记者:两位教授、几名学生、两台电传打字机、一台租来的分时主机——第一次运行只花了几个字节的内存。语言本身的形态同样朴素:十来条语句,每条用最基础的英文单词命名,行号告诉机器执行顺序,新手敲一行就能单独执行一行。这两位教授相信,计算机不该只是工程系与研究生的领地,英语系与历史系的新生同样有权敲下人生第一行代码。
平民的语言:把编程门槛削到文科新生伸手可及
凯梅尼的人生本身就是一部移民传奇:匈牙利犹太家庭出身,战乱中辗转移居美国,在普林斯顿读完逻辑学博士,毕业后做过爱因斯坦的研究助手——给二十世纪最伟大的物理学家整理统一场论手稿的人,后来把后半生交给了新罕布什尔的一所文理学院从爱因斯坦的助手到达特茅斯的系主任,凯梅尼的职业轨迹在旁人眼里是降格,在他自己看来是归位——他要证明的是,最高深的思想与最普通的教育可以共用同一个人。这个信念后来原样注入了 BASIC:一种伟大到能教给任何人的语言,比一种只能被少数人膜拜的语言更伟大。他执掌达特茅斯数学系后大刀阔斧地改革课程,而他与学生库尔茨共同注意到的问题是当时全美高校的通病:计算机虽然已经进了校园,却只对工程与数学系的少数人开放——机时昂贵、语言艰深,FORTRAN 与汇编的门槛把九成学生挡在门外。两人的分工恰好互补:凯梅尼负责语言的长相,库尔茨负责分时系统的内脏——一对教学搭档,把一个数学系办成了全美计算教育的样板。分时机器上的 BASIC 与批处理机器上的 FORTRAN,像两种社会制度:一种按人头分时,一种按资历排队——达特茅斯选择了前者,教育学与工程学在同一块主板上和平共处。凯梅尼的判断简单而大胆:计算是一种通识能力,就像写作与算术这个类比在六十年代末开始兑现:达特茅斯的分时系统上,一半以上的活跃用户来自非理工科系;BASIC 的课程从数学系教室走进了管理学院——通识的边界,每学期都在外扩;要让它成为通识,语言必须简单到外行一节课入门,机器必须慷慨到人人随时可用。DTSS 的实现是两位教授带着本科生完成的——分时系统在当时是大型实验室的专利,达特茅斯用数学系的预算与学生的人手造出了可用的版本。这件事的反差本身就是宣言:如果学生能在导师指导下写出分时系统,学生当然能用 BASIC 写作业。
于是有了两件配套的发明。先是 DTSS 分时系统——几十台电传打字机同时连上一台主机,每人分到一段机时;然后是配套的语言 BASIC(Beginner's All-purpose Symbolic Instruction Code,初学者通用符号指令代码名字里的 B 是 Beginner,初学者——一门语言把目标用户写进自己的名字,这个行为本身就是一份宣言:编程语言不再按机器的型号命名,而按人的身份命名。DTSS 本尊一直服役到七十年代末,数以千计的达特茅斯学生在它上面写下了人生第一行代码——它没有商业化的雄心,却完成了最彻底的一次普及。),名字本身就是设计目标。BASIC 的语法把门槛削到了地板:命令用英文单词,PRINT 就是打印,INPUT 就是输入;错误提示短得像电报,但至少看得懂——在吐出十六进制核心转储才算合理反馈的年代,这已经是温柔。每行有行号,程序按行号从小到大执行,初学者不必理解程序结构与作用域;敲一行 RUN,立即看到结果——反馈环短到像做算术题。
10 INPUT X
20 IF X = 0 THEN GOTO 50
30 LET S = S + X
40 GOTO 10
50 PRINT "SUM ="; S
60 END
初版 BASIC 的全部语法十来条语句,一个求和程序五行写完——行号与全大写的命令名,是那一代人共同的启蒙记忆。立即执行另有一样被低估的教学价值:错误在敲下的当下就暴露,学生把调试当作对话而不是审判——学习心理学后来反复验证的道理。
行号与跳转让初学者三分钟写出第一个循环,也让他们三天后写出第一团乱麻——凯梅尼对此并非不知情;他和库尔茨的取舍,是把第一次成功放在第一次挫败之前,先让人爱上编程,再谈编程的德行。后来的迪杰斯特拉把 GOTO 钉上耻辱柱时,BASIC 首当其冲;达特茅斯的回应平静:启蒙的语言允许犯错,就像小学的作业本允许橡皮擦。首批学生的反馈远超预期:文史专业的学生一个下午就学会了写计算平均分的程序,教授们开始把成绩统计交给学生自写的程序——启发的证据不需要统计,需要的是眼神,达特茅斯的机房在 1964 年就已经用机器实现了。从设计哲学上说,BASIC 反的是当时语言界的共同假设:语言应该强大、严谨、面向专业程序员。凯梅尼与库尔茨反其道而行:语言的第一用户是十八岁的文科新生,一切设计为他们让路配套的分时系统 DTSS 同样按这个标准建造:几十台电传打字机接进同一台主机,机时按人切块,学生随时可以坐下来敲几行、试几行、错几行。当年一所大学能让本科生直接上机,本身就是新闻;达特茅斯的招生简章甚至把这件事写进了卖点——在这里,每个学生都拥有一台计算机。BASIC 的扩散还有一层与教育无关的推力:它便宜。学校买不起专属机房,就分时租用;厂商发现附送 BASIC 能提升整机销量,便把它烧进出厂的芯片——启蒙的火种之所以烧得动,一半靠信念,一半靠免费。此后二十多年,BASIC 成为全球中学与大学入门课程的默认语言,微机时代到来时,它又顺手成了个人电脑上第一种被写进 ROM 的语言——平民启蒙的路线,从达特茅斯的机房一路铺进了每个家庭的卧室。
1975 年,这条路线迎来了它最著名的一次移植。Altair 8800 微机上市,内存以千字节计的底配机型只给了 4KB——两位年轻的哈佛学生在《大众电子》上看到这台裸机后,决定为它写一个 BASIC:保罗·艾伦与比尔·盖茨,在几台模拟 8800 指令集的 PDP-10 上赶出了能在 4KB 内存里连解释器带代码一起塞下的版本,随后创办了自己的公司来经营这份产品——那家公司叫 Micro-Soft,后来省去了连字符。Altair BASIC 卖得谈不上体面(爱好者圈子的复制传播让两位创始人第一次体会了软件盗版),但它立下了两条影响深远的先例:个人电脑的第一种大众语言由 BASIC 担纲,以及——软件本身可以是一门卖钱的生意。达特茅斯在 1964 年免费散播的火种,十一年后在阿尔伯克基的车库里,第一次被装进了商业的火柴盒。
还带来了一个教科书式的副产品:因为语言小,它可以在任何机器上被快速重实现。此后十几年,几乎每一种新上市的分时系统与微型机都自带一个 BASIC 解释器——语言随着宿主四处落地,像一场没有组织的标准化运动。入门语言的市场,被一条教学路线无意间统一了。达特茅斯自己则守着另一条原则:语言的每一次扩充,都要先在真实课堂里检验——凯梅尼甚至拒绝给初版添加让教师省事却让学生困惑的特性,教学语言的舵,始终握在教的人手里。
结构化的学院派:为编译器设计一门语言
同一时期的大西洋彼岸,苏黎世联邦理工学院的尼古拉斯·沃斯(Niklaus Wirth)正走向另一极。他是 ALGOL 阵营的学院派传人,参与过 ALGOL W 的设计。他的学术生涯几乎就是与语言膨胀对抗的历史:欧洲的 ALGOL 阵营在六十年代末因下一代标准的方向公开分裂,沃斯站在抗议规范膨胀的一侧,联名上书反对把语言变成各派特性的陈列馆。抗议没有改变那个标准的命运,却改变了他的下一步——既然委员会做不出干净的语言,那就自己动手。这段分裂的余波,也是理解 Pascal 品味的关键:它的每一处克制,都是对着一份失控的规范清单写下的,又在 1968 年前后遭遇了那个时代所有软件工程师的共同噩梦——项目延期、成本失控、错误丛生,业界很快把这种状态命名为软件危机。1968 年的慕尼黑会议把这个词钉进了正史——与会者的共识悲观而清晰:软件的成本与复杂度,正在以人类驾驭能力之外的速度增长。沃斯的诊断与多数人不同:危机的根源不在机器太快或太慢,而在语言——既有的语言要么像 FORTRAN 那样结构松散、错误丛生,要么像 ALGOL 68 那样规范膨胀到无人能完整实现;程序员需要一门小而严谨、能教会人写出好结构的语言。1968 年 9 月,他开始设计;1970 年,新语言发布,命名为 Pascal,致敬三百年前发明了第一台机械计算器的法国人布莱兹·帕斯卡。命名也是一份设计说明书:以帕斯卡为名,沃斯在提醒世人计算的历史可以上溯到机械时代——第一台加法器的发明者,早已预告了这门学科的名字。沃斯本人在八十年代的图灵奖讲台上受勋,十年后又以一篇著名的短文继续布道:臃肿的系统注定不可靠——个人信条就此定型。沃斯晚年对 Pascal 的评价同样诚实:它教会了世界结构化,却也让他看到模块机制的缺失——教学语言的一生,就是不断被要求变成工业语言的一生。
语言谱系上,它是 ALGOL 学院血统的正宗后代:块结构、词法作用域、递归,这些 ALGOL 60 立下的家规被完整继承;数据则比祖先丰富——记录、集合、文件、指针一应俱全,静态强类型贯穿始终。它证明了纪律与表达力可以共存:类型系统的存在,与其说是限制思想,不如说是替程序员记住那些容易忘记的事。具体的语言形态也处处透着这种保守的智慧:标量、记录、集合与文件各归其位;指针只指向命名过的对象,悬空的可能被语法排除;程序被强制写成清晰的块,从首行到末行一眼可见边界——后来整整一代教科书用 Pascal 教语言,教的就是这种把思想落成结构的章法。沃斯那句信条随后广为流传:简单,是可靠的前提。这份保守与瑞士制表业的哲学如出一辙:零件标准化、公差写死、误差为零——后来工程师评价 Pascal 的用词,与评价一块机械表芯的用词几乎相同。教学现场的反馈也印证了设计:学生第一次编译就能收到一张完整的类型错误清单,纠错从跑起来之后的崩溃,前移到按下编译键的一瞬——教学效率的提升,量纲从百分比变成了代际。工业界的评语则更实际:苹果公司在八十年代初选择 Pascal 作为 Macintosh 的主要开发语言,欧洲的电信与航空业也用它写过运行数十年的系统——教学语言的出身,并没有挡住它进入生产环境。
Pascal 的工程哲学浓缩在编译器的实现策略里:单遍扫描。传统编译器要把源代码读上好几遍才能生成机器码,又慢又占内存;沃斯把语言的结构反过来设计,让编译器从前往后只读一遍源码、一次完成翻译——语言里不允许任何需要回头重看的写法,所有声明先于使用。这个决定让 Pascal 的编译器小到能在教学用的小型机上飞快运行:学生按下编译键,几秒钟内就能看到自己代码的全部语法错误。反馈环与 BASIC 一样短,纪律却严得多单遍扫描的技术机关在于语言的书写规则:一切先声明后使用,符号表按顺序一次建满,编译器永远不需要回头。传统编译器为查一遍符号要在磁盘与内存间往返多趟,Pascal 的编译器读一遍源码就交出机器码——在以秒计费、内存按千字节出售的年代,这种效率差异,足以决定一门语言能不能装进教学机房的生死线。这门纪律的日常形态是:类型必须声明、结构必须成块、每一处数据的边界都被编译器盯着。Pascal 很快成为欧洲大学的标准教学语言数组带着边界、指针受着约束,这些设计在教学机器上几乎零成本,却在工业界埋下了另一条伏线——后来若干主流语言的安全特性,都能在 Pascal 的类型规则里找到课堂讲义。教科书里的经典练习是汉诺塔:三根柱子、几个盘子,递归三行写完——同样的任务用非递归写法要绕出半页状态表。Pascal 用这个例子告诉学生:有些复杂是问题固有的,有些复杂是工具逼出来的,并以它为母体繁衍出一条影响深远的教学语言谱系沃斯本人沿着这条路走到了远方:此后的 Modula 与 Oberon 一脉相承,每一代都比上一代更小——在语言界集体做加法的年代,他的一生都在示范怎么做减法。语言发布之后,ISO 与多国标准机构相继为它立规,教育界以教科书与考试把它制度化——一门语言的普及,一半靠编译器,一半靠考卷。多年后回顾,沃斯把这次成功归结为一句朴素的方法论:缺少合用的工具,就自己造一个。
失败案例栏:PL/I 的全能陷阱
在 BASIC 的低门槛与 Pascal 的严纪律之间,还躺着一具规模大得多的残骸:IBM 的 PL/I。要理解它的崩塌,必须先承认它起飞时的正当性。1960 年代中期,IBM 决定用 System/360 把自家互相冲突的几条产品线统一成一套体系——硬件统一了,软件的割据却刺眼地留了下来:科学计算用户写着 FORTRAN,商业用户写着 COBOL,学院里讲着 ALGOL,系统程序员抱着汇编;同一个客户往往要养三种语言的编译器、三套文档、三批程序员这场豪赌与同一时期的 Multics 遥相呼应:一个是语言的统一乌托邦,一个是操作系统的统一乌托邦;两边都相信更强的通用性等于更低的长期成本,两边都撞上了同一堵墙——通用性的价格,是复杂度的指数。1963 年 10 月,一个委员会成立了:三名 IBM 纽约员工加三名 SHARE——IBM 科学用户组的代表,最初的任务是扩展 FORTRAN。他们很快发现 FORTRAN 的地基撑不起需求,转而基于 ALGOL 的框架设计一门新语言,代号 NPL,后来定名 PL/I,意图一目了然:Programming Language One,第一语言,统一科学计算、商业处理与系统编程的全能语言。
委员会的组成,决定了膨胀的路径。每个成员背后都站着一支真实的用户大军:科学计算派要浮点运算、数组与数学函数库级别的便利;商业派要十进制算术、报表格式与文件处理的便利;系统编程派要指针、字节级操作与中断处理的便利;后来实时与多任务阵营又带着自己的清单进场。每一项要求都有真实的需求托底,每一个派系都有拒绝退让的正当理由——拒绝科学派的浮点特性,等于让数以万计的 FORTRAN 程序员永远无法迁移;砍掉商业派的报表能力,COBOL 用户连看都不会看一眼。于是特性一个不落地全部进入了语言:十进制与二进制算术并存、隐式类型转换规则层层嵌套、异常处理、并发事件、指针与结构、字符串处理,随手翻开那份规范就能看到各派的战利品:来自 FORTRAN 的数组与浮点,来自 COBOL 的十进制算术与报表子句,来自 ALGOL 的块结构与递归,再叠上系统派要的指针、异常与多任务——几十种存储类别与转换规则交织成一张语义之网。规范膨胀到数百页手册委员会的会议以每周数天的频率贯穿了整个设计期,记录显示每一项特性的去留都经过表决,而表决的单位是特性本身——从头到尾,没有人统计过特性与特性之间的相互作用。为把这套语义讲清楚,IBM 维也纳实验室甚至专门发明了一套形式化的定义语言——失败项目的废墟上,倒长出了形式语义学这门学科。
崩塌的机制值得逐层拆解。第一层是实现的崩塌:没有任何一支编译器团队完整实现过 PL/I 的全部规范——不是不想,而是规范内部的特性组合爆炸PL/I 的编译器本身成了一个传奇:调出第一个能用的版本花了数年,缺陷报告摞起来与规范比肩;实现追着规范修订,规范又随实现的理解继续膨胀——循环闭合的那一天,谁也说不清在哪个十年。让完整实现接近不可判定;各家实现都是子集,而子集与子集互不兼容,统一语言的初衷在第一行编译器代码里就已瓦解。IBM 自家的旗舰编译器开发了数年才交付第一个可用版本,交付的也只是子集;第三方与高校的实现各自裁剪,没有一支团队敢宣称完整——一门号称统一的语言,从第一天起就以分裂的姿态存在。到七十年代中叶,PL/I 的方言家族里最大的几支各自服务着稳定的客户群——这门语言以碎片的方式,实现了它从未以整体实现的目标:被广泛使用。子集策略的悖论在于:每裁剪一次,兼容性就少一分;当十家厂商各自裁剪,市场实际得到了十种新语言——统一的成本被平摊成了十份分裂,这笔账最后记在了所有用户头上。第二层是用户的用脚投票:FORTRAN 程序员发现迁移要放弃全部既有代码与直觉,COBOL 程序员发现商业世界的一应需求在旧语言里照样运转;一门宣称能取代所有人的语言,最终连一个人都没有取代。公平起见也要记下它的全盛时刻:整个七十年代,PL/I 在 IBM 大型机客户里拥有真实的用户群,几家银行与保险公司的核心账务系统用它写到了世纪之交——全能语言的失败,指的是没能统一世界,而非没能活下来。IBM 也没有立刻止损:360 的软件策略已经公开,弃之等于自扇耳光;PL/I 被继续维护、继续推销,甚至在多所大学的课程里占据过位置——失败的产品往往比成功的活得更久,因为承认失败的成本总在递延。第三层是方言的泛滥:为了各自的实际用途,工业界裁剪出 PL/M、PL/C、PL/S、PL/8 等一批子集方言——统一语言分裂成一窝方言,每一窝都承认自己是 PL/I,彼此却对不上话。
必须写清,这场灾难里的每一方都干了当时最合理的事。IBM 的商业逻辑无懈可击:360 用统一硬件统一了产品线,统一语言若能成功,将把客户更深地锁定进生态;委员会成员为各自的用户群争取特性,是代表制的本分;规范写厚而不是写薄,源于一个朴素的信念——规范模糊处就是未来二十年厂商扯皮之处,宁可现在写死。还有一层心理机制在当时无人点破:FORTRAN 的巨大成功让设计团队相信,第二代产品应当把第一代的所有遗憾一次补齐——行业后来给这种冲动起了名字,第二系统效应;而 PL/I,是它最完整的标本。真正的结构性病灶在于一个无人负责的缺口:委员会里每个成员都对自己的派系负责,没有人对语言的整体一致性负责;特性可以表决通过,语义的相加性却无人审查——十进制转换遇上隐式类型提升时会发生什么,这类跨特性的语义黑洞,直到实现阶段才被发现委员会的会议以每周数天的频率贯穿了整个设计期,记录显示每一项特性的去留都经过表决,而表决的单位是特性本身——从头到尾,没有人统计过特性与特性之间的相互作用,而那时语言已经发布。PL/I 的教训因此不属于愚蠢,它属于一个更冷的机制:当委员会的决策单位是特性而非整体,规模本身就是 bug;语言设计的敌人从来不是门槛太低或纪律太严,而是试图同时讨好所有人。PL/I 的残骸至今躺在大型机的文档库深处,每年仍有企业为维护它付费——它提醒每一代语言设计者:讨好所有人,最终会成为所有人共同的负担。
两条路线,各自兑现
更长的时段里,两条路线各留了一份遗产。BASIC 路线证明,语言可以是大众文化的入口——此后每一种面向初学者的语言,从 Logo 到 Scratch,都循着达特茅斯的设计哲学:把门槛削到孩子伸手可及。派珀特在麻省理工为更小的孩子发明的 Logo,把这条思路推到了学龄前;几代程序员的第一次编译,都发生在行号构成的世界里。训练线路亦有传人:从 Pascal 到它滋养的一串教学与工业语言,结构化编程的课程大纲统治了此后二十年的计算机系讲台;今天任何一门现代语言里的强类型与块结构,都是沃斯当年那台单遍扫描编译器的远房子孙。两套谱系在八十年代还有过一次正面的交汇——丹麦人菲利普·卡恩在加州创办 Borland 公司,1983 年推出 Turbo Pascal:把达特茅斯的即时反馈与苏黎世的类型纪律装进同一个编译器,编译加运行在一台普通微机上瞬时完成,定价四十九美元九十五美分——当时一套专业编译器的零头;产品靠口碑在微机开发者中横扫,Borland 也凭它从车库里的一年冲成了行业强敌。这次交汇的工程底气仍是那台单遍扫描编译器:正因为语言小到一遍扫完,Turbo Pascal 才能在百美元级的零售价与秒级的编译速度上同时兑现——启蒙与纪律,最终在同一张软盘上和解。
行业的收获清单还可以再列一列:分时服务其后演化为个人电脑,结构化工具其后长成集成开发环境,统一生态其后化作平台战略——语言史与产业史,在这里互为正文与注释。七十年代的教材市场也早已见证了合流的预热:BASIC 的书教人快速上手,Pascal 的书教人写出结构,书架的两端都摆满了,中间那层留给天才与叛徒。两条路线还共同确认了一个行业常识:语言的成败,从来不只取决于语言本身——BASIC 背后是分时系统与中学课堂,Pascal 背后是编译器与大学讲台,PL/I 背后是一场统一生态的豪赌;语言的胜负手,藏在语言之外的制度安排里。合流的另一面则是谱系的提醒:那款产品的成功让 BASIC 与 Pascal 的拥趸都宣称自己赢了——而真正的赢家,是那一代在两者之间辗转的学生:他们从 BASIC 拿到了勇气,从 Pascal 拿到了纪律。
把镜头拉远,这三种命运其实共享同一个时代命题:计算机的用户正在从工程师扩展到整个人类社会,语言设计第一次必须回答“为谁而设计”。为文科新生设计,就放弃完备;为纪律设计,就放弃宽容;为所有人设计,就注定让所有人失望——三个答案没有对错,只有代价由谁支付、何时支付。BASIC 的代价是坏习惯,Pascal 的代价是高门槛,PL/I 的代价是无人问津;三种代价在随后的半个世纪里轮番登场,又各自找到了清偿人:BASIC 的坏习惯被一代人用自学补齐,他们当中走出了一批最务实的工程师;Pascal 的高门槛被工具链消化,类型检查成了所有现代语言的默认;PL/I 的无人问津成了标准制定者的教科书案例——委员会从此知道,特性需要审判。代价不消失,只转移;语言史记录的,就是转移的路径。每一种新的语言浪潮——脚本、教学、企业、系统——都在重演 1964 年的这道选择题,只是换了语法与名字。这三种命运的先后次序也是一句判词:先来的启蒙者等到了微机,后来的立法者等到了课堂,最晚的全能者连迟到都来不及——语言史给后来者的建议,始终是选一个具体的人来服务。
“谁能编程”的社会定义改写,主场在第 027 章所述的 Unix 与小型机——机器先交到了个人手里;BASIC 与 Pascal 接的是同一棒的下半程:语言交到非专业者手里。
这两条线各自留下了课程表的遗产:今天任何一所大学的入门课,仍要在语言的亲和与类型的严谨之间做出与 1964 年相同的选择——只是学生的名字,从文史系换成了每一个专业。半个世纪的争论与合流还留下一句给后来者的提醒:语言的启蒙与纪律,从来不是二选一——BASIC 与 Pascal 在同一张软盘上和解过一次,此后的每一种语言,都在重复这场和解。和解的钟摆从未停过:入门的语言换了一代又一代,每一代都要重新回答亲和与严谨的分界划在哪里;分界的答案随机器的价格浮动——机器越便宜,亲和的分量越重,启蒙的对象越广。划线的人换了,划线的动作没变;入门课的第一课,永远是这条线的当代位置。
第 038 章 1967—1972:从 Simula 到 Smalltalk:对象的两次诞生
1961 年,奥斯陆,挪威计算中心的一张办公桌上,摊着一张挪威造船厂的运营图纸。运筹学家克利斯登·奈加特(Kristen Nygaard)盯着它已经很多天:船进港、卸货、装货、离港,吊车在码头之间移动,风暴让一切排队——他受船运公司委托,要用计算机模拟这一切。图纸上的世界清清楚楚,程序里的世界却支离破碎:船不是船,是一堆分散在数组里的编号;码头不是码头,是一段段谁也不敢乱动的公共代码。他后来对同事说,他想要的是一种语言,让计算机里装下图纸上的那个世界。彼时的程序语言只会做一件事:对数字算术。船的身份要记在数组下标里,船的载重是另一个数组的一格,码头占用是一串逻辑标志——图纸上的世界是有名字的实体,程序里的世界却是无名的数字。模拟一昼夜的港口运转,要把上百个实体、上千个事件一一展开成编号与计数,写出来的程序连作者自己都认不出港口的模样。当时的运筹学工具是蒙特卡洛模拟:把系统折算成概率分布,让计算机掷骰子算出统计期望;方法有效,代价是模型里的人与物全部失去名字与身份。奈加特的不满正在这里——港口经理要的不是平均等待时间,而是三号码头那艘货轮此刻排在哪里。模拟要更进一步,语言就得先记住每一个个体。
从造船厂的图纸上长出来的语言
奈加特出身挪威防务研究机构,长年为军方与工业界做运筹学模拟——库存周转、船舶调度、核废料运输路线,全都要求程序精确复现真实系统里“一个个个体各自行动”的过程。他与语言专家奥利-约翰·达尔(Ole-Johan Dahl)合作,在 1962 年拿出了 Simula I:一种专用的仿真语言,程序不再是“对一批数做运算”,而是“让一批实体按规则活动”。船是一个实体,带着自己的载重与位置;码头是一个实体,带着自己的占用状态;它们在时间的推进中相互作用。两人是需求与实现的经典组合:奈加特带着用户与概念的图景,达尔负责把图景锻造成语言与编译器——他为挪威计算中心的 GIER 计算机从头写过整套 ALGOL 编译器,这门手艺让 Simula 的每一层设计都落在可实现的地面上。需求与实现每天谈判,谈判的成果,就是类。为了描述这样的实体,语言里出现了新的构件:同一类船共享同一张属性模板——这张模板,被命名为类(class);每一艘具体的船,是类的一个实例。这个构件的妙处在于两面同时成立:对机器,类是一张内存布局的模板,多少字节、什么格式,编译期一次定死;对用户,类是一张概念的卡片,船有载重、有位置、会装卸货——概念的边界与内存的边界从此重合。运筹学家要的从来不是更快的算术,而是让程序里的世界与图纸上的世界一一对应;类,就是那次对应的第一枚铆钉。
1967 年,两人把这套从造船厂里长出来的思想整理成一门通用语言,即 Simula 67。ALGOL 60 在这里扮演了值得感谢的底座:它的块结构、过程与递归,恰好是描述实体在时间中活动所需的全部语法原料;奈加特与达尔没有另起炉灶,他们在扎实的地基上加盖了自己的楼层——后来所有成功的语言扩展,几乎都遵循这个看似平淡的秘诀。从仿真专用走向通用的决定在挪威计算中心内部酝酿了数年:1967 年,两人把类、继承与虚方法写进了一门沿用 ALGOL 60 语法的完整语言——语法属于学术阵营,思想属于造船厂。Simula 的影响最初靠口耳相传:六十年代末,几份报告与讲义在学术圈悄悄流传,读过的人里就有后来书写历史的名字——灵感这种东西,只认读过它的人,不认国界与预算。它正式确立了此后所有面向对象语言的三大基石:类与对象——把数据与操作数据的程序封装在一个单元里;继承——子类可以扩展父类,船可以派生出帆船与货轮,复用父类的全部定义;虚方法——父类声明的操作,由运行时实际的对象决定具体执行哪个版本,这是“运行期才确定行为”的第一次语言级实现。
Simula 开创的离散事件仿真,如今是机场、港口与物流公司的日常工具——当年那张造船厂图纸,今天以调度算法的形式挂在每一座智能仓库的墙上。把操作下沉到类型系统的路,还有一段更深的伏线:同一时期的 ALGOL W 把空引用当作便利特性放了进去——设计者托尼·霍尔几十年后公开自嘲,那枚空指针让他损失了十亿美元。对象谱系里的缺陷,也有清晰的宗谱。Simula 67 还顺手带来了协程与自动垃圾回收——在内存要程序员亲手分配归还的年代,这个决定奢侈得近乎任性。奢侈的清单还不止于此:协程让多个实体像同时活动一样交错执行,模拟港口时,船与吊车可以各走各的剧情;引用语义让对象之间可以互相指认——甲船知道乙船是谁。这些设计全都围绕同一个母题:模拟的世界里,实体有生有灭、有来有往,语言必须替程序照管它们的生灭与往来。母题太大,以当时的技术只能用性能去换——Simula 的编译器与运行时以慢著称,慢到多数商业用户望而却步。慢的代价换来的机制却流传至今:虚方法靠一张运行时方法表实现——后来的 C++ 把它继承为虚函数表,Java 又把它继承成方法表,多态的物理实体五十年来没有变过。同样的机制在不同语言里名字各异:C++ 叫虚函数,Java 叫方法覆盖,脚本语言叫鸭子类型——名字吵得不可开交,底下的表格却都是 1967 年那张方法表的翻版。观念的传播在机器层面根本不需要一代人。垃圾回收同样在后世的运行时里复活,只是换上了更快的算法。挪威计算中心是小国的小机构,Simula 没有大厂商的推广,商业上几乎无声无息;但它的基因随着几份论文悄悄漂洋过海,十年后将在贝尔实验室长出 C++ 的前身。两位发明人则在三十多年后共同摘取了图灵奖——评奖词里的“类与继承”,写的就是这张造船厂图纸。它的第一代用户几乎全在北欧:船运公司、银行、电信的研究部门,拿它做调度模拟与业务建模;挪威与瑞典的防务研究机构也长期是它的客户。一个出生在小国的语言,用户群小而忠诚,像一座北方港口——船不多,但每一艘都有去向。挪威计算中心后来把 Simula 授权给多家厂商,北欧的银行与防务项目用它运转多年;1986 年,Simula 还发布了标准化文本——一门被宣判无声的语言,悄悄服务了一个时代。慢有慢的账目:类与继承需要运行时的方法查找,垃圾回收需要额外的扫描,协程需要上下文切换——每一项便利都在运行时里记着账;Simula 的用户接受这份账,是因为模拟本身的账单更大。
Dynabook:给儿童一台心智的自行车
第二次诞生发生在大西洋另一端,动机却与工程毫无关系。艾伦·凯(Alan Kay)的履历横跨得不像同一个人:空军程序员、数学与分子生物学的大学训练、犹他大学的计算机博士、斯坦福人工智能实验室的教授——1970 年前后,三十出头的凯走进了施乐帕洛阿尔托研究中心。从博士阶段起,他心里就装着一个与主流计算工业背道而驰的构想:1968 年他画出一台名为 KiddiComp 的机器草图,1972 年把它正式发展为 Dynabook——一本大小的个人计算机,卖给孩子,人人随身携带;他给这台机器的定位是“心智的自行车”:印刷术让人人得以阅读,个人计算机应当让每个人以自己的速度在思想的天地里驰骋。他在一篇论文里写下整机设想:一本书的重量、平板的形态、无线的连接、足以装下数千页文字的存储——今天的读者会认出,这是一份平板电脑的产品需求书,写于平板电脑出现前三十八年。在施乐,凯不停地向管理层呼吁为儿童开发友好的小型计算机——面试他的主管挠着头录用了这个怪才,而企业规划部门对“复印机公司造儿童电脑”的呼吁始终敬而远之。施乐的处境本身值得同情:复印机业务如日中天,公司建立帕洛阿尔托研究中心的本意,是为纸面办公的未来买一份保险——至于纸面办公之外的世界会不会吞噬复印机,规划部门的直觉是先看到再说。凯的 Dynabook 恰好是纸面办公之外的东西:它面向的孩子今天还不是客户凯在 PARC 组建了学习研究小组,成员里既有工程师也有认知科学家——为儿童造机器这件事,一半是工程,一半是关于人如何学习的科学;Smalltalk 界面上那些窗口与图标,Smalltalk-80 还把界面实践总结成模型-视图-控制器的三分架构:数据、显示与输入各归其位——这套后来统治了桌面与 Web 框架的架构模式,最初只是 Smalltalk 环境里整理代码的组织方式。凯的教育理想后来长成了一门显学:PARC 的 Smalltalk 环境、此后的 Squeak 与 Etoys,都在回答 Dynabook 的同一个问题——孩子能学会编程吗?每一代答案都比上一代更接近凯的想象,而他最初的那台机器,始终没有出厂。PARC 的小组在 Smalltalk 环境里做出了后来图形界面的几乎所有元素:重叠的窗口、下拉菜单、位图图标、鼠标点选——这些今天习以为常的东西,当年都是为了一门教学语言而发明的配件;1981 年施乐推出 Star 工作站把这套环境商业化,苹果在七十年代末参观 PARC 之后带走的,也正是这份完整的理念清单;它替代的纸却是施乐的饭碗。几年后,不满于总部迟钝的研究者陆续出走,把窗口与鼠标的图纸带向了刚起步的苹果与微软——施乐为未来买了保险,却把保单弄丢在了自己的走廊里;个人计算的时代因此到来,而它原本应该姓施乐。 Dynabook 需要一门配得上孩子的语言。凯对“面向对象”的理解,在 PARC 的学习研究小组里成形并推向极端:1972 年 9 月,他押注一门新语言的内核可以在数月内由小团队完成——语言中一切数据皆对象,一切操作皆为消息。Smalltalk-72 就此诞生,名字的意思近乎直白:用小言(to talk small)的方式与机器交谈。七二版的实验性贯穿始终:语法本身都在数月间几经调整,消息的书写形式换过好几轮;凯的小团队相信,与其等一门完美的语言,不如先让想法跑起来。凯的赌注有时间表:团队要在数月内让语言的内核跑起来,语法、实现与开发环境同步推进——在语言设计普遍以年为周期的年代,这是把造语言当成造产品来做。同一时期,贝尔实验室的 Unix 正沿着另一条路走向成熟——一个在打磨小工具,一个在孵化小对象,两条极简路线在同一个年代并行,彼此隔着一整个大陆互不相识。
消息传递:凯的大主意
Smalltalk 与 Simula 表面上说着同一套词汇——对象、类、消息——内里却是一次方向的掉转。Simula 的对象是编译期的分类:你在编译时声明船属于船类,程序从此按类索骥;Smalltalk 的对象是运行期的居民:每个对象是一台独立的小计算机,内藏自己的状态,对外只有一扇门。想让它做事?发一条消息过去。关键在于接收方:同一条消息,不同的对象可以给出完全不同的回应;解释发生在消息抵达的那一刻,而不是程序编译的那一刻。这就是凯反复强调的晚期绑定——行为的含义由接收者在运行时决定,发送方只管诉说,不负责裁决。消息的机制用例子最清楚:向一个整数对象发送相加的消息,它做算术;向一个列表对象发送同样的消息,它做拼接——发送方不必知道接收方是什么,回应由对象自己决定。同样的词汇在不同对象上激起不同的行为,这就是对话与命令的区别:命令假设发出者最懂,对话承认接收者最懂。几十年后,教科书把这种行为称作多态——同一个调用,千万种回应;术语越来越正式,凯的原始表述却始终更准:它就是一场对话。把对话哲学讲得最彻底的,是凯对消息的坚持:哪怕接收方听不懂,它也可以先回应一句不明白——系统里的每一次错位,都会得到一个礼貌而明确的回答;这种设计哲学后来长成了整个动态语言的性格。凯的原话值得原样记录:面向对象对他而言,只有消息传递、状态的本地保留与隐藏,以及万事万物的极度晚期绑定;类与继承并不在清单上——一门语言可以两者兼备,却仍然错失要旨,只要它允许一个对象伸进另一个对象的内部去拨弄它的私有状态。这句话常被误读为对类与继承的否定——他否定的是把它们当作面向对象的全部:类是帮助对象生长的脚手架,继承是复用的手段,它们有价值,但都不是大主意;大主意是消息,因为只有消息能把系统拆成真正独立的部分,而独立,才是应对变化的唯一途径。
两种设计的分歧,在一张对照图里一目了然:
Simula 67:编译期的分类学 Smalltalk-72:运行期的对话学
┌──────────────────┐ ┌──────────────────────┐
│ class 船 { ... } │ │ obj A obj B │
│ class 帆船 : 船 │ │ │消息"航行"→ 接收方 │
│ ↑ 编译时已定层级 │ │ │自行决定如何回应 │
│ 调用=按类查表 │ │ ▼ │
│ 绑定:编译期(虚方法 │ │ 消息→运行期查找 │
│ 为运行期雏形) │ │ (彻底晚期绑定) │
└──────────────────┘ └──────────────────────┘
对象=类型的实例 对象=独立的小计算机
权力在类的定义者手里 权力在消息的接收者手里
这场分歧不只是学术趣味。编译期分类的世界里,系统的形状在开工前就被画进继承树,任何一处类型变更都要惊动整棵树——后来所有大型面向对象项目的“类爆炸”困局,根源在此。运行期对话的世界里,对象只对消息负责,系统的形状可以在运行中生长——代价则是错误也要等到运行时才暴露。一个把安全押在事前,一个把灵活押在事后;而凯的立场始终未变:让各部分真正独立的东西是消息传递,独立,正是大型系统能够成长而不沦为泥沼的前提。凯常把对象比作联网的主机:ARPANET 上的计算机彼此独立,只以报文往来,没有任何一台可以直接伸手改写另一台的内存。对象在他眼里就是缩微的计算机——把网络时代的世界观提前装进了单机时代的编程语言;比时代超前的不只是理念,还有它对十年后分布式系统形态的预感。微服务架构的出现,不过是把这句话放大到服务器之间:每个服务独立部署,只以接口消息往来,绝不伸手改写彼此的数据库——凯在单机时代写下的世界观,最终成了分布式时代的架构教条。
两次诞生的账单
两次诞生各自的账单,同样值得清点。Simula 的账单上是时代的不公:它出生在小国的计算中心,没有 IBM 级的推销机器,编译器性能也平平,多数程序员一辈子只知道它是“另一种 ALGOL”;它提出的思想被拆散了传播——类与继承漂洋过海,协程与垃圾回收却在主流语言外流浪了几十年。Smalltalk 的账单上是商业的错过:PARC 造出了窗口界面、鼠标、所见即所得编辑器与一门为儿童设计的语言,施乐总部却始终没有把这些东西变成产品;天才们后来带着图纸出走,行业这才迎来个人计算的时代——发明权留在 PARC,兑现权给了世界。彻底的晚期绑定也有代价:错误同样延迟到运行时才出现,类型检查的保护被放弃——Smalltalk 的世界灵活,却把安全交还给了程序员的自律。同时期贝尔实验室的 Unix 走了相反的路:编译期的类型检查筑起栅栏,灵活交给了 C 语言的指针——两条路线在安全与自由之间的摇摆,从诞生起就没有停过。还有一笔更微妙的账:面向对象一词在工业时代的旅程中发生了语义漂移,类、继承与封装被奉为三大支柱,消息传递的彻底性反被遗忘;凯本人多次向外界澄清,他发明的是这个名词,而不是后来那门名为 C++ 的语言。名词被继承,主意被搁置——对象概念在商业化年代的第一次泄漏,泄漏的正是它最核心的那个想法。贝尔实验室的后来者把 Simula 的类带进了 C,又明确拒绝了垃圾回收与运行期检查——性能是留下来的理由;三十年后 Java 把垃圾回收补了回来,消息传递的彻底性却仍被静态类型拒之门外。1979 年,贝尔实验室的本贾尼·斯特劳斯特卢普(Bjarne Stroustrup)动手时说得直白:他要的是 Simula 的组织方式与 C 的效率——这句话就是后来 C++ 的全部路线图;类与继承被原样移植,垃圾回收与运行期安全被原样舍弃。两个诞生,一半各自被继承,一半各自被遗忘。
八十年代,对象的浪潮以商业语言的形式全面登陆:Smalltalk-80 完成了语言与环境的定型,Objective-C 把消息传递带进苹果的世界,C++ 把分类学带进了每一间机房——两大血统各自开枝散叶,相互之间的论战至今未歇。对象之间只靠消息往来的设计,在多核时代显出了第二重价值:没有共享状态,就没有数据竞争——1967 年为模拟港口设计的孤立性,恰好是多核时代最稀缺的安全性。性能账单也有后续:Smalltalk 的实现者发明了最早的即时编译技术之一——为动态语言造即时编译器的传统,源头就在 PARC 的机房里;三十年后,缓存与即时编译把这份开销摊薄成可接受的成本,动态语言的春天,是从这张时间表里提前预支的。
把两次诞生并置,能看到思想传播最真实的方式:同一个概念在两个大洲、两种动机下各自发芽——一个为了模拟真实世界,一个为了启迪儿童的头脑;一个生于小国的运筹学,一个长于巨企的实验室。它们后来在工业语言里合流,合流的版本保留了分类学的骨架,又在三十年间不断补进对话学的血肉——运行期类型检查、动态消息、接口与实现的彻底分离,每一次语言进化,都在重新回答奈加特与凯各自提出的问题。把目光放回语言年代的全景:FORTRAN 教机器算题,COBOL 教机器记账,BASIC 教人说话,Pascal 教人守规矩,Simula 与 Smalltalk 则教机器模仿世界——每一种语言都是一次对计算是什么的回答;对象的两问——它是什么、它能回应什么——是这些回答里离哲学最近的一问。这三种命运的先后次序也是一句判词:先到的仿真学等到了物流行业,后到的对话学等到了图形界面,最晚的合流者连名字都来不及统一——语言史给后来者的建议,始终是选一个具体的问题来服务。两次诞生留下的考卷,今天仍在发放:每一门新语言的发布文档,都在回答同一个 1964 年式的问题——你的语言,为谁而写。
骨架留下,血肉另补:合流的三十年
斯特劳斯特卢普 1979 年动手的取舍,诚实得近乎残酷:Simula 的组织方式留下,C 的效率留下,垃圾回收与运行期检查舍掉。这个取舍在当时的机房里完全站得住脚——方法查找的每一次查表、回收器的每一次扫描,在按秒计费的机器上都是看得见的账;一家要交付操作系统与通信软件的实验室,先拿走分类学的秩序,把对话学的自由留给以后,是工程师式的分期付款。C with Classes 沿着这条路长成 1985 年的 C++,类与继承由此进入每一间机房;被舍掉的那一半并没有消失,只是在账本的另一页记着,等待硬件降价把它赎回。三十年后 Java 把垃圾回收赎了回来,运行期的自动内存管理从此成为工业语言的默认配置;彻底的消息传递却始终没有被静态类型世界赎回,类型检查的栅栏立在那里,门后是另一条路的风景。
Smalltalk 这一路的遗产,走的恰好是相反的兑换方向。Smalltalk-80 完成的是语言与环境的整体定型:窗口、浏览器、调试器与代码同处一个活的系统,改一行即见一行,开发环境本身就是语言的一部分。1981 年施乐推出 Star 工作站,把这套环境摆上货架,市场反响平平;但图纸已经出走,苹果与微软各自拿走了窗口与鼠标的那几页。Objective-C 把消息传递的语法带进苹果的世界,成为后来桌面与移动应用里最接近凯原意的工业存在。环境遗产里还有两件耐用的东西:其一是模型-视图-控制器三分,数据、显示与输入各归其位,整理代码的家务做法长成了此后桌面与 Web 框架的通用架构;其二是为动态语言造即时编译的传统,1984 年德意志与希夫曼的工作是这个谱系的先驱,缓存加编译把晚期绑定的开销逐年摊薄。合流的版本因此呈现出固定的形状:分类学的骨架承重,对话学的血肉逐年回补——运行期类型信息、动态分发、接口与实现的分离,每一次回补都在回答同一个问题:系统要在运行中生长,语言至少要留出一扇运行时的门。
这场合流里最值得正视的,是当年反对者的分量。坚持静态类型与编译期检查的人并非守旧:他们手里的项目是操作系统、交换机与银行账务,错误在编译期暴露的成本远低于在运行现场暴露;贝尔实验室拒绝回收器与运行期检查,Unix 沿着 C 语言的指针把灵活交还给程序员自律,都是同一判断的不同写法——在周期昂贵、内存论字节计的年代,把安全押在事前是负责任的选择。分类学与对话学的争论因此从来不是先进与落后的对决,是两种账单的对决:事前检查的账单写在编译时间里,事后灵活的账单写在运行时间里;三十年硬件降价改写的只是两张账单的相对价格,从未宣判其中一张天然正确。把后来的胜利者读成先知的读法,在这里尤其要警惕:C++ 胜出靠的是站在 C 的生态与性能位置上,Java 胜出靠的是托管运行时恰好撞上网络应用的规模红利;血统的纯正程度,从来不是工业胜负的裁判。2001 年,图灵奖同时授予奈加特与达尔,表彰的正是类与继承;两人在次年先后去世,没有看到对象思想后来的全部合流。奖项来得迟,迟本身也是判词的一部分:小国的计算中心没有推销机器,思想的兑现只能借别人的机房完成。挪威银行与防务项目里运转多年的 Simula 程序,是这门语言直接服务过的工业现场;它的大规模兑现,发生在别人的语言里;它的发明者,则在图纸的位置上被记住。
记住结构,分发留给机器
回到卷四的主导约束:人类工作记忆容量与底层硬件表达精细度之间的妥协。对象正好落在这个妥协点上。类把上百个实体压缩成几张卡片:人一次只记一张卡片的字段与操作,卡片之外的细节由编译器按模板铺成内存布局;概念的边界与内存的边界重合之后,工程师的短期记忆第一次追上了港口的规模。虚方法与消息把另一半负担卸了下去:调用者不必记住每一分支的归属,分发的细节推迟到运行时由方法表或消息查找完成;人少记一张分发表,机器多做一次查表。这就是两次诞生共用的减负公式:让人只记结构,把分发留给机器。公式的另一面是账单:Simula 把账单写成缓慢的编译器与运行时,Smalltalk 把账单写成推迟到运行时的错误与交还给自律的安全;妥协没有免费的一面,减负的每一分都由另一方足额支付。
这笔妥协还顺带改写了准入名单。FORTRAN 把公式的书写权交给科学家,COBOL 把账簿的书写权交给业务人员,BASIC 把终端的书写权交给非理工科学生;Simula 与 Smalltalk 则把建模的书写权交给了更外圈的人——港口调度员可以在类里指认船与码头,孩子可以在消息里命令图形动起来。被赋权的是那些手握具体世界却不懂内存布局的人,他们第一次可以用名字而非编号与机器交谈;被驱逐的是另一门手艺:手写分发表、亲手铺内存账本、用编号管理上百实体的工匠技艺。平民化的每一步都是这个形状:旧的认知负担被剥离,旧负担的承担者随之离场。模型-视图-控制器三分同样在此列:显示与输入从业务数据里剥离,前端与后端的分工第一次有了语言级的说法;分工确立之日,全栈手艺人被拆成两种工种之时。任何抽象都有击穿条件,对象也不例外。分类学的击穿点在继承树里:继承最初是复用父类定义的手段,可一旦被当成代码复用的万能钥匙,层级越叠越深,改动父类的一处细节会沿着整棵树向下传导,对子类的惊动远超预期;大型项目里类数量膨胀到无人能俯瞰全图的那一天,就是分类学反噬之日,接口与组合取代继承的回摆随后到来。对话学的击穿点在消息的另一面:接收方自决意味着阅读发送方代码时无法一眼断定行为归属,理解的成本从书写时转移到了阅读时;错误推迟到运行时暴露,测试必须覆盖更多实际执行的路径才能找回编译期失去的确定性。孤立性在多核时代的第二重价值同样带着账单:对象之间只靠消息往来、没有共享状态,数据竞争随之消失,可消息本身的拷贝与排队是新的开销;1967 年为模拟港口设计的实体隔离,在半个世纪后恰好撞上并行硬件最稀缺的安全性,旧药治了新病,药费另计。
本章的断言是:Simula 与 Smalltalk 留下的真正遗产,是一次认知分工——让人只记结构的分类学,与让机器承担分发的对话学,共同构成了对象思想的完整形态;此后三十年工业语言的全部演化,都是在这份分工上讨价还价。这句话可以被反驳:如果未来出现一门主流语言,既不要分类学的骨架、也不用对话学的消息,却同样驯服了大型系统的复杂度并取下可观的工业份额,那么本章把两次诞生说成完整形态就是错的,对象只是漫长妥协里的一段插曲。
第 039 章 1972:C:给贴近金属的指针一份可移植外衣
2011 年 10 月中旬,全球各地的技术论坛上出现了一批奇怪的帖子:没有文字,没有图片,正文只有一个分号。那是程序员在悼念丹尼斯·里奇(Dennis Ritchie)——一周前,这位 C 语言的创造者在长期病痛后于新泽西的家中去世。在 C 语言里,分号标志一条指令的终结;用一行指令的结束来悼念一个人,是这门语言的使用者们能想到的最贴切的讣告格式。行业给里奇的官方评语里藏着一句后来被反复引用的判词:C 是一门诡异、有缺陷、却获得了巨大成功的语言。诡异与缺陷都真实存在——它把内存地址直接交到程序员手里,不做任何边界检查,数组在函数之间悄悄退化成一个光秃秃的地址;巨大成功也真实存在——五十年后,全世界几乎每一台联网设备的底层仍在这门语言写就的代码上运转。一门把最危险的东西原样交给使用者的语言,为什么成了历史上最普及的语言?答案要从一台只剩二十四 KB 内存的小机器说起。
一门为 24KB 而生的语言
C 不是从石头里蹦出来的,它的家谱可以一路数到剑桥。1960 年代的 BCPL 是一门极简的系统语言,肯·汤普森(Ken Thompson)在贝尔实验室参与 Multics 的岁月里用过它;1969 年贝尔实验室退出 Multics 项目,汤普森在一台几乎无人使用的 DEC PDP-7 上,用汇编写出了 Unix 的雏形,随后想在这台机器上跑一门高级语言——他从 BCPL 里提取简化,造出了 B 语言。这门语言有个极端的特征:完全没有类型。整门语言只认一种东西——机器字;整数是一个字,字符塞在字里,指针就是字数组的下标。这个设计在 PDP-7 上天衣无缝,因为那台机器按字寻址,内存编号的最小单位就是一整个字。里奇在 1993 年的回忆论文里给 B 下的定义带着调侃:B 可以看成没有类型的 C,更准确地说,是被塞进 8K 内存、又经过汤普森的脑子过滤了一遍的 BCPL。
B 语言的名字取自 BCPL 的首字母,C 的名字又取自它的次字母——两代人从同一份遗产里各取了一个字母,中间隔着一台换了的机器。B 语言还给世界留下了一个今天随处可见的小零件:自增与自减运算符。它的来历与数学无关,源头是硬件——PDP-7 的内存地址单元自带自动递增模式,汤普森顺着这个硬件特性,给语言加上了自增与自减运算符,让代码直接映射到机器的便利指令。这个细节预示了 C 的全部气质:语言特性不来自抽象理论,来自具体机器的肌肉。
转折在 1970 年到来。此前几年并不太平:Multics 项目的流产让贝尔实验室退出了这场分时盛宴,也让汤普森失去了可以施展的机器——他在走廊里找到的那台 PDP-7,原本是实验室的闲置设备。实验室买了一台新的 DEC PDP-11——处理器先到,磁盘又让人等了三个月;这台机器后来成了整个故事的摇篮。这台十六位机器与 B 语言有一个根本性的冲突:PDP-11 按字节寻址,内存的最小编号单位是八位字节,而 B 的世界只有机器字,指针就是字的下标——在字节机上,一个“字指针”连准确的地址都算不出来。更麻烦的是 B 是解释执行的,性能撑不起系统程序。里奇接手了汤普森的工作,把 B 逐步扩展成一个新语言,内部代号 NB(New B):加入类型声明,让 int 与 char 各归其位;把解释执行改编译;重做了指针与数组的处理,让指针可以按字节步进。类型在这台机器上并非学术洁癖,而是生存必需——字节寻址意味着“一块内存”与“一个字节”不再是一回事,字符占一字节、整数占两字节,指针必须知道自己跨出去一步是多远;没有类型的语言在字节世界里连一次加法都算不准。到 1972 年,这门语言与它的祖先已经足够不同,需要一个新名字——里奇选了 C,字母表上紧跟 BCPL 与 B 之后的第二个字母,像是给这段谱系盖下的一个邮戳。
新的语言被新机器的贫瘠雕刻成型。PDP-11 是当时小型机帝国的当家产品,造价不菲,即便如此它总共也只有 24KB 内存,其中一半要留给操作系统内核,留给用户程序的空间苛刻到每一字节都要与内核争夺——正是这种贫瘠逼出了 C 的全部气质:语言里没有冗余特性,每一个语法构造都必须有直接的硬件映射;一段 C 代码会被编译成哪几条指令,程序员大致可以预测。这种可预测性后来成了 C 与使用者之间的核心契约——它是一门你永远可以往下看到机器的语言,它也要求你往下看。换一个对照更容易看清这种气质:后来的主流语言一行代码背后往往站着一整个运行时的代理——内存有回收器看着,数组有检查器拦着,类型有系统护着;C 的一行代码背后没有代理,只有编译器照字面翻译出的几条指令。往上看是源代码,往下看是机器指令,中间没有夹层——这门语言的全部信任与全部危险,都住在这个没有夹层的空间里。
指针:把地址变成一等公民
C 从它的先辈那里继承的最重要的遗产,是指针;C 自己完成的最重要的改造,是让指针在字节寻址的世界里精确工作。指针的本质毫无神秘之处:它就是一个存着内存地址的变量——语言没有给地址披任何外衣。它的全部威力与全部危险,都来自类型系统给地址附加的两条规则。第一条:解引用一个指针时读取几个字节,由指针的类型决定——字符型指针读一字节,整型指针读四字节,双精度读八字节。第二条:指针加一跳过几个字节,同样由类型决定——这两条规则让“地址”从一个裸数字变成了带量纲的量,指针运算因此可以直接翻译成机器的寻址指令。量纲的效果立等可见:同一个地址,字符型指针加一后前进一字节,整型指针加一后前进四字节——加法的字面量相同,落到的位置不同;类型就是指针的尺,尺的单位由所指之物决定。这套设计的直接后果是:C 里的地址运算与物理内存的寻址是同构的,程序员写下的每一次解引用,都对应着机器的一条访存指令——语言与金属之间没有翻译损耗,也没有翻译保险。指针的规矩后来也在标准化时补了两笔:限定词让程序员可以声明“这个值不许改”或“这个指针不许挪”,另一个限定词则提醒编译器这个变量会被外部改动、别擅自优化——两个关键字都是后来加的,也都是给“信任程序员”的契约补订的附则。指针还是这门语言补齐自身缺口的万能胶:C 的函数按值传参,被调函数拿到的只是副本,想修改调用者的变量、想从一次调用里带回多个结果,唯一的办法就是把地址递过去——每一个初学者写不对的那个交换两个变量的函数,教的就是这门语言的世界观:要么接受副本,要么亲手交出地址。最著名的例子是字符串:C 没有字符串类型,一段文字就是一个字符数组,以一个值为零的字节收尾——读字符串的库函数从头走起,一直走到那个零字节为止。字符串有多长、内存够不够放,全部是使用者的责任;这个以零结尾的约定后来成了越界漏洞最经典的案发现场,也成了 C 语义最容易被指认的案底。同构的自由还延伸到了代码本身:函数在内存里也有地址,把函数的地址存进变量、当作参数递给别的函数,语言同样不加限制——回调、插件、状态机,这些今日软件的骨架结构,全部建立在这门语言把“代码也是地址”当常识的起点上。
数组与指针的关系是这套语义里最精妙也最容易伤人的部分。C 规定,数组名在表达式里会退化成指向首元素的指针——数组下标访问 arr[i] 在编译器眼里就是 *(arr+i),即“从首地址出发、按元素步长走 i 步、再解引用”。退化有一个让几代初学者集体翻车的副作用:数组作为函数参数传递时,形参列表里写的 int arr[] 与 int *arr 完全等价,编译器实际传给函数的是指向首元素的地址;于是同一个数组,在函数外用 sizeof 算出的是整片内存的大小,进了函数再算,得到的只是一个指针的大小。长度信息在越界的那一刻就消失了,函数从此不知道自己拿到的是十个元素还是一万个——它只领到一个起点。这个语义的源头仍是那台机器:B 语言的指针本来就是字数组的下标,“指针即下标”的观念深入骨髓;当 C 在字节寻址的机器上重建指针时,里奇保留了指针算术的全部语法,只是给每一次跨步乘上了类型的字节数——旧世界“指针即下标”的直觉被原样保留,新世界“字节与字宽”的复杂性被类型悄悄吸收。数组的退化,是这场翻译工程里最不动声色的一处接缝。
数组 a[4]:连续 16 字节(每个 int 4 字节)
地址: 0x1000 0x1004 0x1008 0x100C
┌─────────┬─────────┬─────────┬─────────┐
│ 10 │ 20 │ 30 │ 40 │
└─────────┴─────────┴─────────┴─────────┘
│ │
a, &a[0]│ │a+2 (即 &a[2], 步长 4 字节)
▼ ▼
sizeof(a) = 16 ── 例外1:sizeof 处不退化
&a = 数组指针 ── 例外2:&a 处不退化
其余一切场合:a 退化为 &a[0],类型 int*
传参:void f(int arr[]) 完全等价于 void f(int *arr)
── 函数内只拿到一个地址,长度需另传
这个设计不是疏忽,是三重算术的结果。第一重是效率:数组可能很大,传参时整体复制一份,时间与栈空间的开销在当时不可承受。第二重是哲学:C 的世界里,数组本来就是一段连续内存的首地址,“传数组”从来就是“传地址”,没有必要为同一个东西发明两套语法。第三重是那台机器:在 24KB 的预算里,为数组的每一次传递附加长度信息、为每一次下标访问插入边界检查,都是要花真实内存与真实周期去支付的奢侈品。长度信息的消失、边界检查的缺席,与指针的全部自由,是同一枚硬币的三面——这枚硬币的名字叫“不为安全付运行时的钱”。
无边界检查:一笔 1972 年的理性账
今天回头批判 C 不做边界检查,几乎成了编程语言的道德仪式。但把时间拨回 1972 年,这笔账的算法完全不同。每一次边界检查都意味着:每一次数组访问前多一次比较、多一个条件跳转、多一份存放长度信息的内存——在 PDP-11 的 24KB 里,写操作系统的每一个字节都要与内核争夺,运行时检查无异于“加一层保险”——而且是直接从本已见底的空间里抽血。C 的服务对象是写 Unix 内核的人:他们要的是写出的每一行都能预测成哪几条指令,任何隐藏在语言之下的运行时代理都是敌人。所以 C 的选择干脆得近乎冷酷:语言不做任何检查,数组的边界由使用者自己守住,指针的合法性由使用者自己担保。这门语言的克制,从它的类型清单上看得最清楚。C 的基本类型只有几个宽度不一的整数与浮点,加上派生规则;它没有字符串类型——字符串是一段以零字节结尾的字符数组,结尾的哨兵由程序库的约定维护;它多年没有布尔类型——真与假就是整数的一与零;它甚至没有真正的数组参数——上一节已经看过,数组在函数之间就是一个地址。这些“缺失”没有一个是遗漏:每一种补齐它们的语言设施,都意味着一层运行时的代理与一份程序员看不见的开销,而 1972 年的预算里没有这一项。这门语言的设计者后来被概括出的立场是:C 是为专业系统程序员准备的工具,它给予程序员对硬件的绝对控制权,同时要求程序员承担内存管理的全部责任——信任程序员,是 C 的一切前提。
静默是这类错误最险恶的性质。一个循环多走了一步、一次复制少算了一个字节,写下的数据就会落进相邻变量的领地——比如函数里紧挨着放着一个存循环上限的整数,越界的那一次写入恰好把它改成一个大数,循环从此永无止境地写下去,把栈上所有东西挨个碾过。程序不会在案发现场崩溃,它带着被污染的内存继续运行,直到很远之后某个不相干的计算莫名出错。调试者赶到时,证据早已被时间冲刷;案发与爆发之间的距离,是这类漏洞的刑事责任最难认定的地方。围绕这份信任,两种立场争了几十年:批评者说,把边界检查的责任推给程序员,等于把整个行业的内存安全押注在“人人永不犯错”的假设上,而这个假设五十年间天天被证伪;辩护者说,检查的代价是真实的,而且不该由不需要它的人支付——一门允许你关掉保护的语言,与一门不许你关掉保护的语言,提供的是两种不同的自由。这门取舍在后来的语言分化里被无限放大。此后主流的新语言几乎都走了另一条路:把边界检查、垃圾回收、类型安全内置进运行时,用持续的运行时代价购买永久的安全垫——代价是每一次数组访问多一次比较、每一块内存背后多一层簿记,以及一个常驻内存的运行时系统。安全的账没有消失,它只是从程序员的工时搬进了 CPU 的周期表;C 时代的代码与托管时代的代码之间的所有恩怨,源头都是 1972 年那笔关于“由谁来付安全账”的分工。而选择留在 C 世界里的工程师,则把信任转化成了制度:汽车与医疗行业的编码规范逐条禁用危险的写法,静态分析工具昼夜扫描每一个可疑的越界,代码评审的第一问永远是“这里的长度谁保证”——一份 1972 年签下的无检查契约,由整个行业用五十年的流程建设来代偿。1973 年,汤普森与里奇用 C 重写了 Unix 内核——操作系统历史上第一次,一个主要系统脱离汇编、用高级语言写成。在当时这是一件近乎离经叛道的事:系统程序的圣地是汇编,高级语言被普遍认为“效率无法比拟手工精细优化”,用它写内核等于把系统的命脉交给一个未经证实的翻译官。重写用实际性能终结了这场争论:C 编译出的内核跑得足够快,而它带来的东西是汇编永远给不了的——整个系统变成了一份可以被另一种机器重新编译的文本。此后四十年,优化编译器的每一次进步都在继续这场翻案:今天编译器生成的代码质量,早已反超绝大多数程序员手工所能达到的水平;当年那道“无法比拟手工”的判词,被一代代编译器研究者逐字收回。语言由此获得了一个最强的能力证明,也背上了一个最重的身份:从此每一台想运行 Unix 的机器,都得先学会说 C。此后的连锁反应超出了所有人的预期:因为操作系统本身是 C 写的,把 Unix 移植到新机器,等价于给新机器写一个 C 编译器;编译器与操作系统绑在一起扩散,Unix 的系统接口也顺理成章地长成了 C 函数与 C 结构体的形状。可移植性这一次跳跃,比表面看起来更惊险。此前的操作系统与它的机器是焊死的:汇编指令的每一条都对应特定型号的电路,换机器等于从零重写。C 的翻译方案是把机器差异装进两个抽屉:语言里留白的部分(比如整数的准确宽度)由每台机器的编译器自行决定,语言里确定的部分(字符是一字节、指针的步长语义)由所有机器严格遵守;配套的可移植编译器把与机器相关的代码压到全部代码的两成左右。为移植新机器补上的 long 与 short 两个类型,就是这个抽屉机制的产物——文件偏移需要三十二位、旧数据需要十六位,语言不再假设宽度,而是把宽度变成可选件。一整套操作系统软件,从此第一次变成了可以随身携带的行李。这件事改写了硬件行业的生意经:从那以后,卖一台新机器就必须配一个 C 编译器,编译器成了硬件出厂的标配附件;四十多年后剑桥那家小公司发布自己的第一颗处理器时,先写好的也是 C 编译器——芯片与编译器从此在产业上结成了不能拆散的连体婴。别的语言要调用系统、要与系统对话,都得按这套格式来——C 的普及不是靠语言特性打赢的,而是靠它寄生其上的操作系统。留白的代价同样在几十年后现形:整数宽度由编译器自行决定,意味着同一段代码在十六位机器与三十二位机器上可能算出不同的结果——当年为可移植性留的活口,在一代代码迁移时变成了成片的隐患;后来标准一次次收紧宽度的下限,就是在为这笔旧账补利息。1978 年 2 月,克尼汉(Brian Kernighan)与里奇合著的《C 程序设计语言》出版,这本被昵称为 K&R 的白皮书成为此后十余年 C 语言的事实标准。写书的人此时已经拿遍了这门手艺能拿到的荣誉:里奇 1941 年生于纽约,在哈佛拿到数学博士后进入贝尔实验室,与汤普森共享了 1983 年的图灵奖与美国国家技术奖章。他生性低调,此后四十年几乎没有离开过贝尔实验室的继承者;2011 年 10 月他去世时,主流媒体的讣告篇幅远小于同年早些时候另一位苹果创始人得到的,但全世界的程序员用一行分号完成了科技史上最克制也最准确的一次集体致哀。书中示例代码的排版风格——大括号怎么换行、缩进怎么处理——被称作 K&R 风格,至今仍是 Linux 内核的官方代码风格。1989 年,美国国家标准协会的委员会把 C 收编为正式工业标准(C89),为它补上了函数原型与类型限定词等机制,语言从两间实验室的事实约定,变成了全世界的契约文本。K&R 的遗产不止于语言本体:那本书里示例代码的排版习惯——大括号跟在行尾、缩进用制表符——被戏称为“唯一真正的大括号风格”,此后几十年关于大括号该另起一行的所有论战,都是从这本白皮书的排版里长出来的宗教战争。此后半个世纪,C 的标准一路演进——1999 年的修订加长了特性清单,2011 年引入多核时代的内存模型,2024 年的新标准甚至彻底废除了 K&R 式的旧函数声明——但它的核心语义,指针、数组、无边界检查,从 1972 年到今天一字未改。最耐人寻味的是 2024 年那版标准的一个细节:半个世纪前写下的 K&R 式旧函数声明,被从语言里正式废除——这门最保守的语言用了五十二年,才温和地清掉了自己出生时的第一份语法;而指针的每一个字节,都原样保留。
高危自由的账单
自由的价格在 C 自己的语义里就写着。没有边界检查,意味着越界读写不会在任何一层被拦截——程序会静默地读写邻居的内存,把别的变量改得面目全非,或者把写进去的数据埋在自己都不知道的地方;这一切没有任何报错,错误要到很远之后的某个不相干时刻才爆发。指针的灵活性则源源不断地制造新的危险形态:未初始化的野指针指向随机地址;已释放内存上残留的悬垂指针随时可能被再次解引用;空指针的一次疏忽解引用就能把整个进程打崩。与 C 同年代有一门著名的对照语言。帕斯卡——沃斯在 1970 年前后设计的语言——几乎在每一个 C 放纵的地方都竖起了栏杆:强类型、明确长度的字符串、编译期的范围约束。两门语言同年成熟、面向不同的人群,此后半个世纪的路线之争,本质上是同一个问题的两次作答:语言应该替程序员挡住什么?帕斯卡的答案是教育场景里的一切,C 的答案是——什么都不挡。历史给了两个答案各自的疆土:一个成了计算机系的教材,一个成了全世界的地基;这场分岔没有胜者,只有各自被自己的用户养成的形状。同一时期的另一门语言提供了反面坐标:PL/I 试图用一门语言同时统一科学计算、商用处理与系统底层,规范庞杂到没有编译器能完整实现它——C 走了严格相反的路,把几乎所有“通用”的诱惑全部砍掉,只留下系统编程那一亩三分地里最必要的收成。两门语言后来的命运,给所有语言设计者立了一杆秤:语言的力量与它敢不做什么成正比。C 的使用者们用几十年时间编纂了一门专门识别这些陷阱的知识体系——那些被标准默许、被编译器纵容的歧义点与边界漏洞,被一代代工程师写进书里、贴进代码评审清单、编成静态分析工具的规则库。这门语言最著名的攻击案例——利用缓冲区越界改写执行流程的整类漏洞——其设计根源都在 1972 年的那笔账里;它们在安全史上的深度清算,是本书后面章节的任务,此处只立此存照:把高危自由全盘交付给程序员的决定,让整个软件产业在此后五十年里,为“边界”两个字支付了以百亿美元计的防御成本。而 C 的接口帝国也在同步扩张:此后几乎所有新语言——不管自己多么安全、多么现代——要调用操作系统、要追求极致性能,最终都得按 C 的函数格式与结构体布局递出名片。语言的疆界由编译器划定,编译器的疆界由操作系统划定,操作系统的接口由 C 划定:这是一条让所有后来者都无法绕行的引用链。
这笔账单的另一面同样需要记账,否则对 C 的清算就成了不诚实的追债。它交付的高危自由,正是它全部价值的来源:操作系统内核、设备驱动、嵌入式固件、高性能基础设施——所有需要“每一行代码都可预测、每一次访存都不经中间人”的领域,五十年间没有找到替代品,直到近年内存安全语言才开始在系统层站稳脚跟——安卓平台新代码里内存安全漏洞的占比,直到 2025 年才第一次降到两成以下,而即便是进入 Linux 内核的 Rust 代码,也还要先包一层 C 的接口才能与旧世界对话。给金属穿衣服的这门语言,衣服薄到看得见金属的纹理;五十年来所有想给它加厚的人,最后都不得不承认:需要直面金属的场合,至今仍是它的疆土。
回望 1972 年的那笔设计账,真正的要害不是里奇选了什么,而是他的选择标准。语言的每一个特性都要问:在 24KB 里值几个字节、几个周期?边界检查不值得,长度信息不值得,运行时代理不值得——于是它们全部出局;地址运算值得,硬件映射值得,可预测性值得——于是它们全部入选。C 是被一台小型机的内存条雕刻出来的语言,它的每一处危险都对应着一处当时的理性。这正是本章要留给卷四的证词:语言设计的每一次取舍,都是认知带宽与硬件表达之间的讨价还价——C 把几乎全部认知负荷压到了程序员身上,换来硬件表达的零损耗;这门语言此后的一切荣光与一切罪债,都从这笔交易的那一刻起息。它可以被指责为把汇编的高危自由原样交给了程序员,但不能被指责为不知情:从第一行代码起,这笔账的双方都签了字,签名的墨水,是 PDP-11 上那 24KB 买不起的边界检查。五十年后回看,这份契约的双方其实都履了约:程序员交付了五十年不知疲倦的边界守卫,C 交付了五十年从不动摇的可预测——契约没有违约,违约的是环境:当机器的内存从 24KB 涨到几十 GB,当软件的规模从千行涨到亿行,当初那笔交易的定价前提,已经在几乎所有地方悄悄失效;只有契约文本本身,因为写得足够诚实,一直留到了今天。1988 年,白皮书为标准化出了第二版;2024 年的新标准废除了 K&R 式的旧声明——文本修订了两轮,契约的条款一字未动。它的血脉也早已漫出语言本身:为系统而生的直系后裔继承了它的指针与性能哲学,为应用而生的各路新语言继承了它的语法外衣,连最坚决的批判者设计的内存安全语言,也要先学会与它对话才能进入它统治的领地。判断一门语言的历史地位,从来不是数它自己写了多少代码,而是数整个世界有多少代码在用它的方式说话。2011 年 10 月,程序员们把分号贴上论坛的那一刻,他们悼念的其实不止是一个人:那个分号在 C 里意味着一条语句的终结,而里奇留下的语句——每一台开机自检的设备、每一个路由数据包的内核——没有一条就此终结。用终结符号致哀,悼念的却是永不终结的运行,这大概是同行能给出的最高技术评价。
第 040 章 1972:Prolog:一阶谓词逻辑作为声明式程序
1981 年 10 月,东京。日本通产省向全世界宣布了一项为期十年的国家计划,通产省的官员在发布场合毫不掩饰地表示,日本要定义计算的下一个时代:造出第五代计算机——不再基于冯·诺依曼结构,而是以逻辑推理为核心的知识信息处理机器,机器语言已经选好,就是一门在法国南部的大学里诞生了九年的小众语言 Prolog。西方世界震动的方式很有时代特色:彼时的日本半导体与消费电子正把美国同行打得节节败退,通产省的产业扶植模式刚刚被验证了二十年,没有人敢把这份计划书当作空炮。美国政府火速牵头组建产学研联合体,英国启动自己的阿尔维计划,欧洲共同体立项尤里卡——一场以“逻辑”为武器的算力军备竞赛,因为一份东京的计划书而被点燃。十年后,计划按期结束,专用机器没有走出实验室,项目解散,日本在这场豪赌中投下的数百亿日元没有换来它许诺的任何一台商用系统。但这场大溃败纪念的这门语言值得被认真对待:Prolog 是人类第一次把数理逻辑直接变成编程语言——程序员不再告诉机器怎么做,只声明什么为真,推理交给机器。它与 C 同年诞生:一个把人拽向金属,一个把人拽向数学;两门语言在 1972 年分道扬镳,各自代表了对“人类认知带宽”这笔预算的相反花法。
马赛的小组
Prolog 的出生地是法国艾克斯-马赛大学的一间人工智能小组。组长阿兰·科尔默劳尔(Alain Colmerauer)的研究领域不是计算机,而是自然语言处理——他想让机器理解人类语言,而这需要一种能表达“关系”与“推理”的语言:机器要能回答关于一句法语的问题,就得先有能力存储词与词之间的关系、再从关系里推出答案。这个需求把马赛小组推到了数理逻辑的门口——Prolog 的第一个真实用例,正是用规则处理法语的句子结构:语言处理是这门语言的本命,人工智能的其余应用都是它后来的开枝散叶。它的精神谱系则要上溯三百年:霍布斯说“推理就是计算”,莱布尼茨梦想一种把人类思想化为符号演算的通用文字,让争论的哲学家们像会计师一样拿出纸笔说“让我们算吧”——Prolog 是这句三百年的口号第一次拥有了一门可执行的语言:把逻辑写成程序,把提问变成计算。理论的一半来自英国:罗伯特·科瓦尔斯基(Robert Kowalski)在爱丁堡提出了霍恩子句的过程式解释——数理逻辑里有一类形状规整的子句(后来以逻辑学家霍恩命名)——它们至多只有一个肯定的结论,形如“如果条件一成立且条件二成立,则结论成立”。形状的限制换来了决定性的性质:这类子句的证明过程可以完全机械化,科瓦尔斯基发现,这类子句不仅可以当作逻辑命题来读,还可以当作过程来执行:子句的前提是“怎么证明”,结论是“要证明什么”,证明一个目标等价于执行一段程序。这个解释把两个此前互不相干的世界接通了:逻辑学家的定理证明器,与程序员的编程语言,从此说的是同一件事。科瓦尔斯基后来把这次接通概括成一个公式:算法等于逻辑加控制——逻辑描述“要解决什么”,控制描述“怎么解决”,两者可以分离、可以各自演化;马赛与爱丁堡的两个小组,恰好一个深耕逻辑、一个深耕控制,Prolog 是这场双城协作的产儿。理论落到实现的另一半在马赛完成:1972 年,科尔默劳尔与菲利普·鲁塞尔(Philippe Roussel)写出了第一个 Prolog 解释器——用 Fortran 写的。语言的名字是鲁塞尔定的,他听了妻子的建议,取法语 Programmation en logique(逻辑中的程序设计)的缩写。这门语言此后最重要的一次技术接力发生在爱丁堡:沃伦(David Warren)把马赛的 Fortran 解释器带到苏格兰,重写了前端与编译器,确立了此后所有实现沿用的“爱丁堡语法”,又把解释执行的核心思想提炼成一台抽象机——后世几乎每一个 Prolog 系统,都是这台沃伦抽象机的后代。第一门逻辑编程语言的名字里带着法语,这门语言后来的主要对手叫 Lisp——欧洲人与美国人在人工智能的路线之争里各执一端,争了几十年。而支撑这两家的自动推理技术,源头是 1965 年罗宾逊提出的归结原理:它能自动证明一阶谓词逻辑的定理,是机器定理证明领域数十年积累的最高峰——Prolog 的搜索内核,就是把这条数学引擎装进了一门语言。
事实、规则与提问
Prolog 的世界观可以用三个词说尽:事实、规则、查询。程序员的工作不再是描述“怎么做”,而是陈述“什么为真”。事实直接声明关系成立:某某是某某的父亲。规则声明条件化的真理:如果 X 是 Z 的父亲、Z 是 Y 的父亲,那么 X 是 Y 的祖父——竖杠加等号的写法读作“如果”。查询是向知识库提出的问题:X 是谁的父亲?机器的回答方式不是执行一串指令,而是搜索一棵证明树。
驱动这台证明机器的是两个机制。第一个叫合一(unification):把查询与规则的模式对齐,变量与常量互相绑定——查询“约翰的祖父是谁”会先与祖父规则的模式合一,再顺着规则的条件一路绑到具体的事实上;这个看似简单的匹配算法,是整门语言唯一需要“计算”的地方,后来它还悄悄统治了另一个领域——函数式语言的类型推断,本质上就是类型之间的合一:编译器为两个类型表达式找一组变量替换,让它们变得完全相同,与 Prolog 为查询和规则找绑定,是同一个算法在两块大陆上的各自远行。第二个叫回溯(backtracking):Prolog 默认按深度优先搜索证明树,一条路走到头发现证不下去,就退回到最近的选择点,换一条路再试——所有可能的解,都在这棵树的遍历里被逐个枚举——Prolog 的执行器不生产答案,它只系统地遍历答案可能藏身的所有岔路。它与 C 的对照在每一个编程概念上都成立。C 的变量是存储单元,赋值是覆盖;Prolog 的变量是待解的未知,它一经绑定就不再改变,名字里带着的是一次求解的结果——顺序也是如此:C 由程序员排列每一条语句,Prolog 由搜索器自己决定先证哪一条。C 的程序是一串顺序执行的步骤,顺序错了结果就错;Prolog 的程序是一组彼此独立的事实与规则,子句的先后在理论上不影响真伪。C 的控制流由程序员亲手搭建——循环怎么转、分支怎么走、函数怎么调用;Prolog 的控制流被语言接管——搜索、回溯、枚举,全部是执行器的内政。这不是两种语法,是两种世界观:命令式把认知负荷花在“过程”上,声明式把它花在“结构”上。今天绝大多数程序员每天都用过一次声明式的胜利成果——数据库查询语言的本质就是声明式:你说出要什么数据,由查询优化器决定怎么取;只是这门语言被关在数据库的围栏里,从未被允许接管整个软件。
两台机制合在一起,产生了一种与 C 完全相反的编程体验,也让两种关于“谁该思考”的哲学第一次在软件里正面相遇——这是 1972 年的两场分岔里更彻底的那一场:在 C 里,程序员是调度者,要亲手安排每一步的顺序、每一次内存的去向;在 Prolog 里,程序员是立法者,只负责写下世界应当满足的定律,执行的顺序、搜索的路径、解的枚举,全部是语言的职责。把认知从“过程”里解放出来——这是逻辑编程对人类认知带宽的深情款款。
学习它的门槛不在语法而在世界观:变量不能先声明后赋值,只能被绑定一次;循环要靠递归表达;程序的运行结果是一组解,而不是一个返回值——从命令式世界过来的程序员,要换掉的往往是十几年的肌肉记忆。它的执行模型值得用一张图钉死——同一份家族知识库,查询“谁是汤姆的祖父”展开成的搜索树:
知识库(节选) 查询: ?- grandfather(X, tom)
father(john, mike). │
father(mike, tom). ▼
mother(lily, mike). 规则: grandfather(X,Y) :-
male(mike). father(X,Z), father(Z,Y)
│ 合一: X=john, Y=tom
▼
子目标1: father(john, Z)
│ │
Z=mike Z=lisa(失败,回溯)
│
▼
子目标2: father(mike, tom) ✓
│
▼
解: X = john
深度优先、最左优先、失败即回溯——Prolog 的执行策略简单到可以一句话背下来;这条策略在绝大多数场景工作良好,但它也有代价:搜索树的形状由子句与目标的排列顺序决定,顺序不当会让证明在错误的分支上无限深入;程序员手里那把叫“截断”的剪刀,剪掉的是搜索分支,剪掉的也是逻辑的纯粹性——声明式语言里最常用的操作,恰恰是命令式逻辑的一次秘密返场。另一个暗中让步的是失败否定:证明不出来就当作假——这条规则在工程上极其顺手,在逻辑上却等于悄悄假设“知识库里没有的就是世界上没有的”;数据库的人把这叫封闭世界假设,逻辑学家则一直对它心存警惕。这个内在的紧张关系,是理解它后来全部命运的钥匙。把它与截断合在一起,可以列一张“声明式的泄漏清单”:子句顺序影响求解路径,搜索可能永不终止,截断破坏逻辑纯度,失败否定悄悄假设了一个封闭世界——每一项都是声明式许诺的“只写结构、不管过程”在某处的破口。声明式没有取消过程,它只是把过程藏进了执行器的黑箱;黑箱在玩具上完美,在真实世界的规模上开始漏水。
东京的十年豪赌
把这门语言推向历史舞台中央的,是一场国家级的豪赌。1980 年前后的日本经济如日中天,通产省的官员与日本学界的主流判断都相信,计算机的下一场革命不再是更快的算术,而是知识的处理:冯·诺依曼结构的机器为数值计算而生,已经成为知识时代的瓶颈,新一代机器必须以逻辑推理为心脏。1982 年 10 月,通产省正式启动第五代计算机系统项目,为期十年,预算以数百亿日元计——这是人工智能历史上最大规模的政府资助项目之一。项目的灵魂人物渊一博为它起了个刻意区别于传统计算机的名字:知识信息处理系统。这个命名的言外之意是一场宣言:冯·诺依曼结构为数值计算而生,存储程序、顺序执行的骨架在知识处理面前已经成为瓶颈,第五代机器必须换一副骨架——大规模并行、新的存储结构、新的编程语言、新的人机方式,四样缺一不可——十年计划据此拆解成三条产品线:并行推理的硬件、以 Prolog 为核心的系统软件、面向知识处理的应用接口,每一线都由政府研究所在头、企业研究所与大学在侧。它的机器语言,选定了 Prolog——或者说选定了 Prolog 的一种并行变体;它的性能指标,也用这门语言的方式计量:每秒执行多少次逻辑推理,单位叫 LIPS。项目为它设计了专门的硬件:合一运算的专用单元让最频繁的模式匹配在单个时钟周期内完成,硬件回溯栈让搜索的状态切换不再拖慢推理,大规模并行推理引擎把证明树铺到成百上千个处理单元上——性能的计量单位被定为 LIPS,即每秒完成的逻辑推理次数;当时典型的工作站只能做到每秒十万次,第五代机器的目标比它高出千倍以上。在东京的实验室里,Prolog 不再是一门跑在通用机器上的语言,它就是机器本身的设计纲领。
西方世界的第一反应是恐慌式跟进:美国政府牵头组建产学研联合体,英国启动阿尔维计划,欧共体立项尤里卡——东京的一纸计划书,让整个西方在人工智能上的公共投入在几年内膨胀了几个数量级。第二反应才是冷静的:Prolog 的拥护者们不得不面对一个尴尬的时间差——当时典型的工作站每秒大约能完成十万次逻辑推理,而项目的目标机器要的是这个数字的一千倍以上;为此设计的并行推理硬件,每一个部件都在挑战那个年代工程学的边界。十年之内,项目确实造出了机器:串行推理机、并行推理机的原型相继点亮,围绕它开发的核心语言与操作系统也按时交付——单看工程执行,这是一次合格的国家级攻关。1992 年项目期满,机器没有走向市场,商业化的目标一项都没有实现,项目解散,实验室关闭。它没有制造出第五代计算机;它制造了大量论文、一批优秀的研究者,以及一场让全世界为人工智能虚热了十年的预期。复盘这场溃败,四条原因层层叠加。最底层的是算法与现实的一线之隔:逻辑推理的搜索空间天然组合爆炸,通用程序里“最坏情况”出现的频率,远比学术原型里的玩具问题高——实验室里秒解的查询,搬到真实规模的数据上就是天文数字的搜索。第二层是硬件追赶的失速:专用推理机的每一代原型都要三五年,而通用芯片的进化以年为单位翻番,专用的千倍优势在通用的一万倍进步面前迅速清零——为一种语言造硬件,等于与整个摩尔定律赛跑。第三层是生态的空白:围绕推理机需要重写操作系统、编译器与应用,而全世界的软件人才都是过程式思维的产物,招不到也来不及培养足够多的声明式程序员。最上层才是那场时代风暴:项目过半,专家系统的商业泡沫在全球崩裂,人工智能的第二次寒冬降临,所有为“知识处理”预热的资本市场同时撤资——政策耐心与商业耐心,在同一时刻到期。
反事实短栏:如果逻辑式统治了数据库与操作系统
**推演纪律。**本栏只挪动一个变量:主流编程范式的归属——假设声明式(逻辑式)而非命令式在数据库与系统软件领域取得统治;硬件成本与组织形态按史实推演,不叠加假设。推演的边界:范式更替只追问“软件长什么样”,不追问芯片指令集是否随之重设计——那是另一个量级的假设。
没走的路:让我们认真展开这个从未发生的分支——如果 1972 年之后的主流世界选择了逻辑式编程:操作系统内核以逻辑推理执行,数据库成为知识库的天然形态,Prolog 及其子孙成为与 C 平起平坐的系统语言。这个分支并非纯粹幻想:它的每一块基石在当时都已存在——SQL 证明了声明式查询可以被产业接受,Prolog 的子集 Datalog 后来真实地在数据库领域扎了根,约束求解器至今仍在芯片验证与调度系统里服役。
当时为什么没走:因为两笔账都算不过来。第一笔是硬件账:逻辑推理的执行引擎需要合一单元与回溯栈,通用处理器没有这些部件,为它们造专用硬件的成本在当时是天文数字——日本的十年证明了这笔投资在通用性能上完全追不上主流芯片的进化速度。第二笔是效率账:深度优先搜索在最坏情况下是指数级的,通用软件对“最坏情况”极其敏感——一个每次响应都可能触发表引爆指数搜索的内核,在工程上无法交付。声明式把“怎么算”交给机器,代价是机器无法向你承诺“何时算完”——这层不确定性,通用计算的世界承担不起。
如果当年选了它会怎样:软件的漏洞形态将发生一次整体的结构性搬家。今天我们熟悉的漏洞大类——缓冲区溢出、悬垂指针、未初始化内存、数据竞争——全部依附于“程序员手工管理内存与顺序”的命令式世界观;在一个声明式的世界里,这些漏洞绝大多数根本没有出生的土壤:没有手工内存管理,就没有溢出与释放后使用;没有手写循环,就没有越界。取而代之的新漏洞谱系会是另外一副面孔:搜索不完备——推理策略剪掉了本该找到的解,程序“静默地少答了”;知识库不一致——两条规则推出矛盾的事实,系统的回答取决于子句的物理顺序;截断滥用——为了性能插入的剪枝悄悄改变了解的逻辑含义,声明式的纯粹性被性能补丁一寸寸腐蚀;以及最普遍的一种:解空间组合爆炸——一个合法的程序在真实数据规模上永远算不完。安全从“守住内存边界”变成“守住逻辑完备”,攻防的主战场从堆栈转移到知识库。
它在哪个细分受限领域活下来了,付出了什么代价:这个分支没有整体发生,但它的碎片在多个领域各自存活。数据库世界里,SQL 作为声明式查询语言统治了半个世纪——逻辑式思想在数据查询这条支线上全面胜利,只是它从未向上侵蚀操作系统与系统编程;Datalog 作为 Prolog 的确定性子集,至今活在分布式数据一致性验证与程序分析工具里;约束求解器成为芯片设计与软件验证的隐形基石,每一次芯片流片前的形式验证里都跑着它;日本第五代项目的遗产——并行推理架构的研究、约束语言的设计经验——沉淀进了此后所有关于专用加速器的思考。付出的代价同样清晰:Prolog 至今不是任何主流系统的底层语言,它的执行模型始终没能与通用硬件和解;第五代计划的失败让“为语言定制硬件”成为一个此后三十年无人敢碰的禁区,直到深度学习时代图形处理器意外成了新的例外。一个范式没有统治世界的原因,与它统治了几个子世界的原因,是同一个:它省下的认知负荷,需要硬件用一种当年造不出的形状来偿还。
惨败的清算与幸存的根
第五代计划的溃败是多因的合力,没有单一的责任人。硬件的赌注押错了前提:推理的搜索空间天然组合爆炸,指望专用硬件压住指数曲线,如同指望更快的马追上火车——通用芯片靠着存储层次与流水线的进化每年翻番,专用推理机的每一代原型都在追赶一个移动的靶子。软件的赌注押错了生态:Prolog 的执行模型对程序员是解放,对产业是门槛——主流软件世界的信息与工具链全部为过程式语言而建,一门需要换掉全部思维习惯的语言,在商业世界里不可能靠先进性换防。时代的运气也站在反面:项目启动时专家系统的市场正在膨胀,项目过半时那场市场崩塌与第二次人工智能寒冬一起到来——所有为“知识处理”下的注,都随专家系统的退潮一起蒸发。1992 年项目结束,机器封存,研究者散入学界与业界,东京没有为它举办任何纪念。清点这笔国家投资的损益表,支出栏写满了:数百亿日元的公共资金、十年里最优秀的一批日本计算机科学家、以及一个被推迟的产业共识——日本此后在通用软件领域的缺席,与这场全押专用路线的失败不无关系。收入栏同样写得具体:并行推理机与约束求解的研究经验、一整套关于“如何组织国家级长期研究”的得失样本,还有那些在项目结束后散入学界与业界、把逻辑编程的种子带到各处的研究者——巨舰沉没了,船上的人把航海图带上了岸。另一边的损益表也该翻看:被东京计划吓得仓促上阵的美国联合体与英国阿尔维计划,同样没能造出革命性的机器,却把大笔资金灌进了人工智能的学术系统——为一场虚惊支付的费用,意外养活了两个大洲的十年研究。豪赌的历史作用,经常由输家与被吓坏的人共同书写。
这门语言本身的遗产,则比它的赞助者活得长久。约束逻辑编程把 Prolog 的搜索内核变成了工业调度的求解器;数据日志语言(Datalog,Prolog 的确定性子集)在分布式系统的数据一致性验证与程序分析工具链里成了标准件;Datalog 在数据一致性验证与程序分析的工具链里持续服役;合一算法成了类型系统的隐形骨架——每一种支持类型推断的现代语言,编译器里都跑着那个 1970 年代马赛小组打磨过的匹配算法;逻辑推理作为思想,还在每一次形式化验证、每一枚芯片流片前的定理证明里运转。它没有统治数据库与操作系统,却在所有“需要机器自己推理”的角落里扎了根——这样的角落比想象中多:从航空公司的机组排班,到电信网络的故障诊断,到编译器自身的寄存器分配,约束与推理的影子无处不在;1995 年,国际标准化组织为它颁布了正式标准,一个在马赛实验室里随想而生的名字,最终进入了工业契约文本;知识图谱、语义网络这些新一代的知识工程概念,追溯祖脉时都要经过这间马赛的实验室。SWI 与各类实现至今仍在教学与研究的一线服役,逻辑编程的会议与期刊从未停刊。为它豪赌的那一代人也没有白付:第五代项目训练出的研究者与工程经验,成了此后日本信息技术产业几代人的人才底仓;它逼出的并行推理研究,是后来一切专用加速器思想的远祖——错了方向的项目,常常是正确方向的探路费。就连“为特定计算模型定制硬件”这个念头本身,也在三十年后以另一种计算模型的名义全面复活:当深度学习需要海量矩阵乘法时,行业为它造出了专用加速器,整套思路与当年的推理机如出一辙,只是这一次,数据流的形状终于与硬件的形状对上了。同一个年代,上一章里那条被频率之墙终结的路线也在同步转向——多核、专用加速、为负载定制硬件,计算机工业的两条战线在 2005 年前后得出了相似的结论:通用处理器的一统时代结束了,计算的未来属于为特定形状的负载而生的机器。
回望 1972 年这个奇怪的年份,两门语言在同一时间线上的分道扬镳,值得被并排阅读:C 把语言的抽象层削到最薄,让程序员的每一行代码都贴着机器的纹理,用人类认知的全部辛劳换取机器的零损耗;Prolog 把语言的抽象层抬到最高,让程序员的每一行声明都远离机器的细节,用机器推理的全部辛劳换取人类认知的解放。前者押注人类的认知带宽可以被训练和组织,后者押注机器终将替人类承担推理的辛劳;半个世纪过去,两边的赌注都部分兑现又部分落空——C 的世界建立了庞大的流程与工具来补偿它转嫁给程序员的认知负荷,Prolog 的世界证明了机器接管推理的前提是硬件先长出推理的器官。把它与本卷的其他章节并排放着,卷四的整条张力轴就清晰了:C 与它的后裔们贴着金属,把一切认知重担留给程序员;Prolog 贴着数学,把一切过程重担留给机器;中间的 Pascal 在教学场景里寻找平衡,Smalltalk 在图形界面里重新定义对象。卷四要记录的,就是这门学科沿着这条轴走过的全部摆动——每一种语言都是一次下注,赌的是“哪些复杂度应该由人来扛”。Prolog 的赌注下得最远,也输得最惨,但它标出了轴线的一端:这个端点让后来所有的语言设计者知道,声明式的极限在哪里。
这正是本章留给卷四的证词:语言的每一次进化,都是认知带宽与硬件表达之间的一次重新议价——Prolog 用一门语言的形态提出了这个时代最大的那个要求:让机器替人类思考。它当年的失败,不是因为要求错了,而是因为机器还没有长出兑现它的器官;这个要求在 1972 年被提出、被否决、被遗忘,又在半个世纪后,被整个行业用另一种语言重新提出。重提的方式耐人寻味:今天的大语言模型用概率的方式做着当年 Prolog 用逻辑许诺的事——从海量样本里学会“什么通常为真”,再用它回答查询;知识图谱、神经符号系统、可验证的推理链,每一个热词里都躺着 1972 年马赛小组的旧问题——如何让机器从事实推出结论,并且说清楚是怎么推的。逻辑与统计的两条路线,在这个世纪重新汇流;1972 年落选的那条,从未真正离场。而它留下的另一个教训则属于工程管理的永恒科目:一门语言可以由一所大学在一年内发明,一门语言要统治世界却需要硬件、工具、教育三者同时就位——三者都就位的时刻,历史只会给出一次,错过就是二十年。
第 041 章 C++:在工业野蛮与零开销抽象间走钢丝
1979 年之前,本贾尼·斯特劳斯特鲁普(Bjarne Stroustrup)在剑桥大学做博士论文,题目是分布式系统。为了让论文里的系统组件各就各位,他先选了 Simula——那门在奥斯陆诞生的、带着类与继承的先驱语言。抽象帮了大忙:Simula 的类几乎是为“把系统拆成互相协作的部件”量身定做的,仿真框架让组件之间的消息往来一目了然。但性能把他逼走了:当时的 Simula 实现给不出分布式实验所需的执行速度。他退回去用 BCPL——一门几乎贴着机器跑的语言——速度上来了,组织却塌了:失去抽象之后,几万行程序变成一堆互相纠缠的全局过程,改一处而牵全身。同一个题目,两种工具,两种失败;两份失败报告合在一起,就是一门新语言的完整需求说明书。两项实验各得到半张答卷:Simula 有结构没有速度,BCPL 有速度没有结构。1979 年,带着这两张半卷,他走进新泽西州的贝尔实验室——上一章里 Unix 与 C 语言的诞生地。这里的程序员用 C 维护着电话网络背后庞大的软件资产,也日复一日体会着 C 在大型系统上的组织无力。斯特劳斯特鲁普把两张半卷的答卷摊上工作台,开始把它们缝成一张——这门缝合的产物最初的名字直白得近乎自嘲:带类的 C(C with Classes)。名字的谦虚里藏着一张宏大的蓝图:它要证明的不是又一种语言的可能性,而是一个原则——高性能与高抽象不是两片必须二选一的大陆,中间架着一座桥,桥的名字叫编译期。
性能与组织的两难
斯特劳斯特鲁普的两难,属于七十年代末整个系统编程行业。彼时Unix 与 C 已经证明了“贴近机器的高级语言”可以既快又可移植,C 的指针直通物理地址、数组退化成首地址、不为安全检查付一个运行时周期——上一章里那门语言的全部性格,就是“性能”二字的人格化。但 C 是一门为写小型系统内核而生的小语言,它对“如何组织几万行、几十万行的大程序”几乎没有提供任何工具:没有把数据与操作捆在一起的类,没有访问控制,没有让大型团队各自负责一块边界的机制。程序越大,C 的世界观就越接近丛林——每个人都很自由,自由到互相踩踏。一个几万行的 C 项目里,谁都可以改任何一块内存,模块之间的约定全靠注释与自觉,一个笔误的指针就能让千里之外的模块在三天后离奇崩溃;大型软件的三大病——难组织、难修改、难排查——在 C 的自由里被全部放大。这些病与 C 无关,它们是 C 的定位使然:它是一门小语言,从来不为大程序的设计问题负责。
另一边,Simula 类的语言给了组织工具:类把数据与操作封装成单元,继承让共性行为得以复用,虚函数让“同一接口、不同实现”成为可能。这套机制对大型系统是真实的解药,但它的实现代价在当时同样真实——对象模型、动态绑定、垃圾回收,每一样都要在运行时支付周期与内存。把 Simula 类的语言用在性能敏感的系统底层,等待你的是基准测试上的溃败。于是行业的版图裂成两半:要组织的清晰,就去 Simula 一侧;要运行的快,就去 C 一侧。系统程序员的日常,是在两边之间做痛苦的搬运——用 C 写核心,用 Simula 的思想画图纸,图纸上的优雅一到 C 里就散成全局变量。
斯特劳斯特鲁普的赌注,是这两半可以合并。他的目标说来简单,做起来极难:在不放弃 C 的性能与硬件访问能力的前提下,引入组织大型程序所需的结构化机制——类、模块、封装、更强的类型检查。1979 年,他在贝尔实验室动手实现“带类的 C”;实现策略同样务实到狡猾:不做全新的编译器,而是写一个预处理器 Cfront,先把带类的代码翻译成普通 C,再交给现成的 C 编译器编译。这个决定让新语言几乎零成本地继承了 C 的全部生态——既有系统、既有库、既有受训程序员,任何人都可以在不换工具链的前提下试一试——尝试的成本低到近乎零,这是任何一门从零起家的新语言都不可能享有的起点。这个策略的底层埋着一条常被忽略的事实:七十年代末的 C 标准库贫瘠得近乎荒凉——输入输出、字符串、数学函数之外几乎一无所有,语言层面更没有组织大型代码的任何设施。生态的空白反过来降低了替换的成本:反正大家都在白手起家,多学一套类的语法并不比重复造轮子更贵。一门新语言的成败,一半取决于它带来了什么,另一半取决于它让你抛弃了什么——C with Classes 两边都占了便宜。
钢丝的两侧:继承还是另起炉灶
“在 C 上加东西”这条超集路线,是本章全部戏剧的引线,它同时招来了两侧的敌人。超集还有一层润物无声的便利:互操作——大量既有的 C 库、系统接口与设备开发包可以径直调用,新代码又能以 C 兼容接口反向暴露,存量资产渐进现代化而不必一夜迁移;C++ 对 C 的高兼容度,就是它渗透进每个系统角落的渗透压。C 阵营的老兵冷眼相待:给 C 加类、加构造析构、加访问控制,意味着每一条新特性都可能拖累机器码的洁净——你多写的每一个抽象,最后都要由运行时的周期来买单;Speedcoding 时代“好写但不快”的教训犹在眼前,凭什么这次不一样?另一侧,面向对象的正统派同样不满:既然引入了类与继承,为什么不干脆全盘接受 Simula 与 Smalltalk 的衣钵,做一个纯粹的对象语言?斯特劳斯特鲁普两边都顶了回去,而顶回去的支点,是一条后来被称为零开销原则(zero-overhead principle)的设计宪法。它的条款有二:其一,你不使用的特性,不应为你付出任何时间或内存的代价;其二,你使用的抽象,编译后的实现应能与手写的专用代码一较高下。注意这不是一条性能保证——糟糕的设计照样可以慢——而是一条关于“谁有权定价”的纪律:抽象的代价必须显式、可见、可选,而不是被语言强制摊派给每一个程序。
这条宪法解释了 C++ 后来的几乎所有取舍。为什么对象在不使用虚函数时与 C 结构体一样紧凑?因为对象布局的每一字节都要对得起零开销原则。为什么 C++ 没有 Grand Object Class、没有万物皆对象?因为一个所有类型都必须继承的公共基类,意味着每一次整数加法都可能背上查表与间接寻址的影子——这正是被原则第一条禁止的强制摊派。为什么 C++ 后来同时容纳过程式、面向对象、泛型与函数式多种范式?因为斯特劳斯特鲁普从一开始就拒绝替程序员选择唯一正典——多范式不是设计上的骑墙,而是零开销原则在语言哲学上的延伸:用什么抽象是你的决定,语言只保证你的决定不被迫折价。与同时代的对手相比,这份定位的差异更清楚:Java 把大量决定委托给虚拟机——内存有回收、类型有检查,代价是运行时时刻在场;Python 把开发速度放在第一位,代价是每次操作都带着解释器的间接层;C++ 则把成本与表示的选择直接暴露给你——它不替你隐藏任何账单,也不替你付任何账单。三种语言是三份不同的合同:你签字之前,最好读清自己签的是哪一份。1983 年,这门语言改名 C++——取 C 的自增运算符,意为“递增一版的 C”,连命名都保持着超集的姿态:不自称下一代,只自称上一代加一。
vtable:多态的价格标签
零开销原则最难缠的对手,是面向对象的核心机制本身。当基类指针可以指向派生类对象、同一个调用要根据对象的实际类型走不同代码时——这就是动态多态,Simula 遗产里最有用也最昂贵的一件行李。C++ 的解法是虚函数表(vtable)机制:编译器为每个含虚函数的类生成一张函数指针表,表里按固定次序排列该类各虚函数的实际入口地址;每个此类对象的开头则被悄悄塞进一个指针(vptr),指向自己类的表。调用发生时,机器先从对象头部取出 vptr,再按调用在表中的序号取出函数地址,最后间接跳转过去。同一行源代码,对基类引用调用一个虚函数,落到派生类对象头上执行的就是派生类的版本——绑定发生在运行时,由对象的实际类型决定。
源代码: shape->area() /* shape 是基类引用 */
Circle 对象 Square 对象
┌────────────┐ ┌────────────┐
│ vptr ──────┼──┐ ┌──┼─ vptr │
│ 半径 r │ │ │ │ 边长 a │
└────────────┘ │ │ └────────────┘
▼ │ ▼
Circle 的 vtable │ Square 的 vtable
┌──────────────────┐ │ ┌──────────────────┐
│ &Circle::area │◄──┘ │ &Square::area │◄─ 取出此地址
│ &Circle::draw │ │ &Square::draw │ 间接跳转
└──────────────────┘ └──────────────────┘
这张表就是多态的价格标签,而零开销原则要求这张标签印得清清楚楚。那为什么还要付这个钱?因为有一类场景只有运行时才知道类型:图形界面里的一个控件列表、插件系统里加载进来的未知模块、消息队列里递来的未知消息——类型在编译之后才进入系统,静态模板无从专门化,虚函数表是唯一能把“未来的未知”接进今天代码的插座。虚函数不是多余的设计,它是语言为“运行时的不可知”保留的端口;零开销原则的义务,只是把这个端口的接入成本印在价目表上,而不是假装它是免费的。价目表的诚实还体现在另一面:同一份基类接口,既可以挂虚函数(运行时多态),也可以挂模板参数(编译期多态),两种挂法的价目不同——选虚函数,付出间接与内联豁免;选模板,付出编译时间与代码体积。语言把两份合同并排摆开,签字权在程序员。虚调用的代价明细:一次额外的内存间接寻址(取 vptr、再取函数地址),以及更隐蔽的一条——编译器无法在编译期确定要跳到哪个函数,因此无法内联;内联一旦受阻,此后的常量折叠、循环优化统统失去作用域。在紧循环里大量调用虚函数,代价会被成百万次放大。这正是 C++ 的诚实之处:它没有假装多态免费,而是把价格标注在机制本身——你每写一个 virtual,就是在为运行时的灵活性支付一次间接寻址与一串内联豁免。而不写 virtual 的代码,与 C 一样紧凑。价格标签可见、可选、不摊派——零开销原则在多态问题上执行得像一条商法。这条商法附带一项副产品:既然虚调用有价,语言就必须提供替代品——C++ 的答案在本章后文:模板与泛型编程。价目表与替代品同时在场,选择才成其为选择。而对另一些抽象,语言走的是完全相反的路:价签不印了,整个消除。一个写出来像函数的小工具,编译后常常连函数调用都不存在——编译器把函数体直接粘贴进调用处,参数设置与跳转返回全部蒸发,抽象在机器码里消失了,只剩算术本身。循环同样被照看:对连续范围的朴素循环,编译器在可证明安全时删去边界检查,把循环内不变的计算提升到循环外,并重排循环体以讨好缓存——人写的是清楚,机器交的是快。一个缴税小函数——输入价格、返回加税后的值——编译之后,调用处看到的就是那条“乘一百零八再除一百”的运算被原位展开,连“跳进函数再跳回来”的影子都没有:好名字带来的可读性留在了源代码里,函数调用的开销没有跟到机器码里。常量表达式在编译期提前算完,死代码被整段剪除,循环被重组得对缓存更友好。这套交易的语言学表述是:构建时多付,运行时少付——程序员写下的清晰结构不必在运行时长期付租,机器码保留的是手写般的直接。消除的代价同样记在账上:编译时间变长,多处内联会让二进制变大;构建与运行之间的这笔转移,C++ 交给程序员自己权衡。
真正把这条原则推到极致的是模板。模板把多态从运行时搬回了编译期:你为“一族类型”写一次算法,编译器为每个实际用到的类型生成专门化版本——因为编译器在生成代码时就知道具体类型,虚查表、运行时类型检查、动态分派统统不再需要,内联畅通无阻;为整数生成的 max 函数,最终可能只剩一两条机器指令。标准库里随处可见这套机制的果实:向量容器把元素原样排进连续内存,排序算法在被调用处就地展开成针对该类型的专用循环——泛型的外观,手写的内核。代价被移到了编译期:编译时间变长,二进制变大,错误信息冗长得令人生畏。动态多态与静态多态的对照,是零开销原则最完整的教学案例——同一个“多态”目标,虚函数付运行时的钱换灵活性,模板付编译期的钱换性能;两种账单都印在语言的价目表上,选择权留给程序员。价目表的第三栏是回收成本:模板的实例化与内联会在编译期生成成倍的专用代码,体积与构建时间随之上涨——静态多态省下的运行时账单,一部分转成了开发者的等待。这套分工背后是一条更深的分工:程序员负责把意图表达成抽象,编译器负责把抽象的执行成本删到最低——前者是人优于机器的地方,后者是机器优于人的地方,零开销原则让两者各司其职,谁也不越界替对方做工。
资源管理同样按这条宪法设计。C++ 的析构函数让资源生命周期与作用域绑定:对象构造时获取资源,离开作用域时析构函数自动释放——这套后来被命名为 RAII(资源获取即初始化)的模式,覆盖的不只是内存,还有文件、锁与连接。它的妙处在于直线代码:手动清理要在每个返回路径上记得释放,防御性的 if 与重复的清理调用越积越厚;RAII 把清理写在一处,由语言保证任何离开作用域的路径(包括异常引发的栈展开)都会执行——bug 更少,热路径上的防御性开销也更少,安全与速度在这里罕见地站在同一边。异常场景是这套机制的压轴戏:当异常从函数深处抛出、控制流跳过层层调用栈时,栈展开会沿路调用每一层已构造对象的析构函数——资源在程序“失控”的时刻依然被精确释放。异常自身的代价也要说公道话:贵的是“抛出”的那一下,而不是“可能抛出”的存在——热路径若频繁抛异常,就该改用错误码或结果类型;若抛出确属例外,RAII 加异常反而能让快路径保持干净。手动管理的年代,异常路径上的泄漏是防不胜防的暗雷;RAII 把“无论从哪条路离开都要清理”变成语言保证,异常才第一次能与高性能代码和平共处。
斯特潘诺夫的叛离与加冕:STL(1994)
如果说虚函数是 C++ 对 Simula 的继承,那么标准模板库(STL)就是 C++ 对面向对象正统的一次漂亮叛离。九十年代初,1950 年生于莫斯科的数学家亚历山大·斯特潘诺夫(Alexander Stepanov)带着一个与主流相悖的信念进入这项工作:面向对象的层次结构不是组织代码的终点。他在整个八十年代反复验证一个想法——算法应当与数据结构解耦,以“对迭代器的操作要求”为唯一的连接条件;这条思路在几家公司的内部库里打磨多年,最终在 C++ 模板机制上找到了完美的载体。他的方案后来与孟李(Meng Lee)合作完善,被称为标准模板库——它把三样东西彻底分离:容器(vector、map、list 等存数据的结构)、算法(sort、find、count 等操作数据的过程)、迭代器(在两者之间穿针引线的胶水)。一个排序算法不绑定任何容器,也不要求元素类型继承自任何公共基类——它只要求迭代器满足若干操作约定。三根支柱的分工值得细看:容器管存储——向量连续排布、链表逐节链接、映射按键索引,各自适应不同的访问模式;算法管运算——排序、查找、计数、变换,一份实现通吃所有容器;迭代器管衔接——它像一根指针般的游标,算法只问迭代器要“下一个元素”,不问元素住在哪里。四样组件各司其职——容器、算法、迭代器之外,还有承载行为的仿函数让“做什么”也成为可传递的对象;三者解耦之后,M 种容器与 N 种算法不再需要 M×N 份实现,M+N 份就够了——组合复杂度从乘法降到加法,这是库设计史上最漂亮的一次降维;而降维的前提是迭代器把“元素在哪里、如何走下一步”封装成了几类约定——约定越窄,兼容越广,这条设计律此后被泛型生态奉为圭臬。解耦还把选择权连同选择的知识一起交还给用户:向量连续排布、遍历与随机访问缓存友好,是绝大多数场景的默认答案;链表只在需要稳定迭代器与频繁中段插拔时才值得付出每节点额外开销的代价;有序映射适合区间查询与可预测的遍历顺序,哈希映射则是平均查找速度的冠军。库不替你选,库把每种选择的代价写在脸上——这同样是零开销原则的延伸:不仅实现零隐藏成本,连选择的后果都零隐藏。这与“万物皆对象”的路线针锋相对:STL 的世界里没有对象帝国,只有算法与数据结构的自由联姻。1994 年 STL 被采纳进标准,九十年代末随首个 ISO C++ 标准发布,泛型编程从此成为 C++ 的主要轴线之一——一门以“带类的 C”起家的语言,最终的高峰却是由一个不信任类层次的数学家用模板垒成的。斯特潘诺夫的立场值得原样记录:他反对以对象为中心组织库,主张算法才是一等公民,数据结构只是算法的宿主——这套信念与 Simula 以来的对象正统背道而驰,却在 C++ 的模板机制上如鱼得水。语言的气质再一次由它的使用者重塑:斯特劳斯特鲁普给了容器,斯特潘诺夫给出了容器之间的秩序。委员会在这场并入中的表现同样值得记录:斯特潘诺夫发明的分配器机制,原意是让库彻底独立于底层数据模型,但标准委员会审阅时意识到,对数据模型的完全抽象化会带来不可接受的性能损耗——零开销原则连标准委员会也不放过,抽象的纯度再次向效率交了税——这次交税的反向意义在于:连委员会这样的“抽象理想主义者”组织,也必须在性能现实面前收敛设计,原则的权威由此高于任何提案者的审美。1998 年,首个 ISO C++ 标准发布;此后的语言演进由国际委员会辩论表决,斯特劳斯特鲁普保有影响但不再独裁。标准化的另一重意义是把语言变成集体作品:2003 年的修订、2011 年的大现代化(移动语义、lambda 表达式、并发工具一并到位)、此后约三年一个周期的稳定节奏,concepts、modules、ranges、coroutines 一个个排进日程——每一项特性都要经得起数十亿行存量代码的检验与各国代表团的票决。语言的统治权从一个人手里移交给一个委员会,交接仪式平静,后果深远:从此 C++ 的每一个新版本,都是国际共识的快照。新特性依然沿着零开销的旧宪法推进:移动语义把“只是交出所有权就不要复制”写成语言规则——大对象的内部资源直接转移而非逐字节拷贝,分配与内存流量应声而减;constexpr 让一部分计算搬到编译期完成,运行时只消费烘焙好的常量;范围(ranges)让“取这些、滤掉那些、再变换”的流水线书写得像句子,而良好的实现仍能把它编译成一个朴素的循环。四十年的零开销宪法没有改写,只是条款越写越细。
效率的账单
清算 C++ 的账目,反对方的立场依然要先算完。批评者们抱怨的一切都真实存在:这是一门庞大的语言——四十年演进把过程式、面向对象、泛型、函数式、编译期计算全部塞进同一个语法体系,同一目的常常有五六种写法,每一种背后都是一代人的习惯与一段历史代码;老代码里遍布裸 new/delete、手动所有权与未检查的指针运算;未定义行为潜伏在每一次越界与类型违规之下,它不会稳定地失败——一段代码可能“看似正常”地跑十年,直到某天编译器升级或优化策略改变,把它内里埋着的崩溃与安全漏洞一并翻出来。学习成本同样惊人:教科书与存量代码讲着不同世代的故事,新手在进门之前就要先学会分辨哪些门是陷阱。而兼容性——这门语言所有成功的原因——同时是它最沉重的枷锁:数十亿行存量代码保护在案,任何破坏兼容的重来一次都被禁止,C++ 因此注定无法推倒重来,只能在累积中演化,在演化中继续累积。付款人的名单从七十年代排到今天:每一个为冗长模板错误信息通宵的学习者,每一个在未定义行为的深渊边排查内存损坏的工程师,每一个负责维护百万行混合了五个世代风格代码库的团队。复杂性还向行业征收一种更隐蔽的税——组织税:因为同一目的有太多写法,团队必须额外制定编码准则来统一取舍;因为语言锋利,招聘、培训、代码审查、静态分析工具与模糊测试都要当成一等成本编入预算;因为历史风格层叠,一份现代基线(优先标准容器、禁用裸指针运算、把警告当错误)本身就需要一份说明书。别的语言把安全做成默认,C++ 把安全做成纪律——纪律是要按月发薪的。
但清算也必须写下收益栏,因为卷四的物理主题——认知带宽与硬件表达精细度的永恒妥协——在 C++ 身上走到了最精细的一次平衡。抽象的价值是省认知:类替你记住数据的边界,模板替你记住算法的形状,RAII 替你记住清理的时机;抽象的危险是丢精度:多一层间接、多一次分派、多一个运行时检查,硬件的表达就粗糙一分。绝大多数语言在这两者之间选定一个位置定居——脚本语言把精度几乎全部让给认知,汇编把认知几乎全部让给精度。C++ 的独门手艺是拒绝定居:零开销原则把妥协变成了逐项议价——这里的抽象不付硬件税(模板、内联、RAII 直线代码),那里的抽象明码标价(虚调用、异常、动态分配),价目表公开,选购自由。这门语言的复杂与长寿,都是这份逐项议价的直接后果:每一代人的新需求都作为新选项加入菜单,旧选项因兼容而永不撤下——菜单越来越厚,正是它服务过的程序员越来越多的证明。而所谓工业野蛮,也正是这门语言的服务清单本身:毫秒必争的交易系统用它在硬件与市场之间抢时间,游戏引擎用它在一帧十六毫秒的预算里塞进千军万马,浏览器用它解析整个网页世界,数据库与操作系统的核心模块踩在它上面运转——这些行业对性能的要求近乎野蛮,而 C++ 是唯一同时满足“野蛮的性能”与“文明的抽象”这两个要求的候选。行业的野蛮塑造了语言的锋利,语言的锋利又纵容了行业的野蛮,两者互为因果。野蛮的另一面是忠诚:一旦某个行业把核心押在 C++ 上,重写的成本就超过学习的成本,语言因此获得了一种超越代际的租约——它不靠流行活着,靠惯性与服务年限活着。野蛮也催生了一套朴素的生存纪律:先测量再猜测——缓存与并发上的直觉十有八九是错的;热点路径减少分配——复用缓冲、预留容量、别在内层循环里造临时容器;性能敏感处优先连续的数据布局——更少的指针、更多的“元素数组”胜过满地的对象图;让热路径平淡无奇——可内联的函数、可预测的分支、最少的同步。与口诀配套的是剖析文化:时间花在哪儿、发生了多少次分配、哪些函数被调用得最多——剖析器回答这些问题,基准测试复核答案,延迟的百分位(而不只是平均值)成为汇报的口径。零成本抽象要变得真正可行,靠的正是这套闭环:保留可读的代码,然后逐一消灭测量中现形的开销。卷四的主导约束——人类认知带宽与硬件表达精细度的永恒妥协——在此前的语言里都是一次性的定居选择:汇编与 C 把认知带宽全部押给硬件精细度,Lisp 与脚本语言把硬件精细度全部押给认知带宽。C++ 的独特之处在于把这场妥协写成了可逐条重议的协议:每一段代码、每一个抽象、每一处热点,都可以单独谈判——这里要多一分认知友好(用标准容器、用 RAII、用范围),那里要多一分硬件精度(手写循环、控制布局、消除虚调用)。谈判的秩序由纪律维持,谈判的依据由剖析器提供,谈判的边界由零开销原则守卫。零开销原则最终写下的判词是双向的:抽象不必是效率的敌人——这是它给软件业的正面遗产;而当你允许每一层抽象都与硬件讨价还价时,这门语言本身就会膨胀到无人能宣称完整掌握——这是它给后来所有语言设计者的反面教材。此后每一种新语言,要么选边定居,要么在菜单厚度与点菜自由之间重新定价;C++ 走过的钢丝,成了它们测量自己的标尺。此后的新语言各自在这根钢丝上重新选点:有的把安全设成默认、把控制权大幅上缴,有的干脆带着“零开销”的旗帜重走一遍——无论选哪边,定价的语法都已是 C++ 教出来的通用语。
第 042 章 Erlang:电信级并发与任其崩溃哲学
1995 年,斯德哥尔摩,爱立信的一间项目机房里,一群工程师正围着一门“被公司抛弃”的语言开会。他们手头的项目是新一代电话交换机 AXD301——用分组交换承载语音、数据与宽带业务,复杂度冠绝公司史;项目此前用 C++ 开发,此刻已深陷泥潭、濒临崩溃。死马当活马医的方案摆上桌面:换用 Erlang——一门几年前被公司判定为“不该再碰”的实验语言,它的设计者乔·阿姆斯特朗(Joe Armstrong)等人甚至已经开始四处寻找新的东家。没人想到,这场救场会成为编程语言史上最著名的绝地翻身:AXD301 顺利交付,随它流传开的那个可靠性数字,日后在业界掀起一场持续二十年的口径之争。而救场本身只是一个更大故事的尾声——这门语言从诞生到被自家公司封印、再到被二十亿用户间接平反的四十年,才是故事的正文。要理解那个数字为什么既惊人又可疑,得先回到这门语言出生的地方——那把筛掉了几十种语言的筛子。
一个筛子与二十种语言
八十年代中期的爱立信,站在一个前所未有的需求断崖上。电话网络正从机械与模拟时代全面转向数字时代,下一代的交换系统要同时处理百万级的并发呼叫;用户对“打不通电话”的容忍度是零,监管对“服务中断”的罚款是真金白银,而一个新系统从设计到服役要支撑的年月以几十年计。电话网络正在从机械与模拟时代转向数字时代,下一代的交换系统要同时处理百万级的并发呼叫,任何一次宕机都意味着成片用户的通话中断——电信级可靠的苛刻程度,是软件行业其他领域难以想象的。交换机的软件规模也在同步膨胀:从几万行到几十万行,从几十人维护到上百人接力,大型软件的组织难题与电信级的可靠要求在这里叠加,难度不是相加,是相乘。而爱立信的工程师们发现,他们手里的工具没有一件称手:用 C 与汇编写的交换机软件,并发逻辑散落在中断与回调里,一个错误可以污染整片内存,排查一次故障要动用整支队伍。实验室需要一个更好的办法构建下一代电信系统。
于是有了那把著名的筛子。筛选不是纸上作业——小组把每一种候选语言认真拉出来评估,看它们描述一套并发电信系统时的表达力与出错率;结论是无论怎么排列组合,两条命门始终凑不齐在同一个候选身上。乔·阿姆斯特朗(Joe Armstrong)与罗伯特·维尔丁(Robert Virding)、迈克·威廉斯(Mike Williams)组成的小组,把市面上能找到的二十多种语言逐一放进筛子,标准只有两条:其一,为了生产率,语言必须是高级的声明式语言——程序员应当描述“要什么”,而不是逐条指挥机器“怎么做”;其二,为了高可用,语言本身必须在层面支持并发与错误恢复——这项能力要长在语言的骨头里,靠库与纪律都靠不住。筛子晃了两轮:第一条筛掉了 C、Pascal、Ada 与 C++,它们都太快太低,对并发与容错不闻不问;第二条筛掉了 Lisp、Prolog、Parlog——它们表达力惊人,却没有内建的并发原语,也没有把“谁看着谁、崩了怎么办”写进语言契约。两轮筛完,篮底空空。小组得出结论:没有现成的语言能同时满足电信业的这两条命门,只能自己造一个。这场筛选的价值不在结论而在标准——它把“电信软件到底难在哪”翻译成了两条语言需求:并发在该领域就是常态(一部交换机同时服务几万路通话),容错属于生存权(系统要连续运行几十年,任何“程序偶尔会崩溃”的默认都必须被废除)。把行业之痛翻译成语义需求,再照着需求造语言——这套方法论,让 Erlang 从第一天起就带着问题域的指纹。指纹的另一面是排他性:Erlang 对并发与容错的偏执,也注定了它在字符串处理、数值计算、图形界面这些“电信之外”的领地上毫无优化——它是一门被一个行业的需求凿出来的语言,行业即语言的国境线。
Erlang 的核心构造叫进程,而它对进程的处理,构成了这门语言全部哲学的地基。要体会这个设计的分量,可以先想一个反问:为什么并发的痛苦总与“共享”相伴?因为两条执行流一旦能摸到同一块内存,就必须靠额外的机制(锁、时序、纪律)保证它们不把数据改坏——共享是并发复杂度的总源头。Erlang 的做法是从模型里直接删掉“共享”二字,让复杂度失去滋生的土壤。每个 Erlang 进程是一个极小的独立单元:有自己的邮箱,别的进程向它发消息就落进邮箱;它周期性地检查邮箱,按到达顺序逐条处理消息,然后继续。邮箱的妙处在于它把并发问题降维成了顺序问题:进程内部没有任何并发机制——一次只处理一条消息,处理完才取下一条,进程之内的代码因此可以像初学者的顺序程序一样书写和推理;并发的全部复杂性——消息何时到达、以什么次序到达、处理中会不会有新消息插队——都被邮箱关在了进程之外,连同那些让几代程序员在锁与竞态中耗尽认知带宽的经典噩梦。写 Erlang 的程序员不需要懂锁,因为他的世界里根本没有共享的东西需要上锁;他需要的全部并发知识,只是一条纪律——把事情拆成互不共享的小进程。进程之间不共享任何内存——一个进程的数据,别的进程永远看不见,想传递信息只能拷贝一份随消息发送。这套模型在今天被称为 Actor 模型,而它的物理意义在当年更为惊人:每个 Erlang 进程的开销只有几百字节,一台服务器可以同时跑起几百万个进程;进程还能透明地跨越网络通信,往另一台机器上的进程发消息与往本机进程发消息写法完全一致,扩容只需添加服务器——分布式系统教科书里最难的一章,在这门语言里只是一行普通的发送语句。百万级并发呼叫的需求,就这样被翻译成了百万个互相隔离的轻量进程——每一路通话是一个进程,每一次故障也只属于一个进程。轻量到什么程度,值得与操作系统线程对照:操作系统的线程为性能而生,栈空间以兆字节计,一台机器能承载的线程数以千计;Erlang 进程为规模而生,初始开销以几百字节计,一台机器能承载的进程数以百万计。前者是重装备,后者是细胞——把系统拆成细胞级的隔离单元,正是任其崩溃哲学能成立的前提:只有当失败单位的体积小到可以随手丢弃时,“崩溃了就重来”才是一种经济的策略。
任其崩溃的形而上学
先看它要反抗的对象有多可怕。共享内存的并发世界里,错误有一整本谱系:两个执行流同时读写一个变量,读写的次序不同结果就不同——竞态条件;两个执行流互相等待对方手里的锁,谁也不肯先走——死锁;一处修改了数据,另一处的缓存里还是旧值——可见性错误。这类错误的共同特征是几乎无法在测试中稳定复现,只在高并发的生产环境里随机现身,每一次排查都要跟机器的调度时序赛跑。传统软件工程对它们的信条是防御:写代码时预判一切可能出错的地方,层层包裹,处处校验,务必让程序“永不失败”。这套信条在小型程序里运转良好,在百万行、运行数十年、由多人维护的电信系统里却撞上南墙——你可以防住你能想到的错误,防不住你想不到的;防御代码本身也是代码,也会有错误;而一个未处理的错误在共享内存的世界里不会安静地死去,它会污染公共状态,把整个系统拖下水。Erlang 的回答是对这套信条的整体反转,四个字:任其崩溃(let it crash)。在 Erlang 的世界里,处理错误的职责与执行错误的职责被彻底分开——每个进程只处理它知道怎么处理的情况;遇到它不知道的情况,最好的选择就是立刻崩溃,死得干脆彻底,别挣扎着恢复,不带任何残缺状态。崩溃之后怎么办?交给另一个进程——一个专门负责监督它的进程——去重启它,让系统像什么都没发生过一样继续运转,就像什么都没发生过。
这套哲学的精髓在于一道算术。传统防御式编程的隐含假设是:错误是小概率事件,值得为每一次可能的失败预先编写恢复逻辑。电信系统的现实推翻了假设:硬件会坏、软件有 bug、网络会抖,错误在此地早已是家常便饭;在一台要连续运行数十年的机器上,“永不出错”的代码是不存在的,存在的只有“出错之后还能活下来”的系统。既然失败不可避免,工程问题就从“如何避免失败”改写为“如何让失败变得便宜”:Erlang 把失败的成本压到了极限——一个进程崩溃,损失的是几百字节的内存和一段可以重来的状态,重启的代价是毫秒级;而由于进程互不共享内存,这个失败不会传染,系统的其余部分毫无察觉。对每一个从主流语言转来的新程序员,学 Erlang 的第一课都是心理治疗:先承认失败必然发生,再学会放心地去死——这两课过后,剩下的 Erlang 反而异常简单。电话交换系统需要的“永不宕机”,在这里不是靠永不崩溃实现的,而是靠崩溃的代价低到可以忽略不计实现的。与主流语言的 try-catch 哲学并排对比,分歧一目了然:异常处理的思路是在错误发生的地方就地捕获、就地恢复,程序员要把每一处可能失败的调用都包上处理逻辑;任其崩溃的思路是让错误发生的地方就地死亡,而把处理的责任上移给监督它的上级——通常是它的监督进程,或再上一层的监督树节点。前者把恢复逻辑铺满全部代码,后者把恢复逻辑集中到监督结构的少数节点;前者的假设是每个程序员都该为自己的错误负责到底,后者的假设是出错的那段代码已经不可信任,能信的只有旁边那个健康的进程。两种哲学没有绝对对错,但规模是裁判:要在几百万个并发单元里预防所有失败,防御代码本身就会把系统淹没;而监督树只需在树的每个分叉处放一个哨兵。故障恢复的经济学在这里完成了一次公理级重写:防御式哲学为“避免失败”付费——付费方式是每次编码时的预判与每次运行时的检查,付的是持续税;任其崩溃为“从失败中恢复”付费——付费方式是失败发生后的重启,付的是事件税。持续税在平静岁月里照付,事件税只在事故日结账;电信系统的几十年寿命与海量进程,让事件税的总和远低于持续税——这笔算术,就是任其崩溃的全部合法性来源。## 监督树与不死之身
“崩溃之后谁负责重启”的问题,在 Erlang 生态里被一个名为 OTP(Open Telecom Platform,开放电信平台)的框架给出了标准化答案,这个答案的形状是一棵树。OTP(开放电信平台)是架在 Erlang 虚拟机之上的中间件、库、设计原则与工具集的总和,监督树是它最核心的模式。监督树把进程组织成层级——这棵树的每一层都知道自己该看住谁、该在谁出事时动手;每个工作进程头顶都有一个监督者进程,监督者盯着下属的存活状态,发现谁死了就按预置策略处置——默认动作是重启;监督者本身也有上级,层层向上,直到树根。故障处理因此变成了一个递归结构:一个工作进程崩了,它的监督者重启它;一个监督者自己出了问题,上级监督者重启整棵子树。把系统画成监督树,等于把“哪里坏了、谁负责恢复、恢复到什么粒度”全部写成了结构本身——运维知识不再散落在文档与值班工程师的脑子里,它就是系统拓扑,也是 OTP 库最著名的设计图案。监督树与公司组织图的同构也妙不可言——一线进程、组长、部门经理、树根,层层为下属的生死负责;区别在于 Erlang 的组织从不踢皮球,每级的处置策略都写在代码里。工程师对这个结构一点就通,因为他们早就在别的树上活过一遍。这层结构还有一层更深的含义:故障处理从“编写”变成了“组装”。传统的错误处理是逐处编写的——每一处 try 的内容都独一无二;监督树是逐级组装的——同一种监督者可以挂任何工作进程,同一种重启策略可以贴在任何子树上。运维的逻辑第一次成了可复用件,与 Erlang 进程的轻量特性一配合,整个系统的容错结构可以像搭积木一样生长。
┌──────────────┐
│ 根监督者 │
└──────┬───────┘
┌────────────┼────────────┐
▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│ 子监督者 A │ │ 子监督者 B │ │ 子监督者 C │
└────┬─────┘ └────┬─────┘ └────┬─────┘
┌─┴─┐ ┌┴┴┐ ┌─┴─┐
▼ ▼ ▼ ▼ ▼ ▼
工作进程×n 工作进程×m 工作进程×k
│ 崩溃 → A 重启它 → 其余分支毫无察觉
│ A 自身崩溃 → 根监督者重启整棵子树 A
监督树之下,是五件把“人工停机时间”逐项清零的机制。热代码重载:Erlang 可以为运行中的系统编译并加载一个模块的新版本,BEAM 虚拟机自动完成新旧代码的切换,全程不停止任何进程——升级从此接近零停机。对电话交换机而言,这条特性近乎天赐:电信设备买了就要连续运转十几年,修补一个缺陷、上线一项新业务,都不可能让全城的通话等着重启。代码在机器奔跑时更换零件,这是 Erlang 为电信业量身定做的独门手艺。监督者重启:失败模块被重启的间隔以毫秒计,一个极少崩溃的系统,多年累计的总停机确实可能只有一秒的零头。轻量进程:崩溃被天然隔离在几百字节的边界之内。异步消息传递:发送者发出消息后不必等待,一处停顿不会顺着调用链向上传染——接收者慢了,消息就在邮箱里排队,发送者自顾自继续;一条链路上的阻塞被隔离在该链路内部,不会像同步调用那样把整个调用栈钉在原地。集群:消息跨机器透明传递,负载可以摊到多台服务器上,每台独立宕机而不伤整体——进程的地址空间里根本没有“本机”与“远程”的区别,分布式系统最凶险的地基问题,在语言层面被一句“写法完全一致”抹平了。五件机制合起来,兑现的是阿姆斯特朗那句被广为引用的玩笑——“如果 Java 是‘一次编写,到处运行’,Erlang 就是‘一次编写,永远运行!’”还应补上这五件机制共同依赖的一条会计规则:停机如何计数。模块热替换也好、进程崩溃重启也好,只要对外服务的那个交换进程本身没有停,这些都计入运维动作而不计入停机——就像视频网站的下载可以停顿几秒,只要缓冲够深,播放就不算中断。这条会计规则后来成为九个九之争的核心焦点,此处先行按下。
九个九的口径之争
AXD301 交付之后,那个数字登场了:九个九——99.9999999% 的可用性。这个数字随着 Armstrong 的演讲与 Erlang 的布道文流传全世界,成了这门语言最响亮的名片,也成了它最沉重的包袱。阿姆斯特朗本人在文章里写道:“AXD301 达成了九个九的可靠性(没错,你没有看错,99.9999999%)。放在语境里说:五个九就算优秀——每年停机 5.2 分钟;七个九几乎不可企及……但我们做到了九个。为什么?无共享状态,加上一套成熟的错误恢复模型。”算术把这句话的分量钉在了墙上:按百分之百减去九个九计算,二十年运行的累计停机只有 0.631 秒。而要理解这串九为什么在数学上并非天方夜谭,关键在统计的颗粒度:可用性可以在不同层面计量——单台设备的可用性与整个集群所提供服务的可用性是两个量。设备串联,可用性相乘,越串越低;服务并联冗余,只要随便哪个节点活着就不算中断,集群口径的可用性可以远超任何单机。九个九的数字之所以能在数学上自洽,正是因为它统计的是后者——一整片由大量冗余节点组成的服务网络,而不是某一台机器。理解了这一层,口径之争的双方其实都没有说谎:他们量的是不同的东西。无共享、任其崩溃、监督重启——整套哲学的胜利似乎就此盖棺定论。支持者的论证链条是完整的:无共享消灭了故障传染,进程隔离限制了故障半径,监督重启压缩了恢复时间,热重载消灭了升级停机——每一环都有明确的机制承担,数字是机制的加总。质疑者的证据链同样完整:样本期只有八个月,失败分布远未充分展开;统计对象是服务而非设备,口径偏乐观;二十年与九个九的捆绑是传播的焊接。两种说法各自成立,分歧只在“这个数字证明了什么”——证明架构在特定试验里达到了极高可用性,还是证明 Erlang 系统天然九个九。
然而这正是本章必须停下来较真一段的地方,因为九个九在业界是一场旷日持久的口径之争,而争论的每一层都值得原文照录。第一层是统计对象的口径:高票的考据指出,这个数字衡量的并不是“AXD301 的任何部件在二十年间从未关停”,而是“AXD301 所提供的服务在观测期内没有离线”——是服务不中断,不是设备不停机;只要交换集群里总有别的节点接住话务,单台设备的重启与升级根本不计入停机。第二层是样本口径:一位了解内情的从业者指出,这个数字并非来自 AXD301 二十年的运行,而是来自英国电信一次试验中十四个节点、八个月期间的观测数据——用八个月的样本外推二十年,采样时间不足以覆盖完整的失败分布。第三层来自内部:AXD301 团队成员马茨·克罗恩奎斯特本人在一次演讲中直言,九个九是一个“常被引用但根本上有误导性”的统计。第四层连“二十年”本身也存疑:阿姆斯特朗的文章确实提到过二十年,但它与九个九的数字并无直接关联,两者的捆绑更多是传播中的讹变。把口径摆齐之后的公允表述应当是:在特定试验的特定口径下,AXD301 提供的服务达到了极高的可用性,Erlang 的架构为此作出了实质贡献;而“连续二十年只停 0.631 秒”这句话,是传播过程把几个不同口径的数字焊接在一起的产物。这场口径之争没有埋葬 Erlang——恰恰相反,能够在“服务不中断”的口径下撑住八个月十四节点无故障,本身已是对任其崩溃哲学最有力的工程背书;它埋葬的是把宣传数字当运行数据引用的懒习惯,而这正是本书军规要在此处原样交代的理由。对读者而言,更持久的教训是:凡遇惊人的可靠性数字,第一反应应当是问清三件事——统计的是哪一层(设备还是服务)、观测期多长(采样是否覆盖失败分布)、谁在引用(当事人还是传播者)。三问过后,大多数奇迹都会落回凡间;而落回凡间的成绩依然值得尊敬,这才是对待工程成就的健康姿势。
比数字之争更深的裂口,横在这门语言与它的母公司之间。Erlang 在 AXD301 上的胜利没有换来内部和解:爱立信宣布禁止在公司内部使用 Erlang,理由是电信产品生命周期太长,维护一门自家专有语言的成本太高,不如采用全世界都在用的语言。禁令一出,为这门语言倾注了十几年心血的团队大为震惊,转而游说公司开源;1998 年 12 月,Erlang 正式开源,阿姆斯特朗等初创成员随即离开爱立信,创办了自己的公司 Bluetail,继续为这门语言工作。禁令的逻辑与开源的逻辑,各自站在合理的立场上:电信设备要在客户的机房里运转几十年,二十年后谁来维护这门语言的编译器?如果爱立信哪天不再运营 Erlang 社区,客户的存量设备就成了无源之水——用全世界都在用的语言,是把这份长期风险外包给整个行业。而团队的反驳同样有力:Erlang 的价值恰恰在于它的专有性是围绕电信需求定制的,换成通用语言,那套并发与容错的天赋就要重新发明一遍。立场各对,结果却只有一种:语言离开公司,公司离开语言。一门为救公司之急而临危受命的语言,救完场就被公司封印——这段公案成了软件史上“内部创新之死”的标准案例。而开源反过来救了语言:离开了电信业这个单一客户,Erlang 被放置进市场竞争,它的每一次被采用都成了自证——即时通讯、消息队列、物联网网关、金融交易后端,凡是要“永不宕机”的地方,Erlang 的名字就会冒出来一次。而 Erlang 之所以始终未能跻身主流,技术史家另有公论:理查德·加布里埃尔(Richard P. Gabriel)把设计哲学分成两派——MIT 派坚持设计必须正确、接口必须简单,为此实现再复杂也在所不惜;新泽西派(贝尔实验室的 Unix 与 C)则认为实现的简单性高于一切,宁可只提供八成功能也要让所有人改得动、接得上。Unix 与 C 以八成的功能像病毒一样铺满了世界;Erlang 是标准的 MIT 派——设计精巧、实现厚重,一旦不合用,能改造它的只有高人。它输掉的从来不是能力,是可改性。门槛还叠着第二层:函数式的语法对大众程序员素来陌生——模式匹配、递归替代循环、不可变变量,每一项都要推翻命令式编程的训练本能;连爱立信的多数团队都宁愿继续用 C++,遑论外界。
尾声:二十亿用户的沉默后盾
离开电信业的 Erlang,在互联网时代找到了比电话交换更大的舞台。2009 年,雅虎前员工简·库姆(Jan Koum)与布莱恩·阿克顿(Brian Acton)创办 WhatsApp,面对互联网级的用户数与并发量,他们认定 Erlang 是处理大规模消息的不二之选。此后的事实成为分布式系统教学的常设案例:这款应用增长到全球二十亿活跃用户,2014 年被脸书以一百九十亿美元收购时已有四亿五千万用户、每天以百万级新增,而支撑这一切的服务器后端团队只有十名工程师——人均服务的用户量创下行业纪录,靠的正是轻量进程、消息传递与监督树这套电信时代的遗产——斯德哥尔摩机房里那门救场的语言,最终在太平洋两岸的服务器机房里常驻了下来。这笔账的算法并不神秘:消息传递架构下,服务器的扩容方式是加机器,进程的隔离让故障不必全员排查,监督树让故障恢复不需要人值守——工程师的人时没有被消耗在“照顾系统”上,于是同样的人时可以支撑指数级的增长。电信行业为“可靠性”研发的一切,在互联网行业被重新标价为“人效”。语言社区随后完成了最后的接力:巴西开发者若泽·瓦利姆(Jose Valim)借来 Ruby 的语法糖衣,把 Erlang 与 OTP 包装成 Elixir,又配上网页框架 Phoenix;聊天软件 Discord 的首席技术官在 2017 年公开撰文,Erlang 虚拟机是他们想构建的高并发实时系统的完美候选,系统并发用户数近五百万、每秒处理数百万事件——如果从头再选,仍会选 Elixir。这句复盘的分量在于它出自一家把实时性当命脉的公司——数百万用户同时在线的聊天室,任何一次消息乱序或掉线都会立刻被人肉感知。
回望这门语言的四十年,它对本书卷四主线的回答清晰得近乎固执。并发之所以让一代代程序员恐惧,是因为共享内存的并发把海量的状态一致性判断压进了每一行代码——认知带宽在锁与竞态的迷宫里耗尽;Erlang 的答案是把这份认知负担整个交还给语言:进程隔离消灭了锁,消息传递消灭了共享,监督树消灭了崩溃处理的散装逻辑,程序员只需要安心写好一个个顺序的小进程,像八十年代的电信工程师只管一路通话。认知带宽被解放出来的代价,是与硬件表达精细度的彻底决裂——Erlang 不碰共享内存,不做细粒度的性能控制,数值计算与单线程吞吐从来不是它的战场。这是一次彻底到极点的取舍:把精细度全部让出去,换回并发认知的彻底简化;而电信级可靠性九个九(或接近九个九)的实战记录证明,在并发这个特定的战场上,交出精细度非但不损失质量,反而赢得了质量。Erlang 的故事因此为卷四写下了一条边界清晰的结论:当某一类问题的认知负担大到压垮一代工程师时,最有效的语言设计会把那类问题的全部复杂性收编进语言的运行时,而不是继续给认知加杠杆——哪怕代价是被主流市场当作异端,哪怕要等二十六年,才等到二十亿用户替它平反。1995 年那间斯德哥尔摩机房里的救场会议,因此有了双重的隐喻:爱立信救的是一台交换机,Erlang 救的是这家公司对可靠性的全部想象——而被救的语言走出机房之后才发现,需要它救场的地方,遍布整个互联网。而它的思想遗产早已越出 Erlang 社区:此后微服务与容器时代流行的“快速失败、快速重启”“把状态放进外部存储、让节点随时可弃”等设计语汇,处处能听到任其崩溃的回声——二十亿用户的平反,其实早在整个行业改用它的哲学时就已经开始。
第 043 章 1990:Haskell 与 ML:纯函数式、Monad 与类型证明
一个证明器养出的一门语言
1973 年,爱丁堡大学,罗宾·米尔纳(Robin Milner)的办公桌上摊着一台分时终端,屏幕上跑着他与同事戈登·普洛特曼、迈克尔·戈登正在搭建的定理证明器——LCF,可计算函数逻辑。这台机器的任务宏伟得近乎僭越:让计算机替数学家检查证明的每一步。这套系统的学术地基来自更早的逻辑学:达娜·斯科特在六十年代为“可计算函数的逻辑”搭好了语义框架,证明的每一步都可以被形式地检验。理论就绪之后,缺的只剩一件工程制品——一个能让人类与这台证明器对话的界面。但 LCF 有一个绕不开的软肋——它需要一门脚本语言,让使用者编写“证明策略”:当机器在几千条可能的推理路径里犹豫时,策略告诉它先试哪条。现成的语言没有一个合适:汇编太底层,Lisp 太不设防——证明检查器的核心是“证明的正确性不可伪造”,而一门随便就能改写内存的语言,等于把保险柜的密码写在柜门上。这个困境的前一半属于数学:证明的逻辑必须有严格语义;后一半属于工程:与证明器交互的策略语言必须好用。米尔纳的职业履历恰好横跨两端——他在剑桥学的是数学,在费兰蒂写的是机器码——由他来画这张图纸,几乎是命运的安排。
米尔纳的决定是给这台证明器量身造一门新语言,取名 ML——Meta Language,元语言。名字老实得像一份岗位说明:它不为应用而生,它只负责一件小事,替人类书写证明器看得懂的策略。它的用户在最初几年里不超过一间讨论班的规模——直到人们发现,这门“打杂”的语言藏着一整套语言设计的未来。
他给这门语言立下的第一条铁律,直接来自证明器的天性:在 ML 里,一个表达式的类型若说它是整数,它就绝不会在运行时突然变成一个函数;类型不对的程序根本不许运行。这条规矩的动机极其具体:证明器的核心资产是一份“机器不可伪造”的证明存根——若脚本语言能篡改内存,存根就能被伪造,整台证明器的心血作废。安全的类型系统不是学术洁癖,是这台机器的营业执照。
为了让这条规矩不变成负担,他又给了它一项当时无人见过的能力:类型不用写,机器自己推。你写下一段程序,编译器读完就能告诉你每样东西是什么类型——推理的根据来自 1969 年逻辑学家罗杰·欣德利(Roger Hindley)在组合逻辑中的工作与米尔纳自己在 1978 年给出的算法,史称 Hindley-Milner 类型系统。那套算法有个朴素的名字——算法 W:一条机械的推理链,遇到未知类型就记为变量,从每一次运算里收集约束,最后解出全部未知数;整个过程没有一步依赖人的直觉。有趣的是,两人是在互不知情的情况下各自抵达的,米尔纳的这一份被同事们笑着称作对欣德利的“重新发现”——逻辑学界与计算机界隔着九年与一套不同的术语,写下的是同一套规则;这个巧合后来成了类型论课程的固定开场:好的想法一旦条件成熟,会在不同的大陆同时发芽。
这门为证明器打工的元语言,后来独立成了 Standard ML,子孙满堂:OCaml、F# 皆出此门。1990 年,米尔纳与托夫特、哈珀合著的《Standard ML 的定义》出版——一门语言的语义被写成一本严格的数学书,连同它的形式定义一起接受审阅;ML 家族的谱系此后继续延伸——法国 INRIA 在其基础上发展出 OCaml,微软研究院的 Don Syme 在 2005 年推出 F#,把这套类型推导带进 .NET 世界;语言不再只是一份手册加一个编译器,它第一次以“被完整定义”的姿势存在。米尔纳本人则凭 LCF、ML 与并发理论 CCS、π 演算的四件套,摘得 1991 年图灵奖。他的履历在同行里算得上异类:伊顿公学的国王奖学金得主、皇家工兵部队的少尉、中学教师,然后才是费兰蒂公司的程序员与日后的教授——一位带着军官与教师双重底色的逻辑学家,最终把一生花在“让机器理解结构”这件事上。
类型会自己长出来
要理解类型推导为什么是革命,得先看它推翻了什么。此前的静态类型语言——从 Fortran 到 Pascal——都遵循同一条规矩:程序员必须为每一个变量、每一个函数参数、每一个返回值亲手写下类型声明,编译器照单核查。这规矩保证了安全,代价是喋喋不休:一个求平方根的函数要写出“输入是浮点数、输出是浮点数”,一个链表节点要写出它指向的又是链表。动态类型语言(Lisp 一族)干脆放弃了核查,把风险推迟到运行时——代价是每一处类型错误都要等到程序跑崩才发现。静态与动态之争此后持续了半个世纪,双方各执一词;Hindley-Milner 的价值在于它证明了争论的前提可以松动:安全与轻便并非只能二选一,只要推导算法足够聪明,机器可以替人完成大部分声明而不损失任何检查。
Hindley-Milner 系统在这两难中间劈出了第三条路:类型由编译器自动推导,而推导的结果在编译期就完成核查。程序员写 fun double x = x * 2,编译器看着乘法与字面量 2,自己推出 x 是数、返回也是数;再看到这个函数对整数和浮点数都能工作,它进一步给出一个多态的类型——“接受任何可乘之物的函数”。多态是关键词:一个函数不必为每种数据类型复制一份,一份定义覆盖所有适用的类型。ML 还顺手立了另一项第一:类型安全的异常处理——程序可以在出错时抛出一个带类型的异常,由上层接住处理,而异常本身也被类型系统看管,忘接的异常编译器看得见。今天每门语言里 try 与 catch 的安全用法,制度源头在这里。这套推导在数学上有一条铁的保证:如果编译器能推出类型,这个类型就是这个程序唯一的最佳类型;推不出来,程序必然有错。程序员的书写量降到与无类型语言相同,而安全性反超最严格的显式声明——用后世的话说,这是第一次有工具做到“既要又要”,而且靠的不是运气,是算法 W 的每一步机械推理。
类型推导带来的还有一件当时未被充分领教的事:它让类型系统第一次成为交流工具。由于类型可以精准描述函数的意图——“接受一个列表和函数、返回另一个列表”——熟练的工程师只看类型签名就能判断函数的行为,如同看配电图的接口就懂电器用途。三十多年后,这个习惯长成了大工业的标配:今天的 IDE 悬浮提示、API 文档的第一行、乃至整门 TypeScript 语言的类型标注文化,源头都是 1973 年那台 LCF 终端上自动浮现的类型。
十几种语言与一纸公约
ML 谱系开枝散叶的同时,另一条支线——惰性求值的纯函数式语言——在八十年代野蛮生长。惰性求值是一种大胆的执行策略:表达式不立刻计算,等到真正需要它的值时才算;于是无穷的列表可以堂而皇之地写出来,取前十个,剩下的永远不会被碰。这条支线上陆续出现了 Miranda、LML、Orwell 等十余门语言,每一门都很漂亮,每一门都只属于一个实验室。这条支线上陆续出现了 Miranda、LML、Orwell 等十余门语言:每门都很漂亮,每门都只属于一个实验室。其中风头最劲的 Miranda 出自学者戴维·特纳之手,语言设计干净得被多所大学选作教材——但它是一款商业产品,授权费与不可改动条款像玻璃罩一样罩着它:所有人都知道玻璃罩里是最好的设计,所有人都碰不到。到 1987 年,问题已经明了:语言比使用者还多,教学与研究各自为政,没有人愿意为一个随时消失的方言投入毕生。
这一年的函数式程序设计语言与计算机体系结构会议(FPCA)上,与会者做了一个影响深远的决定:成立一个委员会,为惰性函数式语言设计一门开放的标准语言。委员会的目标写成了四条,每一条都对照着当时的痛处:它要适合教学、研究与实际应用;它要用形式语义完整描述——语言的每一条规则都数学化,不留方言口音;其一,它要适合教学、研究与实际应用——一份材料同时伺候讲台、实验室与生产环境,省去“学一门、用另一门”的双重成本。其二,它要用形式语义完整描述——语言的每条规则都数学化,不留方言口音,让任何两台机器上的实现都必须一致。它要自由可用——任何人可以拿去用、改、再分发,不受专有许可证辖制(这一条明晃晃地指向 Miranda:那门最流行的惰性语言是商业专有的,作者禁止他人改动,社区被一家公司的授权条款集体卡住);它要只基于成熟的想法——不接受任何实验性设计,委员会不做研究,只做整合。其四,它要只基于已被文献检验的成熟想法——委员会不做研究,只做整合,实验性提案一概挡在门外。委员会里有西蒙·佩顿·琼斯(Simon Peyton Jones)、菲利普·瓦德勒(Philip Wadler)等人,一干三年,1990 年交出 Haskell 1.0;委员会里有西蒙·佩顿·琼斯(Simon Peyton Jones)、菲利普·瓦德勒(Philip Wadler)等人,成员横跨大西洋两岸的多所大学;决议以邮件与会议推进,任何设计决定都要在公开的记录里经受所有人质询。一干三年,1990 年交出 Haskell 1.0;此后标准继续演进——1992 年 1.1、1993 年 1.2、1996 年 1.3 与 1.4,直至 1998 年的 Haskell 98 成为稳定教材基准——每一版都经委员会集体表决,语言的生命从此不再系于任何一位作者。语言以逻辑学家哈斯凯尔·柯里(Haskell Brooks Curry)命名——组合逻辑的奠基人,函数柯里化(currying)即以他为名,尽管这个技巧最早由舍芬克尔(Moses Schönfinkel)发明。以一位逻辑学家命名的编程语言,在工业史上几乎绝无仅有,这个命名本身就把 Haskell 的出身写在脸上:它不是工具的改良,它是一门被当作物证的语言——证明即程序,命题即类型。
委员会设计这个名字,在编程语言史上名声不佳,而这份警惕有完整的先例。1963 年 10 月,IBM 与其科学用户团体 SHARE 也成立过一个委员会:三名 IBM 纽约雇员加三名 SHARE 成员,最初的任务只是给 Fortran 提出一些扩展。但目标在会议中步步膨胀——科学计算要它、商业记账要它、系统编程也要它,一个语言统吃所有领域的野心吞掉了原定任务。产出的语言就是 PL/I:特性清单长得像三本语言手册的合订,编译器难产多年,最终没有任何阵营整体迁移过来。同一个“委员会”的词根,指向两种截然不同的结局,差别不在参与者的智力,而在委员会给自己立的规矩:PL/I 委员会受理一切需求、许诺一切融合;Haskell 委员会开宗明义列出四条不做的事——不做实验、不做专有、不做残缺语义、不做单一场景。语言的委员会设计能否成活,关键从来不是委员们同意什么,而是他们不同意什么。前者把委员会当成满足需求的机器,后者把委员会当成拒绝需求的闸门。两场委员会的时间表也构成一组残酷的对照:PL/I 的六人小组从“给 Fortran 提扩展”起步,需求在每一轮会议里只增不减,最终交付的规模让编译器团队追赶了数年仍难产,三个原本各安其位的语言社区一个也没搬进来;Haskell 的委员会花了三年,交付的 1.0 版克制得近乎寒酸——惰性求值、纯函数、类型类,全部是文献里反复检验过的想法,实验性提案一概挡在门外。语言设计的委员会成活率,关键从来不在委员们就什么达成一致,而在他们就什么达成了拒绝。
纯洁的代价
Haskell 从 ML 继承了类型推导,又往前推了一步,推到了一个此前只有数学家才当真的立场:纯函数。在 Haskell 里,函数是数学意义上的函数——同样的输入永远得到同样的输出,除此之外什么都不发生。一个求两倍值的函数永远返回两倍值,它不打印、不写文件、不改全局变量、不读取时钟。这个立场换来的回报是惊人的:既然函数与外界彻底隔离,编译器就可以自由地重排、缓存、并行、删除任何计算而不必担心被人察觉;一段纯函数代码的正确性可以像数学证明一样逐条推理,测试只需覆盖输入的组合,不需要模拟整个宇宙的状态。并行化也顺理成章:没有共享的可变状态,就没有数据竞争——函数之间不认识彼此,谁先谁后毫无关系;这份“可以放心拆开并行执行”的自由,要到多核时代才显出真价,此处按下不表。纯度的批评者在 1990 年代同样振振有词:真实世界的程序要处理时间、网络与人,把这一切挤出语言,等于把语言挤出真实世界;这个批评在二十年里几乎无可辩驳——直到多核处理器让“没有共享状态”从洁癖变成救命的纪律:并行程序最难制服的数据竞争,恰好被纯度提前掐死在摇篮里。当年最像洁癖的设计,等来了自己的时代。这份“可以放心拆开并行执行”的自由,不再只是理论赞美。
但代价在下一个路口立刻出现,而且无法回避:如果函数不许碰外面的世界,程序怎么读键盘?怎么写文件?怎么拿当前时间、发一个网络包、生成一个随机数?——这些行为统称副作用,而任何有用的程序都不可能没有副作用:一句问候要读键盘,一份账单要写文件,一次抽奖要拿时间当种子。副作用是程序与世界的全部接口——去掉它,程序就像一封信没有地址、没有邮差,写得再漂亮也出不了门。纯函数式的世界像一间从未开窗的无菌实验室:里面的一切纯净可控,可它连一扇门都没有。早期的函数式研究者在这道题前各自绕路。有人给语言偷偷留“逃生舱口”,允许个别函数标记为不纯——结果整座大厦的纯度保证随之作废:只要一个函数可能说谎,所有调用它的函数都不再可信,纯度是一个必须全员守约的承诺,留一个后门就等于没有门。有人设计流式输入输出,把人与机器的对话建模成两条交错的数据流——思路优雅,可真正的交互程序要随时提问、随时分支,流式模型笨重得像用漏勺喝汤。整整十年,纯函数式语言被困在实验室里:理念无可挑剔,就是连一句“你好,世界”都写不体面。外界的批评也从未客气:一行实用的程序要读写磁盘、管理网络、响应时间——把这一切宣布为“不纯”并拒之门外,在工程师听来近乎抽象的洁癖;函数式阵营内部的诚实者同样承认, 纯度的代价被长期低估了。这个僵局的解法不会来自更彻底的纯,也不会来自放弃纯——它需要一个全新的抽象,把“不纯”本身变成一种可以摆上台面讨论的东西。
手套箱
破题的人来自一个意想不到的方向。1991 年,范畴论学者尤金尼奥·莫吉(Eugenio Moggi)发表了一篇论文,提出一个看似只属于纯数学的构造——单子(monad)——可以用来为“计算”这个概念本身建模:在范畴论的语言里,凡是带着某种上下文的计算——可能失败、可能延迟、可能携带状态——都有同一种封装形状;1992 年,菲利普·瓦德勒(Philip Wadler)把它捡起来,写出一篇标题平实的论文《函数式编程的精髓》,向整个函数式社区演示:副作用并非纯函数的敌人,它是一种可以被装进容器的值。
这个容器的物理形象,最好用实验室的手套箱来理解。化学实验室里处理怕空气、怕水汽的样品时,用的是一只密封的箱体,箱体上只留两个孔和一副长橡胶手套:操作员的手留在箱外,隔着手套在箱内作业;样品从传递舱进出,全程与实验室的空气隔绝。Monad 在 Haskell 里扮演的正是这只手套箱:纯函数的世界是无菌室,一切与外界的接触——读键盘、写文件、取时间——都被装进一只密封的箱子,箱子里的操作可以发生,但发生的位置永远在纯函数世界之外。程序员的代码只做一件事:把一只箱子接到另一只箱子上。以读入用户名字并向他问好为例——getLine 产生的并非一行文字,它是一只装着“去读一行文字”这个动作的箱子;箭头把它交给下一个环节,下一个环节产生的还是箱子——装着“打印问候语”的箱子。程序从头到尾没有碰过任何真实的外部世界,它只是描述了一条由箱子串成的流水线;真正伸手接触键盘与屏幕的,是运行这段流水线的运行时。纯度保住了,副作用也发生了——两件事靠着“隔着手套操作”这个动作同时成立。手套箱的隐喻还有最后半层:箱子里的操作执行与否、执行几次,从类型签名上一眼看不出——这就是惰性求值与 Monad 组合后被抱怨最多的一处,纯粹换来了清晰,也藏起了时序。这套设计的代价同样直白:写惯了直来直去代码的工程师,初见 Haskell 的输入输出时几乎无不骂街——打印一行字都要把箱子接来接去,简单的顺序逻辑被类型签名拆成了流水线工位;学习曲线陡到 Haskell 社区自己都拿它开玩笑,说这门语言的第一个门槛不是递归,是读懂数据怎么在箱子里流动。骂声归骂声,箱子的账目是清楚的:所有与外界的接触点都被类型标记出来,审计一份程序干了什么,只需要看它的箱子类型——这个能力在安全审计里值多少钱,此后的工业史给出了答案。
手套箱不止一种。IO 箱装与外部世界的来往——读一行输入、打印一行文字、生成一个随机数(随机数要向系统要熵,也是一次与外界的接触);Maybe 箱装可能失败的计算——一次安全除法在除数为零时交回一只空箱子,后续环节看到空箱便自动跳过,除零错误从此无法让程序崩溃,因为“失败”已经被写进了箱子的类型。错误处理、状态传递、多值返回,每一种上下文都有对应的箱子,而所有箱子共享同一副手套接口:接上、拆下、串联。这套接口的学名分别叫 return 与 bind——前者把普通值装进箱子,后者把一只箱子交给一个会产生新箱子的函数;两个动作合起来,就能把任意长的副作用链条串成一段可组合的代码。名字听上去玄,动作只有两个,恰如手套箱的全部操作也只有:伸进去,拿出来。这个模式后来的扩散远超函数式的小圈子,而且扩散的方式几乎全是无意识的:JavaScript 的 Promise 是一只装着“未来才有结果”的箱子,await 就是隔着手套取值的手势;Rust 的 Option 与 Result 是 Maybe 的直系移植,编译器强迫你在拆箱前处理空箱;Swift 的可选值、各语言响应式编程里的数据流,全都在重复同一个手势——把危险的、异步的、可能失败的部分装进类型标记的容器,让编译器替人盯住它们。绝大多数在这些语言里写下这些代码的工程师,从未听说过范畴论,也从未用过 monad 这个词——这正是这个设计最深的影响力形态:它的名字留在论文里,它的形状长进了所有人的代码里。monad 这个词的接受史本身也是一课:范畴论的术语让几代程序员望而却步,社区里流传的那句玩笑式定义——“单子是自函子范畴上的幺半群,有什么好解释的?”——吓退的人数以万计;而它的实际操作只有 return 与 bind 两个动作,任何会写 hello world 的工程师十分钟就能学会用法。术语吓退的人数,与用它写出的安全代码的数量,是这门语言留给工程文化的一对悖论。
证明与承诺
把 ML 与 Haskell 两支并排看,这一章讲的是一个共同主题的两种完成度。米尔纳的 ML 在 1973 年回答的问题是:如何让程序自动携带类型证明——答案成了今天每一种主流语言的类型系统基石;Haskell 委员会在 1990 年回答的问题是:一门语言能否把“证明”贯彻到底——函数即程序、命题即类型,写下的每一段代码都自带数学含义。这条路线的祖师爷是逻辑学家柯里与霍华德——后世称作 Curry-Howard 对应——而把它兑现成一门可用语言的,正是从 ML 到 Haskell 的两代人。两支的遭遇也互为镜像:ML 因为是工具而活了下来——它是 LCF 的手脚,实用主义的出身让它毫不介意自己的类型系统被后来的语言抄走改写;Standard ML 在 1990 年完成了正式定义,1997 年修订,此后稳稳地活在教学、编译器、金融建模与形式化验证的领域里,从不追求市场份额;Haskell 因为是标准而活着——它从不追求商业份额,却以思想供输的方式把自己写进了几乎所有后来者的设计稿;它自己也没有停下:GHC(格拉斯哥 Haskell 编译器)成了事实标准,类型类、代数数据类型、模式匹配、属性测试(QuickCheck 就诞生在这门语言里),一项项经由这门语言被检验、被打磨。思想供输的清单,同样是对它的致敬。卷四的主导约束是认知带宽与硬件表达精细度的妥协,这一章是这个约束的纯软件版本:类型推导解决的是“人不必写、机器可以推”的认知带宽问题,Monad 解决的是“纯度与副作用不可兼得”的表达精细度问题——两解都把代价从人挪给了机器与规范。这本账也可以反着记:机器替人推类型,人就要学会读机器推出来的类型;箱子替人隔离副作用,人就要学会顺着箱子的链条思考。认知带宽没有被消灭,它只是从“记住类型”转移到了“读懂推导”,从“记住副作用清单”转移到了“识别上下文形状”——本章为卷四主导约束提供的正是这个原型:语言演化的每一步,都是一次认知负担的重新分配,而不是单纯的数量增减。读推导的负担有具体的形状:省略的类型签名让代码变短,也让报错变难——编译器指着一行说类型对不上,缺席的签名把定位的线索一并带走,读者要先把推导的结果在脑子里重算一遍,才能看懂错在哪里。省掉的书写,迟早要在阅读时偿还;推导的便利与报错的难读,是同一枚硬币的两面。用的人越多,硬币的两面越清晰:写时爽快,调时还账——负担的搬家,从不免费;看懂的人越多,硬币才越值钱,学费才越值得交;每一代新入场的人,都在替前人验证这枚硬币的成色,顺手替后人标好价格。
档案的最后一页留给年份的对称:米尔纳生于 1934 年,图灵逝世那年他二十岁,正在皇家工兵部队服役;他去世的 2010 年,从 ML 与 Haskell 汲取的类型系统已跑在数十亿台设备上。逻辑学家柯里与欣德利的两套手稿、一位证明器作者的一次“重新发现”、一个委员会的三年闭门——全部汇进了今天任何一行被类型检查过的代码。语言史上的多数发明都声称改变世界,真正改变世界的几件,先改变了每一行代码的写法。
所以,本章给出的最终判断是:ML 与 Haskell 证明了编程语言可以是数学的直系后代——类型即证明、程序即推导,这条 1940 年代就写在逻辑学里的路线,由一个想造证明器的人和一个想建标准的委员会各自走通;而它们真正战胜对手的方式,与所有的语言战争都不同——不是取代,而是渗透。五十年后几乎没有人在主流工业界写 ML 或“纯”Haskell,但每一种主流语言里都长着它们的器官:类型推导、代数数据类型、模式匹配、以类型封存的副作用。这不是第一次出现这种结局——第二章里法拉第与麦克斯韦的场、第六章里斯特罗格的拨号盘,都是发明者亲手交出、由后来者放大的构造;语言设计这一章的特殊之处只在于,它的“后来者”并不限于另一家公司,它包括了所有写代码的人。这个说法可以被反驳:思想的无形胜利算不算胜利?本书的回答写在统计里——今天每一行被类型检查过的代码、每一个被容器封住的副作用,都在替 1973 与 1990 年的那两间屋子持续运行。而这一章留在卷四坐标上的刻度也值得记下:1990 年,Haskell 1.0 发布的那一年,万维网还要一年才被提出,主流世界的程序员在 C 与 COBOL 里管理指针与内存——一门把“证明”写进类型、把“副作用”关进箱子的语言,在当年像是一封写给未来的信;收信人签收的时间,比寄件人预想的要长得多。
第 044 章 1991:Python:可读性至上与运行时代价
空办公室里的圣诞假期
1989 年 12 月的最后一周,阿姆斯特丹,荷兰数学与信息中心(CWI)的大楼安静下来——荷兰的圣诞假期把整座研究机构清了场。三十三岁的研究员吉多·范罗苏姆(Guido van Rossum)留在了空楼里。他手头的正式任务是 Amoeba,一个分布式的操作系统项目——多台机器协作,像一台机器一样工作,而在这台“合成机器”上写日常工具,是一件让范罗苏姆日益烦躁的差事;而真正的动机,是一个他在心里绕了好几年的问题。隔壁项目组的同事都回家过节了,整层楼只剩下他一个人的键盘声。这个空档是某种自由的形状:没有例会、没有评审、没有排期——一个为雇主写的分布式系统还在等他,而他自己脑子里那个问题,只有放假的时间才装得下。假期的最后,问题的答案有了雏形:一门新的编程语言。次年二月,他给这门语言写出了第一个可用版本;1991 年 2 月 20 日,他把 0.9.0 版发布到了 Usenet 新闻组 alt.sources 上,附上了全部源代码。
三十年后回看,这条新闻组帖子是信息工业史上回报率最高的假期作业之一:它发布的语言叫 Python,日后成为人工智能时代的通用语——TensorFlow 与 PyTorch 两代机器学习框架都把它选作唯一的主接口,全球数以百万计的生物学家、统计学家、金融分析师与中学生通过它第一次写出能运行的程序。而在 1989 年的圣诞周,它的全部存在理由只有一条:写它的那个人受够了。
ABC 的三堂课
受够的对象是一门叫 ABC 的语言。1980 年代初,CWI 组建了一个团队设计 ABC,目标与四十年后的无数教学语言一样:让不会编程的科学家也能编程。这个理想主义的项目持续了整个八十年代,团队把它打磨得干净、严谨、教学效果出色——全国有数百所学校用它教过编程入门;它也在另一个方向上证明了商业世界的铁律:再优雅的语言,进不了产业就是一场安静的告别。范罗苏姆是这个团队的成员,他为 ABC 写了解释器、干了好几年。ABC 有一批真正优雅的想法——用缩进来分组语句,省掉花括号与 begin/end 的噪音;内建的列表、字典、字符串强大到开箱即用;语法干净,读代码像读伪代码。这些想法在 1980 年代是异端,在今天是常识——Python 后来原样继承了全部三条。
ABC 同样给了范罗苏姆三堂教训,每一堂都刻进了 Python 的设计。第一堂:ABC 竟然没有文件输入输出功能——一门号称给科学家用的语言,科学家最需要做的“读数据文件、写结果文件”,它做不到;程序的状态只能靠常驻内存的全局变量保存,关机即失。范罗苏姆为 Amoeba 写工具时尝到的每一个苦头,都能在 ABC 的清单里找到名字:工程师的真问题是“有没有持久的数据、能不能调到底层的系统调用”,而 ABC 的世界里这两样东西都被设计者好心地隔离在了语言之外。第二堂:ABC 是个单体——想给它加一点新功能,唯一的办法是修改语言自己的解析器,而解析器的源码是团队核心的秘密;用户与语言之间只有使用关系,没有生长关系。第三堂:ABC 的关键字全部大写——WHILE、IF、RETURN——范罗苏姆后来承认,敲这些大写词让他觉得又丑又累。三堂课加上一个直接的导火索:为 Amoeba 写系统工具时,用 C 写半个功能要一天,用 shell 写只能做到三分之一,范罗苏姆的原话是——当时就想,要是能用 ABC 那样的语言来代替 C,这些工具每一个都会是半页代码。
于是圣诞假期里勾勒出来的这门新语言,本质上是“去掉了糟糕部分的 ABC”:保留缩进与可读语法;关键字全部改成小写;加上真正的文件输入输出;最关键的一步,是设计了模块系统——Python 程序可以直接调用 C 语言写好的函数库,任何人想扩展这门语言,写一个 C 模块挂上去即可,完全不必触碰语言的核心。第一条铁律解决了 ABC 的文件难题,模块系统解决了 ABC 的单体难题,小写关键字解决了丑与累。至于名字——Python,与蟒蛇毫无关系,出自英国喜剧团体 Monty Python's Flying Circus:范罗苏姆自称是在“一种略带不敬的心情”下选的,他想要一个名字表明这不是一项严肃的事业。后来的事实证明,这是那个冬天里他唯一看走眼的一件事。
半页代码的复利
1991 年 2 月发布的 0.9.0 版已经带着一份超前的陪嫁:异常处理机制、带继承的类,以及四种内建数据类型——列表、字典、字符串、数字。这四样东西从此成了 Python 程序员的第一反应:数据来了一律先想“它是列表还是字典”,问题来了先想“建一个类还是调一个函数”。列表是排队的样本,字典是贴标签的特征,字符串是待处理的文本,数字是最终要的答案——三十年后机器学习工程师描述世界的全部词汇表,就是这四张卡片的扩写版。三十年后机器学习领域描述世界的全部方式——样本是列表、特征是字典、张量是列表的列表——仍然站在那间空办公室里画出的四张底座上。
这门语言的扩展机制在几个月内就经受了第一次社群检验:一位怀念函数式写法的 Lisp 程序员提交了补丁,为 Python 加上了 lambda、map、filter 与 reduce。范罗苏姆接受了补丁——尽管他后来把 lambda 视作一个为向后兼容而保留的错误。这个小小的插曲预演了 Python 此后三十年的全部治理史:语言的核心由一个人的审美牢牢守住,语言的边界向所有来客敞开。补丁者想要的是函数式的表达力,独裁者接受的是社区的诚意——两人各取所需,谁也没有说服谁;语言就在这种“中心强硬、边缘宽容”的张力里,一边被抱怨不够纯粹,一边被所有人继续使用。社群后来给范罗苏姆起了一个半开玩笑的头衔——“终身仁慈独裁者”(Benevolent Dictator for Life),这个词出自 1995 年的一封邮件,却准确得沿用了二十多年。它的妙处在于诚实地描述了一种罕见的治理结构:数百万个小设计决定,由一个人的审美一致性耐心裁决;谁都可以提交方案,但什么能进语言,最终由同一双眼睛把关。这个头衔在 2018 年被范罗苏姆本人辞去——那是后话——而在 1990 年代,它就是这门语言能够保持风格统一的全部秘密。仁慈独裁制的效率在任何会议文化里都显得刺眼:没有提案投票,没有设计评审的往返拉锯,一个特性的生死由一个人读过所有论点后一锤定音;代价则是单点——独裁者的精力、审美与健康状况就是语言的路线图。范罗苏姆后来在多次访谈里坦言,他最怀念的就是早期那种“想清楚就写”的速度;这份怀念,是所有设计委员会都给不出的东西。
鸭子、禅与一种官话的缺席
Python 的类型观念同样是对 ABC 与同期语言的回应。它有类型,而且每个值都有确定的类型,但它不要求你声明——一个函数参数可以接受任何“像数字一样能用”的对象。社群后来给这个哲学起了个名字:鸭子类型——这个说法经工程师亚历克斯·马泰利(Alex Martelli)在社区推广而广为人知,它与强类型并不冲突——每个对象的类型仍然确定,只是检查从“进门查证件”推迟到“干活看手艺”。对类型推导持同一理想的 Haskell 社区看来,这是把安全全押给了运行时;对 Python 用户看来,这是把啰嗦全还给了编译器——两种选择,各自的账单在下一章的 GIL 与上一章的类型证明里分头寄送。这门官话的缺席在 1999 年被一位早期贡献者蒂姆·彼得斯(Tim Peters)总结成了十九行短诗——《Python 之禅》:优美胜于丑陋,明了胜于晦涩,简洁胜于复杂,可读性至关重要。这首诗被藏进了语言本体:在任何安装了 Python 的机器上输入 import this,屏幕上就会打出这十九行——一门语言把自己的设计宪法写成了彩蛋,这份自我意识在 1999 年同样是首创。诗里最常被引用的两行,恰好就是这门语言的全部经济学的摘要:“可读性至关重要”与“实用胜于纯粹”——前者是产品定位,后者是对一切完美主义提案的预先否决。
这些观念合在一起,构成了一道清晰的选择题:可读性与运行时效率不可兼得,Python 选了前者。它的解释器逐条执行字节码,速度比编译型语言慢几十倍;它的动态类型让每个操作都要在运行时查表确认;它把内存管理的垃圾回收也背在了身上。这些代价的物理来源很清楚:字节码意味着每条指令都隔着一层解释循环,动态查表意味着每个属性访问都是一次字典查找,垃圾回收意味着内存的账要随时有人算——三项都是用便利抵押出去的执行效率,利息按每一次函数调用逐笔计收。这些代价每一项都有人反复提议消除,而每一项都被同一个理由挡回去:那些优化会让代码变得难读。可读性至上不是一句口号,它是一条有否决权的设计宪章。最著名的案例是三目表达式:从 1990 年代初起社区就不断请求加入,范罗苏姆以“现有的写法更可读”为由否决了十几年,直到 2006 年才以一个他勉强认可的折中形式放行——一场关于一行代码写法的争论持续了十五年,这在任何其他语言里都是不可想象的内政。
一把锁的宿命
可读性的账单里最贵的一笔,是一把锁。Python 的官方解释器 CPython 用 C 语言写成,为了让内部数据结构在多线程环境下不互相踩踏,它的主循环里安了一把全局互斥锁——全局解释器锁(Global Interpreter Lock,GIL)。规则只有一条:任何时刻,整台解释器里只允许一个线程执行 Python 字节码。锁存在的原因藏在 CPython 的内存管理里——它用引用计数决定对象何时销毁,而引用计数器的加减必须绝对原子,否则计数错乱,内存就泄漏或对象被提前回收;给每一个计数操作都配细粒度锁,实现复杂且单线程速度暴跌,一把全局锁是最省事的正确答案。设计它的年代是多核之前,这把锁换来的是实现的简单与单线程的速度,账面完美。
多核处理器在 2005 年前后全面普及之后,这把锁一夜之间从实现细节变成了全行业的提审对象。CPU 密集型的 Python 程序开十个线程,结果只有一个核在干活,其余九个排队围观——GIL 让多线程在计算场景里形同虚设;工程师们测出的结论一次比一次刺眼:同样的并行代码,Java 能用满八个核,Python 一个都多不了。业内要求移除 GIL 的声音从 1999 年(有人真的提交过自由线程化的补丁,结果是单线程性能大幅倒退,被否决)一直响到 2020 年代,每一次尝试都撞在同一堵墙上:移除锁,就得给所有共享数据加更细粒度的锁,单线程立刻慢掉两倍以上;而不移除,多核时代的大门就永远虚掩。这堵墙的存在还塑造了整门语言的工程文化——Python 社区对“并行”的兴趣,长期让位于对“易用”的执念;别的语言在教用户写线程,Python 在教用户找库。2017 年之后的风向是绕行——把计算密集的部分交给 NumPy 这样用 C 写的扩展库(它们在 C 层可以放开 GIL 用满全部核心)、用多进程代替多线程(每个进程一把自己的锁,互不相干)、用异步框架把等待时间填满。三条绕行路各有各的学费:多进程的内存翻倍,异步的回调地狱,扩展库的开发门槛——Python 社区为绕开一把锁,发明了一整个基础设施部门。锁还在原地,绕开它的路修了整整二十年。卷四的主导约束在此以最直白的方式现身:认知带宽(人读得懂的简单模型)与硬件表达精细度(多核的真实算力)之间的妥协,最终物化成了一把看得见的锁——锁住的不是线程,是 Python 二十年的并行化雄心。
逆袭
绕行路线中修得最宽的一条,通向了科学计算。1980 年代的科学计算世界属于 Fortran 与 C:数值线性代数的全部家底——BLAS、LAPACK 这些沉淀了几十年的底层库——都写在 Fortran 与 C 里,性能无可挑剔,只是用起来乏味到反人类。每一个用 Fortran 做过数值实验的研究者都熟悉同一套日常:写主程序半天,与矩阵的存储格式搏斗一周,最后把算好的数字打成一沓纸带或一摞卡片——计算的智力部分半小时,体力部分一星期。Python 在这个领域起初毫无立足之地:慢几十倍的解释器碰上百万行级的矩阵运算,等于让马穿过针眼。1990 年代末起,形势开始变——MIT 与国家实验室的研究者们受不了 Fortran 的体力活,开始在 Python 里包一层又一层接口;每一层包壳都引入一点开销,也引入一批新的使用者,使用者又写出更多的包。
这场逆袭的钥匙不在算法,在接口——而接口的钥匙,是 1989 年那个假期就设计好的模块系统。转机来自 Python 的模块系统——范罗苏姆在圣诞假期里就画好的那副骨架:1990 年代末起,科学社区的工程师们把 Fortran 与 C 的数值库一层层包进 Python 模块:先是 Numeric,后有 Numarray;2006 年,特拉维斯·奥利芬特(Travis Oliphant)把两条先行路线合并成 NumPy——一个用 C 实现核心、把多维数组当成 Python 原生对象暴露给用户的库。它的核心动作只有一件:把矩阵运算整体下放到 C 与 Fortran 的底层库执行,Python 层只负责“描述要算什么”;一行 A @ B 在 Python 层只是一次函数调用,在 C 层是几百万次浮点运算的全速冲刺。Python 层的循环慢,那就让循环发生在 C 里:用户写的是可读的 Python,真正跑的是几十年打磨过的 Fortran 与 C 代码。性能的异议被架构本身化解了——解释器的慢被限制在“粘合层”,计算的重活全部下放给编译过的底层。这是“借道 C/Fortran 的逆袭”:Python 没有变快,它学会了指挥快的代码。
逆袭的阶梯此后一级不落:NumPy 提供数组,SciPy 提供算法,2008 年前后 pandas 提供表格与统计,scikit-learn 提供机器学习;每一级都踩在前一级的 C 底座上,每一级都比前一级更接近“只描述问题、不描述机器”的理想。2010 年代,深度学习框架 TensorFlow 与 PyTorch 选定 Python 作为唯一主接口——模型定义在 Python 里,真正的矩阵运算在 C 与 CUDA 里。这个选择几乎没有经过犹豫:深度学习的从业者主要来自物理、统计与神经科学,他们的共同语言恰好是十年间被 NumPy 喂养出来的 Python 科学计算生态;框架厂商要争取的是这群人,而不是早已各安其位的系统程序员。AI 时代的研究者清晨打开终端,敲下的第一行 import,指向的是 1989 年那个圣诞假期里画下的四张底座。这条曲线的反直觉之处值得最后停留一次:科学计算选择 Python 的理由恰恰是它慢——研究者要的不是最快的矩阵乘法(那已经由 Fortran 提供了几十年),而是一种能把“想法的修改—运行—再修改”的循环压缩到分钟级的语言;数值在底层飞奔,思维在顶层漫步,两者各司其职。快与慢的分工,正是卷四主导约束最温和的一次和解。运行时的代价没有消失:Python 至今仍是主流语言里最慢的之一,GIL 直到 2020 年代才等来官方的替代方案。但它的用户群已经大到不再在乎——或者更准确地说,用户群的形状刚好让这条短板变得无关:要快的地方有 C 在下面垫着,要写的地方有可读性在上面撑着。
被省略的括号
C 程序员第一次读 Python 代码,不适感来自一种缺席:满眼找不到花括号。同一段“条件成立就连做两件事”的逻辑,两种语言写出来骨架完全不同:
C 的世界:符号划定边界 Python 的世界:位置划定边界
if (x > 0) { if x > 0:
y = f(x); y = f(x)
z = g(y); z = g(y)
} # 块的结束不需要符号
# 左对齐本身就是结束
左侧靠符号围出作用域,右侧靠缩进的位置围出作用域。这就是计划里写的那条关键线索:缩进定义作用域。它同样来自 ABC,是范罗苏姆从旧东家带走的行李里最轻也最重的一件。实现上,解释器的词法分析器逐行测量每行的缩进深度,缩进加深就吐出一个 INDENT 记号,缩进收回就吐出 DEDENT 记号,后续的语法分析只认这两个记号——程序员看到的“对齐”,机器看到的是显式的分组指令。排版即语法,阅读顺序即执行结构,这条链路短到没有中间商。
省掉的括号没有白省。C 语言里缩进只是建议,编译器不看,压垮核电站控制软件的 bug 里有一整类是“缩进说一套、花括号做一套”——人眼被排版欺骗,机器只认符号。Python 把欺骗的可能性连根拔掉:你看到的结构就是机器执行的结构,伪代码与真代码之间不再有翻译层。代价同样具体:从网页复制一段代码,混入的制表符与空格肉眼不可分,解释器直接拒绝运行;新手在论坛求助的第一课,永远是“把你的缩进贴出来”。一门语言把排版错误升级为语法错误,等于把编辑器的显示问题变成了语言的设计问题。这笔交易值不值,取决于站在哪一边:站在机器一边,这是把本该由工具解决的事推给人;站在人一边,这是让代码在写出的那一刻就必须是可读的。这套规则后来长成整个社区的社会契约:新人教程第一章讲缩进,编辑器开箱自带 Python 模式,代码格式化工具把全世界的缩进统一成同一种宽度。格式之争在别的语言里是经久不息的圣战,在 Python 里开战即终战——程序员并没有突然达成共识,争论的对象被写进了词法分析器,没什么可争的。一旦排版成为语法,风格指南就从建议变成了法律。可读性宪章在这里第一次长出了牙齿——它不只是一句审美宣言,它是词法分析器里两条实打实的规则。
缩进管的是代码的形状,另一条继承自 ABC 的遗产管的是代码的构件:一切皆对象。数字、字符串、列表是对象,这不稀奇;Python 走得更远的是,函数本身、类本身、模块本身,也都是第一级对象:函数名只是一张贴在函数对象上的标签,标签可以撕下来重贴,对象可以装进列表、塞进字典、当作参数递给另一个函数。本章前面那场 lambda 补丁插曲,今天可以重新理解:那位 Lisp 程序员的补丁之所以有意义,正是因为函数在 Python 里本身就是可以传递的值——map 接受一个函数、作用到列表的每一项上,这种写法成立的前提,是函数与数字一样享有“被传递”的权利。演示这条机制只需要几行:
def greet(name):
return "hello, " + name
say = greet # 标签重贴,对象还是同一个
handlers = [greet, str.upper] # 函数装进列表,与字符串方法并列
result = handlers[0]("ada") # 从列表里取出再调用
类也一样:定义一个类,就是造出一个类对象;实例化,只是调用这个对象。模块同样是对象,import 只是把模块对象绑定到一个名字上。1989 年假期里设计的模块系统——允许任何人用 C 写扩展挂上去——能成立,靠的正是这套统一的“对象”协议:C 端造出的东西只要长得像对象,就能在 Python 的世界里被传递、被调用、被放进字典。NumPy 的数组后来能伪装成原生类型混进每一行科学计算代码,接口上的无缝,根子在对象协议的无缝。缩进让代码读起来像文章,万物皆对象让代码拼起来像积木——前者管形状,后者管构件,两件都是从 ABC 的行李里翻出来的。
一次不兼容的赌博
2008 年,Python 做了一件主流语言极少敢做的事:发布 Python 3.0,一个不向后兼容的大版本。print 从语句变成函数,字符串默认按 Unicode 处理,一批积攒了近二十年的历史包袱在同一个版本里被一次性清洗。清洗的每一条单独看都合理,合在一起看等于向全世界宣布:旧代码要么改写,要么留在旧版本上。社区用脚投票,投出了一场长达十余年的分裂:库作者不愿迁——迁了就丢掉还在用旧版的用户;用户不敢迁——迁了依赖的库还没跟上。Python 2 与 Python 3 并行了近十年,教程要写两套,问答要先问版本,新人入场的第一课不是写代码,是选边。
这场分裂的收场日期写在素材里:Python 2.7 于 2020 年随 2.7.18 停止支持。官方停止支持的倒计时牌挂了好几年,科学计算社区的大型库一个接一个宣布只支持 Python 3,迁移才在最后两三年里真正完成。一门语言用十余年时间,让全球数百万用户为一次清洗买单——放在任何商业公司的路线图里,这都是会被否决的方案。它居然成功了,原因值得对照本章的另一把锁来看:GIL 不敢动,是因为代价落在每一次函数调用的性能上,无人愿意为单线程慢两倍买单;语法敢动,是因为代价虽然分摊给全社区,却是一次性的、可计划的、分期支付的。独裁者的两本账,记的都是同一件事:代价由谁付、以什么节奏付。GIL 的账是永续年金的利息,Python 3 的账是一次性重组的阵痛——社区愿意为后者排队,不愿意为前者买单。
迁移真正的润滑剂是一批过渡工具。官方随新版本附带了 2to3 自动转换程序,能把旧代码批量改写成新语法;社区则发展出一套同时兼容两个版本的写法,外加薄薄的兼容层,让同一个库在两种解释器下都能跑。这些工具没有消除工作量,但把一次性断裂改成了分期偿还:先让代码在两个版本下都能跑,再逐个模块放弃旧版本,最后清掉兼容层本身。每一步都是小步的、可回滚的,十年摊下来,每年要付的只是小额的迁移税。
随后是整个生态的转向:操作系统发行版与云厂商把默认解释器切向新版本,教材与问答社区跟进改写,新人不再需要选边,旧项目则被停止支持的期限推着走完最后一公里。工具链的完整,是赌博成立的另一半条件:没有自动转换与兼容层的十年铺路,一次性清洗的账单会高到无人敢付。语言设计的决断,最终要靠工具链的体力活来兑现——认知负荷没有消失,它被工具链切成小块,摊进十年的日常里。
反辉格的读法在这里同样必要:今天说 Python 3 清洗得好,是站在迁移完成后的终点回望;站在 2008 年的现场,那是一次成功率未卜的豪赌——同期有多少语言死在“不兼容的新版本”上,Perl 6 就是名单上最刺眼的名字。Python 赌赢的筹码,恰恰是本章一路写来的东西:用户基数大到迁得起,C 扩展生态厚到垫得住,可读性好到重写旧代码的体力活相对便宜。赌局的底气不是设计,是生态的厚度。范罗苏姆在 2018 年辞去终身仁慈独裁者的头衔,某种意义上也是这场赌博的尾声:语言的治理从一个人说了算,转向指导委员会投票——能发起不兼容清洗的权威结构,和能守住可读性宪章的权威结构,是同一套;当语言大到一次清洗要花十年,独裁的效率就还不起它的单点代价了。
可读性的价格
把 Python 与前一章的 Haskell 并排放在卷四的坐标上,两门语言给出了同一个问题的两个极端答案。问题在卷首已经立好:认知带宽与硬件表达精细度如何妥协?Haskell 把天平压向硬件:类型系统严密到能证明程序正确,代价是人必须学会用类型思考,学习曲线陡到成为社群自嘲的梗。Python 把天平压向人:语法可读到生物学家跳过计算机学位直接上手,代价是运行时慢几十倍、多核形同虚设。两门语言都清楚自己让渡了什么,也都清楚自己换回了什么——Haskell 换回的是“编译器替人证明正确性”的确定性,Python 换回的是“读代码像读英语”的低门槛;两个极端在卷四的中轴线上互为倒影,中间地带则挤满了折中的后来者。两门语言都在自己的极端里建立了不可替代的生态位——一个统治了正确性要求极高的领域,一个统治了“人比机器贵”的领域。而两者的共同点更值得注意:它们都没有试图折中。折中的语言——既想编译得快又想解释得灵活、既要静态安全又要动态省事——在货架上换了一茬又一茬,无声消失的居多;极端不是缺陷,它是识别信号:让需要你的人在百万种语言里一眼认出你。
有人会反驳:Python 的胜利有相当大的运气成分——它恰好等到了数据科学革命的船。这个反驳成立,但它解释不了为什么是 Python 而不是同期的 Perl、Tcl 或 Ruby 登上了那条船:船票的差价写在每一行代码里——十年不写注释也能读懂的语法,是数据科学家这种“半路出家”人群唯一能负担的语言。范罗苏姆在空办公室里追求的从来不是性能,他追求的是“半页代码”——三十年后,从基因组到神经网络的每一个突破,都在用半页代码的厚度描述自己。那间空办公室的故事,尾声同样温柔:CWI 在 2019 年授予这位当年的研究员一枚荣誉勋章,理由是他把一门假期里画出来的语言,变成了全世界的公共基础设施;授奖词里没有提性能,也没有提 GIL。
所以,本章的判断是:Python 用运行时的慢,买下了人类认知的快——它的每一行代码都跑得更慢,写代码的人却因此多了两个数量级;可读性至上不是一个美学立场,它是一项把认知带宽当作第一性资源来分配的工程决策,GIL 与解释器的所有代价,都是这项决策按年支付的利息。有人可以反驳:机器不慢下来,人为什么要学一门慢语言?回答藏在数据科学的名单里:语言的历史由用语言的人书写,而人,永远比机器贵。回答还藏在数据的分布里:写 Python 的人数以百万计,其中写性能关键代码的不足百分之一——一门语言的口碑由多数人的日常决定,而多数人的日常是读与写,不是压榨时钟。让百分之九十九的人少痛苦一点,让百分之一的人去调 C 扩展,这笔交易在每一个用户自己的账本上都记为净赚;只要这个分布不变,可读性的宪章就无人能够废除。
第 045 章 1995:Java:跨平台字节码、虚拟机与工业级托管
1995 年 5 月,加州旧金山湾,Sun 微系统公司为一门新语言的全球发布会做最后冲刺——距离登台只剩三天,负责运行环境的工程师蒂姆·林德霍姆(Tim Lindholm)在排查中确认了一个致命结论:这门语言赖以卖点的原生多线程模型存在根本性缺陷,处理器中断信号会让尚未保存的程序状态无法恢复,整套底层设计彻底无法稳定运行。三天的窗期里,底层运行环境被推翻重写。三天后,这门名叫 Java 的语言在 SunWorld 大会上正式亮相,口号随即传遍行业:一次编写,到处运行。没有人想到,这门几乎在发布前夜重写了地基的语言,会在十年内成为全球部署最广的工业语言;更没有人想到,它解决的核心问题,恰是此前二十五年里另一门最伟大语言的阿喀琉斯之踵。Java 与 C,一个 1972 年生于贝尔实验室、一个 1995 年生于硅谷——两门语言隔着二十三年对视,本质上是在对同一道题交出的两份相反答卷:程序的复杂性,应该由程序员来管,还是由运行时来管?这个问题的第二份答卷也在 1995 年问世——同一年的另一家公司用十天拼出的另一门语言,将在三十年后接管浏览器与半个服务端,那是下一章的故事。
为电视机而生的语言
Java 的诞生与万维网毫无关系。1991 年,Sun 微系统公司启动了一个名为 Green 的探索项目,高斯林的同事比尔·乔伊此前的构想是它的思想源头:把 C 语言的效率与 Mesa 语言的优雅合而为一。目标是跳出传统计算机市场,为正在兴起的消费电子——机顶盒、手持设备、家用电器——寻找一套统一的软件底座:让不同厂商、不同芯片的设备能运行同一套从网络下载的程序。项目组很快撞上了那个年代嵌入式开发的标准绝境:C++ 的功能无可置疑,但它把内存管理的全部负担、指针运算的全部自由和跨平台为零的可移植性一并交给了嵌入式工程师——在电视机的芯片上,这三样东西的任何一处出错,返工的成本都以月计。项目负责人詹姆斯·高斯林(James Gosling,1955 年生于加拿大)先尝试给 C++ 做扩展,做了一半放弃,索性从头设计一门新语言。这位日后的“Java 之父”十二岁就能自制电子游戏机、替邻居修理收割机,1977 年在卡尔加里大学拿到计算机科学学士,1983 年在卡内基梅隆大学读完计算机科学博士,随后进入 IBM 设计第一代工作站系统 NeWS——却因为高层不看好工作站方向而郁郁不得志,1984 年转投 Sun。他给新语言起名 Oak(橡树)——灵感来自编写第一行代码时抬头望见的窗外那棵橡树;多年后人们才知道,他最初想给改造版 C++ 起的名字是“C++ 减减”,被同事拦了下来。
Oak 的设计原则全部来自机顶盒的物理约束:芯片型号千差万别,语言必须与任何一种芯片解耦;设备内存以兆计,内存管理必须由系统而非程序员完成;家电一旦出货就无法升级补丁,错误必须被运行时拦截而不是靠程序员小心。为了兑现这三条,Oak 团队选了一条此前的语言都没走通的路:把程序编译成一种面向虚拟机器的中间代码——字节码,然后在每种设备上实现一个小小的虚拟机来执行它。语言与芯片从此彻底解耦:换一种芯片,只需重写虚拟机,程序一行不改。这个思路在计算史上并不算全新的思想,但把它做成一套能在消费级硬件上稳定运行的商品,是第一次。
然后,市场给了这门语言第一次,也是几乎致命的一次打击。1992 年底,时代华纳发布交互式有线电视机顶盒项目的招标方案,Sun 全力竞标,把 Oak 作为核心方案押了上去——结果爆冷,合同被临时入局的硅图公司拿走,而这个项目在几年后也被硅图自己终止。为机顶盒梦成立的子公司 FirstPerson 走到解散边缘:三分之一员工离职,三分之一被调回本部,全员一度被列入裁员名单,靠高管比尔·乔伊的紧急介入才保住核心团队。留下来的产品经理金·波利斯(Kim Polese)回忆当时的氛围只有一句话:我们就像困在被炸毁的掩体里的难民。一门为电视而生的语言,在被电视拒绝之后,才等来了它真正的舞台。历史的吊诡在于为它保住火种的那个人:若非乔伊的紧急介入,Oak 团队将随 FirstPerson 一起解散,此后的一切——字节码、虚拟机、全球的银行系统——都不会存在。技术的存续常常不取决于技术本身,而取决于失业名单上被谁的名字划掉。
三条规则与一个虚拟机
理解 Java 为什么胜利,最快的方式是把它的三条核心规则与 C 的三大痛点一一对照。C 的世界里,程序员最怕的三件事分别是:换一台机器就要重新编译适配、每一次内存分配与释放都要自己记账、数组越界悄无声息地腐蚀邻居内存——三件事没有一件是“功能”,却占掉了系统编程一半以上的工时与事故。Java 的设计者们没有试图把这三件事做得更安全,它们做的事情更彻底:直接把这三件事从程序员手里收走。第一,Java 的源代码不被编译成任何真实芯片的机器码,而是被编译成一种面向虚拟机的中间代码——字节码,每条指令由一个字节的操作码加上若干操作数构成,每种芯片上装一个 Java 虚拟机(JVM),由它把字节码翻译成本地指令。C 的程序在不同平台上必须分别编译、分别测试,Java 的程序在任何平台上运行的都是同一份字节码——“一次编写,到处运行”不是口号,是字节码这个中间层的直接工程后果。第二,Java 取消了指针运算,内存的分配与回收全部交给虚拟机自动完成——程序员创建对象,至于对象何时被回收,由垃圾收集器在后台判断;指针运算则被语言整体移除,程序员拿到的永远是对象的引用,而不是可以随意加减的地址。收集器的设计依据是一条统计学观察:绝大多数对象的生命极短,新生代高频清扫、长命对象晋升老年代的分代策略,让自动回收的开销被压到了产业可接受的范围;判定垃圾的方式是从一组根——正在执行的栈帧、静态变量——出发做可达性搜索,搜不到的对象就是垃圾,这条规则从根上避免了“数引用计数数到循环引用”的死局;技术细节的演进史属于后续章节,此处只需记录它在认知上的划时代——程序员与内存的对话,从“我申请、我负责释放”变成了“我申请,其余的事不要再问我”。第三,数组访问自带边界检查,越界访问不会被静默放行,而是当场抛出一个明确的异常——程序停在案发现场,而不是带着被污染的内存继续运行。三条规则对照的,正是 C 的三大深渊:平台绑死、手动内存、无边界检查——上一章里那笔 1972 年的理性交易,在 1995 年被原样反向重签。
支撑这一切的是一套分工精密的运行时系统,它的结构值得拆开看一遍:
Hello.java (源代码)
│ javac 编译
▼
Hello.class (字节码: 面向虚拟机的指令集)
│
▼
┌─────────────────────────────────────────┐
│ Java 虚拟机 (JVM) │
│ │
│ 类加载器 (双亲委派, 字节码验证, 沙箱) │
│ │ │
│ 执行引擎: │
│ 解释器 ──逐条执行──► 启动快 │
│ JIT 编译器 ──热点编译──► 跑得快 │
│ 垃圾收集器 GC ──自动回收──► 免手动 │
│ │
│ 运行时数据区: 堆(对象+GC 主战场) / │
│ 栈(线程私有) / 方法区(类元数据) │
└─────────────────────────────────────────┘
│ 同一份字节码, 各平台各配一个 JVM
▼
Windows JVM │ Linux JVM │ Solaris JVM │ ...
虚拟机还有一道常被忽略的防线:类加载。每个类在进入虚拟机前都要经过字节码校验,确认指令不会伪造指针、不会栈溢出、不会绕过访问权限;类加载器之间遵循双亲委派——所有的加载请求先向上交给父加载器,父加载器办不了才轮到子级,保证核心类库永远由最可信的加载器先行装载,应用层的类无法冒充系统类。一道校验加一层委派,把“从网络上下载来路不明的代码并运行”这件事,变成了可以托付给浏览器的常规操作——Applet 时代的 Java,安全模型就是它的第一张名片。字节码先被逐条解释执行——启动快但慢;虚拟机在后台悄悄统计每段代码的执行频率,把被反复调用的“热点代码”整块编译成本地机器码缓存起来——这叫即时编译(JIT)。承担这项技术的虚拟机因此得名 HotSpot(热点):它不在启动时编译一切,而是让程序先跑起来,边跑边观察,把真正被高频执行的那一小部分代码编译优化到接近本地代码的速度。分层编译把两全变成了工程:客户端编译器求快,服务端编译器求狠,热点在层级之间逐级晋升;甚至保留了一道去优化的后门——当编译假设被运行时行为推翻时,代码可以回退到解释执行。解释执行与编译执行这对教科书上的对立范畴,在 Java 这里第一次变成了可以按热度调配的连续谱——这也是软件层对硬件之墙的一次回应:当频率之墙挡住了“更快”的直路,虚拟机就用运行时的观察与重写,在既有硬件上继续榨出性能;这条思路在此后二十年里愈演愈烈,从数据库的查询计划到脚本语言的即时编译,运行时优化成了每个性能敏感领域的标配——这句话的另一面是:性能不再只由硬件与算法决定,还由运行时的观察质量决定;能否被优化,取决于程序在真实负载下的行为是否稳定可测。承担这项技术的虚拟机名叫 HotSpot,它的出身是一场收购:1997 年 Sun 买下了一家掌握自适应优化技术的小公司,把整套团队与技术并入 Java 平台,两年后以 HotSpot 之名发布,此后成为全世界 Java 程序真正的运行底座。它的运行机制可以拆成三层:底层是计数器——每个方法、每个循环回边都有计数,一旦越过阈值(默认一万次)就被判定为热点;中层是两级编译器——客户端编译器出手快、优化浅,服务端编译器出手慢、优化狠,热点先经前者快速编译,再被后者深度重写;顶层是一组激进的优化变换——方法内联把调用摊平,逃逸分析发现对象根本不会离开方法就把分配挪到栈上,锁消除在证明无竞争后直接拆掉同步,循环展开把迭代摊成直线。最精妙的是去优化:所有激进优化都建立在运行时的假设之上,假设一旦被推翻,代码可以退回解释执行重新观察——编译器不再是一个发布前就定型的黑箱,而是一个随程序行为持续调整的活物。
托管:把恐慌交给机器
垃圾收集值得单独一节,因为它解决的从来不只是技术问题,而是一种心理问题。在 C 的世界里,每一个 malloc 都伴随着一句无声的质问:谁来释放?每一次 free 之后,指针成了悬在头顶的达摩克利斯之剑——它还指着那块已经交还给系统的内存,任何一次疏忽的解引用都是未定义行为。这种恐慌在工程上的形态是:内存泄露的排查以周计,悬垂指针的崩溃与案发相隔千里,整支团队用代码评审与工具链日复一日地防守一类理论上“只要人人都小心就不会发生”的错误。Java 的分代垃圾收集器把这一切整体接管:新对象在新生代里出生,绝大多数朝生夕死,收集器用复制算法高频清扫;活过数轮清扫的长命对象晋升到老年代,用标记整理算法低频处理。程序员的认知负荷清单里,“内存何时释放”这一项被整体划掉——并非转交给更资深的同行,而是转交给机器。错误的呈现方式也一并改写:C 的越界是静默的,Java 的越界会抛出一个带类型与调用轨迹的异常——程序当场停在案发现场,而不是带着脏数据跑远。错误从“看不见的暗伤”变成了“有名字有地址的急诊”,这一步对工程文化的改变,不亚于垃圾收集本身。另有一项对称的事实值得记录:替程序员管理内存的这台机器——虚拟机本身——是由上一代语言写成的;托管的世界踩在非托管世界的地基上。C 没有被 Java 消灭,它只是从台前退到了幕后,从应用退成了基础设施——所有试图宣布 C 死亡的讣告,最终都被这条地基逻辑驳回。
这个转移的产业意义远超语言设计的范畴,也远超一门语言的兴衰。具体的技术史——标记算法的演进、分代假说的验证、停顿时间的军备竞赛——是本书另一章的任务;本章只清点这次转移改变了什么。第一,错误的时间属性变了:C 的内存错误是潜伏的,爆发点与案发点可以相隔千行;Java 的内存问题是即时的,症状就是慢——慢可以被度量、被优化、被预算,而潜伏不可以。第二,错误的主体变了:C 的团队需要资深工程师把关每一块内存,Java 的团队只需要配置好收集器参数;中级工程师第一次可以安全地参与大型系统。第三,工程的规模上限变了:当最危险的错误类别被托管,软件可以放心地膨胀到千万行——Java 恰好赶上了企业软件从百万行向千万行跃迁的时代,这个时间差是它全部胜利的真正配方。此前,内存错误是系统软件最难防的一类缺陷,而且它与程序员的资历无关——最资深的 C 工程师也会写出悬垂指针。Java 把这类错误从“程序员的道德风险”改造成了“虚拟机的性能问题”:错误不再无声地腐蚀系统,而是以性能停顿的形式按期收账;防错的成本从难以估量的人力,变成了可以预先配置的堆大小与收集器参数。工程团队的心理契约随之改写:新手可以更快上手大型项目,因为最危险的一类错误已经被运行时接管;企业敢于把核心业务架在 Java 上,因为最坏的情况是慢,而不是崩。托管的账单里也因此多出一个此前不存在的职业:虚拟机调优专家——堆该开多大、收集器选哪款、编译阈值设多少,这套参数学问复杂到足以支撑一整层咨询产业;运行时接管的每一项认知负荷,都会在更深处生成一份新的认知负荷,只是这份负荷可以被少数专家集中处理,不再由每个程序员平摊。顺着这个逻辑,Sun 卖的其实早已不是一门语言,而是一个平台——语言、虚拟机与庞大的标准类库捆成一个整体,运行环境、开发工具与兼容性认证一并提供。语言的竞争从此变成了平台的竞争:赢了语言特性的一方,未必赢得过占住了运行时与类库生态的一方。1990 年代末互联网爆发,企业级应用的规模以前所未有的速度膨胀,恰恰需要这样一门“错误有界、托管兜底”的语言——Java 在正确的时间,站在了正确的位置。
一次编写,到处运行
Java 的爆发恰逢其时地撞上了万维网,而它最初抓住的载体此后又把它抛弃——Applet 的兴衰是一整段被遗忘的前史。1996 年网景宣布在浏览器中集成 Java,此后数年,网页里跳动的动画与实时行情几乎都由 Applet 驱动,“浏览器里跑程序”的想象第一次成真;但插件模式的天花板很快显形——启动慢、安全告警频繁、各家浏览器的实现差异,让 Applet 在移动互联网前夜全面退场。它留下的遗产比尸体值钱:Applet 证明的“字节码可以在任何浏览器里执行”,后来以 JavaScript 的方式统治了网页,而 Java 自己则掉头转向服务器,在企业级市场找到了真正的帝国。1998 年平台分立为企业版、标准版与微型版三线,企业版为大型服务器应用制定了成套的规范;此后的 Spring 框架、各类应用服务器,把 Java 焊死在全球金融、电信与电商的核心系统里——有统计称全球百大银行中九成以上以 Java 运行核心业务。一门为电视设计的语言,最终统治了银行。回看 1995 年那场手忙脚乱的发布,Java 兼容性主管的总结成了这门语言一生的判词——“彻底成功的灾难”:成功是彻底的,灾难也是彻底的,两者共用同一份日程表。统治带来的是双向塑造:企业级的复杂需求催生了层层叠叠的框架与规范,规范的堆叠又把 Java 推向了重度工程化的深水区——大团队、长周期、重流程,这门语言与企业软件互相驯化,谁能上岗先学会对方的语言。2003 年前后出现的轻量级框架是一次著名的反弹:开发者用依赖注入与约定优于配置,把企业级开发从规范文档的深水里捞回了代码本身——反弹的成功证明的正是此前的统治:只有统治地位足够稳固的生态,才养得起对自己的革命。转机在 1993 年出现:图形浏览器 Mosaic 发布,团队第一时间意识到,Oak 完全可以嵌进浏览器——让网页第一次拥有运行程序的能力。他们用 Oak 复刻了一个浏览器,取名 WebRunner,后来改名 HotJava;嵌入网页执行的小程序,就是日后家喻户晓的 Applet。1995 年 5 月 23 日,Sun 在 SunWorld 大会上正式发布 Java,同时演示 HotJava——页面上跳动的动态动画让整个行业第一次看到“网页不只是文档”。三个月前,这门语言的名字还叫 Oak,因为商标冲突才在发布前改成了爪哇岛的咖啡——此后的标识是一杯冒着热气的咖啡,工程师们也乐于在解释它慢于原生代码时自嘲:反正等它跑起来,正好够泡一杯。此后的扩张是教科书级的滚雪球:1996 年网景浏览器宣布集成 Java;一年一个版本的节奏里,数据库连接、远程调用、图形组件相继补齐;1998 年平台分立为企业版、标准版与微型版三线并进——从智能卡到大型机,三张许可证覆盖了当时能想到的每一类计算设备,企业级市场从此成为 Java 的腹地;2005 年,谷歌收购安卓后为新手机平台选择了 Java 语法——移动时代最大的软件生态,也长在了这门语言的语法上。
爆炸的代价同样真实。1995 年的那场发布是踩着重写完的地基勉强赶上的;此后 Java 的“到处运行”在实践中长期被调侃为“到处调试”——不同平台的虚拟机实现差异、浏览器厂商各自为政的 Applet 方言,都在稀释口号的成色。微软对 Java 的态度尤其能说明平台战争的逻辑:它推出了自己的方言版本,Sun 为此提起诉讼并最终胜诉——一门语言的兼容性之争,第一次打到了法庭上。而 Java 内部的补丁也从未停过:泛型在 2004 年引入时,为了不破坏既有字节码选择了“类型擦除”——编译器知道类型差异,运行时一概不知;这个决定被社区争论至今,官方的评价颇为诚实:这不是一个正确的决定,而是一个当时最不坏的决定。普及是有代价的,而 Java 用兼容性支付了普及的全部账单。兼容性的另一场战争打在法庭上:微软在自己的浏览器与操作系统里推出了方言化的 Java 实现,Sun 指其破坏兼容并提起诉讼,双方最终和解——这是“一次编写到处运行”的理想与平台霸权的第一次正面对撞;二十年后,谷歌在安卓上重复了类似的故事:使用 Java 语法、自研虚拟机, Sun 与甲骨文的继任者为此把这场官司打到了最高法院。两场官司的共同被告席上坐着的都是巨头,而原告席上的主张始终如一:一次编写,凭什么到你那里就要改。
托管的收账
Java 的账单分给三类人。第一联开给性能:虚拟机的抽象层不是免费的——字节码解释、垃圾收集的停顿、运行时的簿记,让 Java 程序在同样硬件上天然慢于 C/C++;九十年代末“Java 慢”是行业的共识,即时编译技术与二十年收集器进化才逐步填平了差距,而填平的前提是硬件速度替软件抽象挡了几代子弹。第二联开给工程师的自主权:取消指针运算、交出内存管理,意味着底层的某些操作从此不可为——系统级编程的少数场景仍需退回 C,Java 用本地接口为这扇后门留了缝,但每走一次,托管的保险就失效一分。第三联最沉重,开给了创造者本人:高斯林在 Sun 被甲骨文收购后离职,公开写道收购会议上“甲骨文律师的眼睛闪闪发光”;离开后以六十一岁高龄求职,得到的答复是年龄太大——若非“Java 之父”的名头,连面试机会都没有。语言成了全球基础设施,语言之父在就业市场上一度无人问津:这门语言把程序员的内存恐慌转移给了机器,却没有任何机制保护创造者自己的职业安全。
把这一章放回卷四的张力轴上,Java 的位置一目了然。C 在 1972 年把认知负荷几乎全部压给程序员,换来硬件表达的零损耗;Prolog 在同年把过程重担全部推给机器,却因硬件无法兑现而败走。Java 在 1995 年给出的答案是一条中间路线:把最沉重、最重复、最容易出人命的那部分认知负荷——内存管理——交给机器托管,把算法与结构的认知负荷留给程序员,代价是运行时的一层抽象与一部分机器性能。这个中间路线能够成立,靠的不是语言设计的新思想——字节码、虚拟机、垃圾收集在此前的研究文献里早已有之——而是第一次有人把它们组合起来对准了产业最痛的那个点:互联网时代的企业软件,需要千万行规模、多平台部署、大批中等水平工程师协作的工程形态,而这正是 C 的信任程序员模式无法支撑的规模。Java 赢得的不是语言设计的战争,是工程规模变迁的战争。把这门语言放回一个更宽的光谱,它的位置一目了然:光谱的一端是 C——零运行时代理,认知负荷全在人脑;另一端是全托管的脚本语言——运行时代管一切,性能是次要考虑;Java 站在两者的中间偏托管一侧,用一层虚拟机换走了最危险的认知负荷,又用即时编译赎回了大部分性能。此后四分之一个世纪的新语言,几乎都是在这条光谱上重新选址:有的向 C 端回撤,有的向托管端推进,有的干脆在光谱上开出新的点位。选择站位时问的问题始终是同一个:这门语言服务的程序员群体、目标软件的规模与寿命、硬件预算的松紧——三者的交点在哪里,语言就该站在哪里。这句话的反面同样成立:它此后的每一次危机,也都来自工程规模的下一轮变迁——云计算要求秒级启动与极小内存,Java 的虚拟机预热与堆开销一度成了云原生的原罪,提前编译与虚拟线程又花了数年把这门语言重新带回赛道。语言与时代的匹配是动态的,没有一劳永逸的胜利;Java 的五十年(如果从 Oak 算起)给出的最深刻经验是:托管一旦成为约定,卸下托管的成本就由整个生态均摊——这门语言因此再也没法变回轻快的小工具,正如现代企业再也没法退回手工记账。这正是本章留给卷四的证词:语言的兴衰不取决于它把认知负荷压给谁,而取决于被压给的这一代程序员恰好在为什么规模的软件打工——托管不是解放了程序员,托管是让中等水平的程序员第一次能够安全地建造巨型软件,而世界,刚好需要巨型软件。至于被托管的那一代人——他们交出的内存管理技能并没有作废,只是下沉了一层:调试垃圾收集器、编写虚拟机、为托管语言开发底层库的人,接过了同一门手艺,坐到了抽象层的下一级。抽象的每一级都需要有人值守,Java 只是把值班表往上挪了一行。托管不是免费的午餐,它只是一次重新分工:把最残酷的部分集中到少数人手里,把可容忍的部分平摊给所有人——这就是工业级托管的本义。2006 年,Sun 把 Java 开源,OpenJDK 成为全世界 Java 实现的共同上游;此后的版本年图像一部压缩的现代语言演化史:泛型与枚举补齐了类型系统的短板,Lambda 与流式接口把函数式风格请进这门面向对象的语言,垃圾收集器从 stop-the-world 进化到亚毫秒级并发,虚拟线程把“一个请求一个线程”的模型推到了百万并发的规模——每一步都没有推翻地基,每一步都在地基上加高。此后的 Java 以半年一个版本的节奏滚动,函数式特性、模块化系统、虚拟线程相继落进这门以保守著称的语言——保守到固执的兼容性,正是它敢于持续演化的底气:数百万个存量应用不必在每次升级时重写一行代码。
第 046 章 1995:JavaScript:十天拼凑的胶水与三十年平台化
1995 年 5 月,加州山景城,网景公司的工程师布兰登·艾奇(Brendan Eich)接到一项任务,期限是十天。四个月前他入职网景时,招聘方的说辞是把 Scheme——一门学院派的函数式语言——塞进浏览器;而此刻管理层的指令已经变成了另一句话:做一门看起来像 Java 的脚本语言。艾奇后来在为技术经典撰写的序言里平静地复述了这个转变,语气里没有委屈,只有一个工程师对现实的认领。十天后的演示让网景管理层打消了疑虑——原型证明这个人是真的——于是这门十天语言的作者继续留在网景,做它的维护者与标准捍卫者,一路成为 Mozilla 基金会的联合创始人、首席技术官,以及 2014 年那段只持续了十一天的首席执行官任期。十天里他写出了第一版原型:函数是一等公民——这是 Scheme 的遗产;对象没有类,靠原型逐级克隆——这是另一门语言 Self 的遗产;花括号与分号长着 Java 的模样——这是管理层要的皮。此后三十年,这门十天拼凑出来的语言长成了人类历史上部署最广的编程语言:每一块屏幕、每一次点击背后都有它在运行,任何一种新硬件想进入互联网世界,第一件事都是实现一个它的解释器。这不是一个关于天才的故事,这是一个关于生态如何反向塑造语言的故事。
十天的产儿
要理解这门语言的起点,得先看清 1995 年网景公司的处境。它的 Navigator 浏览器占据了九成以上的市场份额,万维网正以月为单位爆发,但网页是死的:超文本标记语言只能静态展示文本与图片,用户在网页上填一张表单,点提交后数据要发回服务器校验,再等整页刷新返回结果——在拨号上网、以字节计费的年代,一次表单填错的代价是分钟级的等待与全部内容重填。网景需要一个嵌入网页的轻量脚本语言,让“填错了”这类校验在用户自己的机器上当场完成。需求本身很小:表单校验、鼠标悬停、页面动效。管理层为它定的边界同样明确:要简单到让设计师与业余者都能上手,同时要长得像正炙手可热的 Java——那是与 Sun 结盟的战略姿态。
艾奇的十天是一场三种语言传统的强行焊接。他要的第一层遗产来自 Scheme——他在伊利诺伊大学接触的函数式方言:函数必须是一等公民,可以像数值一样被传递、被存储、被随时调用;闭包让函数可以记住它出生时的环境。第二层遗产来自 Self——Sun 实验室里那门用原型取代类的面向对象语言:对象不需要类的图纸,直接从另一个对象克隆并增添差异即可。第三层是皮:花括号、分号、与 Java 雷同的关键字拼写。三种传统彼此并不调和——函数式的世界没有类,原型的世界没有继承树,Java 语法的世界两者都要——但十天容不下调和,艾奇把它们并排焊死在一个解释器里,内部代号 Mocha。焊接的接缝今天藏在最普通的语法里:每个函数天生就是一个对象,函数身上可以挂属性、可以被当参数传递——这是 Scheme 的一等公民;每个对象都有一个指向其原型的隐式链接,属性查不到就顺着链接向上找——这是 Self 的原型链;而这一切都被套上了与 Java 同款的花括号外衣。三种传统在语法表层拼成一门语言,在语义深处各自为政——此后三十年里,关于这门语言的每一场“它到底该怎么用”的论战,都是这三条血缘的暗中角力。发布前网景把它更名为 LiveScript,随后又借与 Sun 的结盟,在 1995 年 12 月把它定名 JavaScript——尽管它与 Java 的技术关系约等于雷克雅未克与爪哇岛。这次借名的品牌操作后来被评价为最成功也最误导人的一次:整整一代初学者因为名字以为它与 Java 血缘相近,而它真正的血亲是 Lisp 的直系后裔。
十天产儿的缺陷清单,此后三十年被逐条背诵。相等判断有两个运算符——宽松相等会把不同类型强行转换后比较,严格相等才区分类型,于是教科书里永远有一章专门解释何时该用三等号;变量的声明提升让先使用后声明合法,代码的阅读顺序与执行顺序从此分家;对空值取类型,返回的竟是“对象”——一个被语言自己承认的历史错误,因为底层表示的一位之差,永远无法修正。这些缺陷没有一个是十天工期的必然产物——工期决定了艾奇没有时间为它们设计得更严谨——但它们此后三十年都必须保持原样,因为互联网上已经部署的亿万网页依赖每一个错误的细节继续错误下去。这门语言从此背上了人类工程史上罕见的枷锁:它的每一个缺陷都是法律。最广为流传的例子是宽松相等:数字一与字符串一比较,语言会先把字符串转成数字再比,结果为真——类型不一致本该是错误,在这里却成了可以被强行撮合的婚姻;不同类型在隐式转换下产生的一系列反直觉结果,被程序员们当作玄学段子传了几十年,段子的背后是一个严肃的工程事实:隐式转换把“类型的意外”从报错变成了静默的错误结果。这门枷锁的来源与上一章的 C 恰好相反:C 的缺陷源于年代——1972 年的机器买不起边界检查,语言把危险留给了整个产业;JavaScript 的缺陷源于工期——1995 年的浏览器等不了更好的设计,语言把仓促留给了自己的全部未来。C 用五十二年才敢废除一个过时的声明语法,JavaScript 的每一个语法——无论多怪——都因网上已部署的亿万页面而被永久锁定:Web 的向后兼容铁律比任何语言的国标都严苛,因为谁也不敢承担“弄坏互联网”的责任。
胶水的宿命
JavaScript 出生时被定位为胶水:把网页里的静态零件粘起来的辅助语言,真正的计算由服务器完成,真正的界面由 Java Applet 提供——包括网景自己在内的所有人都认为,重活理应由那些更“正统”的语言来干。但胶水的宿命由两场战争与一次意外改写。第一场是浏览器大战:1996 年 8 月,微软在 IE3 中推出了自己的实现 JScript——为了不付授权费也不落在下风,微软给这门方言加上了只属于自己生态的扩展。同一年网景把语言提交给欧洲计算机制造商协会标准化,1997 年第一部标准 ECMAScript 发布,语言从此有了所有厂商共同遵守的法典;但法典只规定了内核,浏览器提供的操作网页的接口——文档对象模型——各家依旧各说各话,同一个网页要为不同浏览器写不同版本,开发者把大量工时花在“侦测这是哪家浏览器”上。1999 年发布的第三版标准成了此后十年的稳定基线;而下一次标准化要等到 2009 年——标准进程被厂商分歧冻结了整整十年,其间第四版草案因争议过大被彻底废弃,语言停在原地,互联网却一日千里。给这场僵局画上临时句号的是一线开发者自发的民间发明:一个把各家浏览器接口差异包装成统一写法的函数库在 2006 年前后席卷前端——它没有消灭差异,只是把差异藏进了一块所有人共享的垫片;垫片的流行证明了标准化的滞后,也为即将到来的 AJAX 应用爆发清了场。
第二场战争的结局决定了 JavaScript 的起落。网景在浏览器大战中败给了捆绑发行的 IE,公司 2003 年倒闭,但它把浏览器源代码开源成了 Mozilla 基金会,火狐浏览器继承了对标准最较真的血统;艾奇也在这条血脉里继续做了多年引擎与标准的工作。战争的另一遗产是那个时代积累的所有不兼容教训,最终都变成了标准化组织的经验——此后二十年,网页标准的每一次推进都比上一代谨慎。
真正的意外发生在 2005 年前后。谷歌发布了 Gmail 与谷歌地图,网页在没有整页刷新的情况下实现了流畅的邮件收发与地图拖拽——支撑这一切的技术此前已在暗处存在多年:异步交换数据的接口最早是微软为自家的网页邮箱在浏览器里塞进的私货,2005 年被冠以 AJAX 之名总结成方法论,一夜之间成为全行业的标准动作。它的意义不在技术深度——核心不过是让脚本悄悄向服务器要数据——而在于它验证了一件事:浏览器可以承载应用级的交互,只要脚本够快。整个行业突然意识到:网页不再是文档,网页可以是应用。而运行在每一个浏览器里、无需安装、天然跨平台的编程语言只有一个——JavaScript。此后十年,这门语言从表单校验员成长为应用平台:从原型式继承到各类框架,网页应用的复杂度以年为单位翻番,代码规模从几十行涨到几十万行。这门为十天工期设计的语言,接下了人类最大软件平台的全部负载。
V8:把解释变成测量
应用时代的语言需要一个像样的引擎,而 JavaScript 此前的引擎都不算快。转折出现在 2008 年:谷歌发布 Chrome 浏览器,附带了自研的 V8 引擎——它带来的性能跃升是断崖式的,让此前“浏览器里跑不了复杂程序”的断言作废。谷歌的动机直白:它的全部生意都长在浏览器里,浏览器快一分,广告与应用的体验就快一分——全世界没有第二家公司比它更有理由把一门脚本语言编译到极限。V8 的核心思想,是把这门动态语言也纳入了运行时测量的轨道:脚本先被解释执行,引擎同时收集每一次操作的类型反馈——这个属性被访问过多少次、每次都是什么形状;当一段代码成为热点,优化编译器就依据收集到的反馈做激进假设并深度编译;一旦假设被运行时推翻,引擎执行反优化,退回解释状态重新观察。这套“解释先行、优化跟进、假设失效即回退”的管线,与上一章 HotSpot 为 Java 设计的机制在结构上几乎同构——两门出身迥异的语言,在性能的天花板前收敛到了同一套答案:不要预测,去测量;测量之后,再大胆地赌。这条收敛线还带着一层反讽的余味:二十世纪九十年代,英特尔曾试图把同类的赌注押进硬件——让编译器在编译期算尽一切并行性——结果以安腾的全面溃败收场;而把同样的赌注押进运行时的这两台引擎都赢了。分出胜负的并非运气,而是观察的时机:运行时的反馈永远比编译期的猜测新鲜。
V8 的每个部件都值得在图里钉死:
源代码 (JavaScript 文本)
│ 解析
▼
┌──────────────────┐
│ Ignition 解释器 │◄── 收集类型反馈:
│ 逐条解释执行 │ 隐藏类(对象形状)、
└────────┬─────────┘ 调用点、属性偏移
│ 热点判定
▼
┌──────────────────┐
│ TurboFan 优化编译器 │◄── 依据反馈做激进假设:
│ 生成高度优化的机器码 │ 内联缓存、隐藏类转换
└────────┬─────────┘
│ 假设被运行时行为推翻?
▼
反优化: 退回解释执行重新观察
隐藏类与内联缓存是这套管线的两根支柱。动态语言的每个对象可以随时增删属性——同一行构造代码造出的对象,形状可能各不相同,属性的访存地址因此无法在编译期确定。V8 的解法是给每个对象形状建立一个隐藏类,属性布局相同的对象共享同一个隐藏类;代码反复访问同形状对象时,内联缓存记住“上次在这里找到属性”,下次直接跳到偏移量——形状不变就一路全速,形状一变就退回慢速重新学习。程序的内存行为越规整,跑得越快;这门十天语言把“规整”作为性能的定价单位,反过来规训了此后二十年前端工程的代码风格。竞赛随即扩成全行业:火狐的引擎源自艾奇当年写下的第一版解释器,此后历经数代重写;苹果的引擎演化出从低级解释器到超光速编译器的四级台阶——三大浏览器、三套引擎、同一种语言,性能军备竞赛的赢家是每一个网页使用者,这门十天语言就这样被全行业的竞争推着,跑出了它十天设计时做梦也不敢想的性能。
Node:语言逃离浏览器
2009 年,一个叫瑞安·达尔(Ryan Dahl)的开发者发布了 Node.js:把 V8 引擎从浏览器里拆出来,配上事件驱动、非阻塞输入输出的架构,让 JavaScript 直接运行在服务器上。这个组合的化学反应超出了所有人的预期。彼时的服务端主流模型是“一个连接一个线程”:每个请求占一条线程,连接等待输入输出时线程空等;并发一高,线程切换与内存开销就把服务器压垮。Node 的模型反其道而行:单线程事件循环,所有输入输出都注册回调,谁的数据就绪就处理谁——高并发之下没有线程切换的税,只有事件队列的顺序处理。这个模型天生匹配互联网应用最常见的负载:大量短促、以读写网络为主的请求。它瞄准的痛点是一切服务器的隐痛——线程在等待硬盘与网络时纯粹的空转:请求越多,空等的线程越多,内存与切换开销同步膨胀;事件循环把等待改成排队,让单核在等待的间隙里处理所有就绪的事件,用一台机器吃下过去需要一个机架的并发。服务器端的世界就此裂开一道口子:前端工程师第一次可以用同一门语言写完后端,全栈从口号变成岗位;围绕 Node 的包管理器 NPM 迅速长成人类规模最大的软件包生态,数以百万计的库彼此引用——软件的复用在这个生态里达到了此前任何语言都未曾企及的密度。复用的密度很快演出了自己的戏剧:2016 年,一个只有十一行代码的工具包被作者一怒撤下,连锁掀翻了大半个行业的构建流水线——这个事件成了软件供应链风险最著名的教学案例,它证明的是一种结构的脆弱,而非哪个人的失职:当每个应用平均依赖数百个层层嵌套的第三方包,任何一颗螺丝的松动都会沿着依赖树传导到整个世界。生态的繁荣与生态的脆弱,从此在 JavaScript 的世界里互为表里。语言疆域此后还在外扩:用网页技术打包桌面应用的框架让 JavaScript 写出了代码编辑器这样的重型桌面软件,跨端框架让它跑进了手机原生应用,物联网设备里也装上了它的解释器——一门十天拼出来的胶水语言,最终跑在了人类能造出的每一类计算设备上。复用的另一面是依赖的深井:一次普通的前端构建要拉取上千个第三方包,任何一个深处的维护者撤回自己的代码,全世界的构建流水线同时断粮:复用的密度有多高,信任的杠杆就有多长。
十天语言的收账
这门语言的账单同样按三联清点。第一联开给历史包袱:所有的缺陷都是法律,严格相等与宽松相等并存、声明提升、类型隐式转换,每一个“当时来不及”的细节都永久留在了语言里;此后的标准化只能在绝不破坏旧网页的前提下做加法——2015 年的第六版标准一次性补上类、模块、块级作用域与箭头函数,被视为这门语言的二次诞生,但它治标的方式是加法而非修正:旧缺陷一个都没有删,新特性负责绕开它们。第二联开给类型:动态类型让十天原型成为可能,也让百万行规模的应用在重构时寸步难行——类型错误要等到运行时才暴露;这个账最终由 2012 年后出现的 TypeScript 以“给 JavaScript 加上渐进类型注解”的方式偿还,类型系统作为一层编译期检查架在原语言之上——原语言缺陷的账,由衍生物分期支付。第三联开给安全:一门运行在全世界浏览器里、可以随时从任何服务器加载执行的语言,天然是攻击的入口与供应链的战场——每一次依赖包的更新都是一次信任投票,而投票的机制远比投票的对象脆弱。最经典的攻击是把恶意脚本注入他人页面:网页把用户输入原样渲染,攻击者就借别人的浏览器执行了自己的代码——这类跨站脚本攻击的根子不在语言,而在“语言可以操纵页面”这门语言的天职本身;能力即攻击面,是托管世界交不完的学费。
把这门语言放回卷四的张力轴,它的位置在所有章节的最远端。C 把认知负荷全部压给程序员,换零损耗的机器表达;Java 把最危险的负荷托管给虚拟机,用运行时代价换工程安全;Prolog 把过程认知全部交给推理引擎,被硬件拒绝。JavaScript 是唯一一门不需要安装、不需要审批、只需要一个浏览器就被强制分发给全人类的语言——它的认知负荷设计面向的从来不是专业程序员,而是“所有打开网页的人”;十天工期、松散类型、随写随跑,都是这个定位的忠实投影。它后来的平台化不是设计的胜利,是位置的胜利:只要浏览器还是人类最大的软件入口,这门语言就垄断了那个入口的母语权。这正是本章留给卷四的证词:语言普及的规模可以与其设计的严谨完全脱钩——当一个生态只有一门母语,母语的缺陷就会成为整个文明的方言习惯;JavaScript 用三十年证明,一门语言最大的护城河不是没有缺陷,而是所有缺陷都已被亿万行代码依赖。这门语言的每一次“补课”——类型层、模块系统、标准化进程、新一代引擎——都不是在设计一门更好的语言,而是在为一个不能重来的地基做加固;这与本卷所有语言的故事构成了完整的对照:C 的地基是物理约束浇筑的,Java 的地基是工程规模浇筑的,Prolog 的地基是数学理想浇筑的,而 JavaScript 的地基,是全人类不由分说的日常使用浇筑的——最不讲道理的地基,反而是最结实的一块。
加法的艺术:2015 年之后的标准节奏
2015 年第六版标准的真正含义,要到此后的年份里才看得清楚。它一次性补上类、模块、块级作用域与箭头函数,规模相当于给一座住了二十年的老楼加装电梯、重排管线——住户不搬,结构不动,功能照加。此后标准化进入一年一版的小步节奏:每年收录一批体积可控的增补,旧网页的运行语义冻结在原地,新能力以不触碰旧语义为前提叠加上去。立宪的时代结束了,持续修宪的时代开始了。这套节奏是对 2000—2008 年停滞的直接回答:第四版草案当年想做一次干净的重写,兼容派与革新派在委员会里僵持到草案被彻底废弃,语言原地停摆八年;教训被写进流程——重写一步到位是死路,加法细水长流是活路。冻结旧语义的代价同样清楚:宽松相等、声明提升、隐式转换,一个都删不掉;新语法只能教程序员绕开它们,不能替语言改正它们。修宪者手里的工具只有加法一项,加法的好处是永不弄坏互联网,加法的坏处是语言体积单调膨胀,每一代初学者都要先背一遍“哪些写法是历史,哪些写法是现在”。
类型账的偿还走的是另一条路。2012 年后出现的 TypeScript 给 JavaScript 套上一层可擦除的类型注解: 形状先用接口描述,错配在编译期被拦下,运行的仍然是原语言。渐进二字的含义是开发者可以逐文件收紧:旧的动态代码不碰,新的模块先加上类型守卫,两种写法在同一个工程里共存。这个设计的高明处在于不切断动态生态——它从不要求重写,只提供分期付款:工程每大一圈,多买一份类型保险。偿还的上限也写在机制里:类型系统架在语言之上,能拦住的是注解覆盖范围内的错配,拦不住的是底层语义的隐式转换;注解没有覆盖的地方,运行时仍是那门十天语言。衍生物替原语言还账,还的是利息,本金——那些冻结的语义——一分没有少。2015 年补上的类值得单独看一眼:它不是真正的分类学,只是原型链的语法糖——写法长得像 Java,跑的仍是 Self 的血缘。糖衣的意义不在机制,在迁入成本:整整一代其他语言背景的工程师可以零心理负担地写下第一行,认知的门槛又下调一格。语言向严谨方向迈出的每一步,都被包装成向易学方向的让步;这就是加法时代的伪装术。
引擎一侧的竞赛也在变道。2008 年 V8 把竞争焦点定在峰值速度:谁的优化编译器更敢赌,谁跑分更高。此后移动端把入场条件改写了:启动时间与内存占用比峰值速度更刺眼,解释器的层级被重新加回来,低内存设备上的快速启动与高内存设备上的极致优化走不同的管线。隐藏类对代码风格的规训则进入了框架层:构造形状稳定的对象、避免运行中增删属性,从性能手册的建议变成脚手架生成的默认;多数开发者从未读过隐藏类的论文,却每天都在按它的定价单位写代码。规训完成时,优化知识就从引擎团队沉淀为生态习惯,习惯又反过来保证引擎的假设长期成立——测量、假设、回退的管线,转成了习惯、形状、速度的正循环。回头看,标准冻结的十年并不是空白的十年:法典只管内核,浏览器的页面接口各说各话,一线开发者用共享垫片把差异藏起来,用 AJAX 方法论把脚本送进应用级交互——语言停在原地,生态先行十年。垫片与方法论的流行证明了同一件事:当正式标准缺位,生态会自己长出非正式标准;2015 年之后的年度修宪,不过是把这十年里已经发生的进化追认为法条。先有事实上的统一写法,后有标准里的对应条款——顺序永远是这个方向。疆域的扩张沿着同一方向继续:用网页技术打包桌面应用的框架,让同一套代码写出代码编辑器这样的重型桌面软件;跨端框架把脚本送进手机原生应用;体积经过裁剪的解释器住进物联网设备。扩张的逻辑是人力复用优先于性能最优:团队学会的一套写法,能原样搬运到下一类设备;新硬件想进入互联网世界,第一件事仍是实现这门语言的解释器。分发的复利一旦转起来,语言就不再竞争,竞争的是运行它的设备;设备越多,母语的地位越不可动摇。这也是平台化最难复制的一课:后来者可以设计更好的语法,却买不到1995 年以来攒下的三十年设备覆盖。
负荷的极限:为零分发成本让位
把全卷的语言放在卷四主导约束下排成一列,JavaScript 的位置最说明问题。这条约束的原话是人类工作记忆容量与底层硬件表达精细度之间的妥协:每一门语言都在回答,记忆的负担由人担几分,由机器担几分。C 的回答是人全担——指针直连内存,边界自己检查;Java 的回答是虚拟机分担最危险的那几分——内存管理托管,类型在运行前查清;JavaScript 的回答是把人的份额压到历史最低:不用学类型,不用装工具链,不用理解内存,打开浏览器就能随写随跑;连类型不一致都不报错,能撮合就撮合。省下来的每一分记忆负担,都由另一方足额支付:V8 的测量管线替程序员记住形状,框架替程序员记住兼容差异,NPM 替程序员记住复用库存。负荷没有消失,负荷只是搬家了。
搬家的终点正是本章的泄漏清单。抽象把记忆的负担从使用者手里拿走,代价在三个地方击穿:第一,引擎工程师替全世界记住了形状——优化编译器的复杂度是全卷最高的几套系统之一,赌错就回退的管线本身就是一座精密工程;第二,应用开发者替历史记住了兼容——构建工具链层层包裹转译、打包与垫片,一次普通构建拉取上千个包,每一层都是为“旧网页不能坏”交的税;第三,全网用户替便利记住了风险——可从任意服务器加载执行的脚本与层层嵌套的依赖树,让每一次更新都成为信任投票。平民化与精英化在这里互为表里:写第一行脚本的人门槛归零,维持这个零门槛运转的人门槛登天。赋权与驱逐同样成对出现:被赋权的是数以千万计能用脚本表达想法的人,被驱逐的是“亲手管理一切”的旧手艺——内存有人管,兼容有人垫,复用有人包;旧手艺的持有者要么去造垫片,要么离开牌桌。
反辉格的读法在这里只有一种:不把三十年平台化读成运气,也不读成“烂语言赢了好语言”。批评者的分量同样要正面称量:学院派与工程派对这门语言的指责没有一句是空话——类型缺失在百万行规模下是真实灾难,隐式转换把本该报错的错配变成静默的错误结果,要求用更严谨的语言重写关键应用的主张,在工程上完全站得住脚。这些批评输掉的不是道理,是位置:重写派的方案要求全网同时换跑道,而跑道的使用者是全人类。道理在会议室里全对,位置在浏览器里全错,这就是约束决斗的常见结局。在需要零分发成本的生态位上,严谨是负资产——每多一分类型严格,就多一分把业余者挡在门外的门槛;每多一次不兼容的修正,就多一次弄坏既有网页的风险。1995 年的十天工期恰好砍掉了所有会抬高门槛的东西,砍的时候没有人知道砍对了;2005 年浏览器变成应用入口之后,人们才发现被砍剩的形状恰好是入口母语该有的形状。标准组织花十年学会的谨慎、引擎团队用两代编译器换来的速度、框架作者替全世界垫掉的差异,全都是在为这个形状补运维。位置决定命运,设计只决定口碑——这句话在本章不是感慨,是约束位置的直接推论:离零分发成本越近,生态位越不可替代。
本章的断言是:JavaScript 用三十年证明,一门语言的命运由它在人类认知带宽与硬件表达精细度之间的妥协中所处的位置决定,离零分发成本越近,护城河越深;语法的严谨程度只决定口碑,不决定存亡。这个断言可以被反驳:如果未来出现一个取代浏览器成为人类最大软件入口的新平台,其母语的更替被证明与设计质量正相关——更严谨的后来者成功替换了在位者——那么位置决定论就是错的,JavaScript 的三十年只是特定入口形态下的一段插曲。
第 047 章 2000—2012:C# 与 TypeScript——工程规模重塑静态类型
一门语言的第四次出生
2012 年 10 月,微软宣布了一门新语言:TypeScript。名字本身就是它的自我介绍——给 Script(脚本)加上 Type(类型),除此之外什么都不加。发布时机与组合在旁观者眼里颇为古怪——这家以 Windows 与 Office 为根基、与开源网页社区长期互相提防的公司,宣布给一门以“十天拼凑”闻名的动态语言加一套类型系统,而且选择以开源方式发布——编译器源码托管在公共代码库上,任何开发者都能查看类型检查的每一个判定规则。这个姿态本身就是对 2012 年生态现实的承认:一门不开源的语言,根本无法敲开 JavaScript 世界的大门;而主持设计的人,是语言设计领域资历最深的建筑师之一:安德斯·海尔斯伯格(Anders Hejlsberg)。他此前的履历是一条清晰得近乎排练过的弧线:二十岁出头在 Borland 写出 Turbo Pascal 编译器,随后主导 Delphi;1996 年跳槽微软;2000 年起担任 C# 的首席架构师。到 2012 年,这是他参与定型的第四门主流语言。他的起点在 1980 年代初:二十岁出头在 Borland 写出 Turbo Pascal 的编译器与一体化开发环境,以极低价格与秒级编译横扫微机市场——软盘机还要咔咔作响的年代,它几乎在松开回车键的同时完成编译。这门以 Pascal 命名的语言从此有了自己的招牌:编译快、报错准、便宜到学生也买得起——整个产品小到一张软盘就装得下,它成了整整一代人学习结构化编程的入口。此后主导的 Delphi 又把可视化开发与数据库工具揉成一体——拖控件、连数据表、生成界面,企业应用的骨架当天成形——成了九十年代企业开发者的宠儿。教学与企业,两个他此后反复出没的市场,在这门语言的少年时代就已同时开张。到跳槽微软时,他已完整经营过一门语言从编译器、开发环境到用户社区的整个生命周期——这份履历,任何面试都考不出来。前三次,他把“类型”从教学的拐杖做成企业的契约;这一次,他要回答的问题是——动态语言统治的互联网世界里,类型还能怎么加进去,才能不弄断任何一根线?
类型之外:LINQ 与声明式的合流
这个问题背后站着同一件事的两个名字。一个是 C#:2000 年 7 月底,微软公布了自己的新语言与新平台,彼时它刚刚在与太阳微系统的 Java 诉讼中失去对 Java 的控制权——C# 从一开始就是这场法律败局的回应,海尔斯伯格的团队受命在一年之内交出一门企业级静态语言。几年后的第二个大版本加入泛型,企业代码的第一张契约网就此织密。海尔斯伯格的解法是把重心放在“比 Java 更进一步”上:属性、事件、委托、特性的语言级支持,让企业开发里最常见的样板代码直接进了语法——在其他语言里要写一对读写方法才能暴露的字段,在这里是一条属性声明;组件之间的通知不必手写回调登记,事件机制原生接管。把高频动作语言化,就是把出错机会语言化地消灭。这些设计大多谈不上发明——它们是把企业开发里反复出现的手工套路收编为语法;语言的进步,常常以这种收编的形式发生。这场败诉还给微软上了一堂战略课:一门你深度依赖却无法控制演化方向的语言,是埋在自家资产里的定时炸弹——别人的一纸判决就能让你的生态悬空。C# 因此带着“主权”的胎记出生:它属于微软、服务于微软的平台,这一点从不掩饰;后来 TypeScript 的开源姿态,则又是对这份主权执念的一次自我修正——语言的主权可以属于公司,生态的主权必须属于社区。另一个是 TypeScript:十二年后,同一群工程师面对的是另一个失控的对象——JavaScript。浏览器里跑着的代码以亿计,全都没类型;前后端交互的数据结构散落在无数脚本里靠约定维系;工程规模大到任何一次重构都可能引发连锁爆炸。动态的自由曾是它普及的燃料,如今成了它规模化路上的塌方点——就在 TypeScript 发布的前几年,运行时层面的革新又把这门语言推上了服务器,脚本的疆域刚翻了一倍,规模的失控也跟着翻了一倍。两代问题,同一个解法的不同侧面:工程规模大到一定程度,类型的守卫就从奢侈品变成了地基。
C# 真正让同行侧目的设计,出现在 2007 年的第三个大版本。这一版引入了 lambda 表达式、扩展方法,以及一个被寄予厚望的组合技:LINQ(Language Integrated Query,语言集成查询)——把对集合、数据库、XML 文档的查询,统一成一种写在语言内部的声明式语法——对内存集合、关系数据库与 XML 文档这三类最常见的查询,全部纳入这一种语法。在此之前,程序员查内存里的列表要写循环,查数据库要学 SQL,查 XML 要学另一套查询语言;三种数据三套语法,每一套都是命令式的逐步操作。LINQ 把它们统合进同一套声明式表达:你描述“要什么”,不必写“怎么取”——过滤、排序、投影的执行细节交由编译器与提供器分别翻译到各自的数据源。声明式的思想在 SQL 里早已存在,LINQ 的贡献是把它从数据库的方言提升为语言的一等公民:查询不再是嵌在字符串里的外语文本,而是带类型检查、可被编译器验证、可被重构工具安全改写的语言本体。lambda 与扩展方法是这套语法的地基:前者让“一小段逻辑”可以像数据一样被传递与组合,后者让既有类型无需修改就能长出新方法——两者合起来,才让查询语法是长在语言身上的器官,而非另起炉灶的外语。这一步合流的意味后来在整个行业显形——声明式查询从此成了通用语言的标准配置,而不再属于数据库的领地。它还示范了一种语言设计的合流方式:数据库用几十年的实践证明了声明式的价值,通用语言最终把这套价值收编进来——查询与数据源的解耦,从此是语言的职责而非外部工具的恩惠。此后的响应式数据流、各类语言内建的查询构建器,走的都是这条 LINQ 铺出的路——把“描述意图”留在代码里,把“如何执行”交给专门引擎。一段典型的 LINQ 读起来是这样的:
var adults = from p in people
where p.Age >= 18
orderby p.Name
select p.Name;
查询写在语言内部,过滤与排序的条件带着类型一起被编译器验证;数据源换成数据库,同一套写法由提供器翻译成对应的查询语句,意图的形状不变。
不弄断任何一根线:超集、擦除与逃生舱
TypeScript 的设计分成三步,每一步都在回答“如何不切断生态”。第一步是超集:每个合法的 JavaScript 程序,天然就是合法的 TypeScript 程序——存量代码一行不改即可入场,语言版本升级也不会没收任何人的旧写法。第二步是擦除:类型只在编译构建时检查,编译产物就是纯粹的 JavaScript——类型注解在运行时被整体抹去,引擎不用改装,浏览器不用升级,运行时开销为零。类型守卫的全部成本发生在写代码与提交代码之间,越过了运行时这条任何人都碰不得的红线。擦除这个决定还暗含着一种立场声明:类型不是运行期的存在,而是工程期的共识——它与测试、与代码评审同类,是开发阶段的质量设施,而不是需要运行时背书的特权。这个定位让浏览器与各 JS 引擎厂商无需任何配合,守卫由编译器独家执勤。第三步是渐进:类型注解是可选的——老文件维持无类型状态照常工作,新文件逐个加注解,迁移工程以文件为单位推进;实在搞不清结构的角落,另有一处显式的逃生舱:标注为 any 的值跳过一切检查。三条合起来,回答的是同一个问题:怎么让一个亿级代码量的动态生态,在不停止运行、不推翻重写的前提下,一寸一寸地长出类型。这门语言初发布时被开源社区视为又一次“帝国入侵”,几年后却成了大型网页工程的事实标配——态度逆转的机制没有任何秘密:它从未要求任何人改动任何一行现有代码,也从未强制任何人使用类型。一个不索要什么的东西,人们最终会自己走过去拿起它。这条渐进路线的身后,站着若干条以“推倒重写”开场的历史——它们的共同结局是生态断裂:旧代码的作者被告知一切作废,新世界的大门又迟迟不开。TypeScript 的胜利因此有一半来自克制:它从不宣布旧世界非法。这个问题还有一层社会学的分量:迁移不是一个人的决定,而是一个团队数年的日程——渐进设计让迁移可以按文件分批推进,让代码评审多了一项“类型密度”的检查项,让每一次合并请求都顺手把一小片代码纳入守卫。大规模代码库的实践给出了最终裁决:类型的覆盖程度被写进工程健康度的指标清单,迁移工作在无数团队里以年为单位推进,而推进的单位正是文件——渐进设计在无数个代码库里被重复执行,证明它经得起真实世界的组织摩擦。被逐步纳入类型守卫的代码于是像草皮一样蔓延:不靠运动式的重写,靠日常惯例的自然生长。
守卫本身也有讲究。TypeScript 采用结构类型:类型的匹配不问声明时的名字,只问值的形状——一个对象只要具备函数要求的全部属性与类型,就被接受,无论它从哪儿来、声明成什么。这与 C#、Java 的名义类型形成分野:名义世界里,两个形状完全相同的对象,若声明的类型名不同就不能互换,身份靠名册;结构世界里,身份靠形状,名册不存在。这个选择的背后是对两片土壤的尊重——名义类型服务契约文化,每个类型是一个正式的接口协定;结构类型服务鸭子类型文化,JS 程序员相信“走起来像鸭子就是鸭子”。TypeScript 没有把前者强加给后者,而是给后者配了一套能被编译器理解的鸭子鉴定法:
interface Duck { quack(): void; swim(): void; }
function pond(d: Duck) { d.quack(); d.swim(); }
pond({ quack() {}, swim() {}, fly() {} });
第三行的对象从未声明自己是鸭子,它只是碰巧具备了鸭子的全部形状——结构类型只看形状,不查名册;多出来的飞行能力不妨碍它下水。
账单:逃生舱里的幽灵
渐进类型的账单同样要列。any 这个逃生舱使用一次,检查就在那一处彻底失明——它对编译器说“别管这里”;于是工程实践里出现了一种新型债务:开发者遇到类型报错,最快的解脱不是修正代码,而是把变量标成 any——类型系统的覆盖比例从此悄悄失血,报错消失,风险原地不动。any 还会传染:它流入的每一个表达式都跟着变成 any,像电路里一根剥掉绝缘层的裸线,让下游一整串类型标注形同虚设。渐进还带来一种更隐蔽的错觉:团队看到编译通过,便默认类型守卫在工作,实际上守卫的覆盖范围取决于注解的密度,而这个数字没人统计。TypeScript 社区后来发展出“严格模式”与禁用 any 的规范,等于承认:逃生舱必须有配额,否则它会从安全门变成惯用出口。不少团队把 any 的出现次数写进代码质量的硬指标,与测试覆盖率并列——一个类型的合法逃逸被管理成了可量化的库存。配额制之外,更彻底的做法是把豁免变成评审仪式:每一次新增的 any 都要在合并请求里写明理由,理由随代码一起入库,后人读到此处,能看到当初为什么绕过守卫;逃生舱于是从暗门变成登记在册的侧门,用一次,留一次案。守卫的覆盖率数字会骗人,案卷不会——案卷里写满的,才是团队与类型系统之间真实的讨价还价。严格模式则是另一枚硬币的反面:更严的检查意味着更响的报错,存量代码开启它,往往要一次性清偿多年累积的隐性债——守卫的收紧从来不是免费的,只是这笔钱付得越早越便宜。C# 那边的账单则偏向前史——它自出生起就背着“Java 的应答品”的身份,最初的相似性让它在舆论场上被反复比较了多年;一门语言因法律而生的出身,要靠十几年持续的设计积累才能洗成中性的履历。两笔账单指向同一条经验:为工程规模设计的东西,自身也要按工程规模去维护——类型系统不是发布即完成的产品,它是需要持续运营的公共设施。C# 与 TypeScript 的版本节奏也印证了这种运营属性——前者按年滚动小版本,后者数月一版,语言规范以远超从前的频率持续生长。而两门语言也各自在向批评者学习:C# 在后续版本里持续吸收函数式的表达方式,TypeScript 用严格模式回应每一个“类型不可靠”的指责——语言的生命力,一部分来自持续吸收批评的能力。类型声明本身也是要维护的代码:字段的类型改了,注解要跟着改;文档化的类型成为契约后,契约的修订就成了日常——这笔维护成本,是静态类型的隐性租金,按代码库的规模逐月收取。
两代问题与认知负荷的重新分配
TypeScript 的诞生还回答了一个组织问题:谁来做、以什么姿态做?微软作为 JavaScript 生态的外来者,没有另立门户,而是选择开源、选择兼容、选择让每一行存量代码保值——克制本身就是设计的一部分,而且是让整个方案成立的那一部分。开源的另一层含义是把守卫生长的速度交给社区:类型规则的判定、边缘语法的覆盖、报错信息的打磨,不再取决于一家公司的排期,任何使用者都能提交修正。守卫的运营从此众包化,语言的改进速度第一次超过设计者本人的打字速度;主权属于公司,生长属于所有人——这就是 2012 年那个古怪组合的完整答案。
把 C# 与 TypeScript 并排,能看到两个场景里同构的认知负荷。C# 面对的是企业级团队协作的负荷:几百名工程师按接口协作,接口就是合同,类型的每一次变更都要被编译器验证、被全队知晓——静态类型在此是团队的共同语言。TypeScript 面对的是动态代码长期维护的负荷:互联网时代的网页代码以惊人的速度膨胀,没有类型的脚本在半年后就连作者本人都读不懂——类型在此是代码的自述文档,是把“这个参数应该是什么”从人的记忆里搬进机器的检查里。它还是给工具读的文档:编辑器的自动补全、重构建议、错误提示的质量,全部取决于类型信息的完备程度——类型标注得越全,机器替人操心的范围就越大。两个场景的负荷不同,解法却同构:把负荷从人的记忆与自觉,转移到机器的静态检查。类型的另一重红利在重构时兑现:有了完备的类型,机器才敢于替人完成跨文件的重命名、参数迁移与结构调整——没有类型,任何自动化修改都是在盲区里动刀。海尔斯伯格的四次设计,恰好构成这条转移路径的四个刻度——每一次都把更多的负荷交给编译器,每一次都比上一次更尊重既有生态的惯性。四门语言的共同点也在此:它们都为某一种具体的认知负荷而生,而不是为语言学理论的完备而生。
把两次设计放进卷四的主线里,它们回答的是同一道题在两个时代的不同解。类型系统本质上是一份负荷分配合同:动态类型把负荷全部后置——写的时候零负担,读的时候靠猜,改的时候靠运气;静态类型把负荷前置——写的时候多打字,读的时候有文档,改的时候有守卫。哪一边便宜,取决于项目的规模与寿命:几百行、活一个月的脚本,前置纯属浪费;几十万行、要活十年的工程,后置是慢性中毒。海尔斯伯格的洞见在于看清了这条曲线的移动:互联网把网页代码从脚本养成了工程,负荷的最优位置随之从后置滑向前置——而语言若不跟着滑,就会被工程抛弃。TypeScript 的渐进设计,本质上是承认这条曲线移动得并不均匀:同一个代码库里,有的文件已经到了该前置的时候,有的还留在后置的舒适区——那就允许两种状态共存,让每一段代码自己选择缴税的时点。工程规模重塑静态类型,重塑的方式既没有让类型更强大,也没有让类型更纯粹,而是让类型可以按工程的需要分期到位。这半个句子此后被反复引用:每一门试图进入大型工程的新语言,都得回答自己给类型的负荷安排了什么位置——答案的档次,几乎决定了这门语言在工程界的席位。
守卫的价格:谁为类型缴税
缴税的时点可以自选,缴税的事实无法免除。类型守卫的税单分三联开给三个人:写代码的人当场缴税——每一个参数、每一次返回都要多打字,多写一行注解,多做一次形状的自我交代;读代码的人免税——半年后重返旧文件,类型就是代码的自述文档,编辑器的补全与跳转全部以它为索引,不必再把调用关系装在脑子里;改代码的人退税——重命名与结构调整由机器代劳,编译器先把所有受影响的调用点圈出来,人才下刀。税率还是累进的:文件为单位逐步覆盖,严格程度逐级可调,新文件按高税率全额征收,老文件维持低税率照常运行。累进的含义是工程可以按自己的现金流缴税,现金流好的模块先上严格模式,历史包袱重的模块缓交——守卫的覆盖范围与团队的支付能力同步生长。
监督前移同样有它的附加费。编译器从离线裁判变成在线教练之后,误报成了新的摩擦:类型体操写得越精巧,报错的信息越难读;为了让编译器满意而追加的类型断言,本身又是另一种噪音。教练在场边喊得越多,运动员分心的时候也越多——这笔账没有记在类型系统的宣传册里,记在每一次“明明是对的,编译器非说不对”的叹气里。另一笔附加费收在海关:类型在运行时擦除,从网络与存储进入的外部数据,类型系统一无所知;工程界的补救是在入口处做一次性边界校验,此后才放行进类型世界。海关的值守从来不是免费的——校验的规则要手写,规则的版本要跟着接口走,漏检一次,类型世界里的全体守卫等于集体下班。守卫的价格因此有两本账:一本记在写代码时的手指上,一本记在海关值守的排班表上。
反对者的分量在这里要正面称量。动态阵营对类型守卫的抵触,没有一句是外行话:在原型阶段,类型是纯税无退——产品方向一天三变,注解的维护成本超过它的全部收益;脚本的规模停留在几百行时,后置是最便宜的位置,前置的每一分钱都是浪费。互联网早期的繁荣本身就是证据:恰恰是零负担的后置,让业余者与设计师得以入场,让网页的数量以年为单位翻番。半步哲学的全部含义,就是对这份反对的吸收——只把类型推到当下工程规模承受得起的位置,多一步都不走。渐进设计允许两种状态共存,等于承认反对者在小规模下是对的;严格模式做成可选项,等于承认守卫的税率应该由纳税人自选。最好的类型系统不是最严格的,是最会看规模脸色的。严格模式的档位设计就是这句话的语法形态:编译器的检查项被做成一排可以逐个打开的开关,每开一档,多拦一类错误,也多缴一档税——空值检查、隐式 any 的收紧、属性初始化的核验,各自独立标价。团队按模块的偿付能力逐档开启,税率表贴在墙上,迁移的进度第一次变得可度量:本月开了几档,还剩几档,任何一次合并请求都能读出数字。税率可视化的意义在于把争论变成算术——“要不要严格”不再是信仰之争,是对照模块规模查表。查表的结果常常是同一个:核心链路全开,边缘脚本缓行;守卫的密度与代码的寿命成正比,与代码的年龄无关。收编的名单后来还加上了异步:后续版本把等待异步操作写成顺序的语句,回调的嵌套由编译器生成的状态机接管——程序员描述“等什么”,机器安排“怎么等”。异步心智负担曾是服务端代码最隐蔽的认知税,税单被收编进语法的那一天,语言又替人记住了一种流程的形状。从属性到事件,从查询到异步,收编的对象一直在变,收编的动作始终是同一个:把反复出现的手工套路变成编译器替人操心的事。泛型是这张收编名单上最早的一员:第二个大版本把它交到企业开发者手里,同一套容器逻辑不再为每种元素类型复制一遍,类型参数把“长得一样、类型不同”的代码折成一份。契约网织密的含义正在这里——复用不再靠拷贝,靠参数;拷贝的每一份都是未来要分别维护的负债,参数的一份才是机器替人看守的资产。一门企业语言的成熟度,可以用它替用户消灭了多少复制粘贴来度量。
把这条线放进卷四的主导约束,位置一目了然。约束的原话是人类工作记忆容量与底层硬件表达精细度之间的妥协,类型系统正是这道妥协的记账本:C 把记忆的负担全压给程序员,指针与边界自己看;Java 把最危险的几页托管给虚拟机,内存管理不再占用人脑;JavaScript 把人的份额压到历史最低,连类型都可以不写;而 C# 与 TypeScript 做的是把一部分记忆从人脑搬进编译器——接口的形状、参数的契约、重构的牵连,不再靠人的自觉维系,靠机器的检查维系。搬运的方向只有一个:缴税的时点前移,猜测的负担后减。前移的每一寸都有价格,后减的每一寸都是收益;工程规模越大,收益相对价格越划算——这就是类型守卫只在大型工程里成立的全部算术。上一章的 JavaScript 把地基浇在全人类的日常使用上,这一章的两门语言做的,是给地基上已经跑着的房子逐间加装消防系统;加装的方式只能是渐进,停业装修的代价没有业主付得起。
编译器的身位与半步哲学
Turbo Pascal 的另一项发明常被忽略:它把编译器与编辑环境装进了同一个程序。在编译器是独立命令行工具的年代,这是一次身份的合并——写代码与编译代码之间的距离,从一个终端命令缩短为一次按键。此后海尔斯伯格的每一件产品都在沿这条轴推进:Delphi 把界面设计与代码编写合在同一个窗口;C# 的开发环境把编译检查实时做进编辑器;TypeScript 更进一步,类型错误在键入的瞬间就地标红。编译器从离线工具变成在线伙伴,它监督的时机越来越早,反馈的延迟越来越短——工程师的认知负荷,就这样被一寸一寸地转移给了实时运转的机器;编译器也从裁判变成了教练——它不再只在事后宣判对错,而是在每一次按键的当下即时提醒。这条身位线还有一层税的含义:类型的前置税缴在写代码的瞬间,反馈的延迟决定了税感的轻重。等一夜才出结果的编译,缴税如服刑;键入即标红的检查,缴税如刷卡——税额相同,痛感不同。Turbo Pascal 把编译压到按键级,Delphi 把界面与代码合进同一窗口,C# 把检查实时做进编辑器,TypeScript 把标红做到键入瞬间——四次设计在身位线上是同一方向的推进:让缴税的动作离写税单的手越近越好。前置的负荷只有配上即时的反馈才成立,否则没有团队愿意年年加税;半步哲学能走通,一半靠税率定得准,一半靠教练站得近;税感轻了,税才收得上去;反馈越即时,前置越少遇到抵抗。Turbo Pascal 时代的秒级编译,约定的正是同一种东西:等待越短,缴税越爽快。从软盘机的咔咔声到键入即标红,四十年压缩的不只是机器时间,还有纳税人的耐心阈值;编译器离手越近,类型的前置走得越远。
擦除式的类型检查还留了一道小小的裂缝要补:类型在运行时消失,意味着运行期间发生的动态行为——从网络返回的数据、从存储读出的记录——类型系统无从知晓。工程界的应对是一套“边界校验”的纪律:数据在进入类型世界的入口处接受一次性校验,此后便在类型的庇护下流转。这道校验边界是动态与静态两个世界的海关,它的工作质量决定了整个类型体系的成色——而它的存在本身也在提醒:渐进类型不是免费的午餐,边界上的每一次握手都要有人值守。兼容的税同样在收:JavaScript 生态几十年来积累的各种怪癖写法,TypeScript 都必须无条件支持——旧写法的每一个怪癖都要被永远支持,这是超集路线的终身义务;语言设计者对此的回答是把开关做进配置:严格程度逐级可调,让每个项目自己选择与历史的清算进度。
把海尔斯伯格的四次设计并排,能看出一种与激进派完全相反的方法论。Pascal 时代,类型是教学工具,教会初学者数据有形状——海尔斯伯格的起点正是 Turbo Pascal 这门 Pascal 编译器,发明结构化语言的理想经由同一双手延续了三十年;C# 时代,类型升级为企业契约,让大型团队按接口协作;TypeScript 时代,类型干脆变成可选项,把决定权逐文件交还给工程师。每一次都不把类型推到理论上最严格的位置,只推到当下工程规模承受得起的位置——多一步都不走。这套半步哲学的合理性由两次验收背书:C# 没有因为“像 Java”而死,反而长成了企业市场的主力;TypeScript 没有因为“类型不彻底”而死,反而成了大型网页工程的事实标配。两次验收也各自附了账单:C# 的账付给了它的出身争议,TypeScript 的账付给了 any 的滥用。静态类型六十年没有一次赢在纯粹——它每次都赢在允许工程师只承担当时承受得起的负荷。这个结论可以反驳,反驳者会指出:正因如此,行业至今仍在为历次放纵缴利息——而不缴利息的那条路,人类至今没有走通过一次。同一时代,另有两门语言从完全不同的方向出发,给出了关于安全与效率的另一种答案——那是下一章的故事。
第 048 章 2007—2010:Go 与 Rust:后多核时代关于安全与效率的迥异答案
2007 年 9 月 21 日,谷歌总部的一台服务器前,三位工程师在等待一个 C++ 程序编译完成。等待的时间长到足够开一局新的讨论:四十五分钟,机器在重造依赖树的每一条边,人只能看着进度条。三人里有 Unix 的共同发明人,有 UTF-8 的共同设计者,有做过两代虚拟机的编译器专家。他们等待的不是一次编译,是一个时代的日常——在超大规模代码库里,改一行、等一刻钟,工程师的一天被切成编译的碎片。履历的分工恰好对应语言的三个面:做过操作系统的管进程与内存,做过编码的懂兼容与简洁,做过虚拟机的懂运行时与优化。一门想同时解决构建、并发与部署的语言,需要的同时是这三种手艺;三个人凑齐,本身就是一句宣言:这不是修修补补,是另起炉灶。三人的履历本身就是一部微缩的系统史:做过操作系统的人知道进程的代价,做过编码的人知道兼容的分量,做过虚拟机的人知道运行时的余地。Go 的四个设计目标——简洁、并发、快速、安全——恰好是三张履历拼出来的;拼图的接缝处,就是 2007 年 9 月 21 日的那场讨论:构建的痛谁都忍过,并发的难谁都见过,把两种痛写进同一门语言,时机就是现在。讨论的结论后来写进项目史:与其继续等,不如造一门等得起的语言。等待的机制值得先看清楚:C++ 的头文件包含是文本级的复制粘贴,一个基础头文件被成千上万个源文件包含,每一次修改都要触发雪崩式的重新编译;模板的实例化在每个编译单元里各自生成一遍,链接器再把重复的结果合并,机器的大部分时间花在做重复功上。依赖图越大,重复功的占比越高,构建时间随规模超线性增长——这就是超大规模代码库的构建诅咒:代码每翻一倍,等待时间翻的不只一倍。诅咒的组织后果比技术后果更贵:工程师的一天被切成编译的碎片,注意力在等待里冷却;提交变成需要勇气的事,改动攒到足够大才敢按构建按钮,集成的频率越来越低,合并的冲突越来越大。构建越慢,提交越少;提交越少,合并越痛;合并越痛,下一次提交越不敢——慢构建把团队推进一个自我强化的循环。分布式构建能把单次等待摊薄,摊不薄这个循环;循环的根子在依赖的形状,不在机器的数量。工程师的应对是把构建拆成分布式任务,可拆分本身又有协调成本;拆到最后,人们发现真正该换的不是构建系统,是产生这种依赖形状的语言。同一时期,在大洋另一端的温哥华,一位程序员爬了二十一层楼梯回家——公寓电梯的软件崩溃了。一个是等编译等出的语言,一个是爬楼梯爬出的语言;十年后,它们成了后多核时代最重要的两个答案。
四十五分钟的账单
谷歌 2007 年的痛,是规模的痛。内部的 C++ 代码库以千万行计,一次完整构建耗时以数十分钟甚至小时计;头文件的包含机制让依赖关系织成一张越理越乱的网,改一处头文件的代价沿着包含链传导到整个构建。线程加锁的并发模型在多核普及之后显得又难写又易错,语言特性的持续膨胀让新人的学习曲线越来越陡。三位发起人的履历恰好覆盖这张痛点清单的每一项:肯·汤普森(Ken Thompson)是 Unix 的共同发明人与 B 语言作者,罗布·派克(Rob Pike)是 UTF-8 的共同设计者与 Plan 9 的核心成员,罗伯特·格里泽默(Robert Griesemer)参与过 V8 引擎与 Java 虚拟机的开发——操作系统、编码、虚拟机,三种手艺凑齐,动手的就是语言本身。2007 年 9 月 21 日,Go 项目在谷歌内部启动;2009 年 11 月,它正式开源。
Go 的设计目标写得像一份施工要求:简洁、并发、快速、安全。关键字只留二十余个,冗余的符号能省则省;编译速度是硬指标,改完即编、编完即跑,等待从分钟级压到秒级;部署是静态链接的单个二进制文件,拷贝即运行,不依赖外部运行时。工具链被当成语言的一部分发行:格式化、测试、依赖管理全部内置,代码风格由机器统一,争论在工具层面终结。2012 年 3 月,Go 1.0 发布并给出兼容性承诺;2015 年,编译器与运行时彻底去除 C 代码实现自举;2016 年起,容器与编排项目相继用它书写,它成了云原生生态的事实标准语言。兼容性承诺的含义是冻结用户侧的契约:用 1.0 规范写出的程序,在此后所有的 1.x 版本里都能编译运行;语言从此可以演化,用户的代码不必跟着演化。这份承诺是企业采用的前提——没有它,谁也不敢把生产系统押在一门年轻语言上。自举的含义则是独立宣言:编译器与运行时全部用 Go 自己书写,不再依赖 C 工具链;一门语言能编译自己,是它长大成人的仪式,意味着它的表达力已经够描述自己的实现。从借宿到自立,Go 用了八年。云原生生态的认领是这八年里最顺理成章的一笔:容器与编排要的是启动快、部署散、并发多——单二进制文件随镜像分发,启动即运行;goroutine 的便宜让代理与网关敢为每个连接开协程;编译的秒级让基础设施的迭代跟得上业务。生态选择语言的时候不看语法,看的是运维的账:部署的步骤越少越好,出故障的形状越规整越好。Go 的三张牌恰好是运维的三副药,认领它的不是品味,是值班表。
依赖管理的革命藏在包机制里。C++ 的头文件模型把接口与实现混在包含关系里,循环依赖与重复包含是日常;Go 规定包的依赖必须是显式的单向图,编译器直接拒绝循环引用,不合法的依赖形状连编译都过不了。显式约束的另一面是构建速度:依赖图无环,编译器可以按拓扑顺序一次走完,重复功被釜底抽薪。包的路径本身就是它的地址,获取依赖变成一句话的命令,版本管理随后长成模块系统。依赖从“需要的话术”变成“机器检查的形状”,这是 Go 替大规模协作还的第一笔账。工具链的第二笔账还的是风格:格式化工具把代码风格收归机器统一,缩进、换行、括号位置不再有讨论空间;测试、文档、依赖获取全部是一句话的命令,新人入职的第一天就能构建整个工程。风格争议在许多团队里是经久不息的内耗,Go 的解法是取消争论的资格——机器说了算。标准库的第三笔账还的是复用:网络、加密、压缩、文本处理,连同生产级的超文本传输服务能力,全部随语言发行;许多生产服务只依赖标准库就能上线,不必先逛一圈第三方生态。三个随附的决定共用一个逻辑:把工程里反复出现的组织成本也写进语言的发行物,让“开箱即用”从口号变成默认。
用通信代替共享
Go 的并发模型借自托尼·霍尔(Tony Hoare)的通信顺序进程理论。核心机制只有两件:goroutine 与 channel。前者是运行时调度的轻量协程,创建成本极低,初始栈只占 2KB 量级,单个程序可以轻松启动数十万个;后者是协程之间传递数据的类型安全管道,兼做同步原语。它的信条被概括成一句工程格言:不要通过共享内存来通信,而要通过通信来共享内存。线程加锁的模型里,数据放在中间,谁抢到谁用,抢错了就是竞态;channel 的模型里,数据在管道里流动,到谁手里谁处理,没有“同时伸手”的那一刻。并发的正确性从此不再依赖程序员对锁的记忆,依赖管道的拓扑。
goroutine A ──channel──▶ goroutine B ──channel──▶ goroutine C
│ │ │
▼ ▼ ▼
各自独立的栈 数据在管道里流动 到谁手里谁处理
调度器按需切换 类型随管道约定 无共享则无竞态
ch := make(chan string)
go func() { ch <- "ready" }()
msg := <-ch // 阻塞到数据抵达:等待写成排队
channel 的收发语义把等待写成了排队:发送方把数据推进管道,接收方在另一端等到数据抵达才继续;缓冲的管道还可以当作信号量,调节两端的生产消费节奏。形状规整的并发从此有了统一的写法,写法统一之后,调度器才敢做激进的优化。不带缓冲的管道是严格的交接:发送与接收必须在同一时刻相遇,一手交钱一手交货,交接本身就是同步点;带缓冲的管道是仓库:发送方把货堆进仓库就走,接收方按自己的节奏取,仓库的容量就是两端解耦的程度。两种管道覆盖了并发协作的全部形状:要会合有会合,要解耦有解耦。程序员的表达从此只有一种:画管道,连协程,让数据流动。调度的便宜是这套写法的底气:goroutine 的创建销毁由运行时接管,初始栈只占 2KB 量级,不够再长,闲了回收;数十万个协程同时存在,调度器在它们之间按需切换,切换的成本远低于操作系统的线程。便宜到可以为每一个连接、每一个请求、每一个小任务单独开一个协程,并发的单位从“省着用的线程”变成“随便用的协程”——写法变了,架构才敢变;架构敢为人人一个协程,服务才敢接海量并发。
线程加锁模型的失败形态,恰好反衬管道的价值。锁的正确性依赖程序员记住每一块共享数据的加锁顺序,顺序错了就是死锁;竞态错误的复现依赖特定的线程交错,压测跑一万次都正常,上线第一天就崩溃,调试靠的是运气。锁把并发的正确性押在人的记忆与运气的交集上,规模越大交集越小。锁的三种死法各有名字:死锁是循环等待,谁也不放手;竞态是时机不对,错过特定的交错就复现不了;粒度是两头不讨好,锁得太粗并行变串行,锁得太细顺序记不住。三种死法共用一个病根:正确性寄托在程序员脑子里那张动态的加锁图上,而图的规模随线程数膨胀,超过工作记忆容量的那一刻,错误就从可能变成注定。管道把同样的正确性押在拓扑上:数据只属于流动,不属于抢夺;没有共享,就没有竞态的温床。代价同样清楚:管道的拓扑写死之后,动态变化的协作形状不好表达;共享内存的灵活性被收走,换来的是从来不出错的等待。这里与第 042 章的 Erlang 隔空相望:Actor 模型让互不共享内存的进程靠消息协作,CSP 让轻量协程靠管道传递——两者同源而不同命,一个在电信交换机里长大,一个在云数据中心里长大。Actor 用地址寻址:消息发给某个进程,进程有邮箱,崩溃了有监督树重启它;CSP 用管道寻址:数据流进某个通道,通道有类型,谁持有通道谁参与协作。寻址的对象不同,容错的哲学就不同:前者相信失败一定会发生,设计的核心是失败之后如何恢复;后者相信拓扑一旦画对,失败可以少发生,设计的核心是让正确的结构易于表达。一个为容错而生,一个为吞吐而生;多核时代同时需要两者,历史把它们发给了不同的工业。
Go 最有争议的设计,是长期不要泛型。为了保住编译极速与语言的简洁,同一套容器逻辑服务多种元素类型的需求多年得不到类型参数的支持;用户要么为每种类型复制一遍代码,要么退回空接口加断言。批评者把这叫作语言的残缺,设计者把它叫作价格:每一个新特性都要在编译时间与心智负担上标价,泛型的标价太贵,先欠着。这笔欠账欠到 2022 年 3 月,Go 1.18 才正式引入泛型,距离开源过去了十二年。十二年的等待本身就是一句证词:编译速度在谷歌的构建规模下不是偏好,是生产资料;为它欠下表达力,是算过账的。
电梯与借用检查器
Rust 的起点比 Go 更个人。2006 年,格雷登·霍尔(Graydon Hoare)的温哥华公寓电梯因软件故障停运,他爬了二十一层楼回家。据项目史的口径,这次攀登直接催生了一个个人项目:在 GitHub 上叫 graydon/rust,目标是写一门不因内存错误崩溃的语言。个人玩具很快被 Mozilla 研究院接手,理由同样具体:下一代浏览器引擎需要高性能与安全性兼得,C++ 的内存错误税在浏览器这种直面全网恶意的软件里贵到付不起。浏览器的处境值得展开:它要解析来自任何服务器的输入,渲染、脚本、多媒体层层叠加,每一层都是攻击者可以直接触达的内存;一个悬垂指针就是一次远程代码执行,一次缓冲区溢出就是一次沙箱逃逸。用 C++ 书写浏览器,等于把内存安全的全部责任压在几百万行代码的每一位作者身上,漏一人,全盘输。Mozilla 要的新引擎 Servo,从立项起就把内存安全写进验收标准——语言若不能在编译期证明安全,引擎就不敢上线。这就是 Rust 被接手的全部理由:它不是学院派的类型实验,是浏览器战争的军火订单。2010 年前后语言成型,2015 年 5 月 15 日,Rust 1.0 发布并承诺向后兼容。
Rust 的核心机制是所有权加借用检查器。规则可以浓缩成三句:每个值在同一时间只有一个所有者;所有权可以转移,转移之后原变量即失效;他人想用只能借,要么一个可变借用独占,要么多个不可变借用共享,两者不可共存。检查发生在编译期:悬垂的引用、同时的读写、释放后再用,还没等到运行就被编译器拦下。2011 年加入 Mozilla 的尼科·马察基斯(Niko Matsakis)主持设计了借用检查器;他的博士论文研究的正是无数据竞争的并行,学术训练与工程需求在这里对上了榫。马察基斯的路径值得多看一眼:本科读电气工程与计算机,毕业后在一家做可扩展标记语言加速设备的创业公司写过即时编译器与网络运行时,博士阶段在苏黎世联邦理工学院研究类型系统如何保证并行不打架,2010 年在面向对象编程顶会上发表时间感知类型系统的论文,次年带着这套学问走进 Mozilla。借用检查器不是凭空长出来的,它是一个研究“怎么让线程不打架”的人十年训练的结晶。工程史里最好的部件常常是这样来的:论文里的问题与产品里的灾难是同一道题,只是换了个题面。
let s1 = String::from("hello");
let s2 = s1; // 所有权转移:s1 此后失效
// println!("{}", s1); // 编译错误:已转移的值不可再用
println!("{}", s2);
这段代码的第三行若取消注释,程序连编译都过不了——错误在写完的当下被抓住,而不是在压测的深夜。所有权的另一面是仿射类型:值默认只能被使用一次,复制必须显式声明;线程之间的数据传递由 Send 与 Sync 两组标记把关,不满足安全条件的共享在编译期就被拒绝,并发的数据竞争从而在类型层面被消除。这套设计的代价同样写在明处:学习曲线陡峭,初学者要重学一整套内存范式,频繁与编译器“对抗”;编译时间长,运行时灵活性受限,没有反射,循环数据结构要借助引用计数或显式的不安全代码。三类内存错误值得逐个看清它的死法:空指针解引用死于 Option 类型——“可能不存在”必须显式声明为一种类型,用之前先处理不存在的分支,不存在“忘了判空”这回事;数据竞争死于借用规则——读写不能同时发生,编译器数着每一份借用的可变性,数不清的程序不配运行;悬垂指针死于生命周期——引用的有效期被标注成类型的一部分,短命的引用流不到长命的位置,流过去的那一刻编译就失败。三个死法共用一个逻辑:把运行时的“可能出错”翻译成编译期的“必然报错”。翻译的另一面是误伤:生命周期标注写起来啰嗦,初学者分不清谁该活多久;聪明的写法常常因为 borrow checker 数不清而被迫改笨——编译器看不懂的正确,一律按错误处理。证明的边界同样值得看清:类型系统能证明内存不错用、数据不竞态,证明不了逻辑不错、死锁不发生。一门消灭了内存错误的程序,照样可以在业务逻辑上错得离谱;编译期证明的从来不是正确,是某一类错误的不可能。Rust 诚实的地方在于从不许诺正确,只承诺内存与并发的确定性——承诺的范围越窄,兑现的把握越大。把证明的范围限定在机器擅长的部分,把判断留给测试与人,这是证明派的自我克制,也是它与形式化验证殊途同归的边界感。逃逸舱是 unsafe 代码块:允许裸指针与外部函数接口,但要求开发者自行保证安全,审计的边界清晰地画在 unsafe 的花括号边上。花括号的含义是责任状:括号里面的内存安全,编译器不管了,签名的人负责。工具链把语言的严苛包上了糖衣:包管理器集成构建、测试与文档,一条命令建工程,一条命令出发行版;格式化工具统一风格,静态检查工具提前指出可疑写法。糖衣的逻辑与 Go 如出一辙:语言越严格,工具越要体贴,否则没有团队愿意上船。严苛的规则配上体贴的工具,diff 的摩擦才降得下来;规则是编译器定的,体贴是工具链给的,两者缺一不可。空指针被 Option 类型取代,错误被 Result 类型强制处理——“不存在”与“失败”从此是类型的一部分,而不是运行时的惊吓。判空的旧写法从此变成这样:
let v: Option<i32> = Some(5);
match v { Some(n) => println!("{}", n), None => println!("empty"), }
拿到值的每一行之前,先回答“没有值怎么办”;编译器数着分支,漏掉一个都不放行。错误处理同理:失败是返回值的一部分,调用者必须显式接住,甩手不管连编译都过不了。啰嗦是故意的:把“想当然”从代码里赶出去,代价就是多写几行“废话”。
两份账单与反对者的分量
两门语言的批评者都值得正面称量。C++ 阵营的反驳在当时完全站得住脚:零开销抽象已经给了程序员“不用为没用的东西付费”的自由,既有代码资产以亿行计,重写不如改良;把构建慢归罪于语言,不如先修构建系统。垃圾回收阵营的反驳同样有分量:停顿时间随着硬件进步逐年下降,用可接受的运行时开销换开发生产力,是已被验证过的划算买卖;让每个工程师都重学所有权,学费由全行业支付。Go 的简朴在学院派眼里近乎简陋:类型系统表达力有限,泛型欠账十二年,错误处理靠重复的样板;Rust 的严格在实践派眼里近乎苛刻:编译器挡住的路比指出的路多,小项目用它是大炮打蚊子。这些批评没有一句是外行话,它们输掉的从来不是道理,是规模:当构建以小时计、当内存错误以安全漏洞计,道理的账本就换了一本。Go 的泛型欠账最能说明价格的实在:十二年里,用户要么复制代码,要么退回空接口加类型断言,断言失败在运行时爆炸——省下的编译时间,分期付给了运行时的风险与维护期的重复。欠账的偿还同样实在:泛型到来之后,旧代码一行不用改,新代码逐步用上参数化,十二年的等待换来的是零断裂的升级。这就是 Go 式还账:宁可让用户绕路十二年,不让任何一次构建从此变慢。Rust 的苛刻也有它的还账记录:按 Mozilla 的口径,用它重写的浏览器组件内存错误大幅下降;开发者调查里多次蝉联最受喜爱——被编译器折磨过的人,反过来最信任它。折磨与信任是同一枚硬币:拦住的错误越多,托付的信心越重。信任的组织成本同样实在:团队引入 Rust,第一拨人要在几个月里持续与编译器对抗,产出爬坡之前先交学费;布道者拿内存安全的账单说服管理层,怀疑者拿编译时间与招聘难度反问。学费的回收期按年计,回收的方式是深夜的故障越来越少——愿意预付学费的团队,买的从来不是语法,是少值夜班的未来。不愿预付的团队也算得清楚:错误代价不够大的业务,不值得为确定性缴税。两边的账都成立,成立的条件不同。
内存模型的细节留给卷五,语言设计的分野在本章已经清楚:Erlang 用进程隔离换容错,Go 用管道拓扑换吞吐,Rust 用编译期证明换确定性。三条路回答的是同一个问题:多核与并发之下,谁来为正确性付费。Erlang 让监督树付费,Go 让调度器与管道付费,Rust 让编译器付费。
工业的验收各有形状。用 Go 书写的容器与编排项目成了云原生的底座,部署的简单与并发的便宜在这里是刚需;用 Rust 重写的浏览器组件按 Mozilla 的口径内存错误大幅下降,确定性在这里是刚需。验收的另一面是拒绝:追求表达力的团队嫌 Go 简陋,追求迭代速度的团队嫌 Rust 缓慢——两门语言从未试图取悦所有人,它们的形状就是它们的立场。选型的指南可以写成一句话:并发的规模越大,Go 越划算;错误的代价越大,Rust 越划算。原型阶段两者都不划算——那是脚本语言的领地,编译与证明都是多余的税。税只有在规模与代价长大之后才值得缴,缴给谁,取决于痛的是构建还是内存。合流的方向在十二年里已经显形:Go 向表达力借了一块泛型,Rust 向易用性借了工具链的体贴——简朴的一端在补表达,严格的一端在补体贴。借的方向相反,借的原因相同:再极端的立场也要为用户的真实规模让路。立场是旗帜,借款是日子;旗帜可以鲜明,日子必须能过。两门语言都没有背叛自己的起点,只是在起点之外各加了一个侧门。分野的工业形状也值得收束:Go 守住的是吞吐与部署的领地,容器、网关、工具链,凡是并发多、启停频、部署散的活,都是它的主场;Rust 守住的是确定与底层的领地,引擎、运行时、基础设施,凡是错不起、漏不得、停不起的活,都是它的主场。主场不重叠,对抗就很少发生;两门同龄的语言各自长大,靠的不是打败对方,是各自找到了非己不可的位置。
两种答案,一道约束
回到卷四的主导约束:人类工作记忆容量与底层硬件表达精细度之间的妥协。Go 与 Rust 站在这道约束的两端,却付的是同一种货币——编译时。Go 把人的记忆负担压到最低:二十余个关键字,统一的格式,读代码几乎不用猜;省下来的不确定性由编译速度与运行时调度承接,改完秒级验证,猜测的成本趋近于零。Rust 把机器的验证推到最高:所有权、借用、生命周期的全部规则在运行前查清,人脑记不住的别名关系由编译器记住;省下来的运行时错误由编译时间的等待承接,写时多对抗,运行时少惊吓。一个把“写得快”做到极致,一个把“错得早”做到极致;极致的方向相反,前移的动作相同——都把问题的发现时点从运行推向编译。把本卷的语言排成一列,预付比例一目了然:C 预付零,指针直连内存,边界自己检查,性能分文不少,风险分文不减;C++ 预付到抽象层,零开销的承诺下,构造与析构替人管住资源的生死,剩下的仍归程序员;Java 预付到虚拟机,内存管理整体托管,类型在运行前查清,代价是运行时的常驻税;JavaScript 预付为负,把类型推迟到运行错误,用零分发成本换来全人类的入场券;C# 与 TypeScript 按工程规模分期预付,税率表贴在墙上。Go 与 Rust 只是把预付推到了当年最远的两个点:一个预付给编译速度,一个预付给编译证明。列车的终点早就写在起点里:你在哪一站下车,取决于你的规模付得起哪一站的票。
这道约束也解释了为什么泛型与借用检查器是各自阵营里最贵的部件。泛型把表达力的负担从用户手里拿走,代价是类型检查与代码生成的膨胀,Go 为此欠了十二年;借用检查器把别名分析的负担从测试手里拿走,代价是编译时间的增长与心智模型的陡峭,Rust 为此掉了无数初学者的头发。贵的东西共用一条定价逻辑:谁在运行时付不起,谁就在编译时预付。多核时代把这条逻辑推到了台前:主频的免费午餐吃完之后,性能只能向并行要,并行只能向更多的执行单元要,更多的执行单元意味着更多的数据竞争与同步开销——免费的性能没有了,免费的正确也没有了。C 把一切留给运行时,Java 把内存托管给虚拟机,JavaScript 把类型推迟到运行错误——本卷的语言排成一列,每一门都在这道约束上选了一个不同的预付比例;Go 与 Rust 只是把预付推到了当年最远的两个点。记忆的容量账还可以再算一笔:Go 要求记住的形状最少,二十余个关键字加一套管道写法,读代码的心智负担接近读伪代码;Rust 要求记住的规则最多,所有权三条、借用两态、生命周期的标注,一个都不能含糊。少的代价是表达力受限,多的代价是学习期漫长——约束的两端各有一份价目表,价目表上没有免费项。工程师选择语言的时候,选的从来不是语法,是自己愿意把记忆预算花在哪:花在记住业务上,还是花在记住规则上。构建规模决定前者有多贵,错误代价决定后者有多值;两本账算清楚,选型就只剩算术。
两门语言的 1.0 有同一个动作:承诺向后兼容。承诺的含义是把演化的权力关进笼子——用户代码写一次,长期有效;语言的改进只能做加法,不能没收旧写法。承诺是工业语言的成人礼:没有它,企业不敢押注;有了它,生态才敢生长。Go 在 2012 年立约,Rust 在 2015 年立约;立约的时间不同,立约的对象相同——都是生产系统的信任;失约的代价也相同——都是生态的用脚投票。
本章的断言是:Go 与 Rust 证明,后多核时代不存在免费的安全,并发与内存的每一分确定性都要在编译时标价——Go 把价格写进语言的简朴,Rust 把价格写进编译器的严格;标价越诚实,生态位越稳固。这个断言可以被反驳:如果未来硬件或运行时让数据竞争与内存错误在零编译成本下消失,而两门语言的用户规模不增反减,那么标价论就是错的,并发安全只是特定硬件阶段的临时税种,约束本身会被新的抽象绕过去。
「计算机百年史」系列第 4 篇(共 10 篇)。全系列统一标签:计算机百年史。