本文永久链接 – https://tonybai.com/2025/12/28/state-of-ai-vs-human-code-generation-report

大家好，我是Tony Bai。

“天下武功，唯快不破。但在软件工程里，‘快’可能是致命的诱惑。”

2025 年，AI 编码助手/智能体已经成为开发者的标配。它像蜜糖一样，让我们尝到了开发效率飙升的甜头：从自然语言一键生成函数，到自动补全繁琐的样板代码，甚至的整个项目的源码，功能交付周期从未如此之短。

然而，CodeRabbit 最新发布的《2025 年度 AI 与人类代码生成现状报告》却揭示了这层甜蜜糖衣下的残酷真相：Bug 激增、逻辑漏洞百出、安全隐患翻倍。

如果不加控制，这些由 AI 快速生成的劣质代码，很可能成为慢性发作的砒霜，最终毒害整个代码库的健康。这份报告用触目惊心的数据告诉我们：在享受 AI 带来的速度红利时，我们必须建立起更强大的免疫系统。

触目惊心的数字——AI 的“副作用”

CodeRabbit 分析了 470 个开源项目的 Pull Requests (PR)，其中 320 个由 AI 参与编写。结果显示，AI 并不是那个完美的“超级程序员”，它更像是一个高产但粗心的实习生。

问题总量激增 1.7 倍

这是最核心的发现。AI 参与的 PR 平均每 100 个包含 10.83 个问题，而人类纯手工编写的 PR 只有 6.45 个。这意味着，引入 AI 后，你的 Code Review 工作量不仅没有减少，反而可能翻倍。

逻辑错误暴涨 75%

这是最令人担忧的数据。AI 生成的代码在业务逻辑、依赖关系和控制流方面，错误率比人类高出 75%。

为什么？

因为 AI 只是在做“统计学上的模仿”，它并不真正理解你的业务规则。它能写出语法完美的代码，但却可能在转账逻辑里漏掉一个关键的校验。

安全漏洞增加 2.74 倍

AI 在处理敏感信息时表现堪忧。硬编码密码、不安全的对象引用等低级错误，在 AI 代码中出现的频率是人类的近 3 倍。AI 倾向于模仿它在训练数据中看到的“旧代码”，而那些旧代码中往往充满了过时的、不安全的模式。

可读性灾难：飙升 3 倍

虽然 AI 生成的代码乍一看很工整，但在命名规范、代码结构和上下文一致性上，它往往与现有代码库格格不入。这种“违和感”大大增加了后续维护者的认知负荷。

AI 为什么会犯错？——透视“黑盒”

报告不仅列出了数据，还深刻剖析了 AI 犯错的根本原因。为什么它这么快，却又这么容易错？

• 缺乏全局视野：AI 看不到你整个系统的架构图，也听不到资深工程师在茶水间的讨论。它只能根据局部的提示词生成代码，因此经常丢失业务上下文。
• “表面光鲜”：AI 擅长生成“看起来能跑”的代码。它会忽略边界检查、错误处理和异常路径，只为了尽快给出一个“正确答案”。
• 偏爱“简单”：AI 倾向于选择最简单的实现路径（例如，简单的循环、低效的 I/O），而忽略了性能优化和资源效率。

工程师的自救指南——如何驾驭 AI？

既然 AI 有这么多坑，我们是否应该因噎废食，放弃使用它？

当然不是。AI 依然是强大的加速器，前提是我们必须为它加上“护栏”。 未来的软件工程，不再是“写代码”，而是“设计系统来生成和验证代码”。

CodeRabbit 给出了几条务实的建议：

给 AI 喂“上下文”

不要只给 AI 一句简单的指令。把你的业务规则、架构约束、代码规范，甚至关键的配置文件，都作为上下文提供给它。让它在“懂行”的前提下写代码。

自动化“安检”

不要依赖人工 Review 去发现格式问题和低级错误。配置严格的 Linter（如 golangci-lint）、Formatter 和安全扫描工具，在代码进入人工视线之前，先由机器进行一轮清洗。

强化“正确性”护栏

针对 AI 在逻辑和错误处理上的弱点，强制要求：

• 重要逻辑必须有测试覆盖。
• 显式检查空值和类型。
• 标准化异常处理流程。

审查清单升级

Code Review 的重点需要转移。不要再纠结于语法细节，而要专门针对 AI 的弱点进行检查：

• 错误路径是否覆盖了？
• 并发原语是否正确使用？
• 配置项是否验证了？
• 有没有硬编码的凭证？

小结：质量不是自动的，它是设计出来的

这份报告给我们敲响了警钟：AI 不会自动带来高质量的代码。 相反，如果不加控制，它会以前所未有的速度制造技术债。

我们需要构建更强大的 CI/CD 流水线、更严格的自动化测试、以及更智能的 Code Review 流程，来承接 AI 带来的产能爆发。

只有当我们学会了如何像管理实习生一样管理 AI，我们才能真正享受到它带来的红利，而不是被它制造的 Bug 淹没。

如果你不想被“砒霜”毒害，就请先学会如何过滤“蜜糖”。

报告地址：https://www.coderabbit.ai/blog/state-of-ai-vs-human-code-generation-report

深度破局：用 Spec-Driven Development 扼杀 Bug 于摇篮

CodeRabbit 的报告虽然犀利地点出了问题，并建议“给 AI 提供上下文”，但它没有告诉我们具体该怎么做。

在实际工程中，仅仅靠零散的 Prompt 是无法约束 AI 狂野的想象力的。解决“质量砒霜”的终极解药，其实是彻底改变我们的开发范式——走向 SDD (Spec-Driven Development，规范驱动开发)。

与其让 AI 对着模糊的需求“猜”代码（然后我们去修 Bug），不如建立一套以规范为核心的流水线：先用 AI 辅助构建严谨的 Spec，在逻辑层面完成验证，再“驱动”AI 生成高质量代码。

这正是我的极客时间专栏《AI 原生开发工作流实战》的核心内容。

在这个专栏中，我将带你跳出“Prompt 调优”的低维竞争，掌握一套系统性的方法论：

• SDD 实战心法：如何实施“规范驱动开发”，把 80% 的逻辑错误拦截在写代码之前。
• 精准 Context 工程：如何构建结构化的上下文投喂机制，让 AI 真正“读懂”你的架构约束。
• 全链路重构：从需求分析到代码落地的全套 AI 协作 SOP。

不要只做 AI 的“质检员”，要做掌控 AI 的“架构师”。

扫描下方二维码，订阅《AI 原生开发工作流实战》，让我们一起重新定义 AI 时代的软件工程。

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

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

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

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

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

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

© 2025, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/12/27/code-review-hell-in-ai-age

大家好，我是Tony Bai。

最近，在与几位架构师朋友的交流中，一个在 AI 编码时代下越来越普遍的“灵魂拷问”浮出水面。这不仅是一个问题，更是他们正在亲身经历的“代码审查地狱 (Code Review Hell)”。

想象一下这个场景：由 AI Agent 生成的代码正以前所未有的速度涌来，堆积如山；你花费心力给出的精辟修改意见，却被开发者转身当作新的 Prompt 重新喂给了 AI；片刻之后，一个全新的 PR 诞生了——它看起来解决了旧问题，却可能带着一堆你从未见过的新问题。你感觉自己深陷于“生成-审查-再生成”的无限循环中，身心俱疲。

这场危机并非危言耸听。在 Uber，每周有超过 65,000 个变更（相当于 PR）需要审查。当 AI 辅助编码成为常态，传统的 Code Review 流程已濒临崩溃。

但这究竟是末日，还是进化的前夜？答案是后者。这场危机，正催生一场深刻的变革——一方面，它要求架构师完成从“创作者”到“导演”的角色进化；另一方面，它也催生了像 Uber uReview 这样复杂的、系统化的 AI 审查平台。

本文将结合对当前危机的剖析与 Uber 的大规模工程实践，为各位小伙伴儿揭示这场变革的本质与破局之路。

危机的剖析：我们到底在审查什么？

要逃离地狱，必先理解地狱的构造。这场危机的根源，在于 AI 颠覆了代码的“创作”过程，从而动摇了 Code Review 的根基：

1. 思考过程“黑箱化”： 传统的 Code Review，我们审查的是代码，更是其背后开发者的思考路径。而 AI 的介入，将这个思考过程隐藏了起来。
2. 审查对象“降维”： 审查被迫从“这段设计是否优雅？”降维到了“这次 AI 输出是否碰巧正确？”。
3. 学习循环“断裂”： 开发者跳过了对 Review 意见最关键的“理解与吸收”环节，宝贵的经验传承被阻断。

天真地想用“AI 审查 AI”来解决问题，只会陷入更深的陷阱。正如 Uber 在其 uReview 项目初期所发现的，未经驯化的 LLM 会产生大量“幻觉”和“低价值的误报”，比如在非性能敏感的代码中挑剔性能问题。这些“噪音”会迅速侵蚀工程师对工具的信任，最终导致他们“调低音量并忽略它们”。

破局之路（上）：架构师的进化——从“创作者”到“代码导演”

面对危机，架构师和资深开发者的核心价值，必须从 Code Writer (代码创作者)，进化为 Code Director & Editor (代码导演与总编)。

“导演”不亲自扮演每个角色，但他定义了整部戏的基调、框架和最终质量。这份“代码导演”的实战手册，为我们指明了方向：

• 实践 1：审查“左移”，审查“剧本”而非“表演”
  在开发者大规模生成代码前，先审查其核心设计思路、任务分解和关键 Prompt。确保“剧本”是对的，再让 AI 这个高效的“演员”去表演。

• 实践 2：制定 AI 时代的 Code Review 新规

  • 明确标识 AI 代码，为审查者提供“警示”。
  • 强制开发者解释“为何接受”AI 方案，夺回思考的主动权。
  • 禁止“甩锅式再生成”，保护学习循环。

• 实践 3：定义“AI-Go”与“AI-No-Go”区域
  将 AI 的使用限制在单元测试、文档、模板代码等 AI-Go 区域，而在核心业务逻辑、安全代码等 AI-No-Go 区域保持高度警惕，让人类智慧主导。

破局之路（下）：Uber 的 uReview——“导演”的智能副驾

如果说“代码导演”模型描绘了架构师的“个人修炼心法”，那么 Uber 的 uReview 平台则展示了如何将这些理念，构建成一个大规模、系统化的工程解决方案。uReview 并非要取代人类，而是作为一个“智能副驾”或“第二审查员”，来增强人类的能力。

面对 AI 生成代码的洪水，Uber 没有让 uReview 直接进行审查，而是构建了一个精密的、多阶段的过滤管道，这与“导演”的思维方式不谋而合：

1. 预处理: 首先，系统会过滤掉配置文件、自动生成的代码等低价值目标，只聚焦于需要审查的核心代码。
2. 专业分工: uReview 并未使用单一的通用 AI，而是设计了多个“专家助理”：
   • Standard Assistant: 专注于逻辑缺陷、错误处理等 Bug。
   • Best Practices Assistant: 对照 Uber 内部的风格指南，检查代码是否符合规范。
   • AppSec Assistant: 专门寻找应用层的安全漏洞。
     这完美印证了“定义 AI-Go/No-Go 区域”的思想——让专业的 AI 干专业的事。
3. 严格品控: 这是 uReview 的核心，也是对“警惕 AI 幻觉”的最佳回应。它包含一个多层过滤过程：
   • 二次评估：另一个 AI（Review Grader）会对生成的每条评论进行打分，过滤掉低置信度的评论。
   • 语义去重：合并相似的建议。
   • 分类抑制：自动压制那些历史上被证明对开发者价值不大的评论类别。

Uber 的实践经验，为我们带来了几条宝贵的“场内教训”，这些教训与架构师的直觉高度一致：

• 精准比数量更重要: 充满噪音的建议会迅速摧毁信任。uReview 的核心策略就是“提供更少但更有用的评论”。
• 护栏与提示词同等重要: 优秀的系统架构和后处理流程，远比单纯的提示词工程更关键。
• 开发者讨厌文体说教: AI 提出的代码可读性、日志微调等建议，普遍不受欢迎。开发者更珍视对正确性、Bug 和最佳实践这种“高信噪比”的反馈。
• AI 善于抓虫，而非评估设计: 由于缺乏设计文档、业务背景等上下文，AI 无法评估系统设计的优劣。这再次强调了人类“导演”在宏观设计上不可替代的价值。

如今，uReview 在 Uber 内部取得了巨大成功：超过 75% 的 AI 评论被工程师标记为“有用”，每周节省约 1500 个工时，相当于每年近 39 个开发者年。

小结：拥抱人机协同的新未来

AI 带来的代码审查危机，实际上是一场深刻的产业升级。它迫使我们从对“代码”的微观审查，转向对“创作流程”的宏观把控。

“代码导演”模型为我们提供了战略指引，而 Uber 的 uReview 则展示了实现这一战略的工程蓝图。未来的 Code Review，不再是人与人的博弈，也不是人与 AI 的对抗，而是一种全新的“人机协同”模式：

架构师作为“导演”，定义设计、划定边界、把控最终质量；而像 uReview 这样的智能系统，则作为高效、精准、不知疲倦的“副驾驶”和“场务”，处理海量的细节检查，将人类从重复、繁琐的工作中解放出来。

最后，回到那个终极问题：谁来为质量负责？答案从未改变，也永远不会改变：永远是工程师自己。AI 是我们手中最强大的工具，但手握方向盘、对最终结果负责的，永远是我们自己。

资料链接：https://www.uber.com/blog/ureview/

聊聊你的“审查之痛”

AI 时代的 Code Review，正在成为每个技术团队的新挑战。在你所在的团队中，是否也遇到了 AI 代码带来的“审查地狱”？你们是如何应对的？ 是明令禁止，还是像 Uber 一样积极构建自动化防线？

欢迎在评论区分享你的真实经历和思考！ 让我们一起探索人机协同的最佳实践。

如果这篇文章对你有启发，别忘了点个【赞】和【在看】，并转发给你的架构师朋友，也许能帮他从“地狱”中解脱出来！

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

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

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

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

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

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

© 2025, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/11/23/leo-messi-and-fanren-hanli

大家好，我是Tony Bai。

刚刚过去的这几个月，我终于“出关”了——一口气读完了《凡人修仙传》的人界、灵界、仙界全本。那一刻，看着韩立终成道祖，我心中涌起的激荡，竟与三年前看着阿根廷夺冠、梅西捧起大力神杯时的热泪盈眶，产生了奇妙的共振。

是的，我是一个《凡人》的读者，也是一个追随阿根廷近20年的死忠梅西球迷。

但与此同时，我在现实世界里还有一个更冷静的身份：一名写了多年代码的程序员。

正是这三种看似毫不相干的身份——修仙读者的热血、球迷的狂热、程序员的理性，在我的脑海中发生了一次剧烈的“化学反应”。

当我摘下“修仙”和“足球”的滤镜，用一个资深技术人的视角去审视韩立与梅西的成长轨迹时，一个惊人的结论浮现在脑海：韩立和梅西，本质上是同一种人——他们是各自领域里，将“全栈工程能力”修炼到极致的终极样本。

在AI技术浪潮冲击每一个程序员饭碗的今天，他们的故事，或许藏着我们打破内卷、实现职业跃迁的“底层代码”。

拒绝“标签化”：做解决问题的“全栈”，而非某个岗位

在职场上，我们习惯给自己贴标签：“我是后端”、“我是DBA”、“我是写Go的”。但在韩立和梅西身上，标签失效了。

• 韩立：修仙界的DevOps先驱
  作为读完全本的读者，我深知韩立有多“杂”。你说他是法修？他却凭着梵圣真魔功的金刚之躯，能硬撼顶级妖兽。你说他是炼丹师？他布阵、制符、御虫、傀儡术样样精通。
  在韩立的字典里，没有“这不归我管”或者“我是法修，不扛伤害”。为了生存（项目上线/系统稳定）这个终极目标，他打通了从炼气（开发）、炼体（架构）、阵法（运维）到炼丹（资源管理）的全链路。他是一个人活成了一支队伍的DevOps。

• 梅西：绿茵场上的全能架构师
  看过梅西踢球的人都知道，你说他是前锋？他的助攻数冠绝五大联赛。你说他是中场？他的进球效率让所有射手汗颜。
  边锋、伪九号、前腰……他几乎踢过前场所有位置。他既能像底层开发一样做最精细的过人操作，又能像系统架构师一样拥有上帝视角，通过一脚传球调度全局资源。

在AI时代，单一技能的“螺丝钉”最容易被替代。真正的“全栈”，不是会写前端和后端那么简单，而是拥有“解决复杂问题闭环”的能力。不要被Title限制，像韩立一样，哪里有瓶颈就去学什么，把自己打造成一个无法被轻易定义的“系统”。

拥抱“凡人”开局：用“工程化思维”逆袭天才

更扎心的是，这两位大神，开局拿的都不是爽文剧本。

• 伪灵根与侏儒症：非科班的逆袭
  韩立是“四伪灵根”，修仙界的“劝退专业”；梅西年少确诊侏儒症，在对抗激烈的足球世界几乎被判“死刑”。
  他们就像我们大多数非名校毕业、非ACM金牌选手的普通程序员。没有惊天的算法天赋，没有显赫的大厂背景。

• 掌天瓶：高效工具的极致利用
  韩立的成功，很大程度上归功于“掌天瓶”这个外挂。但他从未依赖外挂“躺平”，而是利用它指数级地加速资源的积累（催熟灵药）。
  对于程序员来说，今天的AI大模型以及相关工具就是我们的“掌天瓶”。普通人用来偷懒，高手用来加速试错、加速学习、加速交付。

承认我们是“凡人”，这不可耻。真正的天赋，不完全是智商，更是“工程化思维”——即如何在资源受限（资质平庸）的情况下，通过引入高效工具（AI）、优化流程（勤奋与策略），构建出超越天才的系统稳定性。

“苟”的哲学：防御性编程与SRE意识

如果说全能是他们的外在，那么“苟”，则是他们立于不败之地的内核。

• 韩立的“稳”：防御性编程大师
  “韩跑跑”的名号响彻修仙界。他从不打无准备之仗，战前必先布阵（环境配置/容灾演练），出手前先试探（金丝雀发布），一击不中远遁千里（熔断/回滚）。
  这哪里是胆小？这是最高级别的防御性编程（Defensive Programming）。在充满Bug（危险）的修仙界，他把系统的可用性（活着）放在了第一位。

• 梅西的“散步”：动态资源调度
  梅西在场上的“散步”，常被误解。实际上，这是一种顶级的观察模式。他在用极低的功耗（体能）扫描全场，寻找防线（系统）的Bug（漏洞）。一旦发现，瞬间满频运行（冲刺），一击致命。
  这是高并发系统中的资源动态调度——平时低负载运行节省资源，关键时刻弹性扩容，精准打击。

在内卷的环境中，学会“苟”很重要。

不是让你摸鱼，而是学会Trade-off（权衡）。不盲目堆砌代码（瞎跑），而是在动手前先做足System Design（观察）；不追求炫技，而是追求代码的健壮性和可维护性（保命）。活得久（职业生涯长），本身就是一种巨大的胜利。

小结

读懂了韩立和梅西，你就读懂了顶级技术人的生存之道。

他们告诉我们：真正的强大，不是拥有一项举世无双的长板，而是通过千锤百炼，让自己没有短板。

在这个充满不确定性的时代，我们也许无法成为梅西那样的天才，但我们可以学习韩立的“工程化修仙”：

1. 利用工具（AI/掌天瓶），放大你的努力。
2. 保持谨慎（防御性编程），敬畏每一次上线。
3. 持续积累（全栈能力），构建自己的技术壁垒。

无论是躲在洞府里默默催熟灵药的韩立，还是在屏幕前深夜Debug的你，技术，永远是我们立足于任何世界的硬通货。

还在为“复制粘贴喂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/23/short-form-videos-harm-programmers

大家好，我是Tony Bai。

我想请你回想一个再熟悉不过的场景：

白天，你在成千上万行代码的丛林里艰难跋涉，与一个隐藏极深的Bug缠斗了数个小时，心力交瘁。晚上回到家，你只想“犒劳”一下疲惫的大脑，于是瘫倒在沙发或舒服的大床上，划开手机，沉浸在短视频那无穷无尽的信息流里。一个接一个的精彩片段，让你暂时忘记了白天的烦恼。

你以为这是一种高效的放松，一次精神上的“回血”。但一个令人不安的自我观察，或许你也有同感：为什么我们越来越难以长时间专注于一段复杂的代码了？为什么刚想深入思考一个架构问题，大脑就不由自主地渴望一次短暂的“分心”？

这仅仅是意志力下降了吗？还是我们的认知能力，真的在不知不觉中发生了改变？

最近，一篇发表在顶级期刊《心理学通报》(Psychological Bulletin)上的系统性回顾与元分析论文——《Feeds, Feelings, and Focus: A Systematic Review and Meta-Analysis Examining the Cognitive and Mental Health Correlates of Short-Form Video Use》，为我们揭示了残酷的科学真相。这份综合了71项研究、覆盖近10万参与者的报告，清晰地指出：我们所以为的“放松”，很可能正在系统性地消耗我们写出好代码的核心能力。

那么，这份报告到底说了什么？它又是如何科学地“实锤”短视频对我们大脑的影响的呢？下面，我们就从这份报告的核心发现开始看起。

科学的“实锤”：短视频到底对我们的大脑做了什么？

这篇论文用详尽的数据告诉我们，短视频的消费模式，并非无害的娱乐。

首先，它与认知能力的下降显著相关。 论文指出，增加的短视频使用与较差的认知能力存在明确的关联（中等效应，r = -.34）。而受损最严重的领域，恰恰是我们程序员最宝贵的两种资产：

1. 注意力 (Attention, r = -.38)
2. 抑制控制 (Inhibitory Control, r = -.41)

这是什么意思？让我们用程序员的语言来“翻译”一下：

• “注意力”下降，意味着我们持续跟踪复杂逻辑链条、在庞大代码库中保持上下文的能力正在变弱。你可能刚理清一个函数的调用栈，一个念头闪过就忘了自己刚才想到哪了。
• “抑制控制能力”下降，意味着我们抵抗内部或外部干扰的能力正在削弱。无论是同事的一条消息，还是脑子里突然冒出的“看看新邮件”的冲动，都变得越来越难以抗拒。

这两种能力，正是我们进行深度编程、系统设计和复杂问题排查的基石！

论文中提到的“习惯化与致敏化” (habituation and sensitization) 双重理论，通俗地解释了这一现象：我们的大脑，在反复经受短视频这种“高刺激、快反馈、强情绪”的内容轰炸后，会逐渐“习惯”这种模式。当我们再回到编程这种需要“低刺激、慢反馈、纯逻辑”的深度工作时，大脑会表现出极度的不耐烦和渴望“切换”的冲动，因为它已经被短视频“致敏”，期待着下一次即时的高强度刺激。

程序员的“高危”处境：为何我们更易受其害？

如果说短视频对普通人的影响是“温水煮青蛙”，那对程序员而言，它更像是一场针对核心技能的“精准打击”。

• 工作性质的根本冲突： 程序员是典型的“深度工作 (Deep Work)” 从业者。我们的价值产出，几乎完全依赖于长时间、不间断的专注。而短视频的消费模式，则是“浅层娱乐 (Shallow Entertainment)”的极致，两者在认知模式上水火不容。
• 从“心流”到“心碎”： 我们梦寐以求的“心流 (Flow State)”状态，其核心就是高度的专注和对干扰的抑制。短视频的算法和产品设计，其目标恰恰是系统性地、持续地打破我们的专注，用一个又一个的新鲜刺激来捕获我们的注意力。可以说，短视频正在系统性地摧毁我们进入和维持“心流”的能力。
• “伪学习”的陷阱： 很多开发者，包括我自己，有时也会通过短视频学习一些“技术小技巧”。这看似高效，但往往是碎片化的、不成体系的。这种“伪学习”带来的即时满足感，可能会取代系统性、结构化的深度学习，让我们误以为自己“学到了很多”，实则认知能力的基础正在被侵蚀。

夺回专注力：一个程序员的“数字健康”自救指南

认识到问题的严重性，并非为了制造焦虑，而是为了找到夺回主动权的路径。结合之前分享过的“状态管理”理念，我们可以尝试以下具体的“自救”策略：

1. 拥抱“状态管理”，而非死磕“时间管理”
   承认我们的精力是有限的，不同状态适合做不同的事。将你最宝贵的“高能专注态”严格地留给编程、设计等核心任务。

2. 划分“数字领地”，建立清晰边界

   • 创建“深度工作”场： 在需要专注的时段，将手机物理隔离（放在另一个房间，或开启飞行模式）。使用番茄钟，关闭电脑上所有不必要的通知。为你的大脑创造一个“无短视频”的纯净空间。
   • 设定“浅层娱乐”场： 允许自己在“低能碎片态”（如午休后、通勤路上）适度消费短视频，但必须设立明确的时间边界。例如，定一个15分钟的闹钟，闹钟一响，立即停止。

3. 主动“反向训练”你的专注力
   既然大脑的专注力可以被“去训练”，那它也可以被“再训练”。

   • 刻意练习“长阅读”： 每天或每周，强制自己进行30分钟以上不间断的、无干扰的阅读。内容可以是技术书籍、深度文章，甚至是高质量的源码。这是对抗碎片化最好的“健身”。
   • 尝试正念或冥想： 每天花5-10分钟，专注于自己的呼吸。这看似简单，却是科学证明能有效提升注意力和抑制控制能力的强大练习。

4. 改变消费模式，化被动为主动

   • 从“被动投喂”到“主动搜索”： 有意识地减少在“推荐”页的无尽滑动。将短视频平台当作一个“视频搜索引擎”来使用，带着明确的目的去查找你想看的内容。
   • 关注高质量、长内容的创作者： 关注那些能引发你深度思考的创作者，让算法为你推荐更有价值的内容。

小结：在“快娱乐”的时代，守护“慢思考”的价值

短视频作为一种媒介，本身并无原罪。它在娱乐、信息传播甚至某些知识普及方面，都有其独特的价值。

但作为程序员，我们必须清醒地认识到，我们赖以生存和发展的核心资产——专注力、逻辑推理能力和深度思考能力——是脆弱的，是需要被刻意守护的。

守护它，就是守护我们的职业未来。

希望我们都能在享受科技便利的同时，成为数字工具的“主人”，而非被算法俘虏的“奴隶”。从今天起，让我们重新审视“白天改Bug，晚上刷视频”的生活模式，为我们宝贵的大脑，留出更多“慢思考”的宝贵空间。

资料链接：https://doi.org/10.1037/bul0000498

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

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

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

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

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

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

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

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

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

© 2025, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/11/20/proposal-improve-goroutine-stack-using-page-faults

大家好，我是Tony Bai。

Go 语言的 goroutine 以其轻量和高效著称，而其背后一个关键的“魔法”便是可动态增长的栈 (Resizable Stacks)。然而，支撑这个魔法的机制——在几乎每个函数入口处插入的“栈检查”指令——也并非毫无代价。

近日，在 golang-nuts 邮件组，一位名叫 Arseny Samoylov 的年轻开发者发起了一场引人深思的讨论，提出了一个颇具“革命性”的提案：我们能否借鉴 Linux 内核管理线程栈的方式，用“缺页中断”(Page Faults) 机制来取代 Go 现有的“栈检查”？

这个旨在挑战 Go 运行时基石的大胆设想，引来了 Go 语言联合创始人 Rob Pike 的亲自下场。本文中，我们就来简单看看这个看似优雅的提案，为何会引来社区的质疑，并最终被 Rob Pike 本人以“实现过于复杂”为由，泼上一盆“冷水”。

现状的“痛点”——无处不在的“栈检查”

在深入新提案之前，我们必须先理解 Go 当前的栈增长机制及其代价。

当前，Go 编译器会在几乎每一个非叶子函数的序言 (prologue) 部分，插入几条特殊的指令。这些指令的作用是在函数开始执行前，检查当前 goroutine 的剩余栈空间是否足够。如果不足，运行时 (runtime.morestack) 就会介入：分配一个更大的新栈，将旧栈的内容复制过去，调整所有指向栈上变量的指针，然后才继续执行函数。

提案者指出的当前机制的两大痛点：

1. CPU 开销：频繁的栈检查本身就是一种 CPU 开销，尤其是在调用链很深或存在大量无法内联的间接调用（如接口方法调用）时。
2. 代码体积膨胀：每个函数都增加了额外的序言指令（提案者估计约 10 条指令），这会增加 L1 指令缓存 (L1i Cache) 的压力，对计算密集型任务的性能产生负面影响。

基于此，提案者估计，消除栈检查可能会为真实的 Go 应用带来 3% – 5% 的性能提升。

“革命”的设想——通过“缺页中断”实现栈增长

Arseny Samoylov 的提案，其灵感源自现代操作系统（如 Linux）管理原生线程栈的方式。

核心思想：

1. 在创建一个 goroutine 时，不再只分配一个很小的物理内存（当前为 2KB），而是为其预留 (reserve) 一大块虚拟地址空间（例如 8MB），但不立即分配物理内存。
2. 在这块虚拟地址空间的末尾，设置一个“警戒页”(Guard Page)，标记为不可访问。
3. 移除编译器插入的所有“栈检查”指令。
4. 当 goroutine 的栈增长，触及到未分配的内存页时，会触发一次缺页中断 (Page Fault)。操作系统内核会捕获这个中断，并“懒惰地”为其分配一页新的物理内存。
5. 当 goroutine 的栈增长到极致，最终触及到那个“警戒页”时，Go 运行时捕获这个特定的信号，此时才执行现有的栈扩容逻辑。

这个设计的精妙之处在于，它将持续的、遍布每个函数的“栈检查”开销，转变成了仅在栈空间真正耗尽时才发生的一次性、代价较高的“异常处理”。

社区的讨论——一场关于性能、复杂性与可行性的权衡

这个看似优雅的方案，立刻引发了社区开发者的辩论。经验丰富的工程师们很快指出了这个方案背后隐藏的巨大挑战：

1. 中断处理的巨大开销：Jason E. Aten 指出，处理一次缺页中断并由信号处理器接管，其过程极其缓慢。它涉及至少 4 次昂贵的上下文切换（用户态 -> 内核态 -> 信号处理器 -> 内核态 -> 用户态）。这个开销，可能远高于 Go 运行时目前高效的内存分配器。
2. 区分“好”与“坏”的中断：Go 运行时如何能精确地区分出，一次缺页中断是因为“栈需要正常增长”，还是因为一个真正的 Bug（如 nil 指针解引用）？这是一个极其棘手的问题。
3. 虚拟地址空间的消耗：虽然 64 位系统的虚拟地址空间极其巨大，但为每一个 goroutine 都预留 8MB，依然是一个不小的负担。10 万个 goroutine 将消耗 800GB 的虚拟地址空间。
4. 最小栈的增加：最小的物理内存分配单位是一个页（通常是 4KB）。这意味着 goroutine 的最小栈大小将从 2KB 翻倍到 4KB，对于那些拥有数百万个小 goroutine 的应用，这可能会导致物理内存消耗翻倍。

Rob Pike 的“劝退”——来自创始人的最终裁决

当讨论进入白热化时，Go 语言的联合创始人 Rob Pike 亲自下场，给出了他的最终点评。他的观点，冷静而深刻，几乎为这场辩论画上了句号。

首先，他认为提案者夸大了“栈检查”的成本：

“我相信你夸大了（栈检查的）成本。它是可测量的，但并没有你说的那么严重。并且，随着函数内联越来越普遍，函数的体积变大，摊销后的实际成本都在降低。”

更重要的是，他指出了这个提案在工程上的历史困境，这正是“劝退”的核心理由：

“此外，在过去，使用内核traps 来实现栈增长一直都问题重重。我曾见过其他系统尝试这样做，但最终都因为无法预见的复杂性而放弃了。我不是说这做不到，但这绝非易事。而且，由于细节依赖于架构和操作系统，要做到可移植性非常困难。”

最后，他给出了一个简洁而有力的结论：

“这事不归我管，但我不会这么做。”
(It’s not up to me, but I wouldn’t do this.)

小结：永不停歇的探索，Go 演进的生命力

这场关于 goroutine 栈的“革命”提案，最终在创始人的“劝退”中似乎逐渐平息。然而，将此视为一次简单的“失败”，或许会错失其更深远的意义。

Rob Pike 的点评，以其数十年的工程经验和对复杂性的深刻洞察，为这个提案的技术路径亮起了警示的红灯。他指出的“无法预见的复杂性”和“难以解决的可移植性”，是任何试图修改语言运行时的工程师都必须敬畏的“冰山”。

然而，无论这位提案者 Arseny Samoylov 最终是选择接受劝告，还是不顾一切地继续探索并拿出概念验证 (PoC)，这场讨论本身，对 Go 社区而言，都是一件弥足珍贵的好事，它完美地体现了 Go 社区的生命力所在。

Go 语言的演进，正是在这种“大胆设想”与“审慎权衡”的持续张力中，稳步前行的。

资料链接：https://groups.google.com/g/golang-nuts/c/q3iZk0phN9E

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

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

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

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

© 2025, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/11/10/rob-pike-on-complexity

大家好，我是Tony Bai。

在软件工程的殿堂里，我们常常将算法和数据结构奉为圭臬。我们痴迷于时间复杂度的优化，热衷于讨论各种精巧的数据结构。然而，Go 语言的联合创始人 Rob Pike 早在其1989年的一篇C 语言编程笔记中，就为我们留下了一份更根本的“忠告”。这份忠告，凝练为五条（或者说六条？）关于如何对抗软件“复杂性”的黄金法则。

这些法则，诞生于一个需要手动管理内存的时代，却惊人地预言并塑造了 Go 语言的设计哲学。它们的核心思想是：在构建真实世界的软件时，管理复杂性，远比追求算法上的极致精巧更为重要。

本文，就让我们以一名现代 Gopher 的视角，重新聆听这份来自创始人的忠告，理解为何这五条法则，才是构建健壮、可维护软件的真正基石。

法则一 & 二：停止猜测，开始测量

法则一：你无法预知程序的时间花销。

法则二：测量。在测量之前，不要进行性能调优。

这两条法则是所有性能工作的“第一性原理”。它们共同指向一个核心思想：你的直觉是不可靠的。

我们很容易陷入一个误区，认为性能瓶颈一定出在某个“看起来很慢”的算法上。然而，在现代计算机体系中，真正的瓶颈往往隐藏在意想不到的地方：一次意料之外的内存分配、一次糟糕的并发同步、或者一次灾难性的缓存未命中。

一个在“冷路径”上运行的、从 O(N) 优化到 O(1) 的完美算法，其对整体性能的贡献是零。而一个未经测量的、看似无害的“优化”，则可能因为破坏了缓存局部性或引入了锁竞争，反而让程序变得更慢。先找到正确的战场，远比拥有最锋利的武器更重要。

Go 语言将这两条法则的精神，内化为了其强大的工具链。在你动手将一个 O(N) 的循环优化成 O(log N) 之前，Go 的文化要求你：

1. 使用 pprof 进行宏观分析：让数据告诉你，你的程序 90% 的时间到底花在了哪里。这份“忠告”要求我们，只对那个压倒性 (overwhelms) 的瓶颈进行优化。
2. 使用 testing.B 进行微观验证：当你找到了瓶颈，并进行了一处“速度骇客” 般的优化后，用基准测试来证明你的修改确实带来了显著的提升。

法则三 & 四：简单胜于花哨

法则三：花哨的算法在 n 很小时很慢，而 n 通常很小。

法则四：花哨的算法比简单的算法更容易出错，也更难实现。

这两条法则是对“算法至上主义”的直接挑战。经典的算法复杂度（大O表示法）是一个强大的理论工具，但它在工程实践中具有欺骗性，因为它忽略了常数因子和实现的复杂性。

一个 O(log n) 的自平衡二叉树，其实现的复杂性、指针跳转带来的缓存不友好性，使得它在处理一个只有几百个元素的“日常问题”时，性能和健壮性可能远不如一个简单的、O(n) 的切片扫描。

在真实世界的软件中，可读性、可维护性和健壮性，是远比“理论上的最优性能”更为稀缺的资源。一个因过于复杂而充满 Bug 的“花哨”算法，其带来的危害，远大于一个简单、正确但“不够快”的算法。先做对，再做快——并且只有在测量证明有必要时才去做快。

Rob Pike的这两条法则简直就是 Go 语言的设计宣言！

• 切片 (slice) 和 map 就是一切：Go 刻意保持其内置数据结构的极度精简，正是因为在 99% 的场景下，它们简单、可预测且“足够好”。
• “清晰胜于聪明 (Clear is better than clever)”：这是 Go 社区的集体共识。一段任何人都能在 3 秒钟内读懂的简单 for 循环，其长期维护价值，远高于一段只有作者本人才能看懂的、精巧但晦涩的代码。

法则五：数据为王

法则五：数据为王。如果你选对了数据结构并组织得当，算法几乎总是不言自明的。

这是所有法则中最具哲学高度的一条。它将我们的注意力，从“如何操作数据”（算法），拉回到了“如何组织数据”（数据结构）。

因为一个糟糕的数据结构，是任何精妙的算法都无法拯救的。它会迫使你编写出扭曲、晦涩、充满边界情况的“补丁式”代码。而一个优秀的数据结构，则会自然地引导你走向简单、清晰的算法。好的数据结构，是好算法的“母亲”。

这正是 Fred Brooks 在《人月神话》中思想的精髓：程序设计的核心，应该是对数据的思考和组织，而非对算法的炫技。

这也是 Go 语言面向组合、基于 struct 设计的灵魂所在。在 Go 中，我们花费最多时间思考的，往往是如何设计出清晰、正交的 struct。

一旦你的数据结构被设计得当，操作这些数据的方法自然就会变得简单、短小且不言自明。

// 优秀的设计：数据结构先行
type User struct {
    ID   int
    Name string
    Age  int
    Active bool
}

func (u *User) Deactivate() { ... }
func (u *User) IsMinor() bool { ... } // 是否未成年

当你拥有一个设计良好的 User 结构体时，Deactivate 或 IsMinor 这些方法的实现，几乎是“自证”的。

注：想想将Active换为 StatusFlag int ，Deactivate的实现还是“自证”的吗？

法则六：没有法则六

“Rule 6. There is no Rule 6.”

这句俏皮话，是 Rob Pike 编程哲学思想的点睛之笔。它以一种“元规则”的形式，深刻地诠释了前面所有法则的核心精神：对抗不必要的复杂性。它提醒我们，不要让规则本身成为一种新的复杂性来源。

小结

重温来自1989年 Rob Pike 的这份“忠告”，就像是回到了 Go 语言设计的“原点”。它们清晰地告诉我们，Go 语言的诞生，并非一次偶然的灵光一现，而是一种深思熟虑的、跨越数十年的编程哲学的最终体现。

在日常的 Go 开发中，我们或许会面临各种算法选择的诱惑。但 Rob Pike 的这些法则提醒我们，退后一步，首先去测量，去选择简单，去精心设计你的数据。这些看似朴素的原则，其重要性，往往超越了任何一个单一的、精巧的算法。因为它们所守护的，是软件项目中最宝贵的资产：长期的可维护性和清晰性。

你的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/07/go-simple-illusion-easy-to-learn-hard-to-master

大家好，我是Tony Bai。

“Go 语言看起来如此简单，我的这种假设是错的吗？”

近日，一位刚接触 Go 几个月的新手在reddit golang论坛发出了这样一个真诚的提问。他感觉 Go “超级简单”，并好奇自己是否因为初学者的身份，而忽略了语言中那些“疯狂的复杂性”。

这个问题，立刻引发了社区关注。数百条评论从四面八方涌来，汇成了一场关于 Go 语言简单性本质的深度辩论。最终，社区的集体智慧凝聚成一个经典而又充满辩证性的共识：Go 的简单，是刻意为之的设计；而通往精通之路，则隐藏在简约表象之下的深邃之处。

本文将带你深入探索这座“简单”的冰山，从其光彩照人的水上部分，一直潜入其复杂深邃的水下世界。

“蜜月期”——为什么 Go 语言感觉如此简单？

对于初学者而言，Go 带来的“简单”感受是真实且强烈的。这并非巧合，而是源于 Go 设计者们一系列深思熟虑的“减法”哲学。

极简的语法与关键字

“25 个关键字，宝贝！” 一位评论者这样感叹道。Go 有意地限制了语言的表面积，仅保留了构建大型系统所必需的核心元素。它只有一个循环结构 for，没有 while、do-while 或 foreach 的变体。这种极简主义，让学习者可以快速掌握语言的全貌，而不必记忆大量特殊语法。

“所见即所得”的代码

一位来自 Java/Python 背景的开发者分享道：“Go 给你的玩具可能更少，但至少你可以相信，它们不会在调试时反咬你一口。” Go 缺乏猴子补丁 (monkey patching)、复杂的继承体系和隐式的魔法，这意味着代码的行为更加可预测。“代码读起来就像它实际运行的样子，即便这意味着多写几行。”

“电池自带”的强大标准库

“标准库太棒了，” 社区普遍赞同，“你需要花些时间才能理解，在不引入单个依赖的情况下，你能做多少事情。” 从 HTTP 服务器到密码学工具，Go 的标准库提供了构建现代网络服务所需 90% 的功能，让初学者可以立即开始构建有价值的应用，而无需在茫茫的第三方库中选择和配置。

幻象的破灭——“简单”背后的隐藏复杂性

当“蜜月期”结束，开发者开始构建更复杂的真实世界系统时，Go 的另一面便会逐渐显现。这份复杂性，并非来自语言本身，而是源于 Go 为了维持简单性，而将复杂性“转移”到的地方。

并发：Go 的“光荣与荆棘”

这是社区中被提及次数最多的“深水区”。Go 通过 goroutine 和 channel，将并发编程的门槛降到了前所未有的低度。然而，这种易用性也隐藏着巨大的风险。

“理解并发作为一个概念可能会很复杂，但 Go 让实现它变得简单。”

但“实现简单”不等于“用对简单”。

• Goroutine 泄露：新手很容易创建出无人“负责”的 goroutine，导致其在后台永久运行，悄无声息地消耗内存和 CPU。
• 竞态条件 (Race Conditions)：尽管 Go 提供了强大的竞态检测器 (-race)，但理解和避免数据竞争，需要对内存模型和同步原语（如 sync.Mutex）有深刻的理解。
• Channel 的滥用：“我数不清有多少次，人们到处使用 goroutine 和 channel，然后好奇为什么他们的项目变得如此之慢。” Channel 是强大的工具，但错误地使用无缓冲 channel、忘记关闭 channel、或用它来解决本该用互斥锁解决的问题，都会导致死锁、性能下降和难以调试的 bug。

精通并发，是区分 Go 新手与专家的第一道分水岭。

运维复杂性

Go 的设计哲学，在某些方面将应用程序的韧性责任，从语言运行时“推”给了基础设施。这为 Go 程序带来了一种独特的运维复杂性。

最典型的例子就是 panic 的处理。

• 在某些语言中（如 Java），一个未捕获的异常通常只会导致单个线程死亡，而整个应用程序进程会默认继续运行。
• 但在 Go 中，一个未被 recover 的 panic 会导致整个程序（进程）立即崩溃退出。Go 语言本身不提供自动重启或进程守护的能力，它将这种“灾难恢复”的职责，明确地交给了程序的运行环境。

这意味着，构建一个高可用的 Go 服务，你必须依赖外部系统。正如一位资深开发者在讨论中指出的那样：

“像 panic 这样的东西，要求你在一个编排器（如 K8s/ECS 等）下运行你的生产系统。”

这种设计选择，对于新手来说可能是一个认知上的巨大跳跃。他们必须明白，Go 程序的健壮性，并不仅仅是代码层面的 if err != nil，更是在基础设施层面，通过配置进程管理器（如 systemd）或容器编排器（如 Kubernetes）的健康检查和自动重启策略来共同保证的。

Go 将自己定位为一个用于构建云原生应用的“零件”，而非一个大包大揽的“一体机”。这种对运维环境的隐性依赖，正是其简单性背后的一种深刻权衡。

“魔鬼在细节中”：切片、接口与错误处理

Go 的一些核心特性，虽然表面简单，但其底层机制却充满了需要深入理解的“微妙之处”。

• 切片 (Slices)：新手常常会对其“共享底层数组”的行为感到困惑，不经意间写出因 append 操作导致意外数据修改的 bug。
• 接口 (Interfaces)：nil 接口与“值为 nil 的接口”之间的区别，是无数 Gopher 都曾踩过的经典“坑”。
• 错误处理的冗长：if err != nil 虽然明确，但在 LLM 辅助编码时代到来之前，这种冗长曾是许多开发者的抱怨之源。现在，新的挑战变成了如何确保依赖 AI 的新手，能真正理解他们生成的每一行错误处理代码。

精通之路——从“知道”到“理解”

那么，如何跨越从“简单”到“精通”的鸿沟？社区的智慧为我们指明了方向。

接受 Go 的哲学

Go 是一门“刻意设计的简单语言”。它的目标，是让大型团队能够编写出风格统一、易于阅读和维护的代码。这意味着，你需要接受它的“冗长”，理解它为何抵制某些“高级”特性，并学会在其提供的“约束”下优雅地解决问题。

刻意练习核心概念

不要满足于 API 的表面用法。花时间去：

• 画图理解并发模式：亲自绘制 goroutine 如何通过 channel 通信，理解扇入 (fan-in)、扇出 (fan-out) 等模式。
• 实验切片的底层行为：编写小程序来观察 append 何时会触发底层数组的重新分配。
• 深入标准库源码：阅读 net/http 或 context 包的源码，是理解 Go 设计哲学的最佳途径。

拥抱“造轮子”

“你经常需要‘自己动手造轮子’(roll your own)”，一位开发者评论道。这在 Go 的世界里并非贬义。Go 强大的标准库为你提供了高质量的“零件”，鼓励你根据自己的具体需求，组合出最适合的“轮子”，而不是像其他生态那样，总是先去寻找一个庞大、臃肿的“现成汽车”。

小结：“简单”是起点，而非终点

回到最初的问题：Go 语言真的简单吗？

是的，Go 的入口极其简单。 它拥有平缓的学习曲线，让有经验的程序员可以在一周内上手，让新手也能在短时间内构建出有用的程序。

但精通 Go 绝不简单。 它的真正深度，不在于复杂的语法，而在于理解其并发模型背后的权衡、标准库设计的精妙、以及在简约哲学约束下构建复杂系统的工程智慧。

正如一位评论者所引用的那句古老格言：“一分钟学会，一辈子精通。” 虽说“一辈子”有些夸张，但这或许是对 Go 语言简单性与复杂性辩证关系的最佳诠释。Go 的“简单”，为你打开了一扇通往高效、可靠软件工程的大门，但门后的风景，需要你用持续的学习和深刻的思考，去亲自探索和领悟。

资料链接：https://www.reddit.com/r/golang/comments/1oj9jb6/golang_seems_so_simple_am_i_wrong_to_assume_that/

你的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/10/24/honoring-1024-programmers-day

大家好，我是Tony Bai。

今天，10 月 24 日，是一个特殊的日子。

它并非法定假日，地图上也没有标注。但对于一群特定的人来说，这个日期本身，就是一种无需言说的默契。1024，是 2 的 10 次方，是 1KB，是我们构建整个数字世界的基石。

它，就是属于我们程序员自己的节日——1024 程序员节。

所以，今天这篇文章，不聊源码，不谈架构，只想写给每一个奔跑在二进制世界里的你：

• 致敬那些深夜里，与 Bug 搏斗到天明的执着身影；
• 致敬那些显示器前，在 0 和 1 中创造出无限可能的大脑；
• 致敬那些用一行行代码，默默改变着世界的同行者们。

你们，值得被看见，被理解，被尊重。

程序员的宿命：永远在学习“第一课”

作为程序员，我们的职业生涯，似乎就是一场永无止境的“学习第一课”的旅程。

我至今仍记得自己第一次学习 C 语言时，面对指针的困惑；第一次接触并发编程时，被死锁折磨的痛苦；第一次探索 Go 语言时，被其简单哲学所震撼的喜悦。

无论是学习一门新语言，还是掌握一个新框架，亦或是理解一种新的架构思想，我们总是在不断地“清空自己”，以一个初学者的心态，回到“第一课”的起点。

这正是这个职业最磨人、也最迷人的地方。它强迫我们保持好奇，持续奔跑，永不僵化。

我将我的极客时间专栏《Go语言第一课》沉淀成书，正是源于对这份“程序员宿命”的深刻理解。我希望它不仅仅是教你一门语言的语法，更是想为你提供一套坚实的、可信赖的、能够举一反三的学习体系和思维范式。它是我作为一个“长期主义”布道者，希望能为你的下一段“第一课”之路，铺下的一块最坚固的基石。

灵魂拷问：AI 时代，我们还需要“第一课”吗？

我知道，很多人心里都有一个疑问：在 AI 如此强大的今天，我们似乎可以随时跳过所有“第一课”，直接向 AI 要答案。那么，系统性的学习是否已经过时？

作为一名同样深度使用 AI 的工程师，我的答案是：不，恰恰相反，在这个时代，扎实的“第一课”比以往任何时候都更加重要。

AI 是“陪练”，不是“内功心法”。 它可以极大地加速我们实现想法的过程，但它无法替代我们建立知识体系的“内功”修炼。它能告诉你“是什么”，却很少能告诉你“为什么”。

我看到太多的初级工程师，在 AI 带来的“我什么都行”的幻觉中，陷入了“知其然，不知其所以然”的困境。这种“能力空心化”，会在未来的某个时刻，成为职业生涯中难以逾越的瓶颈。

而系统性地学习一本好的入门书，正是在 AI 时代对抗这种“能力空心化”、构建自己不可替代核心竞争力的最佳途径。它强迫你去理解代码背后的设计哲学、核心原理和权衡取舍，而这些，恰恰是 AI 无法生成的、属于你自己的智慧。

节日献礼：送你一本签名的《Go语言第一课》！

在这个属于我们自己的节日里，我想用一份最“硬核”的礼物，来回馈大家一直以来的支持，也为每一位仍在奔跑的同行者，加一次油，充一次电。

我准备了 2 本我的亲笔签名版《Go语言第一课》，送给我的读者们。

【参与方式】

点击此链接进入我的公众号文章，分享文章，转发朋友圈，并在本文评论区留言，说说你作为程序员最难忘的一个瞬间/故事，或者你对程序员这个职业最深的思考。

它可以是一次通宵排查 Bug 后的豁然开朗，可以是自己的代码被千万用户使用时的成就感，也可以是对这个行业未来的迷茫与期许。

【抽奖规则】

我将从所有留言中，精选 2 条最走心、最能打动我的分享，每人赠送一本我的亲笔签名版《Go语言第一课》！

【活动截止时间】

2025年10月31日 23:59

期待在留言区，看到你的故事。

行动号召：为你的热爱，充一次电！

当然，节日的福利属于每一个人。

如果你不想等待抽奖，或者想把这份礼物送给身边正在学习 Go 的朋友，现在就是最好的时机。双十一促销已经启动，各大电商平台的五折购书折扣都是全年最低。不到 40 元，即可拥有这本经过 2.4w 人验证、300 多页的 Go 入门宝典。

• 图书勘误与配套代码：https://github.com/bigwhite/goprimer

小结：愿我们永远奔跑

最后，再次向每一位奔跑在二进制世界里的同行者致敬。

愿你的代码永远优雅，愿你的编译永远通过，愿你的创造力永不枯竭，愿你的 err 永远为 nil。

1024，程序员节快乐！

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

© 2025, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/09/19/the-tension-in-programmer-comments

大家好，我是Tony Bai。

做公众号/博客这些年，我收到了成千上万条来自程序员朋友的评论。绝大多数都充满了智慧、好奇和善意，正是这些交流，构成了我持续分享的最大动力。但与此同时，我也常常在评论区里，感受到一股强烈的、带有攻击性的无形之气。

比如，当我分享一篇关于Go在业务场景实践的文章时，总会有人跳出来，言简意赅地留下一句：“用Go写业务是不是很垃圾？”

又比如，当社区在探讨用Rust重构某个C++项目时，评论区可能会出现这样的“高论”：“用Rust重写C++代码，就是从一坨屎变成了另一坨屎。”

这些评论，往往脏字当头，不带任何论据，纯粹是情绪的宣泄。我思来想去，觉得用“戾气”或“喷子”来形容，似乎都不够精准。直到有一天，一个词蹦进了我的脑海——“煞气”。

这个词，源于传统文化，意指一种凶戾、非理性、具有破坏性的气场。它精准地捕捉了这类评论的本质：其目的并非交流思想，而是用情绪的冲击波，扼杀讨论，打击分享者的热情。正因如此，我之前公众号的自动精选评论和留言不得不改为手工精选，这不仅增加了工作量，还降低了评论展示的及时性。

今天，这篇文章不旨在批判，而是想和大家一起，深入地聊一聊程序员评论区里的这股“煞气”，尝试理解它从何而来，并探讨作为技术社区的一员，我们该如何面对它，如何保护我们共同的精神家园。

“煞气”的百态图鉴：你一定见过的几种典型“煞评”

这股“煞气”并非铁板一块，它以多种面目出现在我们的视野中，总有一种让你觉得似曾相识：

• “一言以蔽之”型
  这类评论堪称“断言大师”，从不屑于提供论据，仅用一句话便能给一门语言、一个框架甚至一个技术方向盖棺定论。

  • “Go就是不行。”
  • “WebAssembly没前途。”
  • “微服务就是个坑。”
    简洁，有力，不容置疑，仿佛掌握了宇宙的终极真理。

• “非黑即白”型（技术圣战）
  在他们眼中，技术选型不是基于场景和权衡，而是一场关乎信仰的“圣战”。语言、编辑器、操作系统……万物皆可站队，异端必须被消灭。

  • “用Rust重写C++就是从一坨屎变成另一坨屎。”
  • “Vim/Emacs之外皆异端！”
  • “还在用Windows/Mac开发？笑死。”

• “资格论”与“秀优越”型
  这类评论善于通过攻击对方的身份、资历或知识储备，来釜底抽薪式地否定其观点，从而建立自己的优越感。

  • “你连源码都没读过，凭什么评论？”
  • “这东西我十年前就玩过了，没什么新意。”
  • “等你写到百万行代码再来讨论架构吧。”

• “情绪投射”型
  这类评论者，往往将自己在工作中因某项技术受挫而产生的负面情绪，无差别地投射到所有相关的公开讨论中，把评论区当成了情绪的垃圾桶。

  • “我们项目刚被XXX坑惨了，这玩意儿就是个彻头彻尾的垃圾！”
  • “又在吹这门语言？我刚因为它的GC问题加了三天班！”

这些充满“煞气”的评论，像病毒一样侵蚀着技术社区的讨论氛围，让许多乐于分享的创作者心生寒意，也让许多渴望学习的新人望而却步。

溯源“煞气”：它们究竟从何而来？

要应对“煞气”，首先要理解它的来源。它并非简单的“素质问题”，背后往往有更深层次的、属于程序员群体的心理动因：

1. 高认知负荷与挫败感： 软件开发本质上是一项与复杂性搏斗的高难度、高挫败感的工作。代码不工作是常态，被需求反复折磨是日常。长期累积的压力和挫败感，需要一个宣泄的出口，而匿名的网络评论区便成了最廉价的选择。
2. 强身份认同与技术部落主义： 许多程序员倾向于将自我价值与所掌握的技术栈深度绑定。“我是Gopher”、“我是Rustacean”，这种身份认同感带来了归属感，但也催生了“部落主义”。攻击对立的技术，本质上是在捍卫自我身份和所属部落的“荣耀”。
3. 对“最优解”的执念与抽象能力的差异： 我们的工作是与逻辑打交道，追求严谨和正确，这使得许多程序员潜意识里相信存在一个放之四海而皆准的“最优解”。这种思维惯性，导致在面对需要权衡（Trade-off）的工程问题时，容易陷入“非黑即白”的二元对立，无法容忍不同场景下的不同选择。
4. 知识的诅咒： 一些资深开发者，已经忘记了自己初学时期的困惑和挣扎。他们对自己领域内“显而易见”的知识缺乏同理心，容易将新手的提问或不成熟的观点视为“愚蠢”，并报以轻蔑或不耐烦。
5. 网络匿名性的放大效应： 这是所有网络社区的通病。脱离了现实世界的社交约束，人们更容易释放出内心的攻击性。

化解“煞气”：我们每个人的社区修行

面对弥漫的“煞气”，无论是内容创作者还是普通读者，我们每个人都身处其中，既可能是受害者，也可能在不经意间成为助推者。与其抱怨环境，不如从自身做起，共同参与到社区的净化与建设中来。

给所有社区参与者的“修行建议”：

1. 评论前，区分“观点”与“情绪”： 在敲下键盘前，花一秒钟审视内心：我即将表达的，是基于逻辑和事实的技术观点，还是仅仅是想吐槽一下今天遇到的某个Bug或者糟糕的心情？有意识地分离这两者，是理性讨论的第一步。
2. 拥抱“建设性批评”的艺术： 如果你不同意某个观点，这非常正常，甚至是技术进步的源泉。但请尝试用建设性的方式来表达：
   • 提供论据： “我认为这个方案有风险，因为在XX场景下，它可能会导致YY问题。”
   • 提供替代方案： “相比A方案，我更推荐B方案，因为B在处理XX方面更有优势。”
   • 补充上下文： “这个观点在小型项目中可能适用，但在大规模分布式系统中，我们需要额外考虑……”
     这样的评论，远比一句简单的“你这是垃圾”有价值千万倍。
3. 常怀谦逊与同理心： 技术世界浩瀚无垠，我们每个人都只是其中渺小的一粟。承认自己知识的局限性，尊重不同技术在不同场景下的存在价值。我们今天所不屑的，可能正是我们昨天所困惑的；我们今天所熟稔的，可能是别人明天将要探索的新大陆。多一份同理心，少一份优越感。

小结：化“煞气”为“祥和之气”，共建更有价值的技术社区

回到开头的那些评论。Go写业务当然不是垃圾，Rust重写C++也绝非原地踏步。每一种技术选择背后，都有其复杂的工程背景和权衡考量。一个健康的技术社区，应该是一个能够容纳并理性探讨这些权衡的地方。

我们探讨“程序员的‘煞气’”，目标不是消灭所有反对的声音，健康的质疑和辩论是技术进步的基石。我们的目标，是希望将那些无意义的、纯粹消耗热情的情绪宣泄，转化为能够推动我们共同进步的思想碰撞。

这需要我们每一位社区参与者的共同努力：分享者多一份对人性的理解和对经验的珍视，评论者多一份理性和建设性的态度。

愿我们都能成为驱散“煞气”的光，让技术社区的每一次讨论，都离智慧更近一步。

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

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

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

© 2025, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2025/09/08/fanren-xiuxian-programmer-levels

大家好，我是Tony Bai。

最近《凡人修仙传》的电视剧大火，想必各位道友都有耳闻。鄙人也没忍住，不仅刷完了杨洋主演的网剧，还趁着这股热乎劲儿，一口气在微信读书连读再听地补完了小说的人界篇。

当看到韩立资质平平，相貌普通，却凭着“小绿瓶”、远超常人的心智和不懈的努力，在残酷的修仙界中，历经炼气、筑基、结丹、元婴，终至化神时，我猛然拍案：

这不就是我们程序员升级打怪的真实写照吗？！

仔细一想，还真是如此。在这“码农”修仙界，人人皆望飞升，脱离 CRUD 的苦海，证得架构大道。韩天尊从一介凡人，在人界一步步逆天修行；我们则从一行“Hello World”开始，在代码的世界里摸爬滚打。从初窥门径到执掌乾坤，其间的艰辛与突破，又何尝不是一场惊心动魄的修行？

今日，不妨让我们借韩天尊的人界飞升之路，一同探寻这程序员的修仙境界。看看你我，如今身在何处，又该如何“破境”飞升。

第一境：炼气期 – 程序员学徒

此境界的修士初入仙门，刚刚感应到“天地灵气”（编程语言），开始学习吐纳之法（基础语法）。灵力微薄，法术生疏，面对浩如烟海的功法秘籍（API文档），常常感到力不从心，一不小心就可能“走火入魔”（写出 Bug）。

• 境界特征：
  • 初窥门径，灵力微薄： 刚掌握一门或多门“功法”（Java/Python/Go），但理解不深。能写出基础的业务逻辑，但对底层原理一知半解，如同只会念咒却不知其所以然。
  • 修炼功法，打牢根基： 每日勤修不辍，疯狂“吸收灵石”（看文档、刷 LeetCode、学习框架）。主要任务是完成导师（Mentor）分配的“宗门任务”（小功能、Bug修复），以此换取修炼资源。
  • 依赖法器，难离其身： 严重依赖各种“低阶法器”，如 Stack Overflow、CSDN 和各类 AI 代码助手。一旦“法器”失灵（断网），便束手无策，战力大减。
  • 心魔与瓶颈： 最大的心魔是“我是不是不适合写代码”的自我怀疑。常常会遇到“瓶颈”，一个简单的 Bug 可能要耗费数日才能解决，此时急需一颗“筑基丹”（高人指点）方能突破。

第二境：筑基期 – 合格的工程师

经历无数次“走火入魔”后，终于炼化灵气，开辟丹田，成功“筑基”，体内的“灵力”（知识体系）凝聚成形。从此，你不再是修仙界的炮灰，而是一名真正的修士，可以独立执行任务，在宗门（团队）中有了一席之地。

• 境界特征：
  • 筑基成功，道途有望： 能够独立负责一个模块或一条业务线。对团队的技术栈了如指掌，是项目的中坚力量，道基稳固。
  • 拥有本命法器： 不再是见什么用什么，而是有了自己得心应手的“本命法器”（精通的框架或工具链），如 Spring 全家桶、Vue/React 生态。使用起来得心应手，威力倍增。
  • 神识初成，洞察秋毫： 开始具备一定的“神识”（Code Review 能力和设计嗅觉），能发现炼气期修士代码中的明显问题，并预见一些潜在的风险，如同神识外放，探查四周。
  • 独立执行宗门任务： 可以独立外出执行有一定难度的“宗门任务”（负责一个完整需求），并能顺利归来，不再需要师兄寸步不离地看护。

第三境：结丹期 – 资深工程师 / 技术骨干

此乃修行路上的巨大分水岭。修士将全身修为压缩、凝练，在丹田内结成一颗“金丹”（核心技术壁垒）。从此，寿元大增（职业生涯更稳定），神通广大，成为宗门里受人敬仰的长老级人物。

• 境界特征：
  • 凝结金丹，质的飞跃： 在某一领域（如高并发、分布式、数据库优化）形成了自己深厚的知识体系和方法论，这便是你的“金丹”。你是这个领域的 Go-to Person，是众人眼中可靠的“X哥”、“X姐”。
  • 本命法宝，威力大增： 不再满足于使用“法器”，开始炼制自己的“法宝”（轮子、工具库、脚手架），供宗门内弟子使用，极大提升了整个团队的战斗力。
  • 开辟洞府，传道授业： 开始承担起“长老”的职责，为宗门“开辟洞府”（搭建技术分享平台），“传道授业”（指导新人、进行技术培训），培养后辈力量，扩大自己的影响力。
  • 阵法大师，布局为先： 对小型系统的架构设计信手拈来，如同布置“阵法”，懂得权衡取舍，让系统在未来一段时间内稳固运行，易于扩展。

第四境：元婴期 – 架构师 / 首席工程师

碎丹成婴，道行进入全新天地。修士的“元婴”可以出窍，神游天外，对“天地法则”（系统规律）的理解远超常人。他们是宗门的守护神，轻易不出手，但一言一行都足以影响宗门的兴衰。

• 境界特征：
  • 元婴出窍，神游天外： 视角早已超越某个具体项目或业务线。他们的“元婴”（思想和影响力）可以“出窍”，俯瞰整个公司的技术体系，思考跨团队、跨领域的平台级问题。
  • 参悟天地法则： 深入理解分布式、高可用、可扩展性等“天地法则”。他们关注的不再是“术”（具体实现），而是“道”（设计哲学与原则），能在纷繁复杂的需求中，找到最核心的技术模型。
  • 开宗立派，影响一方： 他们设计的“护山大阵”（核心技术架构、平台），能支撑公司未来数年的发展。他们制定的“门规”（技术规范、研发流程），被众多弟子遵守，深刻影响着整个技术团队的文化和效率。
  • 趋吉避凶，未卜先知： 具备强大的技术预判能力，能洞察技术趋势，规避未来的技术债务和架构风险，带领宗门走在正确的“修行”道路上，避免误入歧途。

第五境：化神期 – 技术大牛 / 领域开拓者

此境界已是人界的传说，神龙见首不见尾。他们对“道”的理解已返璞归真，能够洞悉本源，甚至创造规则。他们的存在，本身就是一座无法逾越的高山，是无数修士仰望的目标。

• 境界特征：
  • 返璞归真，大道至简： 他们的言论和代码往往看起来平平无奇，却蕴含着对技术最深刻的理解。能用最简单的语言解释最复杂的原理，如同“大道至简”，一言一行皆是道法自然。
  • 言出法随，创造规则： 他们不再是规则的遵守者，而是规则的创造者。他们创造的某个开源框架（如 K8s, TensorFlow）、某篇论文（如 MapReduce, DynamoDB），可能开创一个时代，成为无数修士修行的“根本大法”。
  • 破碎虚空，飞升上界： 他们的影响力早已超越一家公司，成为整个行业的灯塔。他们可能在顶级技术会议上“讲道”，也可能在某个开源社区中“点化”众生。对他们而言，换个公司已不是“跳槽”，而是“破碎虚空”，去往另一个更广阔的世界（灵界）。

小结：路漫漫其修远兮

修仙之路，道阻且长，行则将至。

从炼气期的迷茫，到筑基期的坚定；从结丹期的突破，到元婴期的洞察，乃至化神期的传说。每一个境界，都离不开日复一日的“打坐”（学习）、一次又一次的“渡劫”（攻克难题），以及那么一点点“机缘”（好的项目和团队以及赛道）。

韩立资质平平，却凭着“勤奋”与“谨慎”二字，终成大道。我辈程序员，或许没有逆天资质，但只要心向大道，勤勉不怠，终有一日，也能突破瓶颈，得见真我。

那么，各位道友，你现在修炼到哪个境界了？在修行路上又遇到了哪些瓶颈或趣事？欢迎在评论区留下你的“道号”和境界，我们一同论道！

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

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

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

© 2025, bigwhite. 版权所有.