Strange Loop Conference
软件后期的维护停滞源于起步时贪图上手便捷而引发概念缠绕,单元测试与类型系统只是无法防范架构崩溃的次要护栏,唯有彻底解耦状态与时间才能维持系统长效演进。
AI-assisted summary of "Simple Made Easy" - Rich Hickey (2011) — original source. Check the original for full context.
Source published:
Key ideas
- Rich Hickey 严格区分了 Simple(简单:客观概念,指单股未编织缠绕)与 Easy(容易:主观概念,指邻近、现成或熟悉),指出开发者常将对现有知识的“熟悉”误认为系统的“简单”。 (1:24)
- 敏捷开发、自动化测试和类型系统充其量只是“护栏与安全网”,无法替代对系统因果逻辑的日常推理,生产环境中爆发的所有 Bug 均已全绿通过了单元测试与类型检查器。 (15:33)
- 可变状态将“值”与“时间”不可逆地编织缠绕在一起,像墨水滴入花瓶般持续渗透毒害架构,而单线程程序同样会因无法还原瞬时隐式状态而陷入调试灾难。 (35:39)
- 软件设计应以“运行产物”(Artifacts)而非“编码打字体验”(Authoring)为首要评价基准,通过纯数据、纯函数、队列与按需多态来取代充血对象模型与 ORM 等高编织度构件。 (9:07)
Detailed notes
## Background 该视频由 Strange Loop Conference 频道于 2021 年 9 月 2 日发布在 YouTube 平台上,是 Clojure 作者 Rich Hickey 在 Strange Loop 2011 大会上极具影响力的开场主题演讲的高清重制版。视频简介提到,拥有 30 余年跨领域系统开发经验的 Rich Hickey 在本场演讲中系统性阐述了软件设计中对抗复杂性的全新思考方式,该演讲被公认为其影响深远的技术代表作之一。
## TL;DR Rich Hickey 深入剖析了软件工程中常被混淆的两个核心概念:“简单”(Simple,客观上没有交织缠绕)与“容易”(Easy,主观上触手可及与熟悉好用)。他尖锐地批判了敏捷重构神话、过度依赖测试与类型系统的“护栏式编程”,以及对象、状态和语法对事物本质概念的强制交织。演讲指出人类工作记忆容量极其有限,面对软件长跑,唯有克制开发时的局部即时快感,用不可变值、纯函数和队列等非编织的简单构件去替代紧耦合模型,才能保障系统运行工件的长期韧性与推理能力。
## Atmosphere & style 整场演讲呈现出一种冷峻深刻又极具冷幽默感的大师气场,Rich Hickey 毫无居高临下的布道说教,而是用三十年被复杂性痛击的实战教训与听众真诚对话。他的叙事从严谨的拉丁词源学探究自然切入,行文中穿插着对“He-Man 式状态编程”与“马路撞护栏”的辛辣嘲讽,引发全场频繁的会心大笑。整场演说逻辑如手术刀般精确犀利,听众能深刻感受到一种拨云见日般的思想震撼与反思共鸣。
## Bulletin - [01:24](https://www.youtube.com/watch?v=SxdOUGdseq4&t=84s) Rich Hickey 严格区分了 Simple(简单:客观概念,指单股未编织缠绕)与 Easy(容易:主观概念,指邻近、现成或熟悉),指出开发者常将对现有知识的“熟悉”误认为系统的“简单”。 - [15:33](https://www.youtube.com/watch?v=SxdOUGdseq4&t=933s) 敏捷开发、自动化测试和类型系统充其量只是“护栏与安全网”,无法替代对系统因果逻辑的日常推理,生产环境中爆发的所有 Bug 均已全绿通过了单元测试与类型检查器。 - [35:39](https://www.youtube.com/watch?v=SxdOUGdseq4&t=2139s) 可变状态将“值”与“时间”不可逆地编织缠绕在一起,像墨水滴入花瓶般持续渗透毒害架构,而单线程程序同样会因无法还原瞬时隐式状态而陷入调试灾难。 - [09:07](https://www.youtube.com/watch?v=SxdOUGdseq4&t=547s) 软件设计应以“运行产物”(Artifacts)而非“编码打字体验”(Authoring)为首要评价基准,通过纯数据、纯函数、队列与按需多态来取代充血对象模型与 ORM 等高编织度构件。
## Key takeaways - [00:04](https://www.youtube.com/watch?v=SxdOUGdseq4&t=4s) Edsger W. Dijkstra 的名言“简单是可靠性的先决条件”切中要害,构建优秀软件系统的唯一基石是构建简单的系统。 - [01:24](https://www.youtube.com/watch?v=SxdOUGdseq4&t=84s) “Simple”词源为单重折叠与无交织(No Interleaving),它是一个与基数数量多少无关、可客观判断的系统属性。 - [05:16](https://www.youtube.com/watch?v=SxdOUGdseq4&t=316s) “Easy”源自拉丁语的“邻近”,具有物理可及、认知熟悉和心智边界三重维度,属于完全主观且相对的概念。 - [09:07](https://www.youtube.com/watch?v=SxdOUGdseq4&t=547s) 过度追求打字手感与语法糖等构造体验(Constructs),会导致开发者忽视软件长期运行产物(Artifacts)的架构韧性与维护成本。 - [12:19](https://www.youtube.com/watch?v=SxdOUGdseq4&t=739s) 人类大脑同时思考多个交织概念的工作记忆容量极小,系统组件的交织编织会引发认知负担的组合级数暴增。 - [14:04](https://www.youtube.com/watch?v=SxdOUGdseq4&t=844s) 敏捷开发宣称重构与测试能让人零成本修改代码纯属妄谈,修改软件的前提是开发者能够对程序行为进行“非形式化推理”。 - [15:33](https://www.youtube.com/watch?v=SxdOUGdseq4&t=933s) 盲目依赖测试套件如同撞着护栏开车的“护栏式编程”,测试只能验证已知用例,无法指引系统朝着正确的架构方向演进。 - [16:48](https://www.youtube.com/watch?v=SxdOUGdseq4&t=1008s) 一味追求上手容易而忽视复杂度的敏捷团队,其开发速度将在中后期因不断重做旧代码而彻底陷入停滞。 - [19:35](https://www.youtube.com/watch?v=SxdOUGdseq4&t=1175s) 使用织布机构建看似精美的“毛线城堡”会带来严重的附带复杂度,一旦面临变更其弹性远逊于正交解耦的“乐高城堡”。 - [22:34](https://www.youtube.com/watch?v=SxdOUGdseq4&t=1354s) 面对复杂系统,人类个体的智力生理差距微不足道,唯一的出路是通过简化架构把问题拉回到人脑能够处理的近处。 - [31:43](https://www.youtube.com/watch?v=SxdOUGdseq4&t=1903s) 古英语词汇“Complect”精准定义了将独立条带扭结编织在一起的原罪,真正的组合(Compose)应是并置独立的模块。 - [33:08](https://www.youtube.com/watch?v=SxdOUGdseq4&t=1988s) 仅仅将代码进行文件与层级切分的“模块化”往往只是将一团乱麻切成数段,无法带来本质上的系统解耦。 - [35:39](https://www.youtube.com/watch?v=SxdOUGdseq4&t=2139s) 有状态编程将“值”与“时间”深度捆绑,即便在单线程环境下也会因隐式状态难以还原而成为线上调试的梦魇。 - [39:26](https://www.youtube.com/watch?v=SxdOUGdseq4&t=2366s) 对象、方法、语法、继承、Actor 与 ORM 等面向对象主流构件,在底层都将不同的概念维度强行交织在一起。 - [42:54](https://www.youtube.com/watch?v=SxdOUGdseq4&t=2574s) 完全可以使用不可变值、纯函数、通用数据结构(Maps/Sets)和按需多态等朴素工具,构建出同等规模的大型系统。 - [47:56](https://www.youtube.com/watch?v=SxdOUGdseq4&t=2876s) 真正的抽象是将物理实体属性抽离出纯粹的规格说明,单纯隐藏实现细节的信息封装绝不等于抽象。 - [54:35](https://www.youtube.com/watch?v=SxdOUGdseq4&t=3275s) 在架构中广泛使用队列能够彻底解开组件调用在时间(When)与空间网络位置(Where)上的强耦合。 - [58:19](https://www.youtube.com/watch?v=SxdOUGdseq4&t=3499s) 开发者必须建立起洞察“Complecting”的纠缠雷达,宁愿拥有更多互不缠绕、垂直垂挂的独立小部件,也不要纠缠在一起的死结。
## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=SxdOUGdseq4&t=4s) 开场与引言:简单作为可靠性的先决条件
Rich Hickey 以一个轻松的玩笑开场,问现场听众是否准备好听更多关于范畴论(category theory)的内容,接着打趣道:“你们都走错房间了。”他指出,这篇演讲的内容乍看之下可能显得“看似极其显而易见”(deceptively obvious)。Strange Loop 的与会者普遍走在技术前沿,许多人正在拥抱新技术、实践函数式编程,听演讲时可能会频频点头认同。然而,Rich Hickey 希望大家在听完这场演讲后,不仅是感到熟悉,更能带走一套切实的思考与表达工具,以便日后能去说服其他人做出正确的架构选择。
随后,Rich Hickey 引用了计算机科学家 Edsger W. Dijkstra 的经典名言作为诉诸权威的切入点:“简单是可靠性的先决条件。”尽管 Rich 坦言自己并非完全赞同 Dijkstra 的所有观点(尤其是在形式化证明方面),但他坚信这句话切中了要害。软件开发者如果想要构建优良的系统,就必须构建简单的系统,而行业目前对此的重视程度远远不足。
- 演讲定位:针对走在技术前沿、探索函数式编程的开发者,提供用于向团队普及架构设计的论证工具。 - 权威引言:“Simplicity is a prerequisite for reliability.”(简单是可靠性的先决条件 —— Edsger W. Dijkstra)。 - Rich Hickey 的核心判断:正如他直接强调的,“We need to build simple systems if we want to build good systems.”(如果我们想构建优秀的系统,就必须构建简单的系统)。
---
[01:24](https://www.youtube.com/watch?v=SxdOUGdseq4&t=84s) 词源探析:何为“Simple”(简单)
Rich Hickey 表达了他对词源学的浓厚兴趣。词汇在日常演变中,其含义往往会被约定俗成地磨损或泛化,而探寻本义往往能带来极具穿透力的精确性。他分析了演讲中最重要的第一个词——“simple”(简单)。该词的词根是“sim”与“plex”,字面本义是指“单股的编织、单重的折叠”(one fold or one braid or twist)。如果一件东西只有一重编织,换言之,它其实没有任何与其他线条绞合的扭结。
与之相对的词是“complex”(复杂),其字面含义是“交织在一起、折叠在一起”(braided together or folded together)。Rich Hickey 指出,衡量软件是否被绞合交织在一起,是本次演讲最核心的立足点。在软件设计中追求简单,意味着系统中的模块、组件或抽象应当扮演单一角色、完成单一任务或目标、专注单一概念(例如安全),或仅解决问题领域中的某一个特定维度。
Rich Hickey 紧接着厘清了一个极其关键的混淆:简单关注的是“有无交错”,而不是数量上的单一。简单并不等于系统只能有“一个”东西,也不等于接口只能包含“一个”操作。开发者必须严格区分基数(cardinality,即计数的多少)与交织(interleaving)。没有交错才是简单的本质。更重要的是,一件东西是否存在绞合交错,是一个客观事实;人们可以通过检查连接关系客观判断它是否交织。因此,“简单”是一个客观概念。
```mermaid flowchart TD accTitle: Simple vs Complex Etymology accDescr: 简单与复杂的词源结构对比:Simple 为单股无缠绕,Complex 为多股交织缠绕。
subgraph Simple["Simple(简单:Sim-Plex)"] S1["单股编织 / 单重折叠"] --> S2["无交错状态(No Interleaving)"] S2 --> S3["单一职责 / 单一概念 / 明确维度"] S3 --> S4["客观属性(Objective Notion)"] end
subgraph Complex["Complex(复杂:Com-Plex)"] C1["多股编织(Braided Together)"] --> C2["交织折叠(Interleaved / Folded)"] C2 --> C3["概念与职责深度缠绕"] end ```
- 词源解析:“simple”源于 *sim-plex*(单股折叠/编织),对立面是 *complex*(缠绕折叠在一起)。 - 维度的专注:简单的组件应专注单一角色、概念(如安全性)或问题空间的一维,不揉杂无关事物。 - 关键辨析:基数(Cardinality,数量多少)≠ 交织(Interleaving,缠绕与否)。简单追求的是“无交织”,而非数量只有一个。 - 客观性判断:如同 Rich Hickey 所断言,“So simple is actually an objective notion.”(因此,简单实际上是一个客观的概念)。
---
[05:16](https://www.youtube.com/watch?v=SxdOUGdseq4&t=316s) 词源探析:何为“Easy”(容易)的三重含义
接下来,Rich Hickey 剖析了常与“simple”混为一谈的词——“easy”(容易)。从词源追溯,“easy”最终源自拉丁语中与“adjacent”(相邻、邻近)同源的词根,本义是“位于近处、就在身边”(to lie near / to be nearby)。其反义词是“hard”(困难),词根意味着坚硬或痛苦,与距离并无对应关系。Rich 将“近”(nearness)拆解为影响软件开发者的三个层次:
1. **物理上的邻近**:触手可及。在现代软件环境中,这体现为代码就在本地硬盘上、属于现成工具链,或者能通过安装器在极短时间内一键下载安装。 2. **认知/心理上的邻近(熟悉度 Familiarity)**:处于现有的技能树或已知知识范围内。开发者往往把“我读得懂、我见过”当成容易。Rich 尖锐地反驳:自己看不懂德语,并不代表德语本身不可读,只是因为自己没学过。一味追求“熟悉”,会导致人永远无法学习新事物,因为任何真正全新的技术都不可能与既有经验高度相似。 3. **能力上的邻近(Near to Capabilities)**:处于人类思维能力的边界之内。Rich 指出,大家往往抗拒讨论这一点,因为它刺痛了程序员的自尊心。如果说拉小提琴或登山需要专门能力,大家不会觉得难堪;但软件开发是纯粹的脑力工作,承认某事超出自己的思考能力,会受到傲慢与不安全感的双重阻挠。然而事实是,人类的心智局限彼此相差无几。
与客观的“简单”截然不同,“容易”是一个完全主观且相对的概念。拉小提琴对某些人轻而易举,对另一些人则寸步难行;阅读德语亦然。Rich 批评道,当人们随口说“我喜欢某项技术是因为它简单”时,他们真正的意思往往只是“它对我来说很容易”,而这进一步等同于“它跟我已知的东西长得很像”。这种概念混淆摧毁了关于软件质量的客观讨论。
- 词源定义:“easy”源自拉丁词根,核心含义为“lie near”(邻近、在近处)。 - 容易的三重维度: - 物理邻近:现成可用、一键安装、能在 5 秒内跑起来(哪怕它内部是个巨大的复杂毛线球)。 - 认知邻近(熟悉度):类似于已有知识。但这会导致学习停滞,因为“熟悉”排斥真正的创新。 - 能力邻近:落在人脑的心智承受极限之内。 - 相对性本质:正如 Rich Hickey 所指出的,“The last thing I want to say about easy and the critical thing to distinguish it from simple is that easy is relative, right?”(关于容易,我想说的最后一点,也是将它与简单区分开的关键所在,就是容易是相对的,对吧?)
---
[09:07](https://www.youtube.com/watch?v=SxdOUGdseq4&t=547s) 构造物与工件:开发体验与长期运行的冲突
Rich Hickey 进一步将分析推向关键领域:编程构造物(constructs)与最终运行的工件(artifacts)之间的脱节。我们在日常编码中使用的是编程语言的语法构造、语法糖和库,开发者往往沉迷于代码敲入时的即时快感,比如“我只敲了 16 个字符!连分号都不用打!”。但软件业务的本质在于它交付后的最终工件——软件并不是把源码打包送去给用户看,用户也不会因为源码写得舒服而买单;用户在乎的是软件长期运行时的表现。
系统的可靠性、性能、应对新需求时的可修改性,全部是“运行工件”的属性,而非“语法构造”的属性。然而,无论是程序员还是企业雇主,都对前两种“容易”(上手快、形式熟悉)陷入了极度痴迷。雇主尤其喜欢“认知邻近与工具普及”,因为当代码库充满大众熟悉的样板代码和工具时,开发者就变成了可以随时替换的标准化零件;只要新人能坐到工位上立刻敲键盘,企业甚至完全不在乎第三种容易——即系统本身到底有没有人能真正理解。
Rich 呼吁,软件工程必须停止把注意力锁死在打字手感、语法糖或某种工具文化的表象上,而应基于工件在长期维护中的真实表现,来重新评估我们所选用的语言和设计构造。
| 对比维度 | 构造物(Constructs)/ 追求“容易” | 工件(Artifacts)/ 追求“简单” | |:--- |:--- |:--- | | **关注核心** | 编码打字体验、语法精简(如少敲字符、无分号) | 系统长期运行的表现、健壮性与架构韧性 | | **评估依据** | 熟练度、上手速度、工具库是否现成可见 | 是否实现预期功能、缺陷修复难度、需求变更能力 | | **企业视角** | 便于招募替代人员,谁坐下都能立即写代码 | 决定系统的长期维护成本与生存寿命 | | **本质属性** | 主观、相对、局部快感 | 客观、全局、系统属性 |
Rich Hickey 严肃地告诫开发者:“We have to start assessing our constructs based around the artifacts, not around the look and feel of the experience of typing it in or the cultural aspects of that.”(我们必须开始根据最终工件的属性来评估我们的编程构造,而不是依据敲代码时的体验感或者某种工具文化。)
[12:19](https://www.youtube.com/watch?v=SxdOUGdseq4&t=739s) 人类心智的物理局限与交织带来的认知负担
Rich Hickey 开玩笑说,他前面的这套简单逻辑只是为了把大家催眠,让大家觉得他接下来讲的一切都言之成理,“因为我没办法用单子(Monads)来做到这一点”。他指出,人类根本不可能造出既高度可靠、自己又无法理解的事物。正如 Gerald Jay Sussman 教授所言,在系统的某些未来发展中,当我们为了让事物更加灵活、动态和可扩展时,必然会在理解系统行为和保证正确性的能力上做出权衡。然而,对于那些我们必须彻底理解并确保无误的核心部分,人类的认知能力其实存在极大的天然限制。
人类一次能在大脑中维持的事物数量非常有限,就像杂耍抛球一样,普通人同时能抛在空中的球非常少。当系统中的事物被紧密交织(intertwined)在一起时,我们就彻底丧失了孤立审视单个组件的能力。每次你想从软件中抽离出一块代码去理解,由于它死死绑定在另一个组件上,你就不得不把另一个组件也强行塞进大脑;两者纠缠在一起,你根本无法单独思考其中之一。这种交织给人类大脑带来的认知负担是呈组合级数(combinatorial)暴增的。因此,从根本上讲,复杂度——也就是事物之间的相互交织与编织——直接锁死了我们理解软件系统的能力。
```mermaid flowchart TD accTitle: 紧密交织导致的认知组合爆炸 accDescr: 展示代码组件交织如何迫使人类有限的脑容量陷入过载
subgraph Mind["有限的人类心智容量"] Slots["工作记忆槽位 (极少数概念)"] end
subgraph Software["交织纠缠的代码 (Braided/Intertwined)"] A["组件 A"] --- B["组件 B"] B --- C["组件 C"] A --- D["组件 D"] end
Software -.->|"无法孤立理解,被迫同时载入"| Slots Slots --> Overload["认知超载 / 无法推理正确性"] ```
---
[14:04](https://www.youtube.com/watch?v=SxdOUGdseq4&t=844s) 敏捷神话的破灭与“非形式化推理”的必要性
面对软件系统的变更,社区流行着一种近乎迷信的论调。Rich Hickey 提到自己在当天的另一场演讲中听到有人声称:敏捷开发(Agile)和极限编程(Extreme Programming, XP)已经证明,重构和单元测试能让人以零风险、零代价完成修改。Rich 对此直言不讳地反驳道,这种说法根本就是无稽之谈:“我从来不知道有这回事。我现在依然不知道,因为那根本不是一件可知的事实,那纯粹是胡扯(That's phooey)。”
要修改软件,开发者首先必须分析代码当前的行为,并判定它未来应当如何表现。你至少必须评估一次潜在改动所带来的连带影响,弄清楚到底要修改哪些模块才能达成目标。无论你使用极限编程还是敏捷方法,都无法绕开一个冷酷的事实:“如果你无法对程序进行推理,你就无法做出这些决定(If you can't reason about your program, you can't make these decisions)。”
Rich 特别澄清,这里所说的“推理”(Reason about)绝非学术界那种形式化验证或数学证明: - 他并不相信在工程中追求形式化程序证明是一个务实的目标。 - 他所倡导的仅仅是“非形式化推理”(Informal reasoning),即人们在日常生活中决定下一步做什么时所用的常识与普通逻辑。 - 开发者不需要搬出范畴论(Category theory)也能对系统做出清醒的因果推导,敏捷实践无法替代这种推导过程。
---
[15:33](https://www.youtube.com/watch?v=SxdOUGdseq4&t=933s) 线上 Bug 与“护栏式编程”的荒谬
软件生命周期中的任务无非两件:一是增加新功能,二是修复没做好的旧功能。Rich 向全场抛出一个耐人寻味的问题:“在线上环境中发现的每一个 Bug,都有什么共同特征?”台下有人回答“它们都被写出来了”。Rich 赞同之后追问更深层的事实:线上所有的 Bug 不仅被写了出来,而且“它通过了类型检查器,它还通过了所有的单元测试”。
面对这种全绿灯通过却依然在线上崩溃的窘境,软件界陷入了一种被 Rich 戏称为“护栏式编程”(Guard rail programming)的悲哀现状。许多开发者盲目自信地认为:“因为我有完善的测试套件,所以我可以肆无忌惮地改代码。”Rich 用了一个辛辣的比喻:这就像一个人开着车在马路上横冲直撞,一路靠不断碰撞道路两侧的护栏来防止坠毁,还沾沾自喜地庆幸“幸好有护栏,不然我都没法准时赶到会场”。
护栏根本无法引导车辆驶向目的地,测试用例遍地都是,但它们从不指引程序演进的正确方向。当所有外部测试的“护栏”都失效、Bug 依然在生产环境中爆发时,最终拯救系统的唯一手段仍然是开发者对代码进行逻辑推理的能力。唯有当系统保持简单、没有被过度交织时,开发者才能通过常识性逻辑断定“根据基本逻辑,Bug 绝不可能存在于这个模块,它必然在那个模块”,从而迅速排查定位。
---
[16:48](https://www.youtube.com/watch?v=SxdOUGdseq4&t=1008s) 速度假象:百米冲刺不能叠加成马拉松
许多人对追求“简单”颇有微词,抱怨思考简单性会拖慢开发进度,吹嘘借助那些“容易上手”的现有工具,自己凭借敏捷开发跑得飞快。Rich 反问:什么样的跑者能够从起跑那一瞬间开始就竭尽全力冲刺?答案显而易见:只有跑极短途赛程的短跑选手才能做到。
软件行业自以为比专业跑者更聪明,发明了一种自欺欺人的解决办法——每跑完一百米就开一次发令枪,并将其命名为一次“新冲刺”(New sprint)。然而现实是残酷的,软件开发是一场漫长的长跑:“我的观点基于实际经验:如果你忽视复杂度,你终将慢下来。从长远来看,你注定会慢下来(It's my contention based on experience that if you ignore complexity, you will slow down. You will invariably slow down over the long haul)。”
Rich 展示了一张幽默的“高度科学折线图”,坐标轴上没有任何具体数值,纯粹源自三十年的经验总结: - **聚焦于“容易”(Ease)而忽略“简单”(Simplicity)**:项目在起跑阶段确实能以最快速度狂飙,但随着时间推移,不断累积的系统复杂度最终会彻底摧毁团队。到了后期,几乎每一个 Sprint 能够交付的实质成果越来越少,团队大部分的冲刺时间都在全盘重做之前已经完成的功能,整体开发完全停滞不前。 - **起步时聚焦于“简单”**:项目初期无法达到那种狂飙的极速,因为团队必须在前置阶段进行深刻的思考,将简单性原则切实体现在架构中。但这道初期的爬坡过渡(Ramp up)一旦完成,系统将维持恒定且长久的高速演进能力。
```mermaid flowchart LR accTitle: 易用与简单在软件生命周期中的速率对比 accDescr: 展现聚焦易用导致后期停滞,与聚焦简单带来长期恒定输出的对比
subgraph EaseApproach["路径 A:只顾易用 (Ease)"] direction TB E1["起跑狂飙 (极速原型)"] --> E2["复杂度死结累积"] E2 --> E3["每个 Sprint 都在重做旧代码"] E3 --> E4["实质进度停滞"] end
subgraph SimpleApproach["路径 B:深思简单 (Simplicity)"] direction TB S1["前期爬坡 (思考与解耦)"] --> S2["构建正交简单组件"] S2 --> S3["独立变更与低调试成本"] S3 --> S4["长期持续高速前进"] end ```
---
[19:35](https://www.youtube.com/watch?v=SxdOUGdseq4&t=1175s) 织布机隐喻与“附带复杂度”的罪责
现代软件开发中充斥着大量看似极其精简、描述极短但底层极其复杂的构件。许多危险的技术在语法层面上看起来微不足道,并且非常符合面向对象编程者的既有习惯;从常规标准来看,它们既容易获取又容易上手。然而终端用户根本不在乎程序员在写代码时有多省力、有多开心,用户真正在乎的是软件运行是否稳定可靠。
如果选用这些便捷构件所产生的系统产物充满了混乱与纠缠,那么这种复杂度就是所谓的“附带复杂度”(Incidental complexity)。这种复杂度根本不是用户原始业务需求的一部分,而是开发者盲目选择了具有固有复杂度的工具后强加进来的包袱。Rich 戏谑地给出了他自己的词源解释:“附带的(Incidental)在拉丁语里就是‘你的错’(Your fault)的意思。”
开发者必须反思自己是不是在用织布机写代码:坐在机器前愉快地将梭子飞快地穿来穿去,看似产出惊人,但织机另一端吐出来的却是一团乱麻构成的“毛线城堡”(Knitted castle): - 无论这团毛线外观编织得多漂亮,一旦你想做任何局部的结构调整,整座城堡就会因牵一发而动全身而崩溃。 - 相较之下,用乐高积木搭建的城堡(Lego castle)各个构件独立正交,拆卸与重组极具弹性。 - Rich 再次质问敏捷倡导者:“拥有测试套件和重构工具,能让你修改毛线城堡的速度比修改乐高城堡更快吗?绝对不可能,这两者毫无关系。”
保持简单带来的第一层直接收益是“易于理解”(Ease of understanding)、“易于修改”和“调试极其轻松”。第二层核心收益则是前所未有的“灵活性”与“决策独立性”:由于关注点没有被交织,开发者可以把部署位置的决策与系统性能优化的决策完全隔离开来,分别进行正交决策。
---
[22:34](https://www.youtube.com/watch?v=SxdOUGdseq4&t=1354s) 认知的生理天花板:必须靠“简单”把问题拉近
如果目标不是一味哀叹软件危机,我们到底该如何让事物变“容易”(Easy)?Rich 回顾了“容易”的维度: 1. **触手可及(Location / At hand)**:将工具加入开发者的工具箱。这相对简单,执行安装即可,最多只需要说服团队管理者同意采用。 2. **熟悉程度(Familiarity)**:面对未见过的概念,通过阅读书籍、查阅教程、请人讲解以及动手实践来完成学习。
前两个维度完全掌握在开发者自己手中,我们可以持续学习更多知识。但最难克服、也最令人回避的,是人类的第三个维度——**心智能力的生理极限(Mental capability)**。
Rich 强调了一个残酷的现实:人类可以学会更多知识,但人类的大脑无法在生理上变得更聪明。我们不可能把大脑硬生生拉近复杂度的深渊,唯一的出路是通过简化事物,把事物拉回到人类大脑能够轻松处理的近处。
有人误以为世界上存在能够轻松驾驭极度复杂软件的“超级天才”,Rich 再次搬出抛球杂耍的客观规律来粉碎这种幻想:一个普通的杂耍演员可以同时抛 3 个球;全世界最顶尖的杂耍大师也许能同时抛 9 个或 12 个球,但绝对没有任何人能同时抛 20 个甚至 100 个球。面对软件系统能够轻易编织出的庞大复杂度,人类个体之间的脑力差异在统计学上几乎可以忽略不计——在应对复杂度的生理能力面前,我们所有人其实都处在同一个水平线上,那就是:我们的大脑都非常有限,都极其不擅长处理交织的事物。
[24:21](https://www.youtube.com/watch?v=SxdOUGdseq4&t=1461s) 杂耍中的多余小球:Lisp 括号的“简单”与“容易”辨析
软件开发就像在空中杂耍抛接小球,人的心智容量非常有限,能够同时兼顾的事情屈指可数。在这些球当中,究竟有多少应当属于解决问题本身的必要部分,又有多少是莫名其妙被塞进来的偶发复杂度(incidental complexity)?常常有人跑过来推销说“快用这个新工具吧”,结果转眼间又往你手里扔进几颗必须要勉强应付的新球。
以 Lisp 饱受诟病的“括号太多太难”(parens are hard)为例,这种抱怨完全是程序员主观使用体验上的反馈。初学者觉得括号难以应付,首先是因为工具不顺手(not at hand)——他们的编辑器缺少括号匹配或结构化编辑的能力,甚至装了插件却从未启用相关模式;其次是因为不熟悉(not familiar),人们虽然都见过括号,但从没见过括号居然放在方法调用的左边。Rich Hickey 强调,这两点属于用户作为学习者自身应当去克服的责任。
然而,更深层的分析在于:全由圆括号构成的语言,在客观上真的“简单”吗?答案是否定的。在 Common Lisp 和 Scheme 中,圆括号的使用方式完全被重载(overloaded)了:它们既用来包裹函数调用,又用来表示代码分组,还用来表示数据结构。按照“交织缠绕即是复杂度”的定义,这种概念重载本身就是客观存在的复杂度。Rich Hickey 指出,早期的抱怨并非完全无理,但原因在于语言设计者留下了缠绕的设计:“And it was not simple for a reason that was the fault of the language designer, which was that there was overloading.”。而解决之道并非抛弃 Lisp 的本质,而是在语言中引入向量(vector)和映射(map)等额外的数据结构来消除重载。一旦客观上的缠绕被解开,剩下的就纯粹是程序员熟悉语法与配置工具的问题了。
[27:35](https://www.youtube.com/watch?v=SxdOUGdseq4&t=1655s) 盲目追逐收益的程序员与简单/复杂工具箱
历史上曾有对 Lisp 程序员的经典讥讽,暗指他们只知概念的价值,却不知其代价——通过大量 `cons` 操作消耗内存并频繁求值,在当时受限的硬件条件下让程序运行得像头笨拙的猪。Rich Hickey 认为这句话完全可以原封不动地送给当今的技术社区。在 Hacker News 等技术论坛上,人们常常看到某个新工具就欢呼雀跃,赞叹它带来的某项优势或代码写起来多么短小,却几乎从未停下来权衡取舍:这项技术带来了什么负面代价?它有什么副产物?现代程序员往往只盯着收益,却对伴随而来的复杂性代价视而不见。
为此,Rich Hickey 罗列了工具箱中常见概念的对比清单,左侧是产生交织的“复杂(Complexity)”,右侧则是解耦独立的“更简单(Simplicity)”。他澄清自己并没有直接打上“好与坏”的道德标签,而是留给听众自行评判,但两者的结构性差异极为鲜明:
| 复杂(Complexity) | 简单(Simplicity) | 简要说明 | |:--- |:--- |:--- | | **状态与对象** (State & Objects) | **值** (Values) | 状态交织了时间与值,而纯粹的值完全不可变且独立。 | | **方法** (Methods) | **函数与命名空间** (Functions & Namespaces) | 类和方法往往构成了极其局促狭隘的迷你命名空间。 | | **变量** (Vars / Variables) | **托管引用** (Managed references) | 显式分离身份与状态演进,减少不受控的就地修改。 | | **继承 / 条件分支 / 模式匹配** (Inheritance / Switch / Pattern matching) | **按需多态** (Polymorphism à la carte) | 避免将类型层级与调度逻辑强行捆绑在一起。 | | **语法** (Syntax) | **纯数据** (Data) | 数据结构透明且易于自省,无需复杂的 AST 语法解析包裹。 | | **命令式循环 / Fold** (Imperative loops / Fold) | **集合函数** (Set functions) | 循环和甚至高级的 fold 仍绑定了迭代顺序或结构,集合操作更声明式。 | | **Actor 模型** (Actors) | **队列** (Queues) | Actor 常常将处理逻辑、状态与通信机制交织,队列职责更单一。 | | **ORM** (对象关系映射) | **声明式数据操作** (Declarative data manipulation) | ORM 试图强行弥合对象与关系模型,带来无穷伪抽象。 | | **最终一致性** (Eventual consistency) | **一致性** (Consistency) | 不一致性在概念上迫使人同时思考分散各处的状态,极其烧脑。 | | **条件判断** (Conditionals) | **规则引擎** (Rules) | 条件分支将流程与判定强耦合,规则逻辑则更平铺可组合。 |
Rich Hickey 提醒大家牢记“简单”的本义是“不缠绕、不扭结”,绝不能把它偷换成“我已经理解它的含义”:“Simple does not mean 'I already know what it means.'”
[31:43](https://www.youtube.com/watch?v=SxdOUGdseq4&t=1903s) Complect:将事物编织缠绕的原罪
为了精准表达软件是如何被一步步搞砸的,Rich Hickey 引入了一个古英语词汇——“complect”。它代表将原本独立的条带互相编织(braid)、穿插缠绕(entwine)在一起。他直言不讳地指出,大家不需要用温和中性的词,因为 complect 本身就带着天然的负面色彩:“Complect is obviously bad. Right? It happens to be an archaic word, but you know, there's no rules that say you can't start using them again.”
复杂度正是在不断 complect 的过程中滋生出来的。从物理结构上看,如果拿出四根笔直垂落的布条,每一根清晰明了,一眼就能看懂;但只要有人将它们互相交错编织成麻花,虽然底层的布条数量和质地没有发生任何改变,最终却变成了一个令人头痛的死结。编程也是同样的道理:同一套业务功能,可以用四行清晰平铺、互不缠绕的解耦代码实现;也可以用另一种语言或糟糕的抽象构架,生生将其绞成一团谁也理不清的乱麻。
```mermaid flowchart LR accTitle: Complect versus Compose accDescr: Visualizing the difference between complecting (braiding together) and composing (placing together side by side). subgraph S1["Complect(编织缠绕 - 复杂)"] direction TB A1["逻辑 A"] --- B1["逻辑 B"] B1 --- C1["逻辑 C"] C1 --- A1 end subgraph S2["Compose(并置组合 - 简单)"] direction TB A2["独立模块 A"] B2["独立模块 B"] C2["独立模块 C"] A2 -.->|"清晰协议连接"| B2 B2 -.->|"清晰协议连接"| C2 end ```
[33:08](https://www.youtube.com/watch?v=SxdOUGdseq4&t=1988s) 模块化的谎言:代码组织不等于系统简单
软件工程界长久以来存在一个共识:我们要构建可组合(composable)的系统。词源上,“compose”仅仅意味着“放置在一起”(to place together),通过并置简单的组件来构建健壮的软件,这个理念本身没有争议。然而,许多人由此产生了一个致命的误解,以为只要把软件做成“模块化”(modular),系统自然就变得简单了。
Rich Hickey 尖锐地反驳了这种观点。他在台上一边调侃自己是不是该讲完下台了,一边举起双手询问台下究竟有多少人见过所谓“模块化”却彼此深度缠绕的代码。两个看似完全独立的模块,可能表面上连显式函数调用都没有,暗地里却在运行逻辑上彻底绑定在一起。这就像乐高积木一样,模块化要真正起作用,关键在于组件被允许“思考”什么——组件之间绝不能去感知对方内部的具体实现,而只能依赖于极其精简、统一的抽象凸起接口。
如果组件本身是高度复杂、互相关联的,那么无论你在水平方向上如何横向切割,或者在垂直方向上做多少层分层架构(stratification),得到的都只是把一团乱麻切成好几段而已,根本无法带来任何本质上的简单性。Rich Hickey 郑重告诫听众,千万不要被优雅的代码组织形式所蒙蔽:类库看起来由很多彼此分离的类构成,调用关系似乎井井有条,可一旦拿到生产环境跑起来,才发现某个模块居然暗中假设另一个模块绝不能返回数字 17。
[35:39](https://www.youtube.com/watch?v=SxdOUGdseq4&t=2139s) 状态的代价:He-Man 式编程与时间交织
谈及有状态编程(stateful programming),Rich Hickey 澄清自己并不是站在某种纯函数式编程的高尚道德制高点上进行空洞说教,他的反思完全来自切肤之痛。他回顾了自己早年从事 C++ 开发的漫长岁月,将其戏称为充满猛男硬汉色彩的“He-Man 式状态编程”:“I did years and years, C++ you know, He-Man stateful programming. It's, it's really not fun. It's not good. It's, it's never simple.”
在程序中引入状态,其本质就是永远不可逆转地把“值”(value)与“时间”(time)给 complect(缠绕)在了一起。一旦某个变量被赋予了可变状态,你就再也无法脱离时间维度的限制去获取一个客观、纯粹的值。你此刻读到的变量,不仅受制于当下的读取时刻,还随时可能在下一个时刻被其他并发执行的指令所篡改,甚至连在真正意义上拿到一个准确的值都变成了奢望。有状态编程之所以在行业内大行其道,仅仅是因为它太容易(easy)、太贴近人们习惯性思考物理世界的直觉,但这绝不意味着它在系统设计上是简单的。
[36:28](https://www.youtube.com/watch?v=SxdOUGdseq4&t=2188s) 状态的渗透性毒害与心智负担
编程语言普遍将可变状态置于随手可得的位置,让开发者轻而易举地陷入复杂性之中。许多人以为借助面向对象的模块化封装就能万事大吉——只要把赋值语句藏在类的方法内部,外界看不见变量就算解耦。然而,Rich Hickey 指出这完全是一种自欺欺人:如果一个方法在传入完全相同的参数时,因内部状态不同而返回不同的结果,状态的复杂性就会立刻从封装的裂缝中渗透出来。只要包裹它的外层是有状态的,调用者每次提问依然会得到不同的答案。
Rich Hickey 用了一个极具画面感的比喻来形容状态的破坏力:“它就像毒药,就像把深色墨水滴进花瓶里一样,最终会蔓延渗透到每个角落。”消除这种复杂性的唯一途径,是将其严格限制在一个对外呈现纯函数式接口(True Functional Interface,即相同输入必得相同输出)的边界之内;寻常的代码组织方式与模块化手段根本无法阻挡状态的扩散。
更关键的是,状态问题经常被误认为是并发编程的专属痛点。Rich Hickey 强调这与并发无关,它关乎的是开发者理解程序运行逻辑的心智极限。即使是一个完全单线程的程序,哪怕所有单元测试全部通过、类型检查器一路绿灯,系统一旦在生产环境中崩溃,开发者仍然束手无策。如果代码里塞满了可变变量,要想重现故障,就必须完整还原客户端发生故障时那一瞬间的隐式状态,而这在现实中几乎是一件不可能轻松完成的苦差事。
- 状态的定义:每次用相同的问题去询问同一个组件,却得到了不同的答案。 - 纯函数边界:只有对外提供严格的“同输入即同输出”的构件,才能阻断状态复杂性的外溢。 - 调试的梦魇:单线程程序同样会被可变状态摧毁,其根源在于外部无法有效捕获或重现错误发生时的瞬时状态。
[38:02](https://www.youtube.com/watch?v=SxdOUGdseq4&t=2282s) 语言中的状态构造:变量、引用与时间解耦
很多新型编程语言标榜自己解决了状态问题,引入了 `var` 或引用(`ref`/`reference`)等语法机制。但在 Rich Hickey 看来,这些语法糖并没有真正让状态变简单,甚至 Clojure 自身的状态构件也谈不上从本质上简化了状态。不过,这类显式的状态声明至少带来了一大收益:它们会在状态出现时发出明确警告。在不可变性非默认的语言中,一旦开发者需要特意声明才能使用可变状态,他们写出的代码中状态总量往往会呈现数量级式的骤降,因为大多数业务场景起初根本不需要可变状态。
在众多语言机制中,Rich Hickey 尤其推崇 Clojure 和 Haskell 处理引用的方式。这两者之所以更为优越,是因为它们在概念上拆分并重新组合了“值”(Value)与“时间”(Time)。这些构件一方面提供了对时间流逝的抽象,另一方面赋予了开发者在特定时间点提取不可变“值”的能力。这种从引用中读取并带走不可变快照的能力,是通往简单性的核心路径;若缺乏这一层解耦,将可变变量到处传递只会让整个系统持续遭受状态毒害。
Rich Hickey 顺势调侃了前一天大会 Keynote 上展示的一张所谓“理想计算机内存模型”幻灯片——图里声称解引用一个内存地址就能直接还原出一个复合对象。Rich Hickey 幽默地感叹道:“我都想买一台那样的电脑了,你们谁用过?反正我买不到,我特意打电话问了苹果公司,他们说根本没有这种东西。”现实中的计算机在解引用地址时,永远只能拿到一个标量(Scalar)或者一个字(Word),没有任何机器能通过单次解引用直接还原一个复合的可变对象。正因如此,普通的变量机制彻底交织了值与时间,让开发者无法安全截取一致的数据状态。
> Rich Hickey 明确指出:“没有哪种机制能让状态变得简单,我甚至不会这么标榜 Clojure 自己的构件;在简单性的本质层面上,它们并没有把状态化繁为简。”
[39:26](https://www.youtube.com/watch?v=SxdOUGdseq4&t=2366s) 软件构造中的交织清单(Complecting)
为了厘清复杂性的根源,Rich Hickey 逐一检视了现代编程范式中常见的各种抽象构件,揭示它们如何将原本独立的概念紧紧“编织”(Complect)在一起,导致系统难以拆卸和推理:
```mermaid flowchart TD accTitle: 编程构件中的交织关系图 accDescr: 展示对象、方法、语法、继承等构件所错误捆绑交织的概念维度
subgraph OO["面向对象与代码组织"] Obj["对象 (Objects)"] -->|"交织"| C1["状态 + 身份 + 值"] Method["方法 (Methods)"] -->|"交织"| C2["函数 + 状态 + 命名空间"] Inh["继承 (Inheritance)"] -->|"交织"| C3["类型与类型之间的绑定"] end
subgraph Lang["语言表意与控制流"] Syn["语法 (Syntax)"] -->|"交织"| C4["含义 + 单向时序"] Switch["分支匹配 (Switch/Match)"] -->|"交织"| C5["执行主体与处理逻辑"] Loop["循环与折叠 (Loops/Fold)"] -->|"交织"| C6["计算目标 + 遍历步骤/方向"] end
subgraph System["系统与架构抽象"] Actor["Actor 模型"] -->|"交织"| C7["做什么 + 由谁来做"] ORM["对象关系映射 (ORM)"] -->|"极限交织"| C8["关系数据 + 内存对象图"] Cond["散落的条件分支"] -->|"交织"| C9["业务规则 + 程序组织结构"] end ```
- **对象(Objects)**:交织了状态(State)、身份(Identity)与值(Value)。这三者被杂糅在一个结构体中,开发者无法单独分离其中任何一项。 - **方法(Methods)**:交织了函数逻辑与内部状态;在 Java 等语言中,方法还与命名空间发生冲突——若子类继承的两个接口含有同名同参方法,系统便陷入混乱。 - **语法(Syntax)**:交织了含义与语序,且往往是严格单向的。Rich Hickey 赞同 Gerald Sussman 教授关于“数据优于语法”的论断,直言无论你多么迷恋某种语言的花哨语法,“它在各个方面都彻头彻尾地劣于纯粹的数据”。 - **继承(Inheritance)**:通过强行绑定将两种类型交织在一起,这在定义上就是典型的主动制造编织。 - **模式匹配与分支判断(Switching / Matching)**:在一个封闭的代码块中,硬生生交织了“谁来处理”与“具体做什么”的多组配对关系。 - **变量(Vars / Variables)**:将值与时间无法分割地绑死,导致外部无法安全读取稳定状态。 - **循环与折叠(Loops / Fold)**:普通循环交织了“做什么”与“怎么遍历”;即便是高阶抽象的 `fold`,也暗中交织了从左至右的处理顺序约束。 - **Actor 模型**:将“要执行的业务任务”与“承载该任务的执行节点/进程”强行交织在了一起。 - **对象关系映射(ORM)**:Rich Hickey 惊呼其编织程度堪称灾难,根本无法用简单的语言描述其恶劣程度。他借用数学对偶(Dual)的概念嘲讽道:如果说“值”代表一致性,那 ORM 映射出来的东西就是对偶物“Co-value”,其本质就是“不一致性”,根本没人真正需要这种糟糕的东西。 - **散落的条件语句(Conditionals)**:大量业务规则被生硬地切割并嵌在系统的各个执行角落,规则本身与程序的控制流结构完全交织。
> Rich Hickey 犀利地总结继承与语法的本质缺陷:“我不在乎你有多喜欢自己钟爱语言的语法,它在各个方面都比数据低劣得多。”
[42:54](https://www.youtube.com/watch?v=SxdOUGdseq4&t=2574s) 用更纯粹简单的工具构建同等复杂的系统
Rich Hickey 提出本次演讲希望听众带走的两大核心收获:第一是分清“Simple”(客观朴素、未编织)与“Easy”(主观便捷、随手可得);第二则是建立一种信心——我们完全可以用极其简单、朴素的工具,构建出与现有重度复杂工具功能完全等价的大型系统。Rich Hickey 回顾了自己数十年的职业生涯,他曾深度使用 C++、Java 和 C# 开发过规模庞大的系统,因此深知那些面向对象机制的繁文缛节绝非必需。摆脱那些语言构件附带的泥沼杂质后,开发者才能把精力彻底聚焦在系统“应该做什么”这一本质目标上。
为了迈向简单的软件工程实践,Rich Hickey 梳理了一份由繁入简的替代清单:
| 制造交织的复杂工具 | 朴素纯粹的简单替代方案 | 替代方案的核心优势 | |:--- |:--- |:--- | | 可变变量 / 对象状态 | 不可变值(Values)与持久化集合(Persistent Collections) | 大多数语言支持 `final` 或 `val`;不可变聚合消除时间与状态绑死的问题 | | 有状态的类方法 | 纯函数(Functions) | 纯粹的无状态逻辑单元(Stateless Methods),相同输入必得相同输出 | | 充血领域模型 / 嵌套类 | 纯数据(Maps、Sets、Sequences) | 数据的本质分类极少,无需为特定业务凭空发明几十万种无关本质的变体类 | | 类继承多态 / 接口绑定 | 自由组合的多态(Polymorphism à la carte) | 类似 Clojure Protocols 或 Haskell Type Classes,将数据结构、函数集与绑定动作三者解耦 | | 紧密绑定的 RPC / 命令行文本 | 数据驱动的通信与队列(Queues) | 告别 Unix 那种依赖文本解析的命令行字符串拼接,统一采用结构化数据通信 | | 散落在代码中的条件嵌套 | 声明式数据操作(SQL、LINQ、Datalog)与规则引擎 | 将决策规则与业务流转从宿主语言结构中剥离,集中由规则系统或事务处理 |
Rich Hickey 语重心长地呼吁:“程序员们,按理说我们写的是‘数据处理程序’,可看看现在的系统,里面根本没有真正的数据!”充斥系统的是层层包裹在数据之外的繁杂对象与类包装。实际上,纯数据的形态极其精炼,无非是映射(Maps)、集合(Sets)以及线性序列(Sequential lists)。人们为了包装数据发明了成千上万种毫无本质意义的类型变体,反而极大阻碍了通用的数据操纵能力。
此外,通信层面亦是同理。Web 通信之所以进步,是因为抛弃了早年 Unix 管道中“任意字符串作为参数、输出任意字符流、全靠写解析器处理”的混乱模式。而在抽象层面,最强大的武器当属“自由组合的多态”(Polymorphism à la carte):它让数据结构的定义、函数签名契约的定义、以及两者之间的实现绑定彻底成为三个互不干扰的独立维度。虽然类似规则引擎、LINQ 或 Datalog 这种与语言深度集成的声明式方案在当下的生态中仍有门槛,但它们指明了软件架构告别复杂泥潭的正道。
> Rich Hickey 总结道:“你完全可以用大幅简化的工具构建出同等精密的系统,这意味着你将真正聚焦于系统本身应有的功能,而不是陷入所用构件衍生出的一堆烂摊子中。”
[47:22](https://www.youtube.com/watch?v=SxdOUGdseq4&t=2842s) 环境复杂性:固有复杂度的真正来源
在阐述了可以通过选择简单工具来规避的人为复杂性(Incidental Complexity)之后,Rich Hickey 话锋一转,引出了另一类开发者极难掌控且无法归咎于个人的复杂性——环境复杂性(Environmental Complexity)。
编写完成的程序最终都必须部署到实体机器上,与宿主机内的其他程序、甚至自身的各个子模块并发运行。在这一物理现实下,所有进程都在疯狂争抢共享资源:物理内存、CPU 运算周期、网络带宽与磁盘 I/O。这种竞争是实现层面无法回避的客观规律。Rich Hickey 带着调侃的语气现场幽默了一把:“这里的‘固有’(Inherent),在实现层面的语境里,其拉丁语词根的意思其实就是‘不是你的错’。”这种复杂性固然不是原始业务问题本身所固有的,但只要代码落地到物理实现空间,竞争与环境制约就会不可避免地降临。
[47:56](https://www.youtube.com/watch?v=SxdOUGdseq4&t=2876s) 策略不可组合的困境与抽象的真正含义
Rich Hickey 坦言,开发者无法理直气壮地对客户说“你想要的功能不行,因为我遇到了垃圾回收(GC)问题”,但在现实工程中,垃圾回收和硬件资源分配等底层瓶颈确实会横生枝节。虽然人们可以尝试采用硬件分片或资源隔离策略——为各个模块切分固定的内存与 CPU,但这种做法极其浪费,因为它强制进行了静态预分配,彻底抹杀了系统的动态伸缩能力。
更深层的危机在于,这类针对底层资源的控制策略根本无法组合。Rich Hickey 犀利地指出:“If everybody says I'll just size my thread pool to be the number of cores. Well, how many times can you do that in one program.” 如果系统中的每一个独立组件都自作聪明地将自己的线程池大小设定为 CPU 核心数,整个程序很快就会在资源争抢中崩溃。分散地做出这类决策非但没有让系统更简单,反而引入了极大的偶合与复杂度,因为这类决策理应由掌控全局信息的协调者在单一位置做出。随后,Rich Hickey 引用了一段名言强调:编程的本质不是敲代码,而是思考。
要设计出属于自己的简单事物,首要工作是通过“抽象”(Abstraction)来解耦。Rich Hickey 澄清了词源上的严谨定义:抽象是指“将某物抽离出来”(to draw something away),特别是抽离其实际的物理实体属性。他严厉抨击了行业内滥用该词的现象:“I do want to distinguish this from the, sometimes people use this term really grossly to just mean hiding stuff. That is not what abstraction is, and that's not going to help you in this space.” 单纯把实现细节隐藏或封装起来根本不是抽象。在系统设计中,最行之有效的心态恰恰是“我不知道,我也不想知道”(I don't know, I don't want to know)。Rich Hickey 回忆自己在讲授 C++ 课程时常把这句话挂在嘴边,以至于有位学生专门送了他一件印有 Booch 图(Booch diagram)的 T 恤,图上的每一条连线旁都印着这句名言。
```mermaid flowchart TD accTitle: 真正抽象与伪抽象的对比 accDescr: 对比真正的抽象(抽离本质与解耦)和伪抽象(仅仅隐藏细节),展示两者的后果。
subgraph TrueAbs["真正的抽象 (Abstraction)"] direction TB A1["审视物理实体与机制"] --> A2["抽离出纯粹的规格说明 (Specification)"] A2 --> A3["保持‘不想知道具体实现’的边界解耦"] end
subgraph FalseAbs["常见的伪抽象 (Information Hiding)"] direction TB B1["将复杂机制打包封装"] --> B2["隐藏具体内部字段与状态"] B2 --> B3["实质仍紧密交织 (Complected)"] end ```
---
[50:39](https://www.youtube.com/watch?v=SxdOUGdseq4&t=3039s) 简化的拆解维度:What、Who、How
为了系统化地拆解问题,Rich Hickey 推荐运用“Who、What、When、Where、Why”的新闻学五要素分析法,逐一审视设计决策。
关于“What”(做什么):这是由操作和目标构成的抽象,即用命名来定义一组操作或函数集合。无论编程语言提供的是接口(interface)、协议(protocol)还是类型类(type class),它们的核心使命都是充当规格说明(specification)。Rich Hickey 强调这些接口必须保持极其小巧: - 现代 Java 等语言中的接口往往庞大臃肿,主要原因在于缺乏联合类型(union types),导致开发者被迫将若干功能捆绑成一个大而全的接口。 - 抽象规格说明在签名中应当且仅当使用不可变的值(values)和其他抽象概念作为输入与输出。 - 最严峻的隐患是把“做什么”(What)与“怎么做”(How)交织(complect)在一起。例如在 API 中直接暴露具体类而非接口,或是在语义中暗示某种固定的求值机制(如 `fold` 操作隐式规定了顺序遍历的方式)。将两者严格剥离,才能把具体的执行策略完全甩给下游机制(如数据库引擎或逻辑求解器)。
关于“Who”(实体与组件):这指代抽象最终所关联的数据或具体实体。构建顶层组件时应当采用直接注入的形式组合子组件,避免把依赖关系写死在代码中。Rich Hickey 认为绝大多数系统中的子组件数量严重不足,开发者往往习惯把所有逻辑塞进一个单元;如果用分析法拆解出了五个小组件,这不仅不是问题,反而是巨大的设计胜利。
关于“How”(如何实现):这是真正的执行代码。实现部分应当通过语言的多态机制与上层规格说明相连接,特别是开放运行时多态(open polymorphism),它的表达力远胜于把所有逻辑写死在单个模式匹配(pattern matching)或 `switch` 分支中。Rich Hickey 警示道:“Beware of abstractions that dictate how in some subtle way, because when you do that, you're really, you're nailing the person down the line who has to do the implementation, you're tying their hands.” 实现代码本身应该尽可能成为互不干扰的独立孤岛。
---
[54:35](https://www.youtube.com/watch?v=SxdOUGdseq4&t=3275s) When、Where、Why 的解耦与“信息即数据”
在处理时间与空间(When and Where)维度时,系统中最常见的反模式是将对象直接连接:
```mermaid flowchart LR accTitle: 对象直接调用与队列解耦对比 accDescr: 模块A直接调用模块B导致时空偶合,而引入队列后彻底解除了时空交织。
subgraph DirectCall["直接连接:产生时空交织 (Complected)"] direction LR A["组件 A"] -->|"必须知道 B 的位置 (Where)<br/>必须立刻阻塞执行 (When)"| B["组件 B"] end
subgraph QueueDecoupled["队列解耦:彻底分离 When 与 Where"] direction LR C["组件 A"] -->|"写入数据"| Q[("队列 (Queue)")] Q -->|"独立拉取"| D["组件 B"] end ```
如果组件 A 在处理完输入后直接调用组件 B,A 不仅必须知道 B 的网络位置或内存地址(Where),还锁定了调用的精确时机(When)。Rich Hickey 直截了当地指出解除这种交织的利器:“Stick a queue in there, right? Queues are the way to just get rid of this problem. If you're not using queues extensively, you should be, you should right away, like right after this talk.”
关于“Why”(业务规则与策略):业务逻辑和规则往往被随意散落在应用程序各处,导致开发者无法把源码拿给客户一起审查逻辑。Rich Hickey 讽刺了那些编写纯英文测试用例以取悦客户的伪测试框架,呼吁应当使用独立的声明式系统或规则引擎,将业务策略外置化。
关于“信息”(Information):Rich Hickey 抛出了颠覆面向对象教条的论断:信息本身是极其单纯的,面向对象机制本意只是用来封装像屏幕、鼠标这类无法直接触碰的 I/O 外部硬件,根本不应该强套在纯粹的信息数据之上: - 把数据包裹在类或 ORM 中不仅扼杀了编写通用数据操作函数的能力,还会把逻辑与具体的物理表现形式深深绑定。 - 正确的做法是“将数据视为纯粹的数据”(represent data as data),直接拥抱最基础的映射(map)与集合(set),而不是每来一个新信息字段就去新建一个无谓的 Class。
对于如何简化既有的复杂遗留系统,Rich Hickey 总结其核心任务就是解开那些交缠在一起的逻辑线条(disentangling),追踪并重构每一个依赖标签。在演讲的收尾阶段,Rich Hickey 掷地有声地总结道:“The bottom line is simplicity is a choice. It's your fault if you don't have a simple system.” 系统的简单与否不是命运的偶然,而是开发者主动选择的结果。
[58:19](https://www.youtube.com/watch?v=SxdOUGdseq4&t=3499s) 复杂性文化与纠缠雷达:摆脱“容易即简单”的思维定势
软件工程行业深陷于一种根深蒂固的“复杂性文化”中。行业里的开发者不断使用那些产出物极度复杂的工具,长此以往陷入了自我强化的陈规陋习之中,难以自拔。Rich Hickey 指出,大家必须跳出这个思维定式。对于台下那些已经理解并践行这套理念、早已选用幻灯片右栏推荐技术(即简单解耦的替代方案)的听众,他希望这次演讲能够成为一套有力的论据库,帮助他们去说服身旁那些仍执迷不悟、不相信“简单优于复杂”的同行。
选择简单绝非一劳永逸,而是一个需要“时刻保持警惕”(constant vigilance)的主动抉择。许多人寄希望于护栏机制,但早前的分析已经证明,所谓的安全护栏根本无法自动带来简单性,在这方面起不到实质帮助。追求简单需要开发者建立起真正的鉴赏力与审慎态度,而多数人最大的盲区就在于直觉性地将“易用”(ease of use)等同于“简单”(simplicity)。正如 Rich Hickey 所言:“Your sensibilities about simplicity being equal to ease of use are wrong.”(你们认为简单等同于容易使用的直觉是错误的。)
要想看清本质,就必须彻底区分“简单”(未交织缠绕)与“容易”(近在手边、熟悉好用)的词源与定义。开发者必须训练并建立自己的“纠缠雷达”(entanglement radar)。当审查一段软件代码时,关键关注点不应仅仅停留在变量命名好不好听、代码外形轮廓是否优雅,或者行尾有没有漏掉分号——这些固然有其意义,但真正的功力在于一眼洞穿系统内部是否存在“complecting”(编织缠绕)。开发者的雷达必须能敏锐捕捉到原本可以彼此独立、如今却被强行绑死互联的各个部件,因为解除这种交织才是获取系统威力与自由度的根本源泉。
```mermaid flowchart TD accTitle: 复杂与简单的思维路径分歧 accDescr: 对比容易导向的复杂缠绕与简单导向的解耦构造
subgraph EasyPath["容易导向 (追求熟悉与就手)"] E1["偏好熟悉的语法与工具"] --> E2["忽视深层交织"] E2 --> E3["事物打成死结<br/>(Complecting)"] E3 --> E4["依赖辅助护栏修补"] end
subgraph SimplePath["简单导向 (培养纠缠雷达)"] S1["关注产物本身的结构"] --> S2["敏锐识别事物交织"] S2 --> S3["各自独立垂直垂挂<br/>(Untangled)"] S3 --> S4["赋予系统极高的变更能力"] end ```
[59:32](https://www.youtube.com/watch?v=SxdOUGdseq4&t=3572s) 安全网的局限性与产物优先:关注长期运行的真正构造
开发者手中掌握的所有关于可靠性的工具(例如复杂的测试套件或重型类型系统),在性质上全都属于次要手段,因为它们根本不是冲着“简单性”去的。Rich Hickey 直截了当地指出,这些保障机制完全触碰不到复杂性问题的核心:“They're safety nets, but they're nothing more than that.”(它们只是安全网,除此以外什么都不是。)如果系统的底层架构从一开始就纠缠不清,再多的安全网也无法消除复杂带来的隐患。
那么,究竟该如何让“简单”变得“容易”?答案在于做出明确的选择:选用那些能够生成简单产物(simpler artifacts)的语言构件,坚决回避那些产物极其复杂的构件。Rich Hickey 强调,评价的核心是“产物本身”,而不是“编写代码时的个人快感”(artifacts, not authoring)。在团队协作中,一旦有人为诸如“我们应该用某某花哨语法或框架”而争吵,就必须把讨论焦点纠正过来:编写代码时敲入键盘的视觉排版和主观手感完全是无关紧要的表面功夫,真正要日复一日与之共存、长期维护和承担后果的,正是那些编译与运行出来的底层产物。
- 必须分清代码编写体验(authoring)与系统运行产物(artifacts)的根本区别,产物的结构决定了维护生命周期的成本。 - 静态检查、自动化测试和类型保护机制等可靠性工具充其量只是跌落时的安全气垫,无法反向治愈设计本身的缠绕病灶。 - 构建抽象必须以简单为基石,在真正动手敲代码前投入时间在源头上将问题解构简化。
[01:00:25](https://www.youtube.com/watch?v=SxdOUGdseq4&t=3625s) 简单并非数量之争:将纠缠解开赋予系统变更的能力
在推进简化的过程中,开发者往往会遇到一个违反直觉的现象:当你把事物彻底理清、去除缠绕后,系统里的构件数量往往反而变多了。对此,Rich Hickey 澄清道:“Simplicity is not about counting, right?”(简单性绝非看构件的数量,对吧?)他用了一个极具画面感的比喻来解释构件数量与复杂度的关系:“I'd have rather have more things hanging nice, straight down, not twisted together then just a couple of things tied in a knot.”(我宁愿要更多个各自笔直向下垂挂、绝不扭结在一起的物件,也不想要仅仅两三个紧紧系成死结的物件。)
把系统部件彻底分离独立开来的最大益处,在于赋予系统应对未来变更的极致灵活性。现实中软件系统维护的最大痛点就是牵一发而动全身,而解开缠绕后,你便能随意替换、修改或扩展其中任意单一部件,而无需担忧整个系统随之坍塌。这才是拥抱“简单”所带来的核心生产力收益。
在全场演讲的最后,Rich Hickey 呼吁大家将这套反思带入日常工程实践,或者将其作为说服团队同仁走向简单主义的思维工具。在全场热烈的掌声与笑声中,他给出了最后一句意味深长、幽默锋利的警句,专门送给那些试图推销繁琐机制的人:“This is what you say when somebody tries to sell you a sophisticated type system.”(当有人试图向你兜售一套复杂的类型系统时,这就是你应该给他们的回答。)
## Notable quotes > [00:04](https://www.youtube.com/watch?v=SxdOUGdseq4&t=4s) We need to build simple systems if we want to build good systems. — Rich Hickey
> [16:48](https://www.youtube.com/watch?v=SxdOUGdseq4&t=1008s) 如果你忽视复杂度,你终将慢下来。从长远来看,你注定会慢下来。 — Rich Hickey
> [54:35](https://www.youtube.com/watch?v=SxdOUGdseq4&t=3275s) The bottom line is simplicity is a choice. It's your fault if you don't have a simple system. — Rich Hickey
> [58:19](https://www.youtube.com/watch?v=SxdOUGdseq4&t=3499s) Your sensibilities about simplicity being equal to ease of use are wrong. — Rich Hickey
> [27:35](https://www.youtube.com/watch?v=SxdOUGdseq4&t=1655s) Simple does not mean 'I already know what it means. — Rich Hickey
> [01:24](https://www.youtube.com/watch?v=SxdOUGdseq4&t=84s) So simple is actually an objective notion. — Rich Hickey
## Mentioned Rich Hickey, Strange Loop, Edsger W. Dijkstra, Gerald Jay Sussman, Clojure, Datomic, InfoQ, Haskell, Common Lisp, Scheme, Java, C++, C#, LINQ, SQL, Datalog, Apple, Hacker News
## Video description Rich Hickey, the author of Clojure and designer of Datomic, is a software developer with over 30 years of experience in various domains. Rich has worked on scheduling systems, broadcast automation, audio analysis and fingerprinting, database design, yield management, exit poll systems, and machine listening, in a variety of languages.
This keynote was given at Strange Loop 2011, and is perhaps the best known and most highly regarded of Rich's many excellent talks, ushering in a new way to think about the problems of software design and the constant fight against complexity.
The video was recorded at Strange Loop in partnership with InfoQ, who have hosted it on their site since 2011. This version (released 10 years later) is a new edit made from the original HD video and slides, restoring the slide transitions and animations as it was given in 2011.
[Source](https://www.youtube.com/watch?v=SxdOUGdseq4)