阅读视图

发现新文章,点击刷新页面。
🔲 ☆

2026 编程语言“饱和度”榜单出炉:JavaScript/Python 已“烂大街”,Go/Rust 成最大赢家?

本文永久链接 – https://tonybai.com/2026/04/02/2026-programming-language-saturation-rankings-go-rust-winners

大家好,我是Tony Bai。

在这个技术浪潮汹涌、AI 随时可能掀翻牌桌的时代,每一个程序员心中都悬着一个终极问题:

“我现在的技术栈,还能吃几年饭?”

我们每天都在焦虑地刷着各种技术文章,试图从 Google、Anthropic、OpenAI、Nvidia等的风向中,窥探下一个技术红利期。但这些信息往往零散、矛盾,甚至充满了各种培训机构的“幸存者偏差”。

就在半个多月前,X 平台上的一位技术博主 Mojisola Alegbe,基于 Stack Overflow、GitHub Trends、JetBrains 等多方数据,整理并发布了一份极其残酷的私房版《2026 编程语言“饱和度”榜单》。

这篇推文就像一颗深水炸弹,在短短几天内获得了 41.2 万的惊人阅读量。大批开发者涌入评论区,有人哀嚎,有人庆幸,有人愤怒,有人不屑。这张榜单之所以能引爆全网,因为它赤裸裸地揭示了我们这个行业最真实的“供需关系”和“内卷现状”。

今天,我们就来深度扒开这张榜单背后的血泪与真相。看看你我手中的“锤子”,到底还能敲几年钉子。

榜单冲击:你的技术栈,在鄙视链的哪一层?

让我们先深吸一口气,看看这份令人心跳加速的榜单:

  • JavaScript (66%): 极度饱和 (Extremely Saturated)
  • Python (58%): 非常饱和 (Very Saturated)
  • SQL (49%): 非常饱和 (Very Saturated)
  • TypeScript (35-40%): 高度饱和,且仍在快速增长
  • Java (26%): 成熟/稳定饱和
  • C# (18%): 中度饱和
  • PHP (10-11%): 正在衰退,但仍很普遍
  • C++ (6-7%): 小众,但用于关键系统
  • Go (4-5%): 低饱和,需求增长中
  • Kotlin (4-5%): 中度小众 (安卓)
  • Swift (2%): 小型但专业的生态系统
  • Rust (2-3%): 低饱和,但正在崛起

看完这张图,我猜很多人的第一反应是:

  • 前端/Python 工程师:完了,彻底“烂大街”了,明天就去送外卖。
  • Java 工程师:稳如老狗,任你风吹雨打,我自岿然不动。
  • Go/Rust 工程师:心中窃喜,果然选对了赛道,未来可期!
  • PHP 工程师:……(我 PHP 是最好的语言!)

但如果事情真的这么简单,那我们这个行业也未免太无趣了。这张榜单真正有价值的地方,在于它炸出了评论区里无数资深架构师和一线开发者的“人间清醒”。

社区百态:饱和、内卷与“幸存者偏差”

在这张榜单的评论区,你可以看到整个技术圈最真实的生态缩影。

阵营一:饱和焦虑派

“完了,我刚想学编程,这可怎么办?”
“怪不得现在工作这么难找……”

阵营二:不屑一顾派

“语言只是工具,解决问题才是关键。”
“这种指标毫无意义。”

阵营三:人间清醒派(重点看这里!)

这部分评论,往往来自那些穿越了数个技术周期的老炮。他们的观点,破具含金量。

一位开发者一针见血地指出:

“语言的饱和度是个误导性指标。真正的问题不是有多少开发者懂它,而是有多少开发者能用它构建出真正有价值的系统。”

另一位开发者则更加直接:

“饱和度百分比毫无意义。重要的是:你能交付吗(Can you ship)?我只看三个信号:1. 真实的生产环境部署(而不是教程);2. 系统设计的深度(而不只是 CRUD);3. 在压力下调试复杂问题的能力。JavaScript 饱和度 66%?那又怎样,其中 90% 的人连一个可扩展的架构都设计不出来。”

而一位博主,更是给出了顶级玩家的“搞钱思路”:

“聪明的开发者从不追逐‘流行’的语言,他们追逐的是‘高价值’的行业
Python → AI
C++ → 高性能系统(游戏、金融)
Rust → 安全基础设施(区块链、操作系统)
Go → 云平台(K8s、Docker)
追逐金钱,而不是追逐炒作(Follow the money, not the hype)。”

架构师的破局之道:从“横向内卷”到“纵向深耕”

扒开社区的口水战,我们可以总结出三条极其宝贵的“反内卷”生存法则。

第一条:停止在“语言层”的低水平竞争

如果你是一个 Python 开发者,你的核心竞争力绝对不是“比别人多会几个 itertools 的函数”。

评论区里的一条建议非常中肯:

“不要只学 Python 的语法。去学它底层的 C++ 和 CUDA。这才是 2026 年 AI 热潮中真正值钱的地方。”

同样的道理,如果你是一个前端开发者,让你在面试中脱颖而出的,绝不是多会几个 CSS 动画技巧,而是你对 V8 引擎的内存管理、对大规模前端项目的架构设计、对 WebAssembly 的底层原理的深刻理解。

饱和的永远是“表层应用”,而“底层原理”的护城河,深不见底。

第二条:将你的技术栈,锚定在高价值的“产业赛道”

你选择的语言,决定了你的“工具”;而你选择的行业,决定了你“工具”的价值。

如果你用 Go,但每天只是在写一些简单的 CRUD 业务,那你和用 PHP 的同行并没有本质区别。

但如果你用 Go,去深耕 Kubernetes Operator 开发、去搞 Service Mesh、去做 eBPF 的底层监控,那你将进入一个截然不同的“高价值稀缺区”。

对于大多数开发者来说,最好的策略不是去学一门全新的、不饱和的语言(比如 Zig 或 OCaml),而是在你现有的、最熟悉的语言生态里,找到那个与“高利润、高壁垒”行业结合最紧密的纵深方向,然后一头扎进去。

第三条:从“语言专家”进化为“系统架构师”

评论区里,有一个非常有趣的现象:初级开发者在讨论“哪个语言好”,而资深开发者在讨论“如何交付(Ship)”。

当一个系统变得复杂时,瓶颈往往早已不在于某个语言的语法特性,而在于:

这些“跨语言”的系统设计能力,才是拉开普通程序员和架构师之间收入差距的根本原因。

语言的红利期是短暂的,而架构的复利是终身的。

小结:你的价值,由你定义

这张“饱和度”榜单,与其说是一份“死亡通知单”,不如说是一张“体检报告”。它提醒我们,如果你安于现状,只停留在语言的表层舒适区,那么无论你现在用的是 Go 还是 Python,你都随时可能被更便宜、更年轻的开发者所取代。别忘了还有不断“蚕食”初级甚至中高级程序员工作的AI!

在这个充满不确定性的时代,真正的安全感,来源于:

  1. 向下扎根,掌握技术栈的底层原理。
  2. 向高处走,将你的能力锚定在高价值的产业。
  3. 向外看,建立跨越语言鸿沟的系统架构思维。

不要再为“哪个语言是宇宙第一”而进行无意义的口水战了。

你的价值,从来不是由你用什么语言决定的,而是由你能用这门语言,解决多大、多复杂、多有价值的问题决定的。

资料链接:https://x.com/yehhmisi/status/2031715243622015239


今日互动探讨:

看完这份榜单,你对自己目前的技术栈感到了焦虑,还是庆幸?在你看来,一个语言的“饱和”是危机,还是意味着更成熟的生态和机会?

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


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

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

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


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

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

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

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

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


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

© 2026, bigwhite. 版权所有.

🔲 ☆

告别古法编程黄金时代:AI 时代不会再有新编程语言诞生的土壤

本文永久链接 – https://tonybai.com/2026/03/24/no-soil-for-new-programming-languages-in-ai-era

大家好,我是Tony Bai。

如果你回望过去十五年的软件工程史,那无疑是编程语言百花齐放的黄金时代。

为了对抗日益膨胀的系统复杂度,人类绞尽脑汁地发明新的“咒语”:

Google 推出了 Go 语言,用极简的 Goroutine 拯救了深陷并发地狱的后端工程师;

Mozilla 孕育了 Rust,用严苛的所有权机制向内存泄漏和数据竞争宣战;

苹果用 Swift 埋葬了晦涩的 Objective-C;

JetBrains 用 Kotlin 为笨重的 Java的使用者提供了一个更优雅的选择;

微软用 TypeScript 彻底规范了狂野的 JavaScript 生态。

每一次新语言的诞生,都伴随着开发者们的狂欢。我们热衷于讨论语法糖、对比编译速度、争论哪种范式更优雅。我们在各大论坛上为自己喜爱的语言摇旗呐喊。

但这已经是最后的余晖了。

站在 2026 年的节点上,当你看着 Claude Code、Cursor 或各类 Coding Agent 在几秒钟内倾泻出数千行逻辑严密的代码时,一个残酷的真相正在浮出水面:

大模型(LLM)的爆发,彻底抽干了孕育下一代通用编程语言的土壤。属于人类的“造语言”游戏,结束了。

这不是危言耸听,而是基于技术演进第一性原理的必然推演。

语料霸权:新语言无法跨越的“生态死局”

在 AI 时代,一门编程语言的生命力不再取决于它的语法有多么优雅,而取决于它在 AI 模型中的“语料权重”

现存的主流语言(Python, Java, JavaScript, Go, C/C++等)在 GitHub 上积累了数年甚至十余年的海量开源代码。这些代码构成了大模型训练的底座,赋予了 AI 极高的“代码智商”。

当你用 Python 或 Go 提问时,AI 能够瞬间理解你的意图,补全复杂的逻辑,甚至自动发现隐藏的 Bug,因为它的“脑子”里装着上千万个成熟的 Python/Go 示例。

但对于一门新语言来说,这是绝对的死局。

假设明天某个天才发布了一门名为 Nova 的新语言,号称性能超越 C,安全性超越 Rust,语法如 Python 般简洁。

结果会怎样?

  • AI 不会写:因为训练语料里没有 Nova 的代码,大模型对它一无所知,无法提供智能补全。
  • 人类不会用:在“没有 AI 辅助就感觉不会写代码”的今天,一个习惯了口述意图,让AI Coding Agent 自动生成全量代码的程序员,绝不可能去碰一门必须纯手工敲击、AI 无法帮他编写和Debug的语言。

这就形成了一个无解的马太效应

没人写就没有语料 -> 没有语料 AI 就不会写 -> AI 不会写人类就不想学 -> 更没人写。

现存的主流语言通过“语料霸权”,彻底锁死了新语言上升的通道。

需求降维:为什么我们不再需要“更好写”的语言?

人类发明新语言的根本动力,是“人脑的带宽有限”

C++ 太容易写出内存泄漏,人脑排查太痛苦,所以我们发明了 Rust,让编译器做“真理警察”。

Java 处理异步回调太繁琐(Callback Hell),所以我们发明了各种新的语法糖。

我们一直在努力打造更锋利、更安全的斧头,因为那是人类自己要挥舞的斧头。

但在 Agentic Coding(智能体编程)时代,挥舞斧头的不再是人,而是不知疲倦的 AI。

当你可以用自然语言对 Agent 说:“用 C++ 实现一个高并发的 HTTP 服务器,并严格检查所有内存泄漏风险,写出 100% 覆盖率的测试用例。”

只要 AI 的推理能力足够强,加上自动化的沙箱验证(Eval),它完全可以写出极度安全、高效的 C++ 代码。

如果 AI 能够不知疲倦地处理最繁琐的语法、填补最冗长的样板代码(Boilerplate),并且不出错,那么“语言本身是否易读、是否好写” 似乎就变得不再重要了。

因为代码根本不是给人看的,也不是人写的。当“人脑带宽”不再是瓶颈,发明一种“让人类写得更舒服”的新语言,就失去了最大的现实动机。

语言的两极化:自然语言与“AI 中间码”

如果不再有新的面向人类的通用编程语言,未来的代码世界会变成什么样?

答案是:极端的两极分化。

上层:英语(或自然语言)成为终极编程语言。

Andrej Karpathy 的预言正在成为现实(Software 3.0)。人类不需要学习晦涩的语法,人类只需要学习如何清晰、严谨地表达意图,编写能够精准约束 AI 的 Spec(规格说明书)。我们与机器的接口,退回到了人类最擅长的媒介。

底层:只有机器能读懂的“AI 专属语言”。

如果你是大模型厂商(比如 OpenAI 或 Google),当你发现 90% 的代码都是你的模型生成的,你还会让模型生成冗长、为了兼顾人类可读性而充满妥协的 Java 或 Python 代码吗?

不会的。巨头们极有可能会研发一种专门面向 AI 优化的中间表示语言(Intermediate Representation, IR)

这种语言对人类来说如同天书,但对于模型来说:

  • Token 效率极高:原本需要 1000 个 Token 表达的逻辑,这种语言只要 50 个 Token,极大节省推理成本和上下文窗口。
  • 逻辑高度压缩:天生适合并行计算和智能体之间的状态传递。

AI 会将人类的自然语言直接“编译”成这种中间码,然后运行。

在这个过程中,介于自然语言和机器码之间、那种专门为了“让人类勉强能懂又能让机器执行”而存在的传统编程语言,其生存空间将被彻底抽空。

小结:致敬“古法编程”的黄金时代

这听起来有些感伤,但这就是技术演进的无情车轮。

就像今天,依然有人沉迷于机械表的齿轮咬合,依然有人热爱在暗房里冲洗胶卷。

“纯手工编写代码(Handcrafted Code)”——这种我们曾引以为傲的工业生产方式,未来可能也会退化成一种个人的“艺术爱好”或“思维体操”。我们称之为“古法编程”

在某个安静的周末,你或许依然会打开编辑器,为了兴趣手撸一段优雅的 Go 并发或者 Rust 生命周期,享受那种久违的、直接控制机器的“心流”多巴胺。

但在残酷的商业战场上,古法编程即将落幕。

不要再为语法糖而争论不休,不要再期待下一个能拯救你的新语言。

去锻炼你的系统思维吧,去学着用自然语言精准地描绘你的蓝图。因为在下一个时代,定义目标的造物主,永远比精通语法的泥瓦匠更稀缺。


你还在坚持“古法编程”吗?

面对 AI 现场生成代码的冲击,你是否还会为了某种语言的“优雅语法”而兴奋?在你的理想中,未来的“AI 专用中间码”应该长什么样?你是更享受亲自掌控每一行代码,还是更向往定义目标的“造物主”角色?

欢迎在评论区留下你对“古法编程”时代的最后致敬!


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

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

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


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

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

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

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

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


原「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 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚,享受技术精进的快乐!欢迎你的加入!

img{512x368}


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

© 2026, bigwhite. 版权所有.

🔲 ☆

硬核测评:哪门语言最受 AI 宠爱?13 种语言横向对比,Go 表现如何?

本文永久链接 – https://tonybai.com/2026/03/09/hardcore-review-13-languages-ai-favorite-go-performance

大家好,我是Tony Bai。

随着 Claude CodeGemini Cli、Codex 等 AI 编程工具的全面普及,“让 AI 写代码”已经从极客的玩具变成了日常的生产力。随之而来的是一个触及灵魂的问题:哪种编程语言最适合交给 AI 去写?

作为 Gopher,我们一直为 Go 语言的“极简语法”、“极速编译”和“强类型安全”感到自豪。我们理所当然地认为,这种没有任何隐式魔法、像白开水一样的语言,绝对是 LLM 的最爱。

然而,现实总是比直觉更骨感。近日,Ruby 核心提交者 Yusuke Endoh(@mame)发布了一份名为 ai-coding-lang-bench 的硬核定量测评报告。他使用 Claude Code(Opus 4.6 模型)对 13 种主流编程语言进行了系统性横向对比。

在这场涵盖了动态语言、静态语言和函数式语言的混战中,Go 语言的表现究竟如何? 是力压群雄,还是黯然失色?那些备受人类推崇的静态类型系统,在 AI 面前是否成了累赘?

本文和大家一起阅读和拆解这份报告,为你揭晓 AI 时代的语言偏好图谱。

实验设计:让 AI 写一个 Mini-Git

在评价这份报告之前,我们先来看看它的实验设计,这是目前业内少见的、针对 AI Agent 的工程化能力的量化评估。

任务目标:让 Claude Code (Opus 4.6) 从零开始实现一个 mini-git(简化版的 Git)。这是一个极具代表性的任务,它包含了文件 I/O、哈希计算、数据结构操作以及命令行接口,足以考验模型对语言生态的综合运用能力。

测试被巧妙地分为两个阶段,模拟了真实的软件生命周期:

  • v1 (新项目构建):实现基础的 init, add, commit 和 log。
  • v2 (特性扩展):在 v1 的基础上,增加 status, diff, checkout, reset, rm, show 等复杂指令。

提示词(Prompt)极其极简:“阅读 SPEC-v1.txt,实现它,并确保 test-v1.sh 测试通过。”这种设计最大程度地减少了人类指令的干预,纯粹考验 AI 代理在闭环环境下的自主编码、调试和测试能力。

参赛选手(13种语言/15种配置)

  • 动态语言:Python, Ruby, JavaScript, Perl, Lua
  • 动态+类型检查器:Python/mypy, Ruby/Steep
  • 静态语言:TypeScript, Go, Rust, C, Java
  • 函数式语言:Scheme (动态), OCaml (静态), Haskell (静态)

每种语言配置运行 20 次,以消除 LLM 生成的随机性带来的误差,并统计其耗时(Time)、成本(Cost,即 Token 消耗)和代码行数(LOC)。

核心发现:动态语言逆袭,Go 位居第二梯队

如果仅看总耗时和总成本(v1 + v2),测试结果呈现出了令人瞩目的阶梯式分布。

第一梯队:Ruby, Python, JavaScript 的绝对统治

在这场 AI 编程竞速中,Ruby(73.1s)、Python(74.6s)和 JavaScript(81.1s)组成了无可争议的第一阵营。

它们不仅生成速度最快、消耗 API 成本最低(均在 $0.40 以下),而且在 20 次测试中表现出了极高的稳定性(标准差极小)。

对于 AI 来说,生成这三种语言的代码就像呼吸一样自然。它们无需繁琐的项目初始化配置(如 Cargo.toml 或 package.json),可以做到“建个文件直接跑”,这种极简的工作流在 v1 阶段(新项目构建)优势极大。

第二梯队:被“强类型”拖慢脚步的 Go 与 Java

现在,来回答大家最关心的问题:Go 表现如何?

答案是:位居第二梯队。Go 的总耗时为 101.6s,平均成本 $0.50。中规中矩。Go 虽然在语法上非常克制,但依然落后于 Python 和 JS 等动态语言。与之类似,Java(115.4s)也因为繁琐的语法结构和强类型约束,留在了这一梯队。

尽管如此,Go 在整个 20 次测试中没有出现一次失败(0 次 fail),这证明了 Go 的编译器在防止 AI 产生“幻觉 Bug”方面,发挥了极其可靠的安全网作用

“后进生”阵营:Rust 与 C 的挣扎

备受人类极客推崇的 Rust(113.7s,且有 2 次失败)和底层的 C(155.8s)在测试中显得步履维艰。

尤为值得注意的是,在总共 600 次的独立运行中,只有 Rust (2次) 和 Haskell (1次) 出现了测试失败(未能最终跑通 Shell 脚本)的情况。这两门语言都以其极高的心智负担和“编译器教你做人”的严格程度而闻名。

这也是将Rust列入“后进生”阵营的主要原因。如果用《飞驰人生》的拉力赛来比喻,Rust 相当于在40站的赛季中,有两站没能完赛!

深度剖析:为什么 AI 更偏爱动态语言?

在传统的工程视角中,“静态类型防止低级 Bug”、“动态语言难以维护”是金科玉律。但在 LLM 驱动的 Agent 开发流中,这个逻辑为何失效了?作者 Yusuke Endoh 提出了几个关键的解释维度。

训练数据的“虹吸效应”

LLM 的能力直接取决于训练语料的规模和质量。Python、JavaScript 和 Ruby 是过去十几年 Web 开发的绝对主流。GitHub 上海量的这三种语言的开源代码、StackOverflow 上的问答,为 Claude Code 提供了极其丰富的“预训练肌肉记忆”。

当 AI 需要实现一个功能时,它在 Python 的隐空间(Latent Space)中寻找最优解的路径,远比在 Haskell 甚至 Rust 中要清晰、笔直得多。

静态类型的“双刃剑”与重构阻力

静态类型系统的初衷是约束人类,防止我们在重构时犯错。但在 AI 的“ Prompt -> 生成 -> 测试报错 -> 思考 -> 再生成”的迭代循环中,严格的类型检查反而成了巨大的“摩擦力”。

  • 编译成本与调试死锁:在 Rust 或 C 中,当 AI 生成的代码出现类型不匹配时,它需要花费大量的 Token 去阅读复杂的编译器报错信息。有时,为了解决一个简单的借用检查器(Borrow Checker)报错,AI 可能会陷入漫长的、无休止的“试错-编译失败”死循环。
  • 重构牵一发而动全身:在 v2 特性扩展阶段,往往需要修改现有的数据结构。对于 Python,AI 只需要在字典里加个 key;而对于 Rust 或 Java,这可能意味着需要重构一系列的 Struct、更新类型签名、甚至修改与之相关的无数个函数的参数声明。这种“爆炸半径”极大地增加了耗时。

“附加类型检查”的巨大损耗

报告中一个非常有意思的对照组是:原生动态语言 vs 附加类型检查器的动态语言。

  • Python (74.6s) vs Python/mypy (125.3s) —— 变慢了 1.6~1.7 倍。
  • Ruby (73.1s) vs Ruby/Steep (186.6s) —— 变慢了 2.0~3.2 倍!

这证明了,迫使 AI 在动态语言中编写严谨的类型注解(Type Annotations),是一项极其昂贵的任务。模型需要耗费额外的算力去推导类型、生成类型声明文件,并且在类型检查器报错时,还要去修复那些在纯动态模式下可能根本不影响运行的“伪 Bug”。

代码量(LOC)的迷思:越短越好吗?

我们通常认为,写得越少,跑得越快。但数据打破了这个迷思。

Haskell 和 OCaml 生成的最终代码行数(224行和 216行)是所有语言中最少的,甚至少于 Python 和 Ruby。然而,它们在生成时间上的表现却排在倒数(Haskell 耗时最长,达 174s)。

这表明,对于 AI 来说,函数式语言那种高度抽象、信息密度极大的代码,生成和推理的成本远高于像 Python、Go 那种稍微啰嗦但逻辑平铺直叙的“大白话”代码。浓缩的未必是精华,对于 LLM 来说,高度浓缩往往意味着更高的生成熵和更高的试错概率。

行业启示:我们需要重新思考 AI 时代的技术栈选型

面对这份详实的基准测试报告,无论你是 CTO 还是普通开发者,都必须开始重新审视未来的技术选型逻辑。

动态语言是快速原型的“绝对王者”

如果你正在启动一个新项目,或者需要用 AI Agent 快速验证一个业务流程,Python 和 TypeScript 是首选(报告中 JavaScript 表现优于 TS,但在实际工程中 TS 的综合权衡更佳)。

不要迷信“大型项目必须一开始就上强类型编译语言”。在需求快速变化的初期,让 AI 用动态语言狂飙突进,是获取业务反馈最高效的手段。

性能王者们的困境:Go 与 Rust 在 AI 时代掉队了吗?

看到测评数据,很多 Gopher 可能会感到失落:难道注重工程严谨性和系统级性能的静态语言,真的在 AI 时代掉队了吗?

结论并非如此悲观。我们需要明确一点:Agent 测评的速度,不等于软件最终运行的速度。

  • 业务试错 vs 基础设施:AI Agent 目前最擅长、也最快速能完成的,是写“胶水逻辑”和“业务 CRUD”。在这些领域,Python 确实快。但当你的系统涉及到高并发、内存精细控制、或者需要打包为轻量级容器部署时,人类依然需要 Go。
  • 容错的底线:在这场 600 次的庞大测试中,只有 Rust 和 Haskell 出现了最终测试失败,而 Go 保持了完美的 100% 成功率。这恰恰说明,Go 在“极度灵活(易幻觉)”与“极度严格(难生成)”之间,找到了一个非常微妙的平衡点。它可能不是 AI 写得最快的,但它一定是 AI 写出来最让人放心的系统级语言。

我们不应期待 AI Agent 能够像写 Python 脚本一样,如德芙般丝滑地生成出一个复杂的 Go 并发系统。但在 AI 给出的初稿之上,Go 语言极佳的可读性和统一的规范,将为人类工程师的最终审查(Code Review)节省巨大的精力。

小结:下一个十年的编程语言,长什么样?

ai-coding-lang-bench 给我们上了生动的一课。它揭示了当前 LLM 的偏好:它们喜欢有海量训练数据的、灵活的、不需要应对死板编译器的语言。

但我们必须认识到,这只是一份基于 2026 年初模型(Claude Opus 4.6)的快照。未来的 AI 编程语言形态,可能会朝着两个方向演进:

  1. AI Native 语言的诞生:抛弃目前设计给人类阅读的语法,出现一种专门为了降低 LLM 生成 Token 成本、且天然抗幻觉的机器中间语言。
  2. 现有静态语言的“Agent 友好化”编译模式:Go 和 Rust 可能会进化出一种特殊的编译模式。在这个模式下,编译器不仅是冷冰冰地报错,还能以结构化的、对 LLM 更友好的方式提供“修复建议”,从而大幅缩短 Agent 修复编译错误的反馈回路。

无论如何,浪潮已经来临。在 AI 主导代码生成的新时代,我们评价一门编程语言的标准,正在从“它对人类大脑是否友好”,悄然转变为“它对大模型推理是否友好”

而在这场新赛道上,动态语言们,已经抢跑了。

本文核心数据与图表均来源于 GitHub 项目 mame/ai-coding-lang-bench


你的 AI 编程初体验

看完这个排名,你是感到意外,还是早已感同身受?在你日常使用 AI 编程时,你觉得它写哪种语言最让你省心?你是否也曾为了修一个 AI 写的编译错误而陷入“死循环”?

欢迎在评论区分享你的“AI 协作”红黑榜!


“语言的严格性正在变成 AI 的摩擦力?在 AI 时代,掌握一套能驱动 Agent 自动化、自修复的‘工作流’比死磕语法更重要。我的新专栏 AI原生开发工作流实战 将教你如何利用 Claude Code 结合 Spec 驱动开发,构建真正高产出的‘软件工厂’。”

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

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


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

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

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

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

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


原「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 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚,享受技术精进的快乐!欢迎你的加入!

img{512x368}


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

© 2026, bigwhite. 版权所有.

🔲 ☆

“棘手”难题:为什么 Go、Rust 与 Java 等语言的包管理永远无法达到完美?

本文永久链接 – https://tonybai.com/2026/03/04/package-management-unsolvable-problem-programming-languages

大家好,我是Tony Bai。

每天,全世界的开发者敲击下数以亿计的 npm install、go get、cargo build 或是 pip install。我们将这些包管理器视作理所当然的基础设施,仿佛它们就像水龙头一样,拧开就有源源不断的开源代码流出。然而,在这些看似简单的命令行背后,隐藏着计算机科学中最复杂、最容易引发争议,且永远无法找到“完美答案”的深水区。

近期,一篇名为《Package Management is a Wicked Problem》(包管理是一个“棘手”问题)的文章在技术社区引发了广泛关注,其姊妹篇《Package Management Namespaces》更是深度拆解了包命名的底层逻辑。作者以其多年参与包管理器数据和工具开发的经验,向我们揭示了一个残酷的真相:包管理不仅仅是一个纯粹的计算机科学问题,它是一个融合了社会工程学、经济学、安全性和向后兼容性的无底洞。 任何在这个层面上的微小改进,都会引发波及全球数千万个项目、数亿个版本的海啸。

本文将结合这两篇深度文章的核心观点,带你全景式地审视现代主流编程语言(如 Go、Rust、Python、JavaScript、Java)在包管理与“命名空间”上的激烈博弈与艰难演进。

包管理为何是一个“棘手问题”(Wicked Problem)?

为了准确描述包管理的困境,原作者借用了 1973 年社会规划学者 Horst Rittel 和 Melvin Webber 提出的“棘手问题”(Wicked Problem)这一经典概念。

在城市规划或公共政策领域,“棘手问题”通常指的是那些没有明确边界、没有唯一正确答案、且试图解决它的行为本身就会改变问题定义的问题。作者指出,在涉及万亿次下载和全球协作的今天,包管理完美地契合了 Rittel 和 Webber 提出的“棘手问题”的多个核心特征:

问题的表述与解决方案是同一件事

当我们谈论“包管理”时,我们到底在谈论什么?

作者敏锐地指出,这个词本身就是模棱两可的。对于前端开发者,它可能意味着用 npm 管理构建时的依赖树;对于系统管理员,它可能意味着用 apt 或 Homebrew 在操作系统上安装已编译好的二进制工具。

即使在同一个生态系统中,命名也充满了争议:我们称其为 package(包)、module(模块)、crate(板条箱)还是 distribution(发行版)?这些并非简单的同义词替换,它们各自编码了对“什么东西被版本化”、“什么东西被发布”以及“什么东西被安装”的深刻假设。正如作者所说:“包管理一路向下都关乎命名,而命名众所周知是计算机科学中的两大难题之一。”

当你决定引入 Lockfile(锁文件)时,你并不是在解决一个大家事先都同意的问题,你实际上是在重新定义“安装依赖”这个行为本身。这正是“棘手问题”的典型特征:解决方案定义了问题。

根本没有绝对的“对与错”,只有“好与坏”

在包管理的世界里,几乎没有任何技术决策可以被客观地评判为“真”或“假”。

作者以 Homebrew 为例:早期 Homebrew 选择直接使用 Git 作为其软件包数据库。这在当时是一个绝妙的设计,降低了门槛,极大促进了早期的繁荣。但随着规模的爆炸,Git 仓库的拉取成了巨大的性能瓶颈。那么,当初选择 Git 是错的吗?这取决于你是看重早期的简单性,还是看重长期的扩展性。

作者还深入剖析了语义化版本控制(SemVer)的困境。SemVer 试图将版本更新变成一种“非黑即白”的契约:引入破坏性变更(Breaking Change)就必须升级主版本号。但在实际操作中,这完全沦为了主观判断。

这里作者引入了著名的海勒姆定律(Hyrum’s Law):“当一个 API 拥有足够多的用户时,你在契约中承诺什么已经不重要了,你系统的所有可观测行为都将被某些用户所依赖。”

这意味着,对于某个开发者来说仅仅是修复了一个底层的 Bug,但对于恰好依赖这个 Bug 特性运行的另一个用户来说,这就是一次彻头彻尾的破坏性变更。版本号的跳动永远无法客观地评估对所有人的影响,它只能是“对特定人群好”或“对特定人群坏”。

不可逆的深远后果与试错的代价

在科学研究中,你可以提出假设并在实验室中进行 A/B 测试。但在包管理器设计中,你没有这种奢侈。作者强调:“每一个实施的解决方案都会留下无法消除的痕迹。”

当年 Python 的包索引(PyPI)决定接受无命名空间的扁平包名时,拼写抢注(Typosquatting)攻击就成为了这个生态不可避免的宿命。即便 PyPI 明天决定强制引入层级命名空间,它也无法改变全球数以千万计的存量 requirements.txt 文件,更不能直接使那些旧代码失效。

同样,RubyGems 至今仍托管着自 2007 年以来就未曾更新的古老包。在这个领域,没有推倒重来的机会(No do-overs)

当年 npm 社区发生的 left-pad 事件(作者因为不满而撤下了一个仅有 11 行代码的基础库,导致全球无数基于 Babel、React 的项目构建失败),就是一个惨痛的教训。当你允许“取消发布”时,你不仅是在做一个功能,你是在制定一项将永久塑造开发者行为的政策。

利益相关者的根本冲突与多重因果

包管理到底应该优化什么?作者为我们罗列了一系列相互冲突的诉求:

  • 注册中心运营者想要极简的存储和极致的稳定性。
  • 安全研究员想要可审计性和不可变性。
  • 库作者想要发布时的灵活性。
  • 企业应用开发者想要绝对的构建可重复性。

这些目标是内在矛盾的。一个允许库作者轻松推送更新的系统,必然也是一个更容易受到供应链攻击的系统;一个能够捕获每一层深层依赖的 Lockfile,必然也是一个在执行安全升级时更痛苦的组件。

npm、Yarn 和 pnpm 能够在前端生态中三足鼎立,正是因为它们对这些冲突的诉求做出了不同的妥协。Yarn 的诞生是因为 Facebook 迫切需要 npm 早期未能提供的绝对可重复性;而 pnpm 的崛起则是因为开发者对磁盘空间和安装速度的渴望压倒了对传统 node_modules 结构的兼容性需求。

命名空间之战——安全与便利的生死博弈

在理解了包管理的“棘手”本质后,原作者将目光投向了包管理的核心战场:“命名机制”。你如何为一个包赋予一个全球唯一的标识符?这不仅决定了开发者的使用体验,更直接决定了整个生态的安全性架构。

作者在其姊妹篇《Package Management Namespaces》中,详细梳理了主流语言生态演化出的四种截然不同的命名范式。

扁平命名空间(Flat Namespaces):“先到先得”的蛮荒时代

代表生态: RubyGems, PyPI (Python), crates.io (Rust)

这是历史最悠久、设计最直观的模式:一个巨大的、全局共享的名称池。规则很简单:先到先得。如果你抢到了 requests,那就是你的。

  • 开发者的蜜月期:在生态初期,这种模式极度舒适。名称简短、好记,在命令行里敲下 gem install rails 或 cargo add serde 时,体验极其顺滑。
  • 作者指出的致命缺陷:命名稀缺与安全梦魇。

随着生态规模的爆炸式增长(如 PyPI 目前已有超过 60 万个项目),好名字很快被耗尽。许多简短的、有意义的词汇被一些只有个位数下载量的废弃项目永久“占坑”。新开发者被迫使用 python-dateutil 或 beautifulsoup4 这样带有笨拙前缀或数字后缀的名称。

更严重的是,这种模式为拼写错误抢注(Typosquatting)提供了完美的温床。攻击者只需注册 reqeusts(对应合法的 requests)然后守株待兔。因为在用户的键盘敲击和注册表查找之间没有任何组织层级的校验,也没有层级结构需要导航,这种基于简单字符串匹配的攻击防不胜防。

作用域命名空间(Scoped Namespaces):组织的介入与权力的转移

代表生态: npm (JavaScript), Packagist (PHP)

为了解决扁平命名的稀缺和冲突,npm 在 2014 年引入了作用域(Scopes)。你可以发布 @babel/core 而不是去争抢早已被占用的 babel-core。PHP 的 Packagist 更是从一开始就强制要求使用 vendor/package 的格式(如 symfony/console)。

  • 空间的释放:这极大地缓解了命名冲突。不同的组织可以安全地使用相同的叶子节点名称,例如 @types/node 和 @anthropic/node 可以和平共处,互不干扰。
  • 作者提示的挑战:治理成本的飙升与“上移的占坑”。

作用域引入了复杂的治理问题。谁有权决定 @babel 属于 Babel 团队?这就需要平台提供账号管理、所有权转移机制甚至处理商标纠纷的流程。

此外,作者犀利地指出,在 Packagist 这种强制模式中,虽然包名(package)不冲突了,但“供应商(Vendor)”名称本身依然是先到先得的。如果有人提前在 Packagist 上抢注了 google 这个供应商名称,那么 Google 官方的所有包都会被拦截在生态之外。这等于是把“占坑”的问题向上推了一个维度,其潜在的破坏力实际上更大。

层级命名空间(Hierarchical Namespaces):绑定全球 DNS 体系

代表生态: Maven Central (Java, Clojure)

Java 生态极其聪明地将包命名的治理权“外包”给了全球最大的、已经建立共识的分布式治理系统——DNS(域名系统)。你必须拥有 example.com 的域名所有权,才能发布前缀为 com.example 的包。

  • 秩序的建立:这几乎彻底消除了无意义的恶意占坑。像 Apache、Google 这样的庞大组织拥有了极其清晰、权威的代码家园。
  • 作者揭示的致命隐患:MavenGate 与域名复活攻击。

这种看似无懈可击的设计,依然存在致命的盲区。域名的所有权并不是永恒的,公司会倒闭,域名会过期。作者引用了安全公司 Oversecured 在 2024 年初发布的 “MavenGate” 报告:在与 Maven 关联的 3 万多个域名中,有近 18%(约 6170 个)域名已经过期或重新流入市场挂牌出售!

这其中甚至包含了被广泛使用的 co.fs2、com.opencsv 等知名库的根域名。这意味着,恶意攻击者只需花费极低的成本(几十美元)买下这些过期的域名,就能顺利通过 Maven Central 的 DNS TXT 记录验证,以合法原作者的身份接管整个命名空间,并发布带有后门的恶意新版本。由于大多数自动化构建工具倾向于拉取最新版本,这种基于“域名复活”的供应链攻击将具有毁灭性的穿透力和隐蔽性。

基于 URL 的标识符:去中心化的乌托邦与残酷现实

代表生态: Go, SwiftPM

Go 模块(Go Modules)做出了一个在当时看来非常激进的选择:直接使用代码托管地址(如 github.com/gorilla/mux)作为包名标识符,彻底取消中心化的“注册(Registry)”步骤。

  • 优雅的直达:这实现了零注册摩擦。URL 在结构上天然保证了全球唯一性,且通过对 Git 仓库的所有权,自然而然地确立了对代码包的所有权。
  • 作者分析的隐藏代价:被基础设施绑架与脆弱的信任链。

这种模式将包的命运与底层的托管平台(特别是 GitHub)进行了深度且危险的绑定。如果一个 GitHub 组织改名了,或者一个生气的开发者删除了他的仓库,所有依赖这些路径的下游系统都会瞬间崩溃。

为了弥补这个“去中心化”带来的巨大可用性缺陷,Go 团队不得不花费数年时间,在核心机制之外构建了极其庞大的辅助基础设施:

  1. Module Proxy(模块代理):用于持久化缓存源码。这样即使 GitHub 上的原仓库被彻底删除,只要代理中有缓存,全球的 Go 构建就不会中断。
  2. Checksum Database (SumDB):这是一个基于透明日志(Transparency Log)的校验和数据库。它提供了一个不可篡改的全局信任锚点,保证了任何人、在任何时间、从任何代理拉取同一个版本的 Go 模块,得到的哈希值必须绝对一致。它防止了作者恶意 force-push 篡改代码,甚至连运营该数据库的 Google 自己也无法在不被察觉的情况下篡改历史记录。

作者通过对比指出,苹果生态的 SwiftPM 起初也采用了类似的 Git URL 模式,但并未配套建立 Proxy 和校验数据库。这导致如果 GitHub 仓库消失,Swift 的构建就会直接面临失败。更糟糕的是,2022 年的安全研究发现,大量 Go 和 Swift 包容易受到“仓库劫持”(Repo-jacking)攻击(即攻击者重新注册已注销的 GitHub 用户名,并重建同名的旧仓库)。Go 因为有强悍的 Proxy 和 SumDB 作为护城河,成功抵御了此类攻击;而 SwiftPM 至今仍暴露在巨大的软件供应链风险之中。

深重历史包袱下的“痛苦迁徙”

我们现在已经通过学术分析和前车之鉴,知道了理想的包管理应该是什么样。但原作者指出了一个无情的现实:大部分语言的包管理器早在十多年前就已经定型,它们带着最初的缺陷狂奔至今,积累了如同天文数字般的历史包袱。 如今想要修复这些缺陷,无异于给一架正在高速飞行的跨洋客机在空中更换引擎。

作者以 Rust (Cargo/crates.io) 的演进为例,生动地展示了这种深度重构的痛苦与艰难。

Rust 社区作为一个极其注重工程严谨性的生态,早在 2014 年起就在讨论引入命名空间。由于一开始选择了扁平命名,优质的单词已被大量占用。直到 2025 年,Rust 社区才终于正式推进了由 Manish Goregaokar 起草的 RFC 3243(可选命名空间) 提案。

他们的过渡方案设计得极其精妙且克制:不引入新的顶级前缀,而是将现有的合法包名升级为潜在的命名空间根节点。

这意味着,如果你当前拥有 serde 这个基础包的所有权,你就可以顺理成章地发布 serde::derive(使用双冒号 :: 是为了与 Rust 原生的模块语法保持高度一致)。这种设计完美地做到了向后兼容:现有的扁平命名继续有效,新的层级命名以一种非常“Rust”的方式平滑引入。

但这依然无法避免阵痛。

作者举例说,像 tokio-macros 这样已经广泛存在于扁平空间中的包,如果未来想将其规范化迁移到 tokio::macros,所有依赖它的下游用户的代码都需要跟着进行繁琐的改写。而对于那些名字被别人占用的项目(比如知名的异步运行时 async-std 团队,其实并不拥有 async 这个基础包名的所有权),这个优雅的方案对他们来说依然是无解的。

Rust 社区作为一个资源充足、治理严密的顶级生态,依然需要花费数年的时间、跨越编译器、Cargo 工具和注册中心三大团队来协调设计和实施这个补救方案。

这充分印证了作者的观点:如果在发布 Registry 的第一天,你没有保留哪怕一丁点命名空间的扩展性(比如预留一个特殊的分隔符),那么一旦生态成型,后续的重构成本将是难以估量的。 同样,Python 的 PyPI 目前也在通过 PEP 752 提案如履薄冰般地尝试让大厂保留包名前缀(如 google-cloud-),但这只对未来的新包有效,对于存量系统依然是一笔难以理清的糊涂账。

小结——放弃“完美”,拥抱“演进”

纵观这两篇深度探讨,无论是 npm 为了处理历史包袱而维护的并行命名系统,还是 Go 利用强大的 SumDB 来硬核弥补 URL 导入天然缺陷的工程奇迹,亦或是 Rust 正在小心翼翼进行的痛苦命名空间迁移,所有的现象都在向我们诉说同一个真理:

包管理(Package Management)作为一个“棘手问题”,永远不会被真正“解决”。

我们无法像推导一个数学定理那样,给出一个让所有人都满意的、完美的包管理公式。我们所能做的,是在不断变化的安全性要求、开发者的灵活性需求、系统的可用性以及沉重的历史包袱之间,寻找属于这个时代的最优解(Trade-offs)

对于语言和工具的设计者而言,在系统上线的第一天保持足够的克制和选项预留价值千金;而对于广大的应用开发者而言,正如作者所呼吁的,我们需要深刻理解这些构建工具背后的“棘手”本质。

当我们面对依赖冲突或奇怪的版本解析时,少一些诸如“为什么这个工具这么蠢”的情绪化抱怨,多一些对供应链安全的审慎态度(如定期审查依赖树、使用内部可信代理、开启严格的校验和哈希验证),才是面对现代软件工程深水区时,我们应有的专业素养与敬畏之心。

下一次,当你敲下那行习以为常的 go get、npm install 或 cargo build 时,不妨停下来思考一秒钟:为了将这几 KB 的代码安全、无误地送到你的硬盘里,背后那套由无数妥协与智慧构筑的庞大机器,是如何在无声中疯狂运转的。

资料链接:

  • https://nesbitt.io/2026/01/23/package-management-is-a-wicked-problem.html
  • https://nesbitt.io/2026/02/14/package-management-namespaces.html

你最想吐槽哪家的包管理?

每一个“依赖地狱”的背后,都有一位在深夜叹气的程序员。在你的开发经历中,哪门语言的包管理最让你感到顺手?哪门又最让你抓狂?你认为 Go 的“URL 导入+校验和数据库”模式是目前的终极答案吗?

欢迎在评论区分享你的“包管理血泪史”!


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

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

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


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

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

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

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

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


想系统学习Go,构建扎实的知识体系?

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


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

© 2026, bigwhite. 版权所有.

❌