本文永久链接 – https://tonybai.com/2026/05/14/uncle-bob-esr-on-why-we-are-turning-to-go-and-rust-in-the-ai-era

大家好，我是Tony Bai。

在软件工程的浩瀚星河中，有两位堪称“活化石”级别的宗师：

一位是 Eric S. Raymond (ESR)，开源运动的先驱，那本被誉为开源圣经的《大教堂与集市》以及《Unix编程艺术(The Art of UNIX Programming)》一书均是出自他手。他是一个写了 40 年 C 语言的硬核黑客。

另一位是 Uncle Bob Martin (Bob 大叔)，敏捷宣言的签署人之一，《敏捷软件开发》、《代码整洁之道 (Clean Code)》等程序员经典书籍的作者，无数 Java 和 C# 程序员的精神导师。

这两位加起来写了快一百年代码的传奇人物，最近却在 X (Twitter) 平台上，不约而同地抛出了一个足以引发技术圈大地震的论断：

在如今这个被 AI 席卷的时代，他们双双放弃了自己曾经最擅长的语言（C 和 Java），转而全面拥抱 Go 语言，并在特定底层场景下使用 Rust。

更令人震撼的是，ESR 直接宣告了手工古法编程模式的死刑：

“手写代码的时代基本结束了（The age of hand-coding is mostly over）。现在选择编程语言的标准，已经彻底变了。”

今天，我们就来深度扒开这场顶级黑客的“赛博夜话”，看看在 AI 智能体（Agent）狂飙突进的 2026 年，我们究竟该如何重新审视和选择我们手中的“兵器”。

认知颠覆：当 AI 成为主程序员，语言的选择标准变了

我们过去是如何选择编程语言的？

语法是否优雅？生态是否繁荣？框架是否齐全？这些都是基于“人类如何高效手写代码”而设定的标准。

但 ESR 尖锐地指出，在如今我们拥有“机器朋友（Robot friends / AI）”来完成绝大部分代码生成和翻译工作的时代，这些旧标准已经失效了。

现在的核心标准只有两个：

1. 你的 AI 朋友，能不能高质量地生成这种语言的代码？
2. 生成之后，作为人类的你，能不能一眼看懂（Review）这些代码？

“如今，我使用什么计算机语言是否顺手，已经不再那么重要了，真正重要的是我正在使用的‘机器朋友’能否高质量地生成它。
同时也重要的是我能否读懂这门语言，因为我需要亲自去审查（Review）这些代码。”

在这个新标准下，那些充满了黑魔法（如各种奇葩的宏、复杂的继承体系、极度隐晦的元编程）的语言，瞬间成了灾难。因为当 AI 吐出几百行充满魔法的代码时，人类审查的“认知负荷”将是灾难性的。

宗师的抉择：为什么是 Go 和 Rust？

在这个全新的游戏规则下，两位宗师给出了他们惊人一致的答案。

Bob 大叔的 Go 语言初体验：快、无聊、但完美契合 AI

Bob 大叔在评论区透露，他正在设计一门关于“使用 Agent 进行软件工程”的在线课程。

“在过去，我会选择像 Java、C# 或 JavaScript 这样流行的语言来做课程。但这次我选择了 Go。不是因为它流行，而是因为它很快（Fast）。我的学生们不会花太多精力去钻研 Go 的语法细节，但他们会看到 Go 的表现。”

Go 语言那常被诟病的“啰嗦”和“无聊”，在 AI 时代反而成了最强大的护城河。

因为 Go 的语法极度收敛，没有隐式类型转换，没有复杂的泛型继承。当 AI 生成一段 Go 代码时，那满屏极其直白的 if err != nil，让人类工程师一眼就能看穿它的逻辑底裤。在审查 AI 代码时，没有魔法，就是最高的生产力。

ESR 的决断：别了，我写了 40 年的 C 语言

ESR 的话更具传奇色彩和悲壮感：

“我可能再也不会用 C 语言开新项目了。那除了自虐还有什么意义？我花了 40 年写 C，我非常精通。但我会毫不留恋地把它，连同它的缓冲区溢出、堆破坏、未定义行为和可移植性问题，全部抛在脑后。”

他现在的探索性编程，全部交给了 Python 或 Go。

“我的机器朋友在生成这两种语言的代码时都非常出色。我认为它们在生成 Go 代码时的表现甚至略胜一筹，这可能是因为 Go 语言拥有更小的表面积（smaller surface）。”

(注：Smaller surface 意味着语法简单，AI 预测下一个 Token 时的歧义和错误率极低)

至于 Rust，ESR 将其定位为“终极的降落场”。

当他需要极其坚固的内存安全保证，且代码的探索期已经结束，进入严肃的生产部署阶段时，他会让 AI 把代码翻译成 Rust。

“Rust 满足了我的要求——我发现它写起来很麻烦，但读起来基本没问题。”

时代的阵痛：被 AI 降维打击的传统生态

这场讨论，不仅是对 Go 和 Rust 的赞歌，更是对一些传统“大厂语言”的残酷揭底。

ESR 毫不客气地吐槽了 Python 曾经的混乱（尽管它现在有了类型提示和 uv 等现代工具，情况有所好转）：

“Python 曾是我的最爱，但在 Python 2 到 Python 3 的灾难性过渡、GIL 导致的并发地狱、以及包管理的混乱之后，我曾对它感到厌倦……如果我现在要写一个比 Python 粘合脚本大得多的东西，我只会耸耸肩，然后直接去用 Go。”

在推特的评论区，另一位开发者的一句话，道出了更多人的心声：

“Go 代码的质量，很大程度上是因为 Go 语言本身往往倾向于极高的质量（因为缺乏炫技的空间）。所以 AI 生成的代码，也顺理成章地继承了这种高质量。”

当一门语言为了迎合人类的“偷懒”和“炫技”而变得越来越复杂时（比如不断叠加新特性的 C++ 和 Java），它在 AI 时代反而会成为一种累赘。

因为 AI 不需要语法糖，AI 需要的是绝对的清晰和确定性。

反思：从“写手”到“审查员”的身份跃迁

两位古灰级黑客的这番言论，给所有还在为了“哪种语言的特性更酷炫”而争得面红耳赤的年轻程序员，狠狠地上了一课。

时代的列车已经呼啸而过。

当代码生成不再是瓶颈，软件工程师的核心价值，正在不可逆转地从“Writer（编写者）”向“Reader & Reviewer（阅读者与审查者）”迁移。

在这个新时代，我们评估一项技术的眼光必须升级：

1. 可审计性（Auditability）大于一切：如果一段代码极其简洁但难以调试，它就是垃圾。Go 语言的“直白”，在 AI 时代成为了最顶级的安全感。
2. 安全性的底座转移：像 Rust 这样通过极其严苛的编译器来保证内存安全的语言，将成为 AI 时代最可靠的“数字基础设施钢筋”。你可能不需要手写它，但你的 Agent 会为你生成它，并由编译器确保它不会在半夜崩溃。
3. 拥抱“机器思维”：放下程序员的“文人相轻”，接受那些对机器友好、对审查友好的“无聊技术”。

小结：向宗师致敬，向未来前行

如果连写了 40 年 C 语言的 Eric S. Raymond，和开创了现代软件工程思维的 Uncle Bob，都能毫不犹豫地放下过去的骄傲，全身心地拥抱 AI、Go 和 Rust。

我们这些普通开发者，还有什么理由紧抱着那些陈旧的“鄙视链”不放呢？

手写代码的时代正在落幕，但软件工程的黄金时代，才刚刚开始。

用 Go 来快速验证和构建业务，用 Rust 来打造坚不可摧的底层，让 AI 成为那个不知疲倦的打字员。这，就是顶级黑客们为我们指明的 2026 年生存法则。

资料链接：https://x.com/esrtweet/status/2054288478750597593

今日互动探讨：

连 Bob 大叔和 ESR 都倒戈了！你同意他们“手写代码时代已结束”、“更看重代码审查的可读性”的观点吗？在日常的 AI 辅助编程中，你觉得哪种语言的体验最好？

欢迎在评论区分享你的看法！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/11/go-vs-rust-backend-architecture-the-2026-strategy

大家好，我是Tony Bai。

如果你经常逛各大技术社区，你一定会发现一个永远充满火药味的话题：Go 和 Rust，到底谁才是未来的后端霸主？

两派的支持者常常吵得不可开交。Go 开发者嘲笑 Rust 编译器像个严厉的教导主任，写个代码能让人掉光头发；Rust 开发者则鄙视 Go 的 GC（垃圾回收）带来的延迟毛刺，觉得它就是个“性能玩具”。

但在真实的商业战场上，这种“非黑即白”的零和博弈毫无意义。

最近，海外技术团队 CodeStax.Ai 发表了一篇文章，题目非常霸气：《Rust vs Go：2026 年唯一有意义的后端语言对决》。

这篇文章没有去纠结语法的优劣，而是直接从企业成本、团队扩张、以及系统演进的宏观视角，给出了一个极具颠覆性，却又务实到令人拍案叫绝的架构结论：

“用 Go 来构建（Build）系统，用 Rust 来优化（Optimize）系统。”

今天，我们就来拆解这套现代后端的终极生存哲学，看看顶级的架构师们，是如何在这对“冰与火”的语言中找到完美平衡的。

无情的现实：每一个后端系统，最终都会撞上“那堵墙”

在讲语言之前，我们必须先认清系统演进的残酷规律。

当你刚刚启动一个新项目时，一切都很美好。

你用微服务框架快速拉起几个 API，部署到 AWS 的容器服务（ECS）里，挂上消息队列（SQS）。一切都运转良好：接口响应很快，团队每个星期都能迭代新功能，老板很开心，每月的云服务器账单也完全在可控范围内。

直到有一天，增长（Growth）发生了。

流量呈指数级上升。突然之间，原本平稳的系统开始出现各种诡异的症状：

• 系统的内存占用越来越大，云账单的增长速度开始远远超过业务的增长速度。
• 在毫无征兆的流量高峰期，API 出现了莫名其妙的延迟毛刺（Latency Spikes）。
• 微小的性能低下，在每天几亿次的调用中，被复利放大成了拖垮整个集群的致命瓶颈。

这就是所有后端系统迟早都会撞上的“那堵墙（The Wall）”。

当撞墙的那一刻，老板问你的问题，将不再是：“我们最快多久能把这个功能做出来？”

而是变成了极其致命的灵魂拷问：

“我们如何在不拖慢业务团队开发速度的前提下，让这个庞大的系统保持稳定、高效，并且把那该死的云账单降下来？”

正是在这堵墙面前，Go 和 Rust 的选择，才真正具有了生死攸关的意义。

Go 的主场：敏捷与编排的绝对王者

在跨越“那堵墙”之前的大部分时间里，以及在墙外 80% 的业务场景中，Go 语言是毫无争议的默认王者。

为什么？因为现代的后端架构，本质上不再是写一个庞大的单体应用，而是在做“服务编排（Orchestration）”。

你需要一个 API 网关来接收请求，需要一个个微服务去读写数据库（RDS），需要 Worker 去消费消息队列（Kafka），还需要后台的定时任务去跑批处理。

这些错综复杂的分布式场景，对语言的要求出奇的一致：

• 启动要极快：为了适应容器和 Serverless（Lambda）的弹性伸缩。
• 并发要极简：遇到高并发？随手 go func() 就能轻松应对 SQS 消费和扇出（Fan-out）模型。
• 心智负担要极低：代码必须像白开水一样直白。今天刚入职的应届生，明天就能看懂并修改跑了三年的核心代码。

Go 语言完美地满足了这一切。它的设计哲学就是：“天下武功，唯快不破；保持简单，拒绝炫技。”

在 Go 的世界里，开发者的个人时间，永远比 CPU 的计算时间更昂贵。它用“相对够用”的性能，换取了团队极高的迭代速度和代码的一致性。

这就是为什么，Go 语言统治了业务服务的“编排层（Orchestration Layer）”。

Rust 的拔剑：在深水区里，手撕性能瓶颈

然而，当你的系统撞上“那堵墙”，当系统中某些特定的组件，变成了吞噬资源的黑洞时，Go 语言的 GC（垃圾回收）和相对粗放的内存管理，就会显得力不从心。

这个时候，就是 Rust 拔剑出鞘的时刻。

Rust 不适合用来写那些三天两头变需求的业务 CRUD 接口，它真正的主战场，是系统里那些承担“重体力劳动（Heavy-lifting components）”的深水区：

• 高吞吐量的消息处理器：比如每天要吞吐数百亿条记录的 Kafka 消费者集群。
• 实时流处理和欺诈检测引擎：在这些场景下，哪怕是几十毫秒的 GC 停顿，都会导致不可估量的经济损失。
• 成本敏感的边缘计算（Edge Compute）：在资源极其受限的环境中榨干最后一滴 CPU 性能。

在这些领域，Rust 的设计哲学展现出了降维打击般的威力：“控制所有重要的事情。”

Rust 假设：线上的 Bug 是极其昂贵的；规模化后的性能低下是致命的。因此，它用极其严苛的编译器，强迫你在写代码的阶段就解决掉所有可能的内存泄漏和并发竞争。

它没有 GC，内存效率极高。在 CPU 密集型的任务中，它通常比 Go 快 2 到 5 倍。

终极兵法：双剑合璧的实战演练

聪明的架构师早就看透了：我们不需要在 Go 和 Rust 之间二选一，我们需要的是将它们各自部署在正确的战线上。

在真实的硅谷大厂和独角兽公司中，最经典的架构模式已经浮出水面：

Pattern 1：用 Go 写服务层，用 Rust 写热点路径（Hot Path）

• 让 Go 去处理绝大多数的 API 路由、微服务间通信和业务编排。这保证了团队的开发速度。
• 一旦监控发现某个模块成了 CPU 或内存的瓶颈（比如音视频转码、核心推荐算法），立刻将其剥离，用 Rust 重写，作为一个独立的高性能微服务被 Go 调用。这种“好钢用在刀刃上”的策略，避免了过度工程化。

Pattern 2：为成本和延迟而战

• 当你的 AWS ECS 集群因为某个 Go 写的聚合管道而不断扩容，云账单即将失控时；或者当你的金融系统要求绝对可预测的执行时间，不能容忍任何 GC 暂停时。
• 毫无犹豫地让 Rust 进场接管。它省下的机器成本，足以支付重写代码的代价。

小结：别为了追求“最好”，而忘记了“为什么出发”

最后，我想分享一下我最喜欢的一段话：

“在这个世界上，你永远无法通过选择一门‘最好的语言’来赢得战争。”

“你赢得战争的方式是：深刻理解你的系统会在哪里崩溃；知道哪种工具能精准地解决那个特定的问题；并且，只有在确实能带来巨大回报的地方，才引入复杂性。”

如果你的系统还在为了活下去而疯狂堆功能，请闭上眼睛，用 Go 语言全力冲刺。

如果你的系统已经庞大到每次发版都在流血，每多消耗 1MB 内存都在烧钱，那么，请翻开 Rust 的手册。

用 Go 来构建你的商业帝国，用 Rust 来捍卫它的边界。

这，才是 2026 年，一个成熟架构师应有的顶级大局观。

资料链接：https://codestax.medium.com/rust-vs-go-the-only-backend-language-comparison-that-actually-matters-in-2026-6b8303dbb7c2

今日互动探讨：

在你的公司里，是否也遇到了系统“撞墙”的时刻？你们目前是如何解决性能瓶颈的？有没有考虑过，或者正在尝试引入 Rust 来重写核心的 Go 模块？

欢迎在评论区分享你的实战经验与踩坑血泪史！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/10/scaling-uber-with-thuan-pham

大家好，我是Tony Bai。

在硅谷的黄金时代，曾有一家公司以一种近乎“暴力”的美学，重新定义了增长的速度。它的名字叫 Uber。

在最癫狂的岁月里，它以“周”为单位攻占新的城市，用海量的资本和补贴点燃市场，其业务增长曲线陡峭得如同悬崖峭壁。

但在这场增长的狂欢之下，是一套摇摇欲坠、濒临崩溃的技术系统。

2013 年，当 Tuan Pham（后来被称为 Uber 的“救火队长”）加入时，这家拥有 40 名工程师的公司，系统每周都会崩溃数次。而他面临的第一个挑战，就是公司的核心派单系统，只剩下 5 个月的寿命。

近日，这位传奇 CTO 接受了一次深度访谈。他不仅首次揭秘了当年与创始人 Travis Kalanick (以下称TK) 长达 30 小时的“魔鬼面试”，更详细复盘了 Uber 是如何在失控的边缘，被迫走上那条被全网群嘲、却又别无选择的 “5000 微服务” 之路。

今天，就让我们跟随 Tuan 的视角，重返那个硝烟弥漫的战场。

从船民到 MIT：一段关于生存的开端

Tuan Pham 的人生开局，堪称地狱模式。

他出生于越南，是战争的亲历者。1975 年后，由于家庭背景，他和家人被迫成为“越南船民”，挤在破旧的渔船上，冒着不足 50% 的生还率，在深夜逃离故土。

在海上漂泊了四天三夜，躲过风暴和海盗，他们最终在马来西亚登陆，却又被拖回大海，最终被印尼的一个荒岛收留。

一年后，他们以难民身份来到美国。身无分文，不懂英语，第一套衣服来自教堂的捐赠衣橱。

“生存”，是刻在他骨子里的第一性原理。

和很多技术天才一样，Tuan 在数学上展现了过人的天赋。高中时，他靠着一台有两个软盘的 IBM PC 自学了编程，甚至用脚本语言帮政府机构把需要 3 周才能完成的财务对账工作，压缩到了 3 小时。

凭借着优异的成绩和推荐信，他被 MIT 录取，正式开启了他的计算机科学之旅。

血泪的教训：两场失败，塑造了 Uber 的基因

在加入 Uber 之前，Tuan 的职业生涯并非一帆风顺。但正是这些宝贵的“失败”，让他积累了足以驾驭 Uber 这头巨兽的认知。

第一场失败，在 SGI（硅谷图形公司）。

上世纪 90 年代，他参与了一个极其超前的项目——交互式电视。在那个连手机和互联网都还没普及的年代，他们已经实现了“视频点播、在线购物”。斯皮尔伯格、迈克尔·杰克逊都来参观过。但这个项目最终惨败，因为机顶盒的成本高达 4.5 万美元。这让他得到一条教训：光有伟大的技术没用，你必须在正确的时间、以正确的价格，出现在正确的市场。

第二场失败，在 NetGravity（一家互联网广告公司）。

他们发明了动态广告系统，并成功上市。但另一家比他们晚成立的公司，靠着更轻量的“广告服务（Ad Service）”模式，野蛮生长，最终被 Google 收购。而他们，因为董事会要求“优先盈利”，错失了市场。这让他得到了另外一条教训：当市场窗口期出现时，增长速度压倒一切，哪怕是以亏损为代价。

这两条从真金白银和血泪中总结出的铁律，仿佛就是为日后的 Uber 量身定制的。

30小时的“魔鬼面试”：与 TK 的灵魂拷问

离开 VMware 后，Tuan 并未主动寻找工作。是 Benchmark 的传奇投资人 Bill Gurley（也是 Uber 的早期投资人）找到了他。Bill Gurley 认识 Tuan，源于十几年前那家失败的广告公司。

Tuan 在访谈中反复强调一个观点：

“我从不刻意经营人脉。你只需要把你手头的每一份工作做到极致，真诚地对待你身边的每一个人。随着时间推移，你的声誉会为你打开所有的大门。”

当他见到 Uber 的创始人 Travis Kalanick (TK) 时，一场长达 30 小时、横跨两周的马拉松式面试开始了。

TK 在白板上写下了密密麻麻的清单：从招聘开除、到代码质量、再到团队文化……他们每天 Skype 两小时，一个一个地辩论。

Tuan 回忆道，那根本不像面试，更像是两个合伙人在激烈地碰撞思想。有一次，聊到一半 TK 要赶飞机，他直接拿起电话让助理改签，然后继续辩论。

T.K. 对技术细节的痴迷，和近乎偏执的激情，让 Tuan 意识到，这是一个将技术视为公司命脉的创始人。

面试的最后，Tuan 发现，这 30 小时其实是一场“模拟工作”。TK 在用最高成本的方式，去观察当他们意见相左时，是否还能有效地沟通、并最终达成共识。

微服务之殇：我们根本不想搞 5000 个微服务！

Tuan 加入 Uber 时，公司只有 40 个工程师，但系统每周都会宕机数次。整个后端是一个巨大的单体应用，派单系统是用单线程的 Node.js 写的。为了扩容，工程师们只能不断地把程序挪到 CPU 更快的机器上（垂直扩容）。

Tuan 问团队：“如果最快的 CPU 也扛不住了怎么办？”

工程师说：“那就换一个有多颗 CPU 的机器。”

Tuan 再问：“那这些进程之间怎么共享状态？”

团队沉默了。

Tuan 迅速算出，当时最大的城市纽约，将在 5 个月后彻底冲垮派单系统的物理上限。

重写，是唯一的活路。

他只提了两个要求：1. 一个城市必须能被多台机器支撑；2. 一台机器必须能支撑多个城市。 没有新功能，只要活下去。

最终，团队在 8 月份惊险上线了新系统，暂时续上了命。

但真正的噩梦，来自那个名为 API 的巨型单体应用。随着业务的爆炸式增长（UberX 上线、新城市扩张），这个单体应用成了所有团队的瓶颈。任何一个新功能，都可能要排队等好几个团队的开发资源。

为了活下去，Tuan 和 TK 做出了那个后来被全行业“群嘲”的决定：

“任何新功能，一律不许再往单体里加！必须作为独立的服务（Microservice）去开发。”

同时，成立一个专门的团队，去把旧的单体应用一块块“拆骨”。

这个拆骨项目，代号“达尔文（Darwin）”。Tuan 苦笑道，如果时间静止，这个项目 3-6 个月就能搞定。但他们花了整整两年。

因为在他们拆解的同时，业务的增长速度比他们拆解的速度还要快！新功能被疯狂地加回到那个正在被拆的单体里。

“当你把一块代码剥离出去后，剩下的部分因为业务增长，变得比你剥离出去的还要大。我们就像在追着自己的尾巴跑。”

5000 个微服务，不是一个被精心设计出来的架构蓝图。它是在极端增长压力下，为了让几百个工程师能够并行开发、不互相阻塞，而被迫做出的“最不坏”的选择。

这是 Uber 用每年几亿美元的服务器成本，换来的开发速度。

中国速度：两个月，拿下中国市场

在 Uber 的历史上，最能体现这种“速度压倒一切”文化的，莫过于 2014 年底的“中国闪击战”。

圣诞节前，TK 宣布：新年过后，Uber 要全面进军中国。他给了 Tuan 两个月的时间，在中国本土，从零开始搭建一套完整的、物理隔离的数据中心。

Tuan 的工程团队评估后，给出的最快时间是 6 个月。他在湾区的朋友们听说后，都嘲笑他疯了：“没有 18 个月根本不可能。”

TK 不接受，最终两人“折中”到了 4 个月。

4 个月后，项目延期了。TK 很不爽。

5 个月后，项目再次延期。TK 暴怒。

Tuan 对 TK 承诺，再给一个月，但必须允许他们“分阶段上线”，而不是一次性点亮所有城市。

TK 同意了，但提了一个极其苛刻的条件：第一个上线的，必须是当时业务量最大的城市——成都。

Tuan 在访谈中回忆道，这在当时看来简直是自杀，但事后回想，这是 TK 做出的最天才的决定。

“当你把最硬的骨头啃下来之后，剩下的就全是下坡路了。整个团队的士气和信心都被拉满了。”

最终，他们真的做到了。IT 团队在两周内完成了服务器的跨国部署，软件团队在无数个通宵后，让代码在中美两地同时跑了起来。

没有人认为这能成功，但它就是成功了。 这就是 Uber 当时的魔力。

小结：AI 时代的生存法则

在访谈的最后，Tuan 聊到了如今最火热的 AI 编程。

他所在的新公司 FAIR，已经开始使用 Agent Swarm（智能体集群） 来辅助开发。他发现，顶级的工程师在使用 AI 后，产出能翻倍。

当被问及“AI 时代，如何区分优秀与平庸的工程师”时，Tuan 的回答，与他在 Uber 血战时总结出的经验如出一辙：

“好奇心、无畏、愿意尝试新事物、敢于打破常规。这些特质，在过去能让你脱颖而出，在今天，同样能让你成为驾驭 AI 的顶级玩家。平庸的人把 AI 当拐杖，而优秀的人把 AI 当作火箭推进器。”

从越南船民到硅谷之巅，Tuan Pham 的一生，就是一部关于“在混乱中寻找秩序，在极限压力下野蛮生长”的史诗。

Uber 的故事或许不可复制，但它留给我们的思考，远未结束。

在技术的世界里，从来没有完美的架构，只有与业务增长阶段相匹配的、充满妥协与权衡的草台班子。

而我们作为工程师的终极使命，就是在这个草台班子上，用最快的速度，把它搭成别人眼中坚不可摧的罗马。

今日互动探讨：

看完 Uber 的故事，你觉得在你的公司里，是应该优先选择“技术正确”的完美架构，还是“能快速上线”的野路子？你对微服务和单体架构有什么切身体会？

欢迎在评论区分享你的看法！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将>带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

你的Go技能，是否也卡在了“熟练”到“精通”的瓶颈期？

• 想写出更地道、更健壮的Go代码，却总在细节上踩坑？
• 渴望提升软件设计能力，驾驭复杂Go项目却缺乏章法？
• 想打造生产级的Go服务，却在工程化实践中屡屡受挫？

继《Go语言第一课》后，我的《Go语言进阶课》终于在极客时间与大家见面了！

我的全新极客时间专栏 《Tony Bai·Go语言进阶课》就是为这样的你量身打造！30+讲硬核内容，带你夯实语法认知，提升设计思维，锻造工程实践能力，更有实战项目串讲。

目标只有一个：助你完成从“Go熟练工”到“Go专家”的蜕变！ 现在就加入，让你的Go技能再上一个新台阶！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/09/cli-printing-press-intro

大家好，我是Tony Bai。

近日，一个名叫 cli-printing-press 的开源项目冲上了 X.com 热搜。它用 Go 写成，解决的是 AI Agent 时代最隐秘、也最致命的痛点——工具不够用，更不好用。

先说一个反常识的故事

Discord 有 300 多个官方 API 端点。

按常理，一个覆盖所有端点的 CLI 工具，应该是最好用的那个。但事实恰恰相反。

OpenClaw 之父 Peter Steinberger 用 Go 写了一个叫 discrawl 的工具，只提供 11 个命令：sync、search、sql、tail、mentions、members……就这些。结果？700多 颗 GitHub Star，社区口口相传，被无数 AI Agent 开发者列为必装工具。

为什么一个”阉割版”打败了”全功能版”？

因为 Steinberger 看到了 Discord API 设计者自己都没意识到的东西：聊天记录不只是聊天，它是一个组织的知识库。

每一条消息线程，本质上都是一份可以被归档、被索引、被本地全文搜索的文档。那 11 个命令，围绕的就是这个洞察。300 个端点包装器，做不到这一点。

CLI Printing Press，就是一台把这种洞察自动化的“机器”。

AI Agent 的”工具饥渴”时代

在聊这个工具之前，我们需要先理解 2026 年的 AI 开发现状。

Claude Code、Codex、OpenClaw、Gemini CLI等 AI Agent 的能力已经突飞猛进。它们可以写代码、查数据、做分析、自主决策。但有一个瓶颈正在成为所有人的噩梦：现有的 CLI 工具，根本不是为 Agent 设计的。

想象一下 Agent 在调用一个普通 CLI 时会遇到什么：

• 输出格式不稳定，有时是表格，有时是纯文本，Agent 根本无法可靠地解析；
• 没有类型化退出码，出了错要去解析 stderr 的文字才能知道是认证失败还是网络超时；
• 每次查询都要远程 API 调用，一个复合问题需要十几次 round-trip，token 哗哗地烧；
• 遇到没有公开 API 文档的网站（比如 ESPN、Google Flights），完全束手无策。

CLI Printing Press 项目 README 开篇就把这个痛点说得很直白：“在 AI Agent 的世界里，没有什么比时间和金钱更宝贵——落到工程层面，就是速度和 token 消耗。一个设计优良的 CLI 是 Agent 的肌肉记忆：不用翻文档，不走弯路，不浪费 token。”

CLI Printing Press，就是为了解决这个问题而生的。

它到底是什么？

用一句话描述：

CLI Printing Press 是一台 CLI 工厂。给它一个 API 地址（或者任意一个网站），它输出一个专门为 AI Agent 设计的 Go CLI 工具 + MCP 服务器 + Claude Code Skill。

安装方式极其简单（Go需要>=1.26版本）：

# 安装工厂本体
go install github.com/mvanhorn/cli-printing-press/v4/cmd/printing-press@latest

# 克隆技能文件（配合 Claude Code 使用）
git clone https://github.com/mvanhorn/cli-printing-press.git

# 在 Claude Code 中启动，直接加载skill
claude --plugin-dir .

然后在 Claude Code 中，一条命令就能启动生产流程：

/printing-press Notion          # 给 Notion API 生成 CLI
/printing-press https://espn.com/nba  # 直接指向网站，无需 API 文档

为什么选 Go？

这是一个值得细聊的设计决策。

在这个 TypeScript、Python 等生产力语言大行其道的时代，CLI Printing Press 选择了 Go，并且坚定地把 Go 作为所有生成产物的语言。原因很现实：

第一，分发极其简单。 go install 一行命令，跨平台，无依赖。Agent 在运行时动态安装工具，最怕的就是依赖地狱。Go 的静态编译二进制文件是最优解。

第二，Go 已经被实践证明。 Peter Steinberger 用 Go 写的 gogcli（Google Workspace CLI）拥有 7000+ Star，而 Google 官方之后推出的 Rust 版本，一周冲到 1 万 Star，却在社区中败给了前者。一个用户的评价是：”我 100% 偏好 gogcli，因为它就是能让 Agent 做到它需要做的事。”广度没能打败深度，Rust 没能打败 Go。

第三，Go 的并发模型非常适合 Agent 的使用场景。 SQLite 批量事务、并发 sync worker、FTS5 全文索引……这些都是 Agent 高频调用场景下的性能关键路径，Go 处理起来得心应手。

核心机制：它如何做到的？

每个 API 都有非显见身份（Non-Obvious Insight）

这是整个项目最有哲学深度的设计。

Printing Press 在生成任何 CLI 之前，都要先找到这个 API 的”非显见洞察”（NOI），一句话的格式：

“[API] 不只是 [显而易见的功能]。它是 [非显见的东西]。每个 [数据点] 都是关于 [隐藏真相] 的信号。”

几个例子，读完你可能会有点震撼：

这个 NOI 是整个 CLI 的创意 DNA。如果 AI 在研究阶段写不出一个 NOI，说明研究深度不够，Phase 0 不会放行。

五层创造力梯子

大多数工具停在第 1 层。Printing Press 直接爬到第 5 层。

第 1 层：API 端点包装命令         ← 99% 的生成工具止步于此
第 2 层：输出格式 (--json, --csv)
第 3 层：本地持久化 (sync, search, SQLite)
第 4 层：领域分析 (stale, orphans, load)    ← discrawl 的水准
第 5 层：行为洞察 (health 综合评分, similar 重复检测)  ← 目前无人到达

第 3 层以上，才是真正的价值所在。一旦数据落在本地 SQLite，compound 查询就成为可能——这是任何无状态 API 包装器永远做不到的事情。

本地优先数据层

Printing Press 生成的每个高质量 CLI，都带有一套完整的本地数据层：

• 领域特定的 SQLite 表（不是 JSON blob，是真正的关系型结构）
• FTS5 全文搜索索引
• 带游标追踪的增量同步
• 直接 SQL 查询接口

这意味着什么？看一个 Linear 的真实 Demo：

$ /pp-linear sql 'blocked issues whose blocker hasn't moved in 7 days'

背后执行的是：

SELECT i.identifier, i.title, age(now(), b.updated_at) AS stuck
FROM issues i
JOIN issue_relations r ON r.issue_id = i.id
JOIN issues b ON b.id = r.related_issue_id
WHERE r.type = 'blocked_by'
  AND b.state = 'in_progress'
  AND b.updated_at < now() - interval '7 days';

结果：

ENG-412  Crash on cold-start        blocked 11d
ENG-388  Reconnect dropped sockets  blocked 9d
ENG-301  Backfill missing rows       blocked 8d

50 毫秒。本地完成。关键是 Linear 的官方 API 无法回答这个问题。

Agent-Native 设计哲学

这是 Printing Press 和普通 CLI 生成工具最根本的区别。每一个生成出来的 CLI，都内置了以下设计：

• 自动 JSON 输出：终端里显示人性化表格，管道传输时自动切换为 JSON，无需 –json 标志。
• –compact 模式：只返回高重力字段（id、name、status、时间戳），减少 60-80% 的 token 消耗。
• –dry-run 安全探索：让 Agent 在不执行副作用的情况下验证命令逻辑。
• 类型化退出码：

- 0 = 成功
- 2 = 用法错误
- 3 = 资源未找到
- 4 = 认证失败
- 5 = API 错误
- 7 = 速率限制

Agent 读一个退出码就知道下一步怎么做，不需要解析错误文字，自我纠正只需一次重试。

为什么 CLI 比 MCP 更适合 Agent？

CLI 的 token 消耗比 MCP tool definition 少 100 倍。LLM 本来就在 shell 交互上训练过。退出码 0 = 完成。–json | jq 是一流的组合模式。

这套设计哲学有一句精辟的总结：“Agent-native 设计，就是认真对待 CLI 设计 的结果。”

无 API 文档？浏览器嗅探搞定

ESPN 没有官方 API。Google Flights 没有公开文档。Dominos 也没有。

Printing Press 的解法：启动一个浏览器，你正常点击浏览，它在后台抓取所有 HTTP 流量，逆向工程出 API 结构，自动生成 OpenAPI spec，然后继续走后面的生成流程。

三种输入模式，覆盖所有场景：

• –spec：直接提供 OpenAPI spec 文件
• –har：DevTools 导出的 HAR 流量包
• 直接 URL：交给浏览器嗅探

工厂流水线，一次生成，双接口输出

每次运行 Printing Press，整个流程分阶段进行：

• Phase 0：解析 & 复用（1-3 分钟）
• Phase 1：研究简报 — API 身份、竞争对手、数据层、产品论点（5-10 分钟）
• Phase 1.5：生态吸收门 — 目录化每个 MCP/skill/CLI 的功能，生成吸收清单（5-10 分钟）
• Phase 1.7：浏览器嗅探门（2-5 分钟）
• Phase 2：生成 Go CLI + MCP 服务器（1-2 分钟）
• Phase 3：构建 GOAT — 吸收所有功能 + 超越命令（10-20 分钟）
• Phase 4：发货检查 — Dogfood + 验证 + 质量评分（3-8 分钟）
• Phase 5：Live Smoke Test（可选）（2-5 分钟）

Printing Press产出的不是一个，而是两个可用工具：

一个 spec 进去
  → <api>-pp-cli    Cobra CLI，供 Claude Code / Codex / shell 调用
  → <api>-pp-mcp    MCP 服务器，供 Claude Desktop / Cursor / Windsurf 使用

两者共享同一个 internal/client、同一个 internal/store、同一套认证逻辑。零代码重复，一套实现，双场景覆盖。

质量不靠玄学，靠四项机械验证

生成出来的 CLI 质量如何保证？Printing Press 用了一套两层 100 分制评分系统，加四项机械化验证。

第一层（基础设施，50分）：检查骨架是否正确——输出模式、认证流程、错误处理、Agent-Native 标志、终端 UX、README、Doctor 命令、本地缓存。

第二层（领域正确性，50分）：检查代码是否真的能跑——生成的 URL 路径是否存在于 OpenAPI spec、认证格式是否和 spec 一致、SQLite 数据管道是否正确连通、是否有死代码和悬挂函数。

Grade A = 85 分以上。两层都过，才算合格。

四项行为证明（Proof of Behavior）：

• 路径证明：所有生成的命令 URL 都存在于 OpenAPI spec
• 标志证明：所有注册的 flag 都被至少一个命令引用
• 管道证明：每个 SQLite 表都有 WRITE 路径（sync）和 READ 路径（search/query）
• 认证证明：认证头格式和 spec 的 securitySchemes 匹配

任何一项证明失败，会触发自动修复流程，重新验证。

已打印的 CLI 库：45 个开箱即用

不想自己生成？官方已经打印好了 45 个 CLI，覆盖主流场景：

• 旅行：flight-goat（Kayak + Google Flights 双数据源，一条命令搞定长途航班搜索）
• 体育：espn-pp-cli（17 个体育项目，实时比分、系列赛状态、伤病报告）
• 生产力：linear-pp-cli（50ms 复合查询）、slack-pp-cli、cal-com-pp-cli
• 电商：ebay-pp-cli（真正的狙击竞价）、craigslist-pp-cli（历史价格对比、骗局评分）
• 房产：redfin-pp-cli（内部 Stingray API 嗅探，$/sqft 净 HOA 排名）
• 美食：dominos-pp-cli（本地最优套餐叠加，这是 Dominos 官网没有的功能）

安装方式同样极简：

# 一键安装入门四件套
npx -y @mvanhorn/printing-press install starter-pack

# 安装指定工具
npx -y @mvanhorn/printing-press install espn sentry linear

两个 CLI 协同工作的真实场景

Printing Press 最打动人的地方，是多个 CLI 可以在同一个 Claude 对话中协同工作。

场景：我想去看 OKC 的季后赛，怎么买最便宜的机票？

$ /pp-espn nba okc round 2 game 1 + /pp-flightgoat sea-okc, fly-in same day

两个 CLI，一次对话：

• espn-pp-cli 拉取实时数据：OKC 刚以 131-122 赢了凤凰城，第二轮第一场预计在 5 月 9 日或 10 日
• flightgoat-pp-cli 立刻查询：西雅图飞俄克拉荷马城，当天往返
• 结果：西南航空 $437 往返，推荐 Wanna Get Away+ 可退款票，Frontier 的那班到得太晚，跳过

这不是 Demo，这是真实运行的输出。两个工具各司其职，一个 Agent 对话完成端到端决策。

写在最后：Go 为什么在 AI 时代逆袭

CLI Printing Press 的出现和走红，其实折射出一个更大的趋势。

Rust 以性能和安全著称，Python 以生态和易用性著称，但在 AI Agent 工具这个细分赛道，Go 正在悄悄胜出。原因很简单：

1. 分发成本最低：单一静态二进制，go install 一行，Agent 可以动态自安装。
2. 并发模型刚好够用：协程 + channel 处理并发 sync 任务，不过度设计。
3. SQLite 生态成熟：go-sqlite3、modernc/sqlite，本地优先架构的标准搭档。
4. 工程师接受度高：Agent 调用的工具，背后的人类也要维护，Go 的可读性是优势。

更深层的洞察是：AI Agent 需要的不是最强的工具，而是最可靠、更好用的工具。 打 5 分的输出稳定输出，胜过偶尔打 9 分但不可预测的输出。Go 的 CLI 恰恰提供了这种可靠性。

而 CLI Printing Press，把这套哲学变成了一条流水线。

如果你也在构建 AI Agent，或者正在为 Agent 寻找合适的工具层，这个项目值得花半小时认真研究一下。它解决的问题，可能比你意识到的还要根本。

参考资料

• 项目地址：github.com/mvanhorn/cli-printing-press
• 官网：printingpress.dev
• CLI 库仓库：github.com/mvanhorn/printing-press-library
• X热搜：https://x.com/i/trending/2052445800421015770

今日互动探讨：

看完这款“CLI 印刷机”，你觉得在 AI 时代，传统的 RESTful API 是否已经走到了尽头？你最想为哪个原本没有 API 的网站“打印”一个专属工具
？

欢迎在评论区分享你的脑洞！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/07/aws-guru-slams-go-concurrency-as-a-joke-vs-jvm

大家好，我是Tony Bai。

过去十年，如果要在后端技术圈选出一个“金字招牌”，那无疑是 Go 语言的并发。

凭借其极简的 go 关键字和优雅的 channel，Go 将并发编程的门槛从“博士级”拉到了“入门级”。在云原生和微服务的浪潮中，Go 几乎就是“高并发”的代名词。

但就在前几天，AWS 的资深布道师 James Ward，在 X 平台上突然向 Go 语言的这个“优势高地”发起了猛烈炮轰：

“开发者普遍认为 Go 在并发方面很出色。但事实并非如此。JVM 的方案要优越得多。当你把虚拟线程、结构化并发和 Effects 加进来时，它甚至是全行业最好的方案之一。”

为了证明自己的观点，他还引用了前 Google 工程师 Ahmetb（以其在 K8s 社区的贡献而闻名）设计的一道极其刁钻的并发编程“考题”——实现一个工业级的、线程安全的网络连接池。

这道题，像一块试金石，炸出了 Go 并发模型背后那些被“易用性”所掩盖的无数“天坑”。

这场由大神发起的“语言战争”，瞬间引爆了技术圈。从前 Uber 工程师到 Victoria Metrics 的核心开发者，无数 Gopher 下场“护驾”。

今天，我们就来复盘这场神仙打架，看看当 Go 的“平民法拉利”遭遇现代 JVM 的“德系重装甲”时，到底谁才是真正的并发之王？

战火的点燃：一道价值千金的“并发考题”

让我们先来看看点燃这场战争的导火索，Ahmetb 设计的这道“连接池”考题：

你需要实现一个线程安全的、有界连接池。
1. Acquire()：当池中无可用连接时，必须阻塞。必须响应 context 的超时和取消。
2. Release()：归还连接。如果池已满或连接已损坏，则关闭连接而不是泄漏。
3. Close()：必须干净利落地关闭整个池。停止接受新请求，立即关闭所有空闲连接，并等待所有正在被使用的连接被归还后，再关闭它们。
4. IdleTimeout：自动清理超过空闲时长的连接。

这道题，看似简单，实则布满了“杀机”。

它几乎涵盖了并发编程中所有最令人头疼的场景：资源限制、优雅启停、生命周期管理、超时与取消、后台清理……

Ahmetb 坦言：

“如果你享受 Go 的并发原语，那就挑战一下自己去实现它。这里面的边缘情况，比我最初想象的要多得多。”

而 James Ward 正是借着这道题，打出了他的第一炮：用 Go 的原生 channel 和 select 去完美地解决所有这些问题，其代码量和心智负担，将远超现代 JVM 的解决方案。

两派的交锋：Go 的“野路子” vs JVM 的“正规军”

面对 James 的炮轰，评论区迅速分裂成两大阵营。

Go 阵营（以实战派为首）的反击：

前 Uber 工程师 Ovais Tariq 现身说法：

“Go 在高并发工作负载下更优越——这是我在 Uber 运营大规模 Go 服务的实践经验。”

另一位开发者则指出了 Go 的核心优势：

“我完全同意（Go 更优）。这个工具（Go）被创造出来，就是为了无缝处理成千上万个大部分时间都在‘等待’I/O 的任务。在这个角色上，Go 至今仍然表现卓越。”

Go 阵营的核心观点是：Go 的并发模型（Goroutine + Channel），就像一把简单、锋利的匕首。它足够轻、足够快，虽然需要使用者自己具备高超的技巧，但在真实的、海量的 I/O 密集型场景下，它的实战表现就是最好的证明。

JVM 阵营（以理论派为首）的降维打击：

James Ward 则对这些“实践经验”嗤之以鼻：

“真的吗？像 Scala ZIO 这样的 Effect 调度器和虚拟线程，在安全处理非阻塞任务时，看起来比 Goroutine 要容易得多。”

JVM 阵营的核心观点是：Go 的并发原语太“低级”了。 它把所有关于取消、超时、错误传播、资源清理的复杂性，全部甩给了开发者。而现代 JVM 生态，通过虚拟线程、结构化并发（Structured Concurrency）和函数式 Effect 系统（如 ZIO, Arrow Fx），已经从语言和框架层面，为你提供了一套“三位一体”的、体系化的解决方案。

• 虚拟线程：让 JVM 拥有了和 Goroutine 一样廉价的“百万级”并发能力。
• 结构化并发：强制所有并发任务拥有清晰的父子关系和生命周期，彻底消灭“野 Goroutine”和资源泄漏。
• Effect 系统：用类型系统来管理异步任务的副作用，让并发代码像写同步代码一样清晰和安全。

这场争论的本质，是“游击队”与“正规军”的对决。Go 提供了最灵活的单兵作战武器，而 JVM 则提供了一整套陆海空协同作战的军事体系。

Go 的“平民化”哲学 vs JVM 的“专家级”哲学

在这场混乱的口水战中，Victoria Metrics 的工程师 Phuong Le 的一篇复盘长文，将整个讨论提升到了哲学的高度。

他没有去争论谁快谁慢，而是深刻地剖析了两种技术路线背后的设计哲学差异：

“Go 在并发方面并不差。一个更真实的说法是：Go 擅长让并发变得廉价、显式和易于上手，尤其是在常见的后端模式中。”

Phuong Le 指出，Go 的核心优势在于“平民化（Approachable）”。

它用极其简单的原语，让一个普通的开发者，也能快速地写出“看起来能用”的并发代码。但这种“简单”的代价是，它把大量的“正确性”责任，下放给了开发者自己。

“Go 给了你相对低级的原语。大量关于取消、任务生命周期、清理、错误传播和背压的正确性保证，都留给了我们程序员自己去处理。”

而现代 JVM 生态，则走向了另一个极端——“专家系统”。

它试图在框架和语言层面，构建一个极其复杂、但理论上绝对安全的“象牙塔”。开发者需要学习大量的概念（Monad, Functor, Fiber…），但一旦学会，就能获得极高的安全性保障。

Phuong Le 的结论是：

“所以，公平的比较不是‘Go vs JVM，谁赢？’，而是：Go 优化的是简单的、实用的并发；而现代 JVM 生态，拥有更强大的工具来处理结构化的、资源安全的并发。 到底哪个更好，取决于你面临的并发问题有多复杂。”

你的团队，需要匕首还是航母？

这场神仙打架，最终没有赢家。但它为我们所有后端架构师，提供了一次极其宝贵的“架构选型”公开课。

1. 承认 Go 的“天花板”

我们必须承认，Go 的原生并发原语，在处理极其复杂的、需要精细化资源管理的场景时，确实存在“天花板”。Ahmetb 的那道“连接池”考题，就是一个完美的试金石。如果你团队的业务复杂到这种程度，直接引入一个成熟的第三方库（或者评估 JVM 生态），可能比自己手搓 Channel 要明智得多。

2. 警惕 JVM 的“学习曲线”

虚拟线程虽然抹平了 JVM 在并发“数量”上与 Go 的差距，但结构化并发和 Effect 系统，依然是较为陡峭的学习曲线。在一个追求快速迭代、人员流动频繁的团队里，引入这些“重型武器”的培训成本和心智负担，是必须被严肃评估的。(注：不知道有多少Java开发至今也没有使用过虚拟线程)

3. “足够好”也许就是最好的

评论区里，Jacob Voytko 的观点极具代表性：

“Go 的并发原语并非在所有方面都理想，但对于终端用户（业务开发者）大多数时候写的那些东西来说，它们是完美的。管理 fan-in/fan-out、处理带超时的异步任务……对于这些 80% 的场景，Go 的‘足够好’方案已经足够了。”

小结：没有银弹，只有权衡

这场由 James Ward 发起的“Go 并发之战”，最终以一场关于“架构权衡（Trade-offs）”的深刻反思而告终。

它像一面镜子，照出了我们这个行业最真实的底色：从来没有“最好的”语言，只有“最适合的”场景。

Go 的成功，在于它用最简单的武器，解决了云原生时代最大多数的并发问题。它的哲学，是牺牲一部分理论上的“完美”，去换取工程上的“极致效率”。

而现代 JVM 的进化，则代表了另一种可能：通过不断叠加更高级的抽象，去追求一个理论上“绝对安全”的并发乌托邦。

作为架构师，我们的终极使命，不是去争论哪条路更高贵，而是在理解了所有路径的代价之后，为我们的团队、我们的业务，选择那条最务实的、能活着走到终点的路。

资料链接：

• https://x.com/JamesWard/status/2049498133013344285
• https://x.com/func25/status/2050243999123009662
• https://x.com/ahmetb/status/2049341220707844340

今日互动探讨：

你如何看待 James Ward“Go 并发不行”的观点？在你的实战中，Goroutine+Channel 是否真的“够用”？或者你更期待 Go 能引入类似 JVM 的“结构化并发”？

欢迎在评论区分享你的看法！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/06/robert-griesemer-on-go-arrow-functions

大家好，我是Tony Bai。

在 Go 语言的演进史上，很少有一个 Issue 能像 #21498 这样，跨越 9 年时光，累积近千条评论，却依然让官方核心团队如履薄冰。

这个 Issue 的目标很单纯：为 Go 提供一种更简洁的匿名函数语法（Short Function Literals）。或者用大白话说，大家想要一个像 JavaScript 或 Rust 那样的“箭头函数”。

每当一个 Gopher 在代码里写下：

slices.SortFunc(users, func(a, b User) int { return cmp.Compare(a.Age, b.Age) })

他大概率会在心里暗骂一句：“这代码真够笨重的。”

然而，Go 团队对此的回应一直是：“我们不想要魔法，我们只想要清晰。” 这种坚持让社区陷入了长达数年的僵局。

但就在最近，这场僵局似乎正在被化解。

Go 语言之父之一的Robert Griesemer 亲自下场发表了一段重量级评论。他没有给出一个试图满足所有人的复杂方案，而是抛出了一个充满工程智慧的诠释：

“也许试图为任何函数解决这个语法问题是误导性的。我们应该只为那些本来就很短的函数提供支持。”

今天，我们就来看看 Robert 最新诠释中的这个“只解决 90% 问题”的箭头函数，到底长什么样？应该如何用？

底层觉醒：放弃对“全能语法”的执念

Robert Griesemer 的这段话，实际上是对过去 9 年社区争论的一次“终极复盘”。

在这 9 年里，无数天才开发者试图设计出一种“完美”的缩写语法：有的想省掉括号，有的想省掉类型声明，有的甚至想通过 $1, $2 这样的占位符来彻底消灭参数列表。

但这些方案无一例外都让 Go 编译器头疼，更让代码的可读性变得支离破碎。

Robert 意识到，真正的问题不在于匿名函数太长，而在于我们试图让“箭头函数”承载它本不该承载的重量。

如果一个匿名函数里包含了 if 逻辑、for 循环、甚至是一个 switch 分支，那么它本质上就是一个多行逻辑块。对于这种逻辑，写出完整的 func() 语法，带上明确的参数名和结果类型，不仅不是负担，反而是对读者的仁慈。

于是，Robert 划定了一条冷酷的边界线：短函数语法，只服务于单表达式或单语句。

蓝图拆解：Robert 亲自执笔的语法模型

在 Robert 的设想中，Go 的短函数（箭头函数）应该由两个核心部分组成。

第一部分：针对“有返回值”的场景（单表达式）

这是高阶函数（如 Map、Filter、Sort）最常用的场景。Robert 提议采用 (args) -> expr 的符号：

ShortFunctionLit = “(” [ IdentifierList ] “)” “->” ( Expression | “(” ExpressionList “)” ) .

这意味着你可以写出如下的代码：

() -> 42                         // 无参数，返回常数
(x) -> math.Sin(x)               // 单参数，返回计算结果
(x, y) -> x < y                  // 多参数，返回布尔值
(x, y) -> (x + y, x * y)         // 多返回值（需括号包裹）

这里的精髓在于两点：

1. 彻底消灭 return 关键字：如果右侧是一个表达式，结果会自动返回。
2. 极简的类型推断：由于它是作为参数传递给某个已知签名的函数（赋值上下文），编译器可以 100% 确定 x 和 y 的类型。你不再需要写 (a int, b int) int 这种啰嗦的废话。

第二部分：针对“无返回值”的场景（单语句）

除了返回值，还有一种场景是“简单回调”：执行一个动作，但不返回结果。

为了严格区分这两种场景，Robert 引入了一个极其精妙的设计：利用大括号 {} 来作为“不返回结果”的视觉信号。

ShortFunctionLit = … | “{” SimpleStmt “}” ) .

例子如下：

() -> { /* do nothing */ }
(x) -> { fmt.Printf("log: %v\n", x) } // 执行打印，无返回
(x) -> { ch <- x }                    // 往通道发数据，无返回
(p) -> { (*p)++ }                     // 修改指针值，无返回

Robert 的设计逻辑非常清晰：

• 没有 {}：必须返回一个值（表达式）。
• 有 {}：必须不返回值（语句）。

这个视觉区分，让任何一个读者在扫过代码的一瞬间，就能理解这个匿名函数的副作用。

架构师的必修课：为什么“只解决 90%”才是最佳答案？

Robert 在评论中提到：

“这能解决 90% 的常见案例，就像短变量声明（:=）一样。”

这正是这篇文章最值得我们升维思考的地方。

一个平庸的语言设计者，会试图通过复杂的规则去覆盖 100% 的场景，最终让语言变得像 C++ 一样臃肿。而一个顶级的语言设计者（如 Robert），懂得利用“帕累托法则（二八定律）”。

:= 并不完美，它在某些特定的作用域重叠情况下会引发困惑。但它解决了 90% 的声明问题，让 Go 代码变得极其清爽。

同样，Robert 提出的这个“箭头函数”蓝图：

• 它不能写多行逻辑？ 没关系，剩下的 10% 复杂场景，写 func() 更有助于维护。
• 它不能省掉参数括号？ 没关系，强制带上 () 可以避免解析歧义，保持 Go 一贯的“明确”风格。

*这种“克制”的艺术，正是 Go 语言在云原生时代能够取得成功的重要原因之一。** 它不追求在每一行代码上都胜过别人，它追求的是在大规模协作、在百万行代码库的维护上，保持最低的认知负荷。

未来的模样：现代化的代码重构

Robert 在文章末尾甚至已经想好了如何推广这个特性：

“如果我们引入了这个短格式，我们可以一键使用现代工具（modernizer）将现有的所有旧代码重写。”

想象一下，当你把你的项目升级到未来的 Go 版本，运行一下格式化命令。原本满屏的：

users.Map(func(u User) string {
    return u.Name
})

会瞬间收缩为：

users.Map((u) -> u.Name)

这既是字符的缩减，更是一场视觉的解放。

小结：在万变中，寻找最地道的“Go 味儿”

看完 Robert Griesemer 的这份亲述，你是否感受到了一种跨越时空的工程美学？

箭头函数在其他语言里早就不是新闻了。但 Go 团队为了把它设计得“更地道、更不容易出错、更符合长期维护利益”，足足纠结了 9 年。

这种对语法的敬畏，才是我们作为开发者真正应该学习的财富。最好的技术方案，往往不是那个功能最全的，而是那个能以最小的代价，解决最普遍痛点的。

只解决 90% 的问题，剩下的 10% 留给严谨与克制。

这，就是 Go 语言的“中庸之道”，也是它最强大的地方。

今日互动探讨：

你认同 Robert 这种“只做单行缩写”的底线吗？你觉得在 Go 中加入 -> 符号，会破坏它原有的朴素感吗？

欢迎在评论区分享你的深度见解！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/04/30/ghostty-creator-leads-github-exodus-cto-apology-go-fix

大家好，我是Tony Bai。

在程序员的江湖里，GitHub 从来不仅仅是一个代码托管平台。它是开源精神的麦加，是数千万开发者的“赛博故乡”，是这个行业赖以运转的、最坚实的“基础设施”。

但就在近几个月，这座我们无比信赖的“圣城”，似乎正在走向“崩塌”。

4 月 28 日，Github 的第1299位用户，在自己的推特与博客上发表了一篇极其悲伤的“分手信”，标题是：《Ghostty Is Leaving GitHub》（Ghostty 正在离开 GitHub）。

这位用户，不是别人，正是 HashiCorp 的联合创始人、一手缔造了 Terraform、Vagrant、Vault、Consul 等一系列云原生和 Devops 神器的“教父级”人物——Mitchell Hashimoto。而 Ghostty，正是他当下倾注心血的、备受期待的新一代终端项目。

他在这封信中，用一种近乎“心碎”的口吻写道：

“写下这些让我感到莫名的悲伤。我从 2008 年 2 月开始使用 GitHub，至今已超过 18 年，横跨了我半个人生。……我曾深爱着 GitHub，胜过一个人应该去爱一个东西。但现在，我受够了。18 年了，我得走了。”

是什么，让这位曾经的“ GitHub骨灰粉”毅然决然地带着自己的“亲儿子”项目“出走”呢？

答案简单得令人窒息：GitHub 正在变得越来越不可用。

“在过去的一个月里，我用日记记录了每一次 GitHub 宕机对我工作的影响。几乎每一天，旁边都画着一个‘X’。就在我写下这些文字的时候，GitHub Actions 又挂了 2 个小时。……如果一个平台每天都要瘫痪几个小时，那它就不再是一个适合严肃工作的地方。”

Mitchell 的这封“分手信”，像一颗炸弹，瞬间引爆了整个技术圈。

就在文章发布的几个小时后，GitHub 的 CTO Vlad Fedorov 紧急发表了一篇官方博客，标题同样沉重：《An update on GitHub availability》（关于 GitHub 可用性的更新）。

在这篇近乎“道歉信”的回应中，GitHub 官方不仅承认了问题的严重性，更罕见地揭示了这场“可用性雪崩”背后的真正罪魁祸首，以及他们正在秘密进行的“技术自救”——其中，Go 语言扮演了至关重要的“救火队长”角色。

今天，就让我们来复盘一下这场由“分手信”引发的技术公案。

压垮骆驼的稻草：被 AI “撑爆”的古老架构

GitHub 到底怎么了？

在官方的回应中，CTO Vlad Fedorov 给我们展示了一张极其恐怖的增长曲线图：“Record Acceleration”（创纪录的加速）。

自 2025 年下半年以来，随着 AI Agent（智能体）编程工作流的急剧加速，GitHub 的各项核心指标都呈现出近乎垂直的指数级增长：

• 每月新增仓库数：2000 万
• 每月合并的 PR 数：9000 万
• 每月 Commits 数：14 亿

GitHub 官方坦言：

“这种指数级的增长，不是只对一个系统造成压力。一个 PR 会触及 Git 存储、合并检查、分支保护、GitHub Actions、搜索、通知、权限、API、后台任务、缓存和数据库。在巨大的规模下，微小的低效会被无限放大。”

队列加深、缓存击穿、索引落后……这些经典的分布式系统“并发症”，在 AI 制造的流量洪峰面前，被彻底引爆了。

Mitchell Hashimoto 的“出走”，只不过是压垮骆驼的最后一根稻草。

Go 语言的救赎：从 Ruby 单体地狱中“紧急救火”

面对这场史无前例的“流量洪水”，GitHub 的工程师们正在进行一场惊心动魄的“架构自救”。

在官方博客的What we’re doing一小节中，我们看到了一个熟悉的身影——Go 语言。

“我们加速了将性能或规模敏感的代码，从 Ruby 单体应用中迁移到 Go 语言的过程。”

这短短的一句话，信息量巨大。它揭示了 GitHub 这座“上古神殿”最核心的技术债之一：一些庞大、沉重、且难以扩展的 Ruby 单体应用。

在过去，当我们需要提升性能时，可能会选择更深入地优化 Ruby 代码，或者在前面加更多的缓存。

但在 AI 时代，这种“小修小补”可能已经毫无意义了。面对 10 倍甚至 30 倍的流量增长预期，唯一的出路，就是对系统进行“外科手术式”的重构。

为什么选择 Go 来“救火”？

因为 Go 语言几乎是为这种“救火”场景量身定制的：

1. 极致的性能与并发：Go 的性能远超 Ruby，其原生的 Goroutine 并发模型，能极其轻松地榨干现代多核服务器的性能，应对海量的网络请求。
2. 极低的资源占用：相比于 Ruby 或 Python 这种动态语言，Go 的内存占用更小、更可控，能极大地降低服务器成本。
3. 简单的部署：静态编译的单一二进制文件，使得将新的 Go 微服务部署到庞大的 Kubernetes 集群中，变得极其简单。

我们可以想象，在 GitHub 内部，正有无数个由 Go 语言编写的、小而美的微服务，像一支支训练有素的“消防队”，正在冲入火场，小心翼翼地从那个庞大的 Ruby 巨人身上，一块块地切下那些已经“燃烧”的性能瓶颈模块（如 Webhooks、认证授权、Git 操作等）。

Go 语言，正在成为 GitHub 这艘巨轮在 AI 洪流中，避免沉没的“压舱石”。

从“深情”到“决绝”：一个顶级开发者的 18 年之痒

Mitchell 的“分手信”，之所以能在社区引发如此巨大的共鸣，不仅仅是因为他的技术地位，更在于信中那份令人动容的“爱之深，责之切”。

他坦言，自己 20 岁时创建 Vagrant 这个成名作，很大程度上就是为了能获得一份在 GitHub 的工作。

“GitHub 是我的梦想。那里的工程师令人难以置信，产品令人难以置信。在过去的 18 年里，我每天都在呼吸着它的空气。”

“当我的感情经历挫折时，我把自己沉浸在 GitHub 的开源世界里；当我在大学里通宵时，我会在凌晨 4 点偷偷提交一个 commit；甚至在我的蜜月期间，我都会趁着妻子还在睡觉时，打开 GitHub。”

但正是这份深沉的爱，让 GitHub 的每一次宕机，都像一把刀子，刺在他的心上。

“这对我来说是私人的。我对 GitHub 的爱，超过了一个人应该对一个东西的爱。所以我对它感到愤怒。”

在文章的最后，他给所有“Git 是分布式的，你怕什么”的言论，给出了最沉重的回击：

“问题不在于 Git，而在于我们围绕它建立的、赖以为生的基础设施：Issues, PRs, Actions……如果它每天都要让你停工几个小时，那它就不再是一个适合严肃工作的地方。”

小结：当“基础设施”不再是理所当然

Mitchell Hashimoto 的“出走”，和 GitHub 官方的“道歉”，共同为我们揭示了 AI 时代一个极其深刻的现实：

当生产力工具的效率被提升 10 倍、100 倍时，它对底层基础设施稳定性的要求，也将被以同样指数级的规模放大。

我们曾经以为像水和电一样“理所当然”的 GitHub，正在成为整个行业发展的瓶颈。

这场危机，对 GitHub 来说是“生死存亡”的挑战，但对我们这些身处其中的技术人来说，又何尝不是一次“机遇”？

它告诉我们：

1. 基础软件领域，永远有仗可打。 当所有人都涌向应用层，去卷 AI Agent 的花活时，那些能用 Go 或 Rust，去重构和加固底层基础设施的硬核工程师，其价值将变得空前稀缺。
2. “稳定性”是最高的壁垒。 在一个功能可以被 AI 瞬间生成的时代，一个系统的长期价值，越来越多地体现在它的可用性、可靠性和可扩展性上。
3. 保持警惕，准备“B 计划”。 将所有的鸡蛋都放在 GitHub 这一个篮子里，可能不再是一个明智的选择。无论是自建 GitLab或Forgejo，还是探索其他新兴的代码协作平台，都值得我们重新审视。

旧神正在踉跄，新王尚未诞生。

在这场由 AI 引发的、史无前例的“基础设施大迁徙”中，你，准备好你的船票了吗？

资料链接：

• https://mitchellh.com/writing/ghostty-leaving-github
• https://github.blog/news-insights/company-news/an-update-on-github-availability/
• https://x.com/mitchellh/status/2049213597419774026

今日互动探讨：

在过去几个月里，你是否也曾被 GitHub 的频繁宕机所困扰？你认为 GitHub 这次“中年危机”的根源，真的是 AI 吗？还是其自身技术债的必然爆发？

欢迎在评论区分享你的看法！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/04/28/go-conditional-expressions-propsal

大家好，我是Tony Bai。

在 Go 语言的江湖里，有一个话题，像幽灵一样，每隔几个月就会重燃战火。它引发的争论之激烈、持续时间之长，甚至超过了当初的“泛型”和“错误处理”。

它就是——三元条件运算符（Ternary Conditional Operator）。

condition ? then : else

这个在 C、Java、JavaScript 里被视为天经地义的语法糖，在 Go 的世界里，却成了一道不可逾越的“柏林墙”。

十几年间，无数开发者前赴后继地在官方 GitHub 仓库发起提案（从 Issue #23248 到 #33171 再到 #78865），用各种详实的数据和血泪案例，请求 Go 核心团队为这门以“简洁”著称的语言，补上这个“最该有”的特性。

但每一次，都遭到了 Go 团队近乎“铁板一块”的无情拒绝。官方 FAQ 里的那句“一门语言只需要一种条件控制流结构”，像一句神圣不可侵犯的教条，终结了所有讨论。

但就在前几天，这座最顽固的堡垒，似乎从内部出现了一丝松动。

Go 语言圣经《The Go Programming Language》的联合作者、Go 核心团队成员、Go 静态分析工具链的大神 Alan Donovan，亲自下场，发起了一个三元运算符的折中提案：Issue #78940。

他提出的新语法，试图在 Go 的“啰嗦哲学”与 C 的“简洁美学”之间，找到一条前人从未走过的“第三条路”。

今天，就让我们来深度复盘这场持续了 15 年的史诗级“内战”，看看 Go 团队为何对一个“小小的”三元运算符如此“深恶痛绝”，以及 Alan Donovan 的“折中提案”，能否为这场旷日持久的战争，画上句号。

为了一个简单的赋值，我被迫写了 5 行代码

让我们先回到一切争论的起点。

在曾经的提案 #78865 中，一位开发者贴出了一个让所有 Gopher 都感同身受的场景：

// 只是想根据一个 bool 值，给变量赋不同的字符串

var priority string
if t.Urgent {
    priority = "high"
} else {
    priority = "normal"
}

看懂了吗？一个在 C 语言里只需要一行 priority = t.Urgent ? “high” : “normal” 就能搞定的简单赋值，在 Go 里，我们被迫写了一个长达 5 行的、笨重的 if-else 流程控制块！

这位开发者甚至写了一个静态分析工具，扫描了包括 golang/go、kubernetes、terraform 在内的多个顶级开源项目。结果惊人：

平均每 6-7 个函数中，就有一个包含这种可以被三元表达式轻易优化的“啰嗦”模式。

这不仅仅是多敲几下键盘的问题。它背后隐藏着更深层次的哲学冲突：

• 三元运算符，是关于“值（Value）”的表达式。
• if-else，是关于“流程（Flow）”的语句。

用一个笨重的“流程控制语句”，去模拟一个轻巧的“值选择表达式”，在很多追求代码表达力的开发者看来，是一种彻头彻尾的“设计缺陷”。

核心团队的“铁壁”：我们到底在恐惧什么？

面对社区排山倒海的请愿，Go 核心团队（主要是 Ian Lance Taylor）为什么十几年如一日地坚决说“不”？

他们的核心论点，在 Issue #33171 的回复中，被总结得淋漓尽致：对“嵌套地狱（Nested Hell）”的恐惧。

在 C 语言中，一个新手程序员很容易写出下面这种连上帝都看不懂的“天书”：

result := a > b ? a > c ? "a" : c > b ? "c" : "b" : b > c ? "b" : "c"

这种缺乏明确括号和作用域的嵌套，极大地增加了代码的阅读和维护成本。

Go 语言从诞生之初，就对这种“隐晦”的复杂性深恶痛绝。它强制 if-else 必须带 {}，就是为了从语法层面杜绝当年 C 语言“悬挂 else”的经典歧义。

Go 团队的哲学是：宁愿让你多写几行“笨”代码，也绝不给你任何机会去写一行“聪明”的、但可能会让同事抓狂的“黑魔法”代码。

社区的声音：这是对开发者的“有罪推定”！

面对Go核心团队的“铁壁”，社区也给出了极其犀利的反驳声音。

一位开发者针对性地指出：

“导致代码不可读的风险，源于‘嵌套’，而不是三元运算符本身。Go 语言并没有限制你写出 15 层嵌套的 if-else。为什么你们相信开发者能管住自己的手不去滥用 if，却不相信他们也能管住手不去滥用 ?: 呢？”

这简直是灵魂拷问。

更重要的是，之前的提案者曾提出，可以通过 go vet 或 linter，在工具链层面直接禁止“嵌套三元表达式”的出现，只允许最简单的“扁平”形式。

Java、C++ 这些拥有三元运算符的工业级语言，早已形成了一套成熟的最佳实践。为什么 Go 社区就不能做到呢？

这种“一刀切”的拒绝，在很多开发者看来，是对整个开发者群体的一种不信任和“有罪推定”。

折中提案：Go 圣经作者的“第三条路”

就在双方僵持不下，ianlancetaylor 再次以“没有新信息”为由准备关闭提案#78865 时，Alan Donovan 出现了。

他没有直接支持经典的 ?: 语法，而是另辟蹊径，提出了一个折中的、极具“Go 语言特色”的语法提案：

(if cond then expr else expr)

这个提案的精妙之处，在于它完美地融合了双方的诉求：

1. 它是一个“表达式（Expression）”，而不是“语句（Statement）”

你可以直接用它来赋值：

role := (if isAdmin then "admin" else "user")

这彻底解决了用 if-else 语句进行赋值的“别扭感”。

2. 它强制使用括号 () 包裹

这是对 Go 语言“明确性”哲学的极致致敬。就像 if 强制使用 {} 一样，() 的强制使用，从语法层面彻底消灭了 C 语言 ?: 运算符在嵌套时产生的歧义和视觉混乱。

嵌套的写法会变得极其清晰（虽然也很丑，但这就是 Go 的目的——让你不想去嵌套它）：

(if (if cond1 then expr1 else expr2) then expr3 else expr4)

3. 它引入了一个新的关键字 then（或者用 ? 替代）

这使得语法在形式上，与传统的 if-else 语句产生了明确的区分，避免了解析器的歧义。

Alan Donovan 的这个提案，试图在“简洁表达力”和“语法无歧义”这两个看似不可调和的矛盾之间，找到一个平衡点。

它既满足了社区对“条件表达式”长达 15 年的渴望，又坚守了 Go 团队对“可读性”和“反魔法”的底线。

小结

Alan Donovan 的新提案（Issue #78940），目前已经被正式提交，并引发了新一轮的激烈讨论。

有人认为这是天才的设计，有人则觉得引入新关键字 then 的代价过高，不如直接用 ?。

这场争论的结果，我们还不得而知。

但它本身，就是 Go 语言魅力的一次完美展现。

它告诉我们：一门伟大的编程语言，其演进过程，从来不是核心团队的“一言堂”。而是在与社区的反复拉扯、辩论、甚至争吵中，不断地寻找那个“更不坏”的解。

Go 对“简单”的定义，也从来不是“代码行数最少”。

它追求的，是一种更高维度的简单——心智负担的最小化（Minimizing Cognitive Load）。

资料链接：

• https://github.com/golang/go/issues/33171
• https://github.com/golang/go/issues/78865
• https://github.com/golang/go/issues/78940

今日互动探讨：

你支持 Go 语言加入三元运算符（或条件表达式）吗？对于 Alan Donovan 提出的 (if cond then expr else expr) 这种新语法，你是拍手叫好，还是觉得多此一举？

欢迎在评论区分享你的看法！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/04/27/render-why-we-wont-rewrite-in-rust-the-power-of-boring-go

大家好，我是Tony Bai。

在技术圈的鄙视链里，Go 和 Rust 这对“欢喜冤家”的战争，似乎从未停歇。

一方是追求极致简洁、被誉为“云原生时代的 C 语言”的 Go；另一方则是以内存安全、性能屠榜著称、被视为“C++ 终极替代者”的 Rust。

就在前些天，云平台 Render 的创始人兼 CEO Anurag Goel，在 X (Twitter) 上发布了一条看似平平无奇的“凡尔赛”推文，却意外地点燃了一场技术圈的论战。

他写道：

“我们在 Render 用 Go 语言（@golang）写的负载均衡器，每月处理超过 1500 亿次 HTTP 请求。”

“而我们想用 Rust 重写它的次数是：零。”

“Go 是基础设施领域最被低估的语言。‘无聊（Boring）’，才是它的终极特性。”

这篇充满“挑衅意味”的推文，像一块巨石砸入了平静的湖面，引得大量 Go 开发者欢呼雀跃，而 Rust 社区则瞬间被引爆。Cloudflare 的工程师更是直接下场，用自家 Rust 实现的、处理能力强 1000 倍的 Pingora 代理进行“数据反杀”。

今天，我们就来复盘这场“神仙打架”，看看在这场关于“无聊与极致”的哲学对撞背后，到底隐藏着怎样的工程思考。

隔空交火：Render 的 5.8 万 vs Cloudflare 的 5800 万

面对 Anurag Goel 的“凡尔赛”，评论区很快就出现了硬核的技术派。

一位的开发者迅速扒出了数据：

“Render 每月 1500 亿次请求，平均下来大约是 5.8 万 QPS。而 Cloudflare 当年之所以用 Rust 重写他们的代理（Pingora），是因为他们遇到了 5800 万 QPS 的瓶颈，大约是 Render 的 1000 倍。”

“所以，这根本就不是语言好坏的问题，而是在正确的场景，选择正确的工具。”

这段评论，精准地揭示了这场论战的第一个核心：场景与规模的错配。

在 5.8 万 QPS 这个量级，用 Go、用 Java、甚至用 Node.js，对于一个经验丰富的团队来说，都能轻松应对。Go 语言的简洁、极快的编译速度和成熟的并发模型，使其成为了 Render 在这个阶段的“最优解”。

正如另外一名开发者在评论中所言：

“如果一个系统已经在这个规模下稳定运行，那确实没有任何理由去切换技术栈。我能理解你的观点。但把 Rust 扯进来，只是为了强调 Go 的优点，感觉有点没必要。”

但这场论战，显然已经超出了纯粹的技术讨论范畴。

哲学对撞：Go 的“足够好” vs Rust 的“无限可能”

这场大讨论的真正引爆点，是另一位开发者抛出的一个经典“电车难题”：

“如果你的余生只能用一种语言写软件，你会选哪个？”
* Go
* Zig
* Rust

这个问题，瞬间将话题从“哪个工具更适合当前场景”，上升到了“哪种哲学代表未来”的形而上高度。

Go 的拥护者，信奉的是“80 分主义”和“极简主义”。

一位开发者 的评论极具代表性：

“我可能会选 Go。它是一种让你‘别挡路（get out of your way）’的语言。它的简单，让你能专注于你正在构建的东西本身，开发速度极快。”

对于 Go 的信徒来说，软件工程的本质，是在有限的时间和资源内，交付一个“足够好”的、能解决商业问题的系统。他们厌恶为了追求那最后 20% 的极致性能，而付出 80% 的额外复杂性代价。

而 Rust 的拥护者，追求的则是“确定性”和“无限的性能潜力”。

RisingWave（一个用 Rust 构建的流式数据库）的官方账号直接下场站台：

“我们选 Rust。Rust 已经不仅仅是一门系统编程语言，它正在成为现代数据基础设施的骨干。顶级的性能、内存安全……这才是基础设施应该有的样子。”

另一位开发者的评论则更加直接：

“Rust 确实比 Go 更好。但它还没好到值得让你把一个稳定的 Go 系统重写的地步。不过，如果你在乎快速的迭代周期，Rust 的编译时间可能会让你受伤。”

这完美地概括了两种哲学的核心冲突：

• Go：给你 80 分的性能和 95 分的开发效率。
• Rust：给你 100 分的性能和 100 分的运行时安全，但你可能要为此牺牲 50% 的开发效率和忍受漫长的编译等待。

AI 时代的变量：当“人类编写”不再是瓶颈

更有趣的是，这场发生于 2026 年的论战，不可避免地被卷入了 AI 编程的浪潮。

一位开发者提出了一个极具前瞻性的观点：

“（我选 Go），因为它现在是写 LLM 的最佳语言。”

这背后隐藏着一个正在成为行业共识的趋势：Go 语言的极简语法、强制的 gofmt 格式化、以及“一眼望到底”的直白控制流，使其成为了对大模型（LLMs）最友好的“编程母语”。当 AI Agent 生成一段 Go 代码时，人类审查的认知负荷是最低的。

而 RisingWave 则更认可正在成为现代数据基础设施的骨干的 Rust 在 AI 时代的潜力。随着 AI 应用对底层算子、向量数据库、推理引擎的性能要求越来越高，Rust 凭借其“零成本抽象”和对底层硬件的极致压榨能力，正在成为构建下一代 AI 基础设施的首选。

这形成了一个有趣的闭环：Go 负责让 AI 更方便地“写”应用层代码，而 Rust 负责构建让 AI 能够“跑”起来的底层高性能引擎。

架构师的终局：从“语言之争”到“问题之争”

在这场充斥着“拉踩”、“凡尔赛”和“信仰之争”的口水战中，我们依然能找到一条属于开发者架构师的、清晰的破局之路。

第一，警惕“语言的锤子”

当你手里只有一把锤子时，你看什么都像钉子。

正如一位开发者所言：“我的公司混合使用了 Go、Rust 和 Zig。最好的解决方案，永远是取决于具体问题的。”

一个优秀的架构师，脑海中不应该有“哪个语言最好”的执念，而应该有一个装着各种工具的“兵器库”，并清楚地知道每件兵器的适用边界和成本。

第二，承认“无聊”的价值

Render 创始人的那句“无聊是终极特性”，是对当下技术圈“追逐 Hype（炒作）”文化的一次降维打击。

一个能稳定运行、默默处理千亿流量的系统，其商业价值，远大于一个用了最新潮技术、却隔三差-五需要半夜起来救火的“实验品”。

对于绝大多数商业公司来说，技术的“可靠性”，永远高于技术的“先进性”。

第三，你的价值，不在于你用了什么语言

另外一位开发者的评论一语中的：

“大多数人会说 Rust。大多数团队依然会选 Go。而‘最好’的语言，是你能维护多年的那门语言。”

在快速变化的技术浪潮中，一个团队、一个公司的核心资产，从来不是某个用特定语言写就的代码库，而是对业务领域的深刻理解、对系统复杂度的掌控能力，以及在出现问题时能快速定位并解决的工程文化。

这些，都与具体的语言无关。

小结：你的选择是什么？

Render 创始人 Anurag Goel 的一条推文，无意间点燃了 Go 与 Rust 两个顶级社区的哲学大碰撞。

这场论战没有赢家，也不需要赢家。

它只是再次向我们证明了软件工程世界的多样性与复杂性。无论是 Go 的务实与简洁，还是 Rust 的严谨与极致，它们都是在用不同的路径，攀登着名为“构建可靠软件”的同一座高峰。

那么，回到最初的那个问题：

如果你的余生只能用一种语言，你会选择哪一个？

资料链接：https://x.com/i/trending/2044880265814978827

今日互动探讨：

如果让你来回答 Ben Dicken 的“电车难题”（Go, Zig, Rust 三选一），你的选择是什么？为什么？

欢迎在评论区分享你的站队和理由！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将>带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/04/25/rust-popularity-vs-redmonk-ranking-reality-check

大家好，我是Tony Bai。

在过去几年的技术圈，Rust 是当之无愧的“流量之王”。

它连续多年在 Stack Overflow 开发者调研中蝉联“最受喜爱的语言”；它是 Linux 内核 30 年来引入的唯一非 C 语言；它是微软、亚马逊等大厂重塑底层安全架构的希望。

如果只看社交媒体和社区讨论，你会觉得 Rust 已经“统治了世界”。在一片赞歌中，大家默认 Rust 杀进主流榜单前十、取代传统语言只是时间问题。

但就在 2026 年 4 月，一份来自权威分析机构 RedMonk 的2026.1编程语言排行榜，却给所有“Rust 狂热者”泼了一盆透心凉的冷水。

数据呈现了一个极其残酷的反差：

在这份以“开发者真实选择”为核心指标的榜单上，Rust 的排名并没有像预期的那样一飞冲天，而是停滞在了第 20 位，甚至被曾被视为小众的 Dart 所超越。相比之下，那个常被调侃“无趣”的 Go 语言，依然稳稳地坐在第 12 位，并在云原生领域保持着统治地位。

为什么人人爱 Rust，但它在工业界的大规模普及却显得如此缓慢？为什么它“攻陷”了最硬核的 Linux 内核，却迟迟进不了普通开发者的日常？

今天，我想结合近期社区的深度讨论，扒开 Rust 这层华丽的外衣，带大家看看这门“天选之子”背后的生存现状与真实挑战。

口碑与数据的鸿沟：被锁死在“塔尖”的生产力

在开发者 Alejandra 最近整理的一份清单里，Rust 的“战绩”堪称辉煌：Windows 11 的核心组件、AWS 的 Firecracker 虚拟化、Cloudflare 的下一代代理服务器 Pingora……

但这恰恰揭示了 Rust 目前最大的尴尬：它是一个“属于 1% 的神兵利器”。

这些成功的 Rust 项目，无一例外都属于“系统级基础设施”领域。它们雇佣的是全球前 1% 的顶级程序员，拥有极其漫长的研发周期和近乎奢侈的调试成本。

正如 RedMonk 的分析师在报告中一针见血地指出：

“Rust 依然面临着非专家程序员难以逾越的学习门槛。专家们愿意投入时间，但更广泛的主流采用似乎面临着巨大的惯性。”

开发者 Alejandra 在其博文的自白中也坦言：

“无论我们如何自我安慰 Rust 已经进入主流，事实是：它离 C++ 甚至 Java 的普及程度，依然有着深不见底的鸿沟。大学教的第一门语言依然是 Java，飞机上依然在用 C++，网页里依然全是 Javascript。”

Rust 已经完成了从 0 到 1 的“极客突围”，却正在撞向从 1 到 N 的“工业化之墙”。

标准库的困局：当“技术洁癖”变成“协作负担”

除了学习曲线，Rust 进军主流的第二个障碍，也许就是它那小而美的标准库。

这篇名为《Unpopular opinion: Rust should have a larger standard library》（非主流观点：Rust 应该有一个更大的标准库）的帖子，戳中了无数一线开发者的泪点：

在我之前写过的一篇文章《别搞“小而美”了！Rust 开发者请愿：求求标准库学学 Go 吧》中也曾提过社区对 Rust 标准库的述求：

“我不想写个程序就要拉几百个三方库！生成一个随机数，std 里没有；想要个异步运行时，std 里也没有。我不得不把信任托付给几百个散落在 GitHub 各地、由个人维护的小型包（Crate）。”

这种对“核心精简”的极致追求，正在引发严重的“供应链安全焦虑”。

在 Go 的世界里，你可以用标准库完成 90% 的后端开发，这意味着你的核心链路是由 Google 顶尖团队直接背书的。但在 Rust 的世界里，开发者面临着“碎片化依赖”的内耗。

这种“标准库贫血”导致了一个反直觉的现象：Rust 是一门为了“安全”而生的语言，但它极度依赖社区包的机制，却在客观上增加了供应链被“投毒”的风险。

正如评论区所感慨的：“标准库是模块最终的坟场。”Rust 团队为了避免标准库变得臃肿，却无意中将“复杂性”和“审计成本”全部转嫁给了一线开发者。这种“技术洁癖”在处理顶级项目时是美德，但在处理追求效率的通用业务时，却成了巨大的阻碍。

Go vs Rust：工业生产力的两种极致审美

为什么 Go 能在 RedMonk 榜单上稳坐第 12，而 Rust 只能在第 20 徘徊？

这是两种完全不同的工程学审美，也决定了它们在大规模协作中的不同命运：

• Go 的审美是“工厂流水线”：它不鼓励个人英雄主义，它用 gofmt 强制所有人的代码长得一模一样。它追求的是“平均生产力的最大化”。即便是一个普通水准的程序员，在 Go 的框架下也很难写出摧毁系统的灾难性代码。这种“无聊”和“简单”，正是大厂进行大规模兵团作战时的首选。
• Rust 的审美是“顶级艺术工作室”：它追求极致的精准、极致的控制。每一个 borrow，每一个 lifetime 都是在进行微雕。它追求的是“个体生产力的上限”。

但在现代软件工业中，“下限的稳定性”往往比“上限的惊艳度”更具普适价值。 绝大多数公司需要的不是一个能手搓编译器的天才，而是一群能够按照既定流程、稳健产出、且易于维护代码的合格工程师。

AI 时代的变数：谁才是对机器最友好的母语？

RedMonk 的报告里还提出了一个极具前瞻性的观察：理论上，AI 编码辅助工具应该能抹平 Rust 的学习曲线，但现实并非如此。

为什么？

大模型（LLM）的本质是模式识别和概率预测。

对于语法单一、推崇“唯一路径”的 Go 语言来说，AI 生成的代码准确率极高，且人类审查的认知负荷极低。

而对于规则极其复杂、生命周期标记繁琐的 Rust 来说，AI 生成的代码极易出现“微妙的语法错误”或“不地道的生命周期设计”。人类开发者在审查 AI 生成的 Rust 代码时，往往比自己重写一遍还要痛苦。

在“机器写代码”即将接管开发流程的未来，简单、标准、甚至有些“死板”的语言，反而拥有更宽、更深的护城河。《HashiCorp 创始人亲口“认错”：AI 让我重新爱上了 Go (文末福利)》一文中Hashicorp创始人Mitchell Hashimoto 因 AI 重新爱上Go，以及Pandas 之父近期更喜欢让 AI 用Go写代码也印证了这一点。

小结：架构师的清醒与权衡

作为一个架构师，我们不必因为 Rust 在榜单上的“冷水”而否定它的伟大。

Rust 正在解决软件工程中最难的问题——在不牺牲性能的前提下，从根源上消灭内存漏洞。它的价值，已经在 Linux 内核和那些“不容有失”的领域得到了证明。

但我们也必须清醒地认识到：技术的流行度（Popularity）与技术的高级感（Elegance）并不总是正相关。

如果你在构建下一代安全操作系统、数据库内核或高性能边缘网关，Rust 是你不二的利剑。

但如果你在构建一个需要快速迭代、支撑公司核心营收、且由几十甚至上百人协作的后端业务系统，请务必保持客观：那个排名第 12、虽然有些“平庸”但永远能准时交付、且对 AI 极度友好的 Go，或许才是那个更优的工程方案。

再次祭出那句话：你的技术护城河，从来不是由你用什么语言决定的，而是由你解决问题的深度，以及你在各种极端权衡（Trade-offs）中做出的选择决定的。

资料链接：

• https://blog.goose.love/posts/what-actually-uses-rust/
• https://www.reddit.com/r/rust/comments/1sqyjxa/blog_ok_what_actually_uses_rust/
• https://redmonk.com/sogrady/2026/04/14/language-rankings-1-26/

今日互动探讨：

看完这份“人人爱 Rust，但榜单很冷酷”的现实反差，你觉得 Rust 挺进主流最大的障碍是什么？你认为“大标准库”是未来编程语言的必然趋势吗？

欢迎在评论区分享你的看法！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.