本文永久链接 – https://tonybai.com/2026/03/28/ai-engineer-gpu-introduction-course

大家好，我是Tony Bai。

就在最近，科技界发生了一件极其戏剧性的事情。本周三美股开盘，全球存储产业巨头——美光、西部数据、希捷的股价遭遇了“黑色时刻”，普遍明显下跌（3%~6%）。

引发这场资本市场大地震的，不是什么贸易战，也不是财报暴雷，而仅仅是谷歌（Google Research）发布的一篇技术论文：《TurboQuant: Redefining AI efficiency with extreme compression》。

这篇论文宣称，他们发明了一种极端的压缩算法，能在几乎零损耗的情况下，将大模型推理时的 KV 缓存（KV Cache）暴降 6 倍，并让注意力机制的计算速度狂飙 8 倍！

很多传统的后端程序员看到这条新闻，可能一头雾水：

• 什么是 KV Cache？
• 为什么压缩了一个叫 KV Cache 的东西，就能让卖物理内存芯片的巨头们吓得半死？

在这些雾水和疑惑背后，隐藏着 AI 大模型时代最核心、也最残酷的技术真相：内存墙（Memory Wall）。

AI 时代的底色：算力过剩，访存为王

在传统的软件开发中，我们习惯了用 CPU 的思维去思考性能。我们认为程序跑得慢，是因为“计算太复杂”，我们需要更强的算力（更快的 CPU 频率）。

但在大语言模型（LLM）的世界里，逻辑变了。

大模型在生成文本时，是逐字生成（自回归）的。为了不每次都把前面说过的话重新计算一遍，模型会把之前所有上下文的内部特征（Key 和 Value 矩阵）全部保存在显存里。这份庞大的“运行记忆”，就是 KV Cache。

随着上下文越来越长（比如从 4K 飙升到 128K 甚至百万级），这份 KV Cache 会像滚雪球一样膨胀。

这就是为什么业界说：KV Cache 是大模型推理名副其实的“吞金兽”。

更要命的是，每次生成一个新的字，GPU 都必须把这份庞大的 KV Cache 从显存（HBM）完整地搬运到计算核心（SRAM）里过一遍。

这就好比你有一个世界上切菜最快的厨师（GPU 算力），但他每次切一片肉，都要跑到 10 公里外的仓库（显存）去取。厨师的手速再快也没有用，整体速度完全被运货卡车的速度（显存带宽）锁死了。

这就是困扰所有 AI 工程师的 “内存墙”。也是为什么各大公司疯狂抢购高显存、高带宽的 H100 显卡的原因。

而谷歌的 TurboQuant 之所以引发地震，正是因为它通过极致的数学算法（极坐标变换 + 1-bit 残差误差校验），直接在软件层面把搬运的数据量压缩了 6 倍！这意味着，同样的硬件，现在能跑更长的上下文、支持更高的并发。存储巨头们能不慌吗？

为什么后端工程师必须懂 GPU？

你可以说：“我只是个调 OpenAI 兼容API 的后端工程师，硬件底层关我什么事？”

在过去的一年里，这是行得通的。但随着开源模型（如 GLM、Qwen、MiniMax、DeepSeek、KIMI等）的全面爆发，以及企业对数据隐私、成本控制的极致追求，“本地化/私有化部署大模型” 也正在成为一些中大型企业的刚需。

当你作为架构师或后端主力，被老板要求把一个 70B 的大模型部署到公司的服务器上时，真正的挑战才刚刚开始：

• 面对 OOM（显存溢出），你该如何调整参数？
• 并发量稍微一高，首字延迟（TTFT）就卡到几十秒，你该怎么排查？
• 采购硬件时，你是买 8 张便宜的 RTX 4090，还是花高价租用带 NVLink 的 A100/H100？
• 你该如何向团队解释引入 vLLM、FlashAttention 和 INT8/FP8 量化的必要性？

如果你把 GPU 当成一个“跑得更快的 CPU”来用，你将会在上述每一个问题上栽大跟头。

你需要建立一套全新的“硬件心智模型”，这也是我编写这门《AI 工程师的 GPU 入门课：从硬件视角看大模型推理》微专栏的主要目标。

这门微专栏将教你什么？

市面上关于 GPU 和 CUDA 的教程很多，但大多是教你如何写出复杂的 C++ 图形渲染代码，或者如何在学术上推导矩阵乘法。

这门微专栏与众不同。它是专为后端/软件工程师打造的“白盒化” GPU 入门课程。

我们不教图形渲染，不深究复杂的 C++ 语法。我们将直接切入大模型推理的痛点，带你一步步从物理架构走到前沿的 AI 工程技术。

• 如果你想吃透热门技术： 我们将为你讲透 FlashAttention、PagedAttention (vLLM)、模型量化背后的物理原理。你会发现，这些看似高深的技术，本质上都是在和“内存墙”做斗争。
• 如果你追求实战落地： 我们不仅教你看懂硬件，还会教你用 Profiling 工具（性能分析器）像侦探一样排查慢查询；作为加餐，我们甚至会教你如何用纯 Go 语言（Zero CGO）直接点火发射 CUDA 内核！

课程目录全景图

为了让你对这趟旅程有一个清晰的预期，以下是本专栏的完整地图：

第一阶段：硬件心智模型
* 第 01 讲 | 硬件解剖：为什么 CPU 是“法拉利”，GPU 是“大巴车”？（含 5090 vs H100 对比）
* 第 02 讲 | 内存金字塔：HBM、SRAM 与不可逾越的“内存墙”

第二阶段：编程模型与工具链
* 第 03 讲 | CUDA 编程模型：指挥“千军万马”的线程艺术
* 第 04 讲 | 性能侦探：性能侦探：拆解 Hello World Kernel 与 Profiling 实战

第三阶段：AI 工程进阶
* 第 05 讲 | 显存管理革命：从 KV Cache 到 PagedAttention (vLLM)
* 第 06 讲 | 算子融合魔法：FlashAttention 的底层原理
* 第 07 讲 | 精度与量化：精度与量化：INT8/FP8 为什么既快又省？
* 第 08 讲 | 分布式推理：Tensor Parallelism (TP) 与通信墙
* 第 09 讲 | 终极指南：如何科学计算 AI 算力需求与硬件选型？

特别加餐：Gopher 的专属浪漫
* 第 10 讲 | 加餐：Go 语言的 GPU 编程——Gopher 的逆袭

小结

在算力的装备竞赛里，最锋利的武器未必是更昂贵的芯片，而是深刻理解软硬件边界的人。

正如谷歌 TurboQuant 证明的那样：懂底层的工程师，只需改写一行底层逻辑，就可能撬动万亿级别的市场价值。

算力时代，不要只做“调包”的局外人。

准备好跨越 CPU 的舒适区，跟我一起深入算力的硅基心脏了吗？

点击这里或扫描下方二维码，开启你的GPU与AI推理工程的入门之旅：

我将在第一讲等你。

还在为“复制粘贴喂AI”而烦恼？我的新专栏 《AI原生开发工作流实战》 将带你：

• 告别低效，重塑开发范式
• 驾驭AI Agent(Claude Code)，实现工作流自动化
• 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码，开启你的AI原生开发之旅。

原「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/01/11/21-lessons-from-google-engineer

大家好，我是Tony Bai。

“当我 14 年前加入 Google 时，我以为这份工作就是写出优秀的代码……我只说对了一部分。我待得越久，就越意识到，那些真正茁壮成长的工程师，不一定是最好的程序员——他们是那些懂得如何驾驭代码周围一切的人：人、政治、协同和模糊性。”

这段话，出自 Google 资深工程师 Addy Osmani 的一篇深刻反思——《在 Google 14 年的 21 条经验》。这篇文章，如同淬炼了 14 年的智慧结晶，几乎没有谈论任何具体的技术栈，却精准地描绘出了一位卓越工程师的成长画像。

这 21 条“法则”，并非关于某种转瞬即逝的技术，而是关于那些在项目、团队、公司之间反复出现的永恒模式。它们不是一场与外部世界的战争，而是一场关于自我提升的漫长“修炼”。这是一份珍贵的“心法”，能帮助我们在这场修炼之路上，走得更远、更稳。本文将为你逐一解读。

1. 最好的工程师痴迷于解决“用户问题”，而非“技术问题”

这是工程师“修炼”之路的第一心法：放下执念。

放下对特定技术的迷恋，将自我从“工具的使用者”升华为“问题的解决者”。

“用户痴迷”意味着走出 IDE，去阅读支持工单，去和真实用户交谈，去观察他们如何在你的产品中挣扎。

当你真正理解了用户的“痛”，你往往会发现，那个最优雅的解决方案，远比你最初设想的任何复杂技术都要简单。

2. 做到正确很廉价，而“一起”做到正确才是真正的修行

你可以在每一次技术辩论中都“赢”，但最终输掉整个项目。

真正的“修为”，不在于证明自己正确，而在于创造一个安全的空间，让团队能够共同对问题达成一致，并对自己的确定性保持怀疑。

记住：“观点强硬，但立场松动 (Strong opinions, weakly held)。”

3. 偏爱行动。交付。你可以修改一个糟糕的页面，但无法修改一个空白的页面

对完美的追求是麻痹剂，是“心魔”。

完美的架构不会在纯粹的冥想中诞生，它诞生于与现实的接触。

先做出来，再做对，再做得更好。

交付那个让你感到“有点尴尬”的 MVP。

一个粗糙的原型所能带来的真实反馈，远超一个月闭门造车的理论辩论。

4. 清晰即资深，聪明是开销

编写“聪明”的代码，是工程师证明能力的本能。

但真正的软件工程，是在时间和团队协作的维度上展开的。

清晰性不是一种风格偏好，而是一种运营风险的降低。

你的代码，是一份写给未来某个凌晨三点需要维护它的陌生人的“战略备忘录”。

资深的工程师，早已学会在他们的“修炼”中，用清晰性去交换那份无关紧要的“聪明”。

5. 新奇是一笔贷款，你将在故障、招聘和认知开销中偿还

像一个预算有限的组织一样，谨慎地对待你的“创新代币”。

只在你拥有独特优势的地方进行创新，其他所有事情，都应该默认选择“无聊”的技术，因为“无聊”意味着失败模式是已知的。

记住，“最好的工具”，常常是那个“在最多场景下最不坏的工具”。

6. 你的代码不会为你代言，人会

以为“好的工作会自己说话”，是工程师“修炼”生涯早期最大的错觉。

代码静静地躺在仓库里，它不会在晋升会议上为你辩护。

你需要将你的工作和价值，以一种可被他人理解和传播的方式呈现出来：写清晰的文档、做有影响力的分享、主动沟通你的成果。

7. 最好的代码，是那些你从未写下的代码

工程文化崇尚创造，但删除代码往往比增加代码更能改善一个系统。

你没有写下的每一行代码，都是你永远不必去调试、维护或解释的一行代码。

在动手构建之前，请先用“无为”的智慧拷问自己：“如果我们就是……不这么做，会发生什么？”

8. 在规模化面前，即使你的 Bug 也有用户

当用户足够多时，你的系统的每一个可观测行为，无论你是否承诺过，都会成为一种事实上的依赖。

有人正在爬取你的 API，有人正在自动化你的“怪癖”，有人正在缓存你的 Bug。

这意味着，兼容性本身就是一种产品。你不能再将修复 Bug 视为“维护”，将开发新功能视为“真正的工作”。

9. 大多数“慢”团队，其实是“失调”的团队

当项目拖延时，我们的本能是归咎于执行力：人手不够、技术不行、工作不努力。

但真正的瓶颈，往往在于协同失败 (Alignment Failure)——团队在做错误的事情，或者以不兼容的方式在做正确的事情。

资深工程师会花费更多时间去澄清方向、接口和优先级，而不是单纯地“更快地写代码”。

10. 关注你能控制的，忽略你不能的

在大型组织中，组织架构调整、管理层决策、市场变化……无数变量都在你的控制范围之外。

为这些事情焦虑，是在浪费你宝贵的精力。

卓越的工程师，会战略性地专注于他们的“影响圈”：你能控制你代码的质量，你能控制你如何响应变化，你能控制你学到了什么。

这是一种专注的“禅定”。

11. 抽象并未消除复杂性，只是将其转移到了你 on-call 的那一天

每一个抽象，都是一次“我未来不需要理解其底层”的赌博。

有时你会赌赢，但抽象总会泄露。

资深工程师之所以坚持学习底层知识，并非出于怀旧，而是出于对“凌晨三点，当你独自面对一个失效的抽象时”的敬畏。

12. 写作倒逼清晰。想学得更快，就去教别人

当你试图向他人解释一个概念时——无论是在文档中、演讲中，还是 Code Review 的评论里——你会立刻发现自己理解上的盲点。

把一个东西教给别人，本质上是在调试你自己的心智模型。

这是最高效的“利己”的学习法门。

13. 那些让其他工作成为可能的工作，无价且无形

“胶水工作”——文档、新人引导、跨团队协调、流程改进——至关重要。

但如果你无意识地、仅仅出于“乐于助人”去做这些事，它们会吞噬你的时间，让你偏离技术主航道。

诀窍在于，有意识地去做，为它设定时间盒，将它转化为文档、模板、自动化等可见的成果，让它成为你明确的影响力，而非模糊的“性格特质”。

14. 如果你赢得了每一次辩论，你可能正在积累无声的抵制

当你“赢”得太轻松时，通常意味着事情不对劲了。

人们不再与你争论，不是因为你彻底说服了他们，而是因为他们已经放弃了尝试。

而这份未解的分歧，将会在未来的执行层面，以“神秘的阻力”的形式爆发出来。

真正的协同，需要你真正去理解他人，并有时公开地改变自己的想法。

15. 当一个指标成为目标时，它便不再是一个好的指标

古德哈特定律的经典再现。

人类会为了被测量的东西而优化。

资深的做法是，用一组成对的指标来响应管理需求（例如，速度 vs. 质量），并坚持解读趋势，而非崇拜某个具体的阈值。

16. 承认“我不知道”，比假装知道能创造更多安全感

当一个领导者或资深工程师坦诚自己的不确定性时，他实际上是在给予整个团队“提问”和“犯错”的许可。

这会创造一种心理安全的环境，让问题在爆炸前被暴露出来。

反之，一个“永远正确”的领导者，只会培养出一群沉默的下属和一堆隐藏的地雷。

17. 你的人脉，比你做过的任何一份工作都更长久

职业生涯早期，我们容易专注于工作本身而忽略人际交往。

这是一个巨大的错误。

那些在公司内外投资于人际关系的同事，在数十年后，会收获巨大的回报。

你的工作不是永恒的，但你建立的信任是。

18. 大多数性能的胜利，源于“移除工作”，而非“增加聪明”

当系统变慢时，我们的本能是增加缓存、并行处理、或者换用更聪明的算法。

但更具影响力的胜利，往往来自于问一个更根本的问题：“我们正在计算的这些东西，真的有必要吗？”

删除不必要的工作，远比把必要的工作做得更快要有效得多。

最快的代码，是那段从未运行过的代码。

19. 流程的存在是为了减少不确定性，而不是为了制造文书工作

最好的流程，能让协作更容易，让失败的代价更便宜。

而最坏的流程，是“官僚主义戏剧”——它的存在不是为了帮助，而是在出问题时用来甩锅。

如果你无法解释一个流程如何降低风险或增加清晰度，那它很可能就是纯粹的开销。

20. 最终，时间会比金钱更宝贵。请据此行事

职业生涯早期，你用时间换金钱。

但在某个临界点之后，这个公式会反转。

时间是唯一不可再生的资源。

答案不是“不要努力工作”，而是“清楚你在交易什么，并深思熟虑地做出交易。”

21. 没有捷径，但有复利

专业知识，来自于经年累月的刻意练习。

但这里有希望的部分：学习是具有复利效应的。

你建立的每一个心智模型，你总结的每一条经验教训，都会成为你未来解决更复杂问题的“可复用原语”。

将你的职业生涯视为复利投资，而非一张张彩票。

小结：修炼的核心永远是人

Addy Osmani 的 21 条经验，最终可以归结为几个核心思想：保持好奇，保持谦逊，并永远记住，修炼的核心是人——你为之构建的用户，以及与你一同构建的队友。

对于我们工程师而言，这意味着，职业生涯的成长，是一场双螺旋式的攀升。

技术能力的“硬实力”是我们的根基，但决定我们最终能达到何种“境界”的，往往是沟通、协作、权衡、同理心这些看似“软”的、关于人的智慧。

这场“代码之外的修炼”，道阻且长，但行则将至。

资料链接：https://addyo.substack.com/p/21-lessons-from-14-years-at-google

你的“第22条”法则

读完这21条法则，相信你一定心有戚戚焉。在你自己的职业生涯中，是否有哪一条“生存法则”是你用惨痛教训换来的？或者，你觉得还有什么重要的经验是这21条没有覆盖到的？

欢迎在评论区分享你的独家心法！ 让我们一起汇聚更多智慧。

如果这篇文章给了你新的启发，别忘了点个【赞】和【在看】，并转发给身边正在迷茫的工程师朋友，也许这就是他破局的关键！

还在为“复制粘贴喂AI”而烦恼？我的新专栏 《AI原生开发工作流实战》 将带你：

• 告别低效，重塑开发范式
• 驾驭AI Agent(Claude Code)，实现工作流自动化
• 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码，开启你的AI原生开发之旅。

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

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

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

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

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

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

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/01/10/go-dropped-from-7th-to-16th-in-one-year

大家好，我是Tony Bai。

新年伊始，TIOBE 发布了最新的编程语言排行榜。当我满怀期待地去寻找 Go 的身影时，差点以为自己眼花了：

Go 居然从去年的第 7 名，断崖式下跌到了第 16 名！ 占比跌幅高达 1.37%，在这个榜单上几乎是“崩盘”级别的表现。

这是什么概念？这意味着在 TIOBE 的统计里，Go 现在的流行度还不如 Delphi/Object Pascal（第 9 名）和 Visual Basic（第 7 名）。

这就很离谱了。任何一个在 2025 年还在写代码的人，都不会觉得 Go 的生态已经萎缩到这种地步。

是 Go真的凉了吗？还是 TIOBE 的算法“疯”了？

平行宇宙：稳如泰山的 Go

为了验证我的认知是否出现了偏差，我特意查阅了 2025 年其他的权威榜单：

• GitHub Octoverse：Go 依然稳居前 10，云原生领域的统治地位不可撼动。
• Stack Overflow 开发者调查：Go 在“最想学习的语言”和“薪资最高语言”中依然名列前茅。
• JetBrains 生态报告：Go 开发者的数量在持续稳步增长，并登顶“最受期待”榜首，没有任何衰退迹象。

全世界都觉得 Go 挺好，唯独 TIOBE 觉得 Go 要完。这种巨大的反差，逼得我不得不去扒一扒 TIOBE 的底裤——它的排名算法到底是怎么算的？

扒皮 TIOBE：一个过时的算法游戏

根据 TIOBE 官方公布的定义文档，它的算法极其简单粗暴，甚至可以说——在 2026 年显得有些可笑。

它的核心逻辑只有一个公式：

在 25 个主流搜索引擎中，搜索 +” programming”，统计返回的页面数量。

就是这么简单。没有什么复杂的加权，没有什么开发者活跃度分析，就是数一数搜索引擎告诉你“有多少个网页提到了这个语言”。

这种算法在 20 年前或许有效，但在今天，它成为了导致 Go 排名暴跌的元凶。

元凶一：AI 杀死了“搜索结果页”

2025 年最大的变化是什么？是 AI Search。

当我们遇到编程问题时，越来越多的人不再去 Google 翻阅那几百万个搜索结果页面，而是直接问 ChatGPT、Claude 或者 DeepSeek。
TIOBE 明确表示：ChatGPT 等 AI 工具不被纳入统计，因为它们没有“返回结果数量”的计数器。

这就导致了一个悖论：越是热门、现代的语言（如 Go、Python(得益于AI模型训练与应用开发)），其用户群体越年轻、越拥抱新技术，也就越倾向于用 AI 解决问题。 这直接导致了这些语言在传统搜索引擎中的“查询热度”和“新内容生成量”出现显著下降。

相比之下，那些老旧的语言（如 VB、Delphi），其用户群体相对固化，且维护遗留系统时更多依赖传统的文档和论坛搜索，因此受到的冲击较小，甚至在对比中显得“逆势上扬”。

注：Python的占比相对于2025.01也下降了0.68%。

元凶二：Go 的名字太“吃亏”了

TIOBE 的核心搜索查询是 +” programming”。

这对于 Python、Java 这种专有名词来说问题不大。但对于 Go 来说，这就是个灾难。

• 通用词的悲剧：Go 是一个极其通用的英语单词。为了过滤掉“去（go）”的含义，TIOBE 必须强制加上 “programming” 后缀。
• 搜索习惯的改变：但在 2025 年，开发者还会搜 “Go programming” 吗？不会了。大家搜的是 “Go generics”、”Golang k8s”、”Goroutine leak”。
• 不成比例的过滤：随着搜索引擎算法日益智能，它开始更精准地理解用户意图，不再机械地匹配 “Go programming” 这个短语。这导致大量讨论 Go 技术的高质量页面（但没有显式包含该短语）被 TIOBE 的简单算法无情过滤。而像 “Python programming” 这种组合，因为 Python 本身的高辨识度，受到的影响要小得多。

元凶三：搜索引擎的“去水化”

Google 等搜索引擎在 2025 年大幅调整了算法，致力于打击 SEO 内容农场和低质量生成的页面。

Go 作为一个在云原生时代极速窜红的语言，过去几年充斥着大量的入门教程、培训班广告和搬运文章。搜索引擎的这一波“清洗”，可能不成比例地删除了大量包含 “Go programming” 关键词的低质、重复页面。

虽然页面总量少了，但生态的“干货密度”其实更高了。 然而，在 TIOBE 这种只看“数量”不看“质量”的算法眼里，这就被简单粗暴地解读为“热度暴跌”。而那些生态早已固化、鲜有新内容产生的老语言，反而躲过了这一劫。

注：以上也是笔者的主观分析，不一定与事实相符！

小结：看个乐呵就行

把 Go 排在 Visual Basic 后面，这本身就是一个笑话。

TIOBE 的这次排名暴跌，反映的不是 Go 语言的衰落，而是 TIOBE 这种基于“网页搜索量”的统计方法，在 AI 和现代互联网面前的全面崩塌。

它就像一个依然在用“收音机收听率”来衡量流行音乐热度的老人，已经无法捕捉流媒体时代的脉搏。

所以，各位 Gopher，该写代码写代码，该摸鱼摸鱼。Go 好着呢，别被这个离谱的排名吓到了。

你的“体感”排名

TIOBE 的数据确实让人啼笑皆非。在你心目中，Go 语言现在的真实热度应该排第几？你觉得还有哪个榜单能更客观地反映编程语言的现状？

欢迎在评论区晒出你的“心选榜单”，或者尽情吐槽这个离谱的排名！

如果这篇文章解开了你心中的疑惑，别忘了点个【赞】和【在看】，并转发给那些正在唱衰 Go 的朋友，打脸要快！

还在为“复制粘贴喂AI”而烦恼？我的新专栏 《AI原生开发工作流实战》 将带你：

• 告别低效，重塑开发范式
• 驾驭AI Agent(Claude Code)，实现工作流自动化
• 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码，开启你的AI原生开发之旅。

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

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

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

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

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

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

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/01/05/how-ken-thompson-developed-go-language-at-google.

大家好，我是Tony Bai。

为什么 Go 语言极其痛恨复杂的特性？为什么 Go 如此执着于编译速度？我们常说 Go 是一门“工程实用主义”的语言，它的设计哲学是“少即是多”。但你是否想过，这种近乎偏执的简洁，究竟是为了对抗什么？

这一切的答案，都藏在 2007 年 Google 内部的一场 C++ 标准委员会汇报演讲中。当图灵奖得主 Ken Thompson 发现自己竟然“看不懂”新的 C++ 特性时，一颗变革的种子就此埋下。

最近，我重温了这段 Ken Thompson（Unix 之父、Go 语言联合创始人）的珍贵访谈。在访谈中，老爷子毫无保留地讲述了 Go 语言诞生的前因后果。 故事的起点，并非某次高瞻远瞩的战略规划，而是一次“听不懂”的 C++ 技术分享，以及 Google 内部那令人绝望的 45 分钟编译时间。

本文基于 Ken Thompson 的访谈实录，带你回到那个决定性的瞬间，还原 Go 语言诞生背后的真实故事。

压死骆驼的最后一根稻草：C++ 的“新特性”

故事发生在 2007 年左右。当时，Google 内部有一位 C++ 标准委员会（ANSI C++）的代表。

有一天，这位代表刚开完标准会议回来，在 Google 内部做了一场技术分享，向大家介绍 C++ 即将引入的“新特性”（注：推测是指当时的 C++0x，即后来的 C++11 草案）。

Ken Thompson 就在台下。作为发明了 B 语言（C 语言的前身）并重写了 Unix 内核的宗师级人物，他在听完这场一小时的密集分享后，感受到的不是兴奋，而是困惑。

“这所谓的‘新东西’，在我看来比语言本身还要大。”
“那些关于指针的形式，除了指针之外还意味着其他东西……我告诉你，我没听懂。”

想象一下，连 Ken Thompson 都直言自己“没听懂” C++ 的新特性，这说明了什么？

在他看来，这些所谓的“改进”，只是在不断地堆砌复杂度。这场演讲成为了催化剂。Ken 回到办公室，找到了同样对现状不满的 Robert Griesemer 和 Rob Pike。

Ken 的不满在于语言的过度复杂，而 Rob Pike 的痛点则在于 Google 庞大的工程规模。

Google 的工程噩梦：10 行代码与 500 万行编译

当时的 Google 面临着一个前所未有的工程挑战：Monorepo（单一代码仓库）的膨胀。

Ken 在访谈中描述了一个令人窒息的场景：

“在 Google，你可以从任何源文件中引用库。你可能只写了一个 10 行的程序，但最终却需要处理 500 万行的编译量。”

这不是夸张。由于缺乏严格的依赖管理和可见性控制，一个微小的依赖引入，可能会像滚雪球一样，将底层的庞大库（如 Protocol Buffers、基础库等）全部卷入编译过程。

更糟糕的是，头文件（Header files）的包含机制导致了严重的重复劳动。

“像最简单的库，可能会被加载和检查成百上千次。”

虽然 Google 拥有当时世界上最强大的分布式编译集群（成百上千个 CPU 并行工作），虽然工程师们发明了各种缓存机制和 ifdef 技巧来避免重复包含，但物理定律是不可违背的。

编译一个简单的程序，需要等待 15 分钟，甚至 45 分钟。

Rob Pike 对此深恶痛绝。这种低效的开发循环，正在扼杀 Google 工程师的创造力。

三个火枪手与“一票否决权”

于是，在 Google 的一间办公室里，Ken Thompson、Rob Pike 和 Robert Griesemer 聚在了一起。

Ken 说出了那句改变历史的话：

“What are we going to do about it? Let’s write a language.”（我们该怎么办？让我们写个语言吧。）

这是一个完美的互补组合：

• Rob Pike：深刻理解 Google 的工程痛点（依赖地狱、构建速度、大规模协作）。
• Ken Thompson：拥有深厚的语言和编译器构建历史。
• Robert Griesemer：被称为“瑞士军刀般的语言专家”，熟悉理论上存在的所有语言特性，是团队的理论百科全书。

在设计 Go 语言时，他们制定了一个残酷但有效的规则：全员同意原则。

“我们必须都同意某个特性，它才能被加入。仅仅因为‘我想要这个特性’是不够的。”

这个规则过滤掉了绝大多数“花哨但非必要”的特性。Go 语言之所以能保持如此干净、紧凑，正是因为这三位创始人在最初就把住了关口。

遗产与未来

Ken Thompson 在 Go 语言开源并走上正轨后，逐渐淡出了核心开发。但他对 Go 的后续发展给予了极高的评价，特别是对标准库。

“在我离开后，后来的人写了一套极其出色（magnificent）的标准库。”

那之后，这位图灵奖得主在 Google 的工作中，几乎只使用 Go 语言，并且几乎只使用标准库。

他对 Go 的评价朴实无华：

“它很简单。任何人都可以在一小时内学会它。当你写代码时，它运行得足够快，给你即时的反馈。”

小结

重读这段访谈，我们就能理解：

• 为什么 Go 甚至不愿意引入三元运算符？
• 为什么 Go 的依赖管理（Go Modules）对版本控制如此严格？
• 为什么 Go 编译器宁愿牺牲一些优化也要保证极快的编译速度？

因为 Go 从诞生的那一刻起，就是为了反抗 C++ 的过度复杂，和解决 Google 级别的工程规模问题。

它不是为了在编程语言理论上创新，而是为了让像 Ken Thompson 和 Rob Pike 这样的工程师，不再需要在编译期等待 45 分钟，不再需要去猜测一段代码到底在通过指针玩什么花样。

Go 的诞生，是工程实用主义对无节制复杂性的一次伟大胜利。

资料链接：https://www.youtube.com/watch?v=NTrAISNdf70

你的“编译等待”时刻

45分钟的编译时间催生了Go语言。在你的开发生涯中，是否也经历过类似的“编译噩梦”？或者，你是否也曾被某些语言的“过度复杂”劝退过？

欢迎在评论区分享你的故事！ 让我们一起致敬那些为了“简单”而努力的先驱。

如果这篇文章让你对Go语言的设计哲学有了更深的理解，别忘了点个【赞】和【在看】，并转发给身边还在忍受漫长编译的朋友！

还在为“复制粘贴喂AI”而烦恼？我的新专栏 《AI原生开发工作流实战》 将带你：

• 告别低效，重塑开发范式
• 驾驭AI Agent(Claude Code)，实现工作流自动化
• 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码，开启你的AI原生开发之旅。

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

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

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

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

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

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

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/12/26/google-2025-research-breakthroughs

大家好，我是Tony Bai。

“2025 年，我们见证了人工智能从一种‘工具’向一种‘实用效能 (Utility)’的根本性转变。如果说 2024 年是奠定多模态基础的一年，那么 2025 年则是 AI 开始真正思考、行动并与我们一同探索世界的一年。”

近日，Google 发布了由 大神Jeff Dean, 诺贝尔奖得主Demis Hassabis 和 James Manyika 三位顶级技术领袖联合署名的《2025 年度研发回顾》。这份报告是对 Google 过去一年技术成就的总结，更是一份关于 AI 未来发展方向的战略宣言。

从 Gemini 3 的推理能力突破，到 AlphaFold 在生命科学领域的持续深耕，再到量子计算的工程化落地，Google 用八大领域的进展，向世界展示了一个 AI 全面赋能科学与创造的新时代。

模型进化：Gemini 3 与“思考”的艺术

2025 年是 Google 模型能力突飞猛进的一年。Google 明确指出，AI 的进化方向已从单纯的“生成”转向了深度的“推理” (Reasoning)。

• Gemini 3 Pro：被誉为 Google 迄今为止最强大的模型。它不仅霸榜 LMArena，更在数学、编程和多模态推理上树立了新标杆。
• Gemini 3 Flash：延续了“Flash > 上一代 Pro”的传统，以更低的延迟和成本提供了顶级的推理能力，成为性价比之王。
• Deep Think：这是 Gemini 3 的核心能力之一。它让模型能够处理需要深度抽象推理的问题，甚至在国际数学奥林匹克 (IMO) 和国际大学生程序设计竞赛 (ICPC) 中达到了金牌水平。

AI 已不再只是概率性的文字接龙，它开始具备逻辑推导和解决复杂问题的能力。这标志着 AI 从“知其然”向“知其所以然”迈出了关键一步。

开发者工具：AI Agent 的崛起

在软件开发领域，Google 正式吹响了 AI Agent (智能体) 的号角。

• Google Antigravity：这是一个划时代的 AI 辅助软件开发平台。它不再是简单的代码补全工具，而是一个能够理解项目上下文、执行复杂任务、甚至与开发者协作的Agentic System。
• MCP (Model Context Protocol) 支持：Google 宣布在其服务中全面支持 MCP 协议，这是一个开放标准，旨在让 AI 模型能够标准化地连接和控制外部数据与工具。这标志着 Google 在构建开放、互操作的 AI Agent 生态方面迈出了坚实的一步。

开发者与 AI 的关系正在重塑。AI 将从“副驾驶”升级为能够独立执行任务的“队友”，而 MCP 协议的引入，将极大地加速这一进程。

科学发现：AI 成为科学家的“超级大脑”

Google DeepMind 继续在“AI for Science”领域领跑，将 AI 的力量注入到基础科学的探索中。

• AlphaFold 的五年：作为诺贝尔奖级的成果，AlphaFold 在发布五年后，依然是生命科学领域的灯塔，服务于全球 190 个国家的 300 万研究人员。
• AlphaChip 与 Ironwood：Google利用 AI (AlphaChip) 设计出了新一代 TPU —— Ironwood。这是一款专为推理时代设计的芯片，展示了 AI 自我进化的潜力：用 AI 设计更强的 AI 芯片。
• 量子计算的新篇章：随着量子纠错算法 Quantum Echoes 的发布，以及 Google 科学家 Michel Devoret 荣获诺贝尔物理学奖，Google 在通往实用量子计算机的道路上又迈进了一大步。

创造力与物理世界：AI 的“具身”时刻

AI 的影响力正在溢出屏幕，进入物理世界和创意产业。

• Robotics：Gemini Robotics 1.5 和 Genie 3 的发布，标志着通用世界模型 (World Models) 的成熟。AI Agent 开始具备理解物理规律、并在真实世界中执行任务的能力。
• 生成式媒体：从 Veo 3.1 (视频生成) 到 Imagen 4 (图像生成)，再到 Nano Banana 系列模型，Google 为创作者提供了前所未有的表达工具。

责任与安全：AI 发展的“刹车系统”

在追求速度的同时，Google 依然强调“负责任的 AI”。

• Frontier Safety Framework：Google 加强了其前沿模型的安全框架，Gemini 3 被称为“迄今为止最安全的模型”。
• AI 内容水印：在 Gemini 应用中引入了对 AI 生成视频和图像的验证功能，致力于解决 AI 内容的深度伪造问题。

小结：向 AGI 迈进的坚实一步

Jeff Dean 等人的这份报告，描绘了一个令人激动的未来：AI 正在从一个被动的查询对象，进化为一个主动的、有推理能力的、能与物理世界交互的智能体。

2025 年，不仅是技术的突破之年，更是 AI 范式转移的关键一年。无论是对于开发者、科学家还是普通用户，学会与这些“会思考”的 AI Agent 协作，将成为新时代最重要的生存技能。

资料链接：https://blog.google/technology/ai/2025-research-breakthroughs/

从“看客”到“领航者”：构建你的 AI 原生开发工作流

Google 的 2025 年度报告为我们描绘了 AI Agent 的宏大未来：AI 将不仅是代码补全的工具，更是具备推理能力、能独立解决问题的“队友”。

但对于此时此刻的开发者来说，最大的挑战在于：如何将这些“飞在天上”的未来技术，落地到我们每天的写代码、修 Bug 和架构设计中？

当 Google Antigravity 和 Gemini 3 正在重塑开发范式时，你是否还停留在只会用 Chatbot 问答的阶段？

是时候升级你的开发“操作系统”了。

在我的极客时间专栏《AI 原生开发工作流》中，我将带你跳出简单的 Prompt 技巧，深入探索：

• 告别低效，重塑开发范式
• 驾驭AI Agent(Claude Code)，实现工作流自动化
• 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

不要只做 AI 时代的见证者，要做驾驭 AI 的“原生开发者”。

扫描下方二维码，订阅《AI 原生开发工作流》，开启你的AI原生开发之旅！

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

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

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

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

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

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

© 2025, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/12/10/russ-cox-interview-go-birth-evolution-future

大家好，我是Tony Bai。

他是 Go 语言的第二代掌门人，在长达十余年的时间里，引领着 Go 从一个内部实验项目，成长为云原生时代的霸主。他也是 Plan 9 的资深黑客，贝尔实验室精神的传承者。如今，他已将 Go 的帅印交给了下一代，转身投入到 AI 模型编码能力的研究中。

他就是 Russ Cox。

在 ACM ByteCast 的一场罕见的深度访谈中，Russ Cox 系统性地回顾了他从贝尔实验室的青葱岁月，到创立 Go 语言的初心，再到对 AI 时代编程语言未来的深刻思考。这既是一段个人回忆录，也是一部关于“如何构建持久的技术”的生动史诗，充满了值得每一位 Gopher 细细品味的智慧。

Go 的“前传”——源自贝尔实验室的“简单”基因

Go 语言对“简单”的极致追求，并非凭空而来，它的种子早已在贝尔实验室和 Plan 9 操作系统的沃土中埋下。

Russ Cox 的编程之旅，始于上世纪 90 年代末的贝尔实验室。作为一个高中生，他有幸在那个创造了 Unix 的传奇之地“厮混”，与 Brian Kernighan, Rob Pike, Ken Thompson, Dennis Ritchie 这些“上古巨神”一同午餐、交流。

“贝尔实验室和 Plan 9 给我最深刻的印记，就是对构建真正简单的事物的执着。那里的人们，那是一个小团队，他们在做着雄心勃勃的事情，而完成它们的最好方式，就是从简单的事情开始，构建那些真正坚固可靠的简单事物。”

这段经历，为他注入了“简单”的 DNA。然而，当他进入 MIT 读研时，他第一次遭遇了“现代 C++”的“恐怖与复杂”。他被当时的业界现状所震惊：多线程不可靠、异步回调横行…… 这让他深信：“一定有更好的方式。”

Go 的“创世纪”——“让我们做点让自己开心的事”

2008 年春天，当 Russ Cox 结束学业，准备进入工业界时，已经先行加入 Google 的 Rob Pike, Robert Griesemer 和 Ken Thompson 向他发出了邀请，他们正准备全职启动一个新语言项目。

这个项目的初心，极其纯粹和个人化。

“我们都曾在 Google 写过大量的 C++ 程序……我们只是再也不想写那种代码了。我们受够了。我们知道有更好的方式，并且我们确信能把它带给 Google 的工程师们。”

“我们想解决的问题是，我们想构建一个能让我们在 Google 开心地编写程序的系统。”

Go 语言的诞生，并非一次自上而下的战略规划，而是一场由几位顶尖工程师发起的、旨在解决自身痛苦的“自救运动”。他们见识过更好的开发环境（Plan 9, Modula-3, Smalltalk），他们无法忍受现代 C++ 的复杂性。Russ Cox 甚至坦言：“说实话，我当时愿意付钱换取和他们一起工作的机会，而 Google 反而付钱给我。这对我来说是双赢。”

Go 的“演进哲学”——稳定压倒一切

从 Plan 9 的“无人问津”，到 Go 的巨大成功，Russ Cox 对开源社区的建设和语言的演进，有着极其深刻的理解。他认为，Go 的成功，很大程度上源于其对“稳定”的执着。

“进步可以有多种形式，一种是不稳定的进步，一种是稳定的进步。我们竭尽全力去寻找稳定的形式，而这通常意味着做得比人们要求的更少，但同时又能让他们解决自己的问题。”

他举了 go test 与 JUnit XML 格式集成的例子。社区曾强烈要求 go test 直接输出 JUnit 格式的 XML。但 Go 团队拒绝了，因为他们不想成为一个复杂 XML 格式的“专家”和“维护者”。

Go 团队的解决方案是：

1. 定义一个极其简单的、稳定的、机器可读的 JSON 输出格式。Go 团队只承诺维护这个简单格式的稳定性。
2. 告诉社区：“然后，你们可以自己写一个从这个 JSON 到你们所需 XML 的转换器。现在，你们可以自己解决自己的问题，而无需等待我们来解决。”

这种“授人以渔”而非“授人以鱼”的哲学，通过提供稳定、正交的底层构建块(build block)，赋能社区在其上构建自己的“进步”，这正是 Go 生态能够健康、蓬勃发展的核心秘诀。

AI 时代的“灵魂拷问”——我们还需要 Go 吗？

如今，Russ Cox 的工作重心已转向“理解和提升 AI 模型的编码能力”。对于 AI 是否会取代程序员这个终极问题，他给出了一个充满历史纵深感的、冷静的回答。

AI 只是进化的又一级台阶

他认为，AI 与编程语言的关系，是计算机发展史上“抽象层次不断提升”这一宏大叙事的延续。

• 40年代：我们通过手动连接电线来编程。后来，我们发明了解释器，用“数据”代替了“电线”。
• 50年代：我们有了 FORTRAN，用 ax² + bx + c 这样的公式，代替了手写机器指令。
• 今天：AI 正在将一些我们曾认为“只有人能做”的工作自动化，比如编写样板代码、调试简单问题。

“我认为 AI 将融入同样的模式……我们会将一些关注点交接出去，然后我们会找到更新、更大的事情来专注。每当我们的能力增长，或者我们将一些工作卸载给机器时，我们的雄心也会随之增长。”

AI 不会让我们失业，它只会让我们站到更高的起点，去挑战更宏大的问题。

编程语言不会消亡，清晰性永恒

Russ Cox 坚信，无论 AI 如何发展，人类可读、行为确定的编程语言都不会消亡。

“英语不会成为编程语言，因为它的歧义性太高了……最终，我们描述的依然是一门编程语言。”

“拥有一门人类可以阅读、理解的编程语言，这一点仍然至关重要。这样，当计算机行为不端时，你可以看着代码说：‘哦，我明白了为什么在这些指令下，它没有做正确的事。’”

AI 可能会帮助我们编写代码，但代码本身，作为人与机器之间那个最基础、最可靠的契约，其地位无可替代。

Go 在 AI 时代的定位

Go 诞生的初衷，是为了解决 20 年前兴起的“多核网络系统”这一巨大挑战。Russ Cox 认为，AI 很有可能在未来提出另一个同等级别的挑战，催生一门全新的语言。

“也许会有一门专为训练模型而生的新语言。Python 目前表现出色，但很容易相信你可以用一门定制语言做得更好。但整个世界并不会都在训练模型。”

他认为，世界上有大约 300 万 Go 开发者，但需要编写模型训练代码的人远少于此。这意味着，Go 作为一门为构建大规模、高并发网络服务而生的语言，其核心价值主张在 AI 时代不仅没有过时，反而愈发重要——因为所有的 AI 模型，最终都需要通过稳定、高效的服务来提供价值。

给后辈的忠告——如何构建持久的事业？

在访谈中，Russ Cox 还给所有有志于创造持久价值的年轻工程师，分享了两条极其宝贵的建议：

1. 花时间去真正理解问题：“很多时候，人们很容易满足于第一个能工作的方案。而我做过的大部分有价值的事，都来自于回头审视一个问题，然后感觉：‘实际上，我还没有完全理解它，我应该再试一次。’” 深入挖掘，直到你发现一个更简单、更根本的解决方案。

2. 找到让你兴奋的环境：“如果你对一件事感到兴奋，你早上醒来就想继续做它，那么你最终能完成的工作，将远超那些只为完成 8 小时任务的人……去找到那些能真正激励你的事情。”

领导力的传承 —— “最重要的期末考试，是退到一旁”

在访谈的最后，Russ Cox 分享了他对领导力，特别是开源项目领导力传承的深刻见解。这或许是整场对话中最具智慧和温度的部分。

他认为，开源社区的领导力，本质上是一种“社会性事业” (social endeavor)，沟通、协作、建立共识的能力，远比纯粹的编程能力更重要。而一个领导者最终极的考验，并非是他能做出多少贡献，而在于他能否以及何时选择“退到一旁”。

“最终，对领导者来说最重要的期末考试，就是退到一旁，然后说：‘好吧，我甚至不需要再在这里了。现在你可以领导这个了。’ 而这很难。”

Russ Cox 坦言，做自己擅长的事情是舒适和安全的，但他清醒地认识到，“项目需要新的想法和新的视角”。他回顾了 Go 领导权的两次交接：

1. 从 Rob Pike 到 Russ Cox：一次非正式的、渐进的交接。Rob Pike 邀请他加入，并在某个时刻悄然地“把项目交给了我，我突然就负责了”。
2. 从 Russ Cox 到 Austin Clements：一次更正式的交接。在领导 Go 长达十年之后，Russ Cox 在 2023 年正式将帅印交给了 Austin Clements。

他强调，这种传承的意义在于：

“确保项目能超越某个特定的人而存在，并且也能获得它们所需要的新视角和新想法。”

这不仅仅是一次权力的交接，更是一位卓越领导者对项目未来的深谋远虑和无私奉献。它确保了 Go 这艘大船，能够在新船长的引领下，继续朝着更广阔的海域航行。

结语

从贝尔实验室的“简单”初心，到 Go 语言的“稳定”哲学，再到对 AI 时代的冷静远见，Russ Cox 的这场访谈，为我们描绘了一位顶尖工程师和技术领袖的心路历程。

他的故事告诉我们，构建持久的技术，其秘诀不在于追逐一时的潮流，而在于深刻地理解问题，坚守核心的原则，并始终保持对创造的热情。这或许也是 Go 语言之所以能穿越喧嚣，成为今天这个样子的根本原因。

资料链接：https://learning.acm.org/bytecast/ep78-russ-cox

还在为“复制粘贴喂AI”而烦恼？我的新专栏 《AI原生开发工作流实战》 将带你：

• 告别低效，重塑开发范式
• 驾驭AI Agent(Claude Code)，实现工作流自动化
• 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码，开启你的AI原生开发之旅。

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

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

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

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

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

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

© 2025, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/11/24/google-adk-go-in-action

大家好，我是Tony Bai。

上周，我花了一个下午，仅仅是为了让一个Python写的Agent能稳定地调用我Go服务里的一个简单函数。在那一刻，看着屏幕上纠缠的gRPC、Python虚拟环境和混乱的日志，我脑海里只有一个念头：这不对劲，这绝对不是软件工程该有的样子！

显然，不仅仅是我一个人在为此焦虑。

就在最近，一个名为 google/adk-go 的项目悄然开源，并迅速霸榜 GitHub Go 语言趋势榜长达一周之久！ 全球的 Gopher 似乎都在用脚投票，表达着同一个渴望：我们受够了“炼丹”，我们要回归工程！

过去的一年，AI 的浪潮席卷了整个技术圈。我们 Gopher，作为构建云原生世界的中坚力量，看着 Python 社区在 AI 领域“杀”得热火朝天，心中或许都有一个共同的疑问：

“这场 AI 的盛宴，我们 Gopher 的主菜在哪儿？”

我们习惯了用 goroutine 优雅地处理并发，用 channel 安全地传递消息，用静态编译的单个二进制文件征服任何服务器。我们是天生的“工程师”，我们信奉的是可测试、可维护、可部署的软件工程哲学。

然而，当我们尝试踏入 AI Agent 的世界时，却常常感觉自己像一个闯入了“炼丹房”的“机械师”。面对那些需要反复“吟唱咒语”（调 Prompt）、结果飘忽不定的“丹炉”（模型），我们不禁会问：

• 我的 Agent 行为不稳定，怎么写单元测试？
• Prompt 稍微一改，整个“丹方”都可能失效，版本管理怎么做？
• 我如何将这个“充满魔法”的 Python 脚本，与我现有的 Go 微服务体系优雅地集成，而不是变成一坨无法维护的“耦合怪”？

这些问题，不是因为我们不懂 AI，而是因为我们太懂工程。我们厌倦了“炼丹”式的不确定性，我们渴望一种能将 AI 的强大能力，用严谨的工程纪律约束起来的解决方案。

现在，Google 亲自下场，为我们递来了“工程图纸”。

Google ADK for Go：写给工程师的 AI Agent 开发框架

这个霸榜的项目，全称是 Agent Development Kit (ADK) for Go。

这不是又一个“玩具”或“研究性”框架。从它的设计理念中，我看到了一个清晰而坚定的信号——AI Agent 开发，正在从“炼丹”式的“艺术创作”，全面进入“工程化”的“工业生产”时代。

而 ADK for Go 的核心哲学，与我们 Gopher 的信仰不谋而合，那就是——代码优先 (Code-First)。

• 你的 Agent，就是你的 Go 代码： 不再有晦涩的 YAML，不再有天书般的“链”，Agent 的所有逻辑、决策、工作流，都由你亲手编写的、地地道道的 Go 代码来定义。
• 天生的可测试性： 你的 Agent 就是一个实现了 agent.Agent 接口的 struct。这意味着什么？你可以像测试任何 Go 代码一样，go test 走起！Mock 依赖、断言行为，所有你熟悉的工程实践，全部回归。
• Git 即版本管理： Agent 的每一次进化，都是一次清晰的 git commit。Code Review、版本回滚，一切都尽在掌握。
• 云原生无缝集成： 它就是一个标准的 Go 模块，可以被无缝地集成到你的 Gin/gRPC 服务中，打包成一个极小的 Docker 镜像，部署到任何 K8s 集群。

这就是为什么它能霸榜 GitHub 的原因——它不是在教你如何更好地“调优 Prompt”，而是在教你如何用坚实的工程代码，去彻底终结那个不可控的“炼丹”时代。

Google的adk-go，就是那座连接 Gopher 工程世界与 AI Agent 智能世界的桥梁。

和我一起，从零开始“造”一个真正的 AI Agent

坦白说，ADK for Go 刚刚推出，市面上的教程几乎一片空白。文档虽有，但如何将其与真实的工程场景结合，如何理解其设计背后的权衡，如何避开那些必将遇到的“坑”——这些都需要有人去探索，去趟路。

所以，我决定做这件事。

我将以一个“学伴”和“探索者”的身份，推出我的全新付费微专栏：

《Google ADK 实战：用 Go 构建可靠的AI Agent》

在这个专栏里，我不会扮演一个无所不知的专家。相反，我会将我从零开始学习、实践、踩坑、顿悟的全过程，毫无保留地分享给你。

我们将一起，手把手地、从一个空 main.go 文件开始，完成一次令人兴奋的创造之旅：

• 第 1-2 讲：思维转变与灵魂注入
  我们将彻底理解“代码优先”的哲学，拆解adk-go，了解其中的概念、架构和核心组件，并亲手定义出第一个实现了 agent.Agent 核心接口的智能体。

• 第 3 讲：为 Agent 插上“手臂”： 让你的Agent能调用任何Go函数，像操作自己的手脚一样自如
  我们将学会 ADK 的“魔法”函数 functiontool.New，将一个普通的 Go 函数，零成本地转化为 Agent 可用的工具。

• 第 4 讲：赋予 Agent “双核记忆”
  我们将深入 session（短期记忆）和 memory（长期记忆），让我们的 Agent 能够理解上下文，并记起与你的历史交互。

• 第 5 讲：从“单兵”到“军团”： 构建一个懂分工、会协作的Agent团队，自动化完成复杂任务
  我们将学习 workflowagents，通过编排多个专家 Agent，构建一个强大的“代码生成-审查-重构”自动化流水线。

• 第 6 讲：从“原型”到“产品”
  我们将为 Agent 建立科学的评估体系，并最终将其打包成 Docker 镜像，部署到通用的 Kubernetes 环境中。

学完这个专栏，你将收获的，不仅是一个能跑起来的酷炫 AI 项目，更是一套可复用的、工程化的 AI Agent 构建方法论，以及在 AI 新浪潮中，属于我们 Gopher 的那份自信和底气。

加入这场 Gopher 的 AI 工程化之旅

这个微专栏，是我为你，也为我自己准备的一份“AI 时代 Gopher 生存指南”。它凝聚了我对 Go 工程哲学的理解，和我对 AI Agent 未来的全部热情。

微专栏共 6 篇深度长文，每一篇都是我亲手实践、细节满满的 step-by-step “航海日志”。

我没有设定一个高昂的价格，而是希望与更多志同道合的 Gopher 一起探索。所以，订阅这份专栏，仅需你一杯咖啡的诚意。

花一杯咖啡的时间，你或许能得到片刻的清醒；而用同样的价格投入到这里，我希望能为你带来一次思维的升级和技能的跃迁。

点击这里，或扫描二维码，立即加入。

让我们一起，用代码，构建智能。

P.S. 如果你对 AI Agent、Go 语言或者这个微专栏有任何问题，欢迎在评论区留言，我们一起交流探讨！

还在为“复制粘贴喂AI”而烦恼？我的新专栏 《AI原生开发工作流实战》 将带你：

• 告别低效，重塑开发范式
• 驾驭AI Agent(Claude Code)，实现工作流自动化
• 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码，开启你的AI原生开发之旅。

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

© 2025, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/11/15/go-turns-16

大家好，我是Tony Bai。

今年的 Go 官方16岁“庆生”文章，来得比以往时候都要晚一些。

往年，我们总能在 11 月 10 日或 11 日，准时收到这份来自 Go 团队的年度“家庭来信”。但今年，日历翻过了好几天，官方博客却依旧静悄悄。前几天，我还在知识星球上和星友们“抱怨”：“今年 Go 官方居然没有发 16 周年庆生纪念文章，比较反常啊！是忙忘了？还是没人有空写？”

现在回头看，这份“迟到”的生日礼物，或许恰恰反映了 Go 团队当前的状态。与其说是“忙忘了”，我更倾向于相信，这是新任技术负责人 Austin Clements 那种众所周知的严谨风格的体现——在没有将过去一年的所有重要进展都梳理清晰、打磨完美之前，宁愿延迟，也绝不仓促发文。抑或是，随着 Go 在 AI 时代的责任日益重大，团队的每一个字，都变得更加审慎和深思熟虑。

那么，这份姗姗来迟的“年度报告”，又为何值得我们全文翻译，并分享给大家呢？

因为这不仅仅是一篇生日贺文，它更是一份极其珍贵的、信息密度极高的官方“战略简报”。

在这篇文章里，Go 团队不仅系统性地盘点了过去一年中，从核心语言、安全体系到工具链的所有重大成果（synctest, Green Tea GC, FIPS 认证, go fix…），更重要的是，它首次清晰地、成体系地阐述了 Go 在 AI 时代的定位与雄心。它告诉我们，Go 团队正在如何将 Go 语言独特的并发、性能和可靠性优势，注入到 AI 集成、Agent 和基础设施的构建中。

对于我们每一位 Gopher 而言，这篇文章就是一张官方的“藏宝图”。它不仅能帮助我们快速跟上 Go 的最新动态，更能让我们洞察这门语言未来的发展方向，从而在技术浪潮中，做出更明智的学习和职业决策。

下面，就让我们一同深入这份迟到但分量十足的“生日礼物”。以下是文章全文。

刚刚过去的周一，11 月 10 日，我们庆祝了 Go 开源发布 16 周年！

我们遵循了现在已经非常成熟和可靠的发布节奏，在二月份发布了 Go 1.24，并在八月份发布了 Go 1.25。为了继续我们构建最高效的生产系统语言平台的使命，这些版本包含了用于构建健壮可靠软件的新 API，在 Go 构建安全软件的记录上取得了显著进展，以及一些重要的底层改进。与此同时，没有人能忽视生成式 AI 给我们行业带来的巨大变革。Go 团队正以深思熟虑且毫不妥协的思维方式应对这一充满活力的领域中的挑战和机遇，致力于将 Go 的生产就绪方法应用于构建健壮的 AI 集成、产品、智能体和基础设施。

核心语言和库的改进

新的 testing/synctest 包在 Go 1.24 中作为实验性功能首次发布，然后在 Go 1.25 中正式毕业，它极大地简化了为并发、异步代码编写测试的过程。这类代码在网络服务中尤为常见，并且传统上很难进行良好的测试。synctest 包通过虚拟化时间本身来工作。它将过去缓慢、不稳定或两者兼有的测试，转变为易于重写成可靠且几乎瞬时完成的测试，通常只需增加几行代码。这也是 Go 软件开发集成方法的一个绝佳例子：在一个几乎微不足道的 API 背后，synctest 包隐藏了与 Go 运行时和标准库其他部分的深度集成。

这并非过去一年中 testing 包得到的唯一增强。新的 testing.B.Loop API 不仅比原来的 testing.B.N API 更易于使用，还解决了编写 Go 基准测试时许多传统的——且常常是不可见的！——陷阱。testing 包还新增了 API，可以轻松地在使用 Context 的测试中进行清理，以及轻松地向测试日志写入内容。

Go 和容器化技术一同成长，并彼此配合得很好。Go 1.25 推出了容器感知调度，使这对组合更加强大。开发者无需任何操作，它就能透明地调整在容器中运行的 Go 工作负载的并行度，防止可能影响尾部延迟的 CPU 节流，并提升了 Go 开箱即用的生产就绪性。

Go 1.25 的新飞行记录器(flight recorder)建立在我们本已强大的执行追踪器之上，能够深入洞察生产系统的动态行为。执行追踪器通常会收集过多的信息，在长期运行的生产服务中不太实用，而飞行记录器则像一个小小的时光机，允许服务在出现问题之后，以极高的细节快照最近发生的事件。

安全软件开发

Go 继续加强其对安全软件开发的承诺，在其原生加密包方面取得了重大进展，并演进其标准库以增强安全性。

Go 在标准库中附带了一整套原生加密包，这些包在过去一年中达到了两个重要的里程碑。由独立安全公司 Trail of Bits 进行的安全审计取得了优异的结果，仅有一个低严重性的发现。此外，通过 Go 安全团队与 Geomys 的合作，这些包获得了 CAVP 认证，为完整的 FIPS 140-3 认证铺平了道路。这对于在某些受监管环境中的 Go 用户来说是一项至关重要的进展。FIPS 140 合规性，以往由于需要使用不受支持的解决方案而成为一个摩擦点，现在将被无缝集成，解决了与安全性、开发者体验、功能性、发布速度和合规性相关的问题。

Go 标准库持续演进，以实现默认安全和设计安全。例如，Go 1.24 中添加的 os.Root API 实现了抗遍历的文件系统访问，有效地对抗了一类漏洞，即攻击者可能操纵程序访问本应不可访问的文件。这类漏洞在没有底层平台和操作系统支持的情况下极具挑战性，而新的 os.Root API 提供了一个直接、一致且可移植的解决方案。

底层改进

除了用户可见的更改，Go 在过去一年中还在底层做了重大改进。

在 Go 1.24 中，我们完全重新设计了 map 的实现，借鉴了哈希表设计中最新、最伟大的思想。这一更改是完全透明的，并为 map 的性能带来了显著提升，降低了 map 操作的尾部延迟，在某些情况下甚至带来了显著的内存节省。

Go 1.25 包含了一个实验性的、在 Go 垃圾回收器方面的重大进步，名为 Green Tea。Green Tea 在许多应用程序中将垃圾回收开销减少了至少 10%，有时甚至高达 40%。它使用了一种专为当今硬件的能力和限制而设计的新颖算法，并开辟了一个我们正热切探索的新设计空间。例如，在即将发布的 Go 1.26 版本中，Green Tea 将在支持 AVX-512 向量指令的硬件上额外实现 10% 的垃圾回收器开销降低——这在旧算法中几乎是不可能的。Green Tea 将在 Go 1.26 中默认启用；用户只需升级他们的 Go 版本即可受益。

进一步发展软件开发栈

Go 远不止于语言和标准库。它是一个软件开发平台，在过去一年里，我们还对 gopls 语言服务器进行了四次常规发布，并建立了合作伙伴关系以支持新兴的智能体应用程序新框架。

Gopls 为 VS Code 和其他基于 LSP 的编辑器和 IDE 提供 Go 支持。每个版本都有一系列的功能和改进，提升了阅读和编写 Go 代码的体验（详情请见 v0.17.0、v0.18.0、v0.19.0 和 v0.20.0 的发布说明，或我们新的 gopls 功能文档！）。一些亮点包括：许多新增和增强的分析器，帮助开发者编写更地道和健壮的 Go 代码；对变量提取、变量内联和 JSON 结构体标签的重构支持；以及一个实验性的内置MCP服务器，用于模型上下文协议（MCP），它以 MCP 工具的形式向 AI 助手暴露了 gopls 的一部分功能。

从 gopls v0.18.0 开始，我们开始探索自动代码现代化工具。随着 Go 的演进，每个版本都带来了新的能力和新的惯用法；Go 程序员一直在寻找其他方法来做的事情，现在有了新的、更好的方法。Go 坚守其兼容性承诺——旧的方式将永远有效——但尽管如此，这在旧惯用法和新惯用法之间造成了分歧。现代化工具是静态分析工具，它们能识别旧的惯用法，并建议更快、更可读、更安全、更现代的替代方案，并且能一键可靠地完成。我们希望现代化工具能像 gofmt 为风格一致性所做的那样，为惯用法一致性做出贡献。我们将现代化工具集成为 IDE 的建议，在那里它们不仅能帮助开发者维护更一致的编码标准，我们相信它们还能帮助开发者发现新功能并跟上最新技术。我们相信现代化工具还能帮助 AI 编码助手跟上最新技术，并对抗它们倾向于强化关于 Go 语言、API 和惯用法的过时知识。即将到来的 Go 1.26 版本将包括对长期休眠的 go fix 命令的全面改造，使其能够批量应用全套的现代化工具，回归其Go 1.0 之前的根源。

九月底，我们与 Anthropic 和 Go 社区合作，发布了模型上下文协议（MCP）的官方 Go SDK 的 v1.0.0。这个 SDK 支持 MCP 客户端和 MCP 服务器，并支撑着 gopls 中新的 MCP 功能。将这项工作开源，有助于赋能围绕 Go 构建的日益增长的开源智能体生态系统的其他领域，例如最近由 Google 发布的Agent Development Kit (ADK) for Go。ADK Go 建立在 Go MCP SDK 之上，为构建模块化的多智能体应用程序和系统提供了一个地道的框架。Go MCP SDK 和 ADK Go 展示了 Go 在并发、性能和可靠性方面的独特优势如何使 Go 在生产级 AI 开发中脱颖而出，我们预计未来几年会有更多的 AI 工作负载用 Go 编写。

展望未来

Go 前方是激动人心的一年。

我们正在通过全新的 go fix 命令、对 AI 编码助手的更深层次支持，以及对 gopls 和 VS Code Go 的持续改进，来提升开发者的生产力。Green Tea 垃圾回收器的正式可用、对单指令多数据（SIMD）硬件功能的原生支持，以及运行时和标准库对编写能更好地扩展到大规模多核硬件代码的支持，将继续使 Go 与现代硬件保持一致，并提高生产效率。我们正专注于 Go 的“生产栈”库和诊断工具，包括由 Joe Tsai 和 Go 社区成员共同推动的、对 encoding/json 的一次大规模（且酝酿已久）的升级；由 Uber 的编程系统团队贡献的泄露 goroutine 分析；以及对 net/http、unicode 和其他基础包的许多其他改进。我们正致力于为使用 Go 和 AI 构建提供清晰的路径，谨慎地演进语言平台以适应当今开发者不断变化的需求，并构建能够同时帮助人类开发者和 AI 助手及系统的工具和能力。

在 Go 开源发布 16 周年之际，我们也在展望 Go 开源项目本身的未来。从其卑微的开端开始，Go 已经形成了一个蓬勃发展的贡献者社区。为了继续最好地满足我们不断扩大的用户群的需求，尤其是在软件行业动荡的时期，我们正在研究如何更好地扩展 Go 的开发流程——同时不失 Go 的基本原则——并更深入地让我们的优秀贡献者社区参与进来。

没有我们卓越的用户和贡献者社区，Go 就不可能有今天的成就。我们祝愿大家在新的一年里一切顺利！

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

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

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

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

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

想系统学习Go，构建扎实的知识体系？

我的新书《Go语言第一课》是你的首选。源自2.4万人好评的极客时间专栏，内容全面升级，同步至Go 1.24。首发期有专属五折优惠，不到40元即可入手，扫码即可拥有这本300页的Go语言入门宝典，即刻开启你的Go语言高效学习之旅！

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

© 2025, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/11/12/16-years-of-go-a-programming-language-built-to-last

大家好，我是Tony Bai。

每年的十一月，对于全球的 Gopher 而言，都是一个值得纪念的特殊时刻。今年，我们迎来了 Go 语言公开发布的第 16 个年头。

在众多的庆祝文章中，来自 Go 社区的知名组织 Ardan Labs 发布的这篇《Go 的 16 年：一门为持久而生的编程语言》，以其深邃的洞察力和饱满的情感，深深地打动了我们。

这篇文章不仅仅是对 Go 历史里程碑的简单罗列，更是一次对 Go 设计哲学——克制、清晰与长远思考——的深刻致敬。文章精准地捕捉了 Go 从解决 Google 内部的工程困境，到成为现代云原生基石的宏大叙事。我们相信，无论对于已经与 Go 同行多年的资深开发者，还是刚刚踏上 Gopher 之旅的新人，这篇文章都能带来启发与共鸣。

为此，我特将其全文翻译为中文，希望能与中文 Go 社区的各位一同分享这份喜悦与思考。以下是正文：

每年的十一月，Go 社区都会为我们这个时代最具悄然变革力量的编程语言之一，庆祝又一个里程碑。

诞生于 Google 并于 2009 年向世界发布的 Go，旨在解决大规模软件构建、庞大代码库、分布式系统以及跨大洲团队协作的复杂性。十六年后的今天，Go 诞生之初秉持的原则——简洁、快速和可靠——依然指导着它的发展。

正如 Go 团队在去年的周年纪念博文中所写：“Go 是为 2007 年的软件工程问题而构建的，但它仍在解决 2024 年的挑战，以及那些尚未到来的挑战。”

起源故事

这门语言源于 Google 三位工程师——Robert Griesemer, Rob Pike, 和 Ken Thompson——的挫败感，他们想要一门像 C 一样快、像 Python 一样高效、并且能满足 Google 基础设施规模化需求的语言。

他们并不想彻底革新编程，他们只是想让编程再次变得令人愉悦。

正如Rob Pike曾经说过的那样，“Go 是一次关于我们能去除什么的实验。”他们去除的过度复杂性、无休止的编译时间和混乱的依赖关系，反而成为了 Go 最大的优势。

Go 编程语言为何能迅速走红

Go 不仅仅是又一门新语言；它是对过度工程化的一次宣言。其设计目标使其脱颖而出：

• 快速编译：代码在数秒内完成构建，而非数分钟。
• 简洁性：极简的特性集，强调清晰与可读性。
• 并发：轻量级的 goroutine，使并发编程变得实用。
• 静态类型 + 安全性：在不牺牲开发速度的前提下，保证类型安全。
• 一流的工具链：go fmt、go test、go mod 及其他工具，塑造了 Go 的工匠精神文化。

这些价值观深深地触动了那些厌倦了语言功能蔓延的工程师们，也触动了那些需要稳定、可维护系统的公司。

现实世界中的 Go

多年来，Go 已悄然成为现代Web的支柱。它驱动着 Docker、Kubernetes、Terraform 和 Prometheus——当今云原生生态系统的根基。

在 Google 内部，它在后端系统中每秒处理数十亿次请求。在 Google 之外，它已成为初创公司构建分布式系统和企业级工具的首选，这些场景都要求在没有摩擦的情况下获得高性能。

“Go 诞生于 14 年前，至今它仍是唯一一门让并发感觉如此简单的语言。”

这种观点体现了 Go 在开发者领域中的独特地位：它既足够古老，经受住了考验，又足够现代，能够不断演进发展。

值得庆祝的里程碑

Go 的时间线上，点缀着一些关键时刻，展示了这门语言是如何有意识地演进的：

• 2009年：Google 正式公开发布 Go语言。
• 2012年：Go 1.0 发布，并作出了向后兼容的承诺。
• 2015–2018年：Go 成为容器化工具和微服务的标准。
• 2022年：泛型在 Go 1.18 中到来——一个期待已久的里程碑。
• 2024年：Go 位列全球最常用的十大语言之一，并在 AI 服务和边缘计算领域的采用率迅速增长。

正是这种稳定性，加上审慎的创新，让 Go 得以经久不衰。当其他语言追逐潮流时，Go 始终立足于实用性。

是什么让 Go 与众不同

与许多在每个新版本中不断膨胀的现代语言不同，Go 的演进一直很保守，而这种克制最终得到了回报。

Go 团队保持了一种罕见的、对向后兼容的承诺。十年前编写的代码，今天依然可以编译和运行。对于那些需要跨越数年甚至数十年维护生产系统的组织来说，这种信任是无价的。

Go 的简洁性也促进了团队协作。开发者可以快速上手代码库并投入工作。没有无休止的语法或模式争论，只有简洁、直接且高效的代码。

这种清晰性塑造了一个重视协作而非“炫技”的社区。

社区的经验教训

在一份以前的 Reddit 周年纪念帖子 中，开发者们回顾了 Go 是如何改变他们职业生涯的：

“Go 让我重新爱上了编程。”

“它不花哨，但它能搞定事情，这就是我爱它的地方。”

这些故事体现了 Go 的不朽精神；与其说是炒作，不如说是把工作做好。

下一章

Go 的下一个十年，将不仅仅是关于 Web 服务器和 API。其生态系统正在扩展到AI 基础设施、数据流和边缘计算等领域，在这些地方，性能、并发和简洁性至关重要。

根据 Go 团队的 15 周年博文，当前的工作重点是：

• 利用现代 CPU 架构，优化运行时性能。
• 改进生产系统中的遥测、可观测性和性能分析。
• 确保 Go 能够随着下一代硬件的发展而持续扩展。

对于押注 Go 的开发者和组织来说，这意味着一件事：这门语言没有放慢脚步，它正在升级。

Go的2025年：稳步求精，基础更牢固

发布于 2025 年 8 月的 Go 1.25 版本，体现了这门语言标志性的演进方式——安静、审慎的改进，而非颠覆。虽然没有破坏性变更，但几项更新有意义地加固了 Go 的基础。通过移除旧的“core type”概念，语言规范得以简化，澄清了类型推断和泛型的工作方式。工具链变得更精简、更快速，工具现在按需构建，go.mod 中加入了新的ignore指令，同时 go vet, go doc, 和 go version 等命令也得到了增强。

在底层，运行时获得了容器感知能力，能够根据 CPU 限制自动调整 GOMAXPROCS，使 Go 在云和边缘环境中更加高效。一个新的实验性垃圾回收器（greenteagc）提供了明显更低的停顿时间，而“ Flight Recorder”追踪则引入了持续的、低开销的可观测性。编译器和链接器现在能生成 DWARF 5 调试信息，以获得更小的二进制文件和更快的构建速度，同时修复了一个微妙的空指针 bug，提升了运行时安全。

在标准库中，开发者现在可以通过 testing/synctest 更容易地测试并发代码，并可以试用更快、更灵活的 encoding/json/v2 包。平台支持也向前迈进——现在要求 macOS 12 或更新版本，而 32 位 Windows ARM 将在此版本后停止支持。

总而言之，Go 1.25 提醒了我们这门语言为何能经久不衰：它在不破坏信任的前提下演进，用稳定、有影响力的进步，取代了喧嚣的炒作。

（来源: go.dev/doc/go1.25）

为 Go 干杯

在 Go 语言诞生 16 周年之际，我们不妨停下来，细细品味它所代表的意义。它不仅仅是一门编程语言，更是一种工程理念，其核心在于克制、清晰和长远思考。

在 Ardan Labs，我们亲眼见证了 Go 如何帮助团队构建可靠、可扩展的系统，从企业平台到初创原型，无所不包。它帮助工程师专注于真正重要的事情：解决实际问题，而不是与工具较劲。

祝愿 Go 语言再创辉煌一年。

不追逐潮流的语言，才能超越潮流而长存。

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

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

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

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

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

想系统学习Go，构建扎实的知识体系？

我的新书《Go语言第一课》是你的首选。源自2.4万人好评的极客时间专栏，内容全面升级，同步至Go 1.24。首发期有专属五折优惠，不到40元即可入手，扫码即可拥有这本300页的Go语言入门宝典，即刻开启你的Go语言高效学习之旅！

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

© 2025, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/11/02/6-months-47-microservices-architecture-disaster

大家好，我是Tony Bai。

“我们有一个运行了 8 年的 Python 单体应用，20 万行代码，工作得很好，很少崩溃，8 分钟就能部署。现在，新来的首席架构师，入职仅 3 个月，就要我们在 6 个月内，把它拆分成 47 个微服务。”

近日，在 r/softwarearchitecture 社区，一篇充满绝望与困惑的帖子引发了近百条评论的热议。这不仅仅是一个团队的技术困境，更像是一部在软件行业中反复上演的戏剧：一个稳定但“不时髦”的遗留系统，遭遇了一位满怀“宏大愿景”（和一堆时髦 buzzwords）的新领导。

发帖人描述的场景，让无数经历过类似“折腾”的工程师感到脊背发凉：

• 宏大的计划：47 个微服务，每个都有独立的 repo、数据库、Sidecar 代理，通过服务网格和事件总线进行异步通信，前端由 API 网关统一聚合。
• 脆弱的理由： 领导的理由也含糊不清，主要是“单体无法扩展”、“我们需要团队自治”，并不断引用“Google 和 Amazon 就是这么做的”。
• 荒谬的资源：一个 25 人的团队，意味着平均不到半个人负责一个服务。团队中绝大多数人没有任何分布式系统经验。
• 不可能的时间线：6 个月内完成，同时还要并行交付新功能。

发帖人绝望地问道：“这究竟是合法的、富有远见的架构设计，只是我太愤世嫉俗无法看清；还是我所见过的、最明目张胆的‘简历驱动开发’(Resume-Driven Development)？”

而社区的回答，几乎是压倒性的一致。在这篇文章中，我们就来看看架构师社区对这个帖子中问题的诊断过程与结论，以及给出的建议“药方”。

诊断一：典型的“简历驱动开发”(RDD)

这是社区给出的最普遍、也最尖锐的诊断。一位评论者一针见血：“你的架构师正在为他的下一份工作，填充他的简历和技能。” 另一位则补充道：“他会在项目成功‘实施’（但还未开始崩溃）后立刻离职，把烂摊子留给你们。”

RDD 的典型特征是：

• 解决方案在寻找问题：架构师带来了一整套时髦的技术栈（微服务、服务网格、事件总线、Kafka、K8s），却并没有清晰地论证当前系统到底遇到了什么非用这些技术不可的问题。
• 理由空洞，诉诸权威：“单体无法扩展”是一个未经证实的断言。当前系统（50k req/day, 即平均 < 1 rps）真的有扩展性问题吗？瓶颈在哪里？“Google 模式”更是典型的“货物崇拜编程”(Cargo Cult Programming)——盲目模仿成功者的表象，却不理解其背后的约束和权衡。
• 忽视成本与团队能力：完全无视一个 25 人的、缺乏经验的团队，在 6 个月内驾驭如此复杂的技术栈所需要付出的巨大成本，以及几乎 100% 会失败的风险。

诊断二：“拆掉洗碗机，重建整座房子”

发帖人的这个比喻，得到了社区的高度认同。一个运行了 8 年的系统，必然存在技术债，就像房子里的洗碗机可能坏了。但理智的做法是修理或更换洗碗机，而不是因此拆掉整座房子。

社区的资深工程师们纷纷指出，一个负责任的架构师，在提出如此激进的计划前，必须回答一系列基础问题：

• 问题是什么？ 当前单体应用最大的痛点是什么？是部署困难？代码耦合严重？还是特定模块的性能瓶颈？
• 现状如何？ 是否有基准测试数据？当前的性能极限在哪里？50k req/day 的负载真的需要 47 个服务来分担吗？（“我的树莓派都能处理 1 req/sec，”一位评论者讽刺道。）
• 价值何在？ 拆分后，业务上能获得什么具体的好处？是加快特定功能的交付速度，还是提升系统的可用性？这些收益是否值得付出巨大的重构成本？

这位新任架构师显然跳过了所有这些关键的分析步骤，直接给出了一个“终极答案”。

微服务的“正确姿势”：它解决的是“组织”问题，而非“技术”问题

许多评论深刻地指出了一个关于微服务的核心真相：

微服务主要解决的，不是技术扩展性问题，而是组织扩展性问题。 (康威定律的推论^_^)

当你有数百甚至数千名开发者在同一个单体应用上工作时，代码冲突、发布协调、团队依赖会成为巨大的瓶颈。此时，将系统按业务领域（Domain）垂直切分成独立的、可独立部署的服务，让每个小团队（“双披萨团队”）拥有自己服务的完全所有权，才能解放生产力。

对于一个只有 25 人的团队，强行拆分成 47 个服务，不仅不能实现“团队自治”，反而会因为引入了复杂的分布式系统依赖和运维开销，导致更多的沟通摩擦和更慢的开发速度。正如一位经历过类似重构的工程师所言：“我们因为‘团队自治’而拆分了所有单体，现在又因为无法忍受的运维开销而试图将它们合并回来。”

社区的“药方”：如何在这场风暴中幸存？

面对这位“愿景宏大”的架构师，社区给出了两条截然不同但同样充满智慧的建议：

药方 A：“向上管理”与“增量演进”

这条路径的核心是尝试挽救项目。一位来自 FAANG 的工程师分享了他们团队的真实做法：

1. 肯定意图，质疑方案：首先，肯定架构师“着眼未来”、“提升系统能力”的良好意图。
2. 提议 POC (概念验证)：建议从一个最小、最独立的业务领域开始。“让我们先用一周时间，只拆分一个服务作为 POC，来证明我们团队有能力构建和运维这样的系统，并验证它是否真的能解决我们的某个具体问题。”
3. 用数据说话：一个理智的领导者，会接受这个数据驱动的、风险可控的提议。如果架构师拒绝，并坚持“大爆炸”式的重构，那么他的动机就非常可疑了。
4. 寻求增量演进：倡导一种渐进式的“绞杀者无花果模式”(Strangler Fig Pattern)，逐步将单体中的功能，一块块地、有选择地、在确认有净收益的前提下，剥离成更小的服务（或者叫“宏服务”/“迷你服务”）。最终，你可能会得到一个“迷你单体” (Minilith) 和一圈环绕它的服务，而不是一个由 47 个碎片组成的“分布式单体”。

药方 B：“上车，刷简历，然后跳车”

这条路径充满了犬儒主义的智慧，但也反映了许多工程师在类似困境中的无奈选择。

“我的建议是：做我曾经做过的事。既然这是个注定失败的项目，那就登上这趟炒作的列车，用这些时髦的技术把你的简历填满，然后在它崩溃之前赶紧跳车。”

这虽然听起来不负责任，但当面对一个无法沟通、刚愎自用的领导，并且申诉无门时，保护自己的职业生涯，有时就成了唯一的理性选择。

小结：架构的本质是权衡，而非信条

这个故事，之所以能引发如此广泛的共鸣，是因为它触及了软件架构的本质：架构，是一系列关于权衡 (Trade-offs) 的决策，而不是一套可以盲目套用的信条或模式。

一个优秀的架构师，会像一名侦探一样，深入理解现有的系统、业务的约束和团队的能力，然后提出一个恰如其分的解决方案。而一个糟糕的架构师，则像一个手持锤子的人，看什么都像钉子——尤其是当那把锤子是印有“微服务”、“服务网格”等时髦字样的“黄金锤”时。

最终，这个故事提醒我们，在软件工程中，最危险的，往往不是过时的技术，而是脱离了现实约束的“宏大愿景”，以及那些打着“谷歌范儿”旗号，却对工程现实一无所知的“海鸥架构师”——飞进来，拉一堆屎，然后飞走。

资料链接：https://www.reddit.com/r/softwarearchitecture/comments/1o6re10/lead_architect_wants_to_break_our_monolith_into/

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

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

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

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

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

想系统学习Go，构建扎实的知识体系？

我的新书《Go语言第一课》是你的首选。源自2.4万人好评的极客时间专栏，内容全面升级，同步至Go 1.24。首发期有专属五折优惠，不到40元即可入手，扫码即可拥有这本300页的Go语言入门宝典，即刻开启你的Go语言高效学习之旅！

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

© 2025, bigwhite. 版权所有.