标签 Go语言 下的文章

刚刚,2025图灵奖揭晓!面对即将瘫痪的传统密码学,Go 语言的“抗量子”底牌曝光

本文永久链接 – https://tonybai.com/2026/03/19/2025-turing-award-go-quantum-resistant-cryptography

大家好,我是Tony Bai。

就在昨天(2026 年 3 月 18 日),计算科学界的最高荣誉——ACM A.M. 图灵奖正式揭晓。2025 年的图灵奖,颁给了 Charles H. Bennett 和 Gilles Brassard 两位伟大的科学家,以表彰他们在“量子密码学(Quantum Cryptography)”和量子信息科学领域的开创性贡献。

或许你会觉得,图灵奖、量子力学、薛定谔的猫……这些高大上的词汇离我们每天 CRUD 的业务代码太遥远了。

但实际上,这场发端于理论物理界的革命,正在引发全球软件工程界一场最高级别的“红色预警”。

早期的图灵奖往往颁发给操作系统、数据库或编程语言的设计者(比如Unix 之父、B 语言(C 语言前身)以及 Go 语言联合设计者的Ken Thompson),而这次颁给量子密码学,传递出了一个极其明确的信号:传统的数字世界护城河,马上就要守不住了。

今天,借着图灵奖揭晓的热点,我想和大家聊一个极其硬核、且关乎我们所有后端开发者未来饭碗的话题:当“量子末日(Q-Day)”逼近,作为云原生时代绝对霸主的 Go 语言,手里究竟握着怎样的“抗量子底牌”?

你的数据,正被黑客“先存后破”

在理解 Go 团队的动作之前,我们必须先弄懂,为什么我们需要“后量子密码学(PQC)”?

目前,我们用来保护 HTTPS 流量、验证 JWT 登录、以及签署 Git 提交的底层基石,绝大多数是 RSA 或 ECC(椭圆曲线)算法 。这些算法的安全假设,建立在大质数分解和离散对数计算极其困难的数学事实上。

但早在 1994 年,Peter Shor 就提出了著名的 Shor 算法。该算法在数学上证明了:只要拥有一台足够规模的量子计算机,RSA 和 ECC 算法不仅能被破解,而且破解速度是指数级倍增的!

你可能会想:“量子计算机离真正商用还早着呢,急什么?”

黑客们可不这么想。现在全球的顶级黑客和某些国家级 APT 组织,正在疯狂执行一种名为 “Store Now, Decrypt Later”(先收集,后破解,SNDL) 的战略。

他们把现在截获的、由 RSA/ECC 加密的核心机密数据全部存储在硬盘里。等若干年后量子计算机成熟,他们就能在一瞬间把这些历史机密全部解开。

为了应对这场“降维打击”,美国国家标准与技术研究院(NIST)紧急发布了后量子密码学(PQC)的 FIPS 标准草案。而作为全球云基础设施底层语言的 Go,自然被推到了抗击量子危机的第一线。

Go 团队的“抗量子”谋略

如果你经常关注 Go 社区,你会发现 Go 核心团队早就确定了引入新密码学算法的策略。在 Go 官方仓库的 Issue #64537(crypto: post-quantum support roadmap)中,现任 Go 安全团队负责人 Roland Shoemaker 和 Go 密码学专家 Filippo Valsorda 明确抛出了 Go 在面对量子危机时的三大铁律:

  1. 绝对不当小白鼠:Go 标准库只实现那些结构已经绝对稳定、并在业界(如 WebPKI、TLS)被广泛验证的算法。那些还在实验阶段的半成品,一律拒之门外。
  2. “按需”引入,绝不盲目:PQC 算法分为两类,一类是密钥封装(KEM,用于加密和协商密钥),一类是数字签名(Signature,用于身份认证)。
  3. “内测”转“公测”机制:任何新的 PQC 算法,Go 都会先在 internal 包中悄悄跑几个版本,等把所有可能的开发者“误用坑”都踩平了,才会暴露为 Public API。

基于这套严谨的哲学,Go 团队打出了他们的第一张底牌:优先解决“先收集后破解”的威胁。

在 Go 1.24 中,Go 已经通过提案 #70122 和 #69985,在底层网络库中悄然集成了 ML-KEM(即 Kyber 算法)与 X25519 的混合密钥交换机制。(注:ML-KEM 从 Go 1.23 就以实验特性引入)

这意味着,如果你使用的是最新的 Go 版本构建的 HTTPS 服务,你的连接在建立之初,就已经具备了抵抗未来量子计算机窃听的能力!

密钥交换的问题解决了,那么用来证明身份的数字签名(Digital Signatures)呢?这就引出了 Go 团队即将放出的第二张王炸。

揭开 crypto/mldsa 的硬核源码

数字签名的重要性不言而喻:微服务之间的 mTLS 认证、固件升级包的防篡改、区块链的交易防伪,全靠它。

就在最近,Filippo 在 Go 官方 GitHub 上正式提交了 Issue #77626(proposal: crypto/mldsa: new package),提议在即将到来的 Go 1.27 中,正式向全世界暴露 ML-DSA(NIST FIPS 204 标准)的公有 API。

让我们剥开这层提案,看看顶级大厂架构师是如何设计这套跨时代 API 的。

极简的参数集隔离

ML-DSA 并不是一个单一算法,它包含了不同的安全级别。Go 提案非常干净利落地定义了三个常量函数:

func MLDSA44() Parameters // 推荐日常使用,安全级别相当于 AES-128
func MLDSA65() Parameters // 相当于 AES-192
func MLDSA87() Parameters // 极高安全级别,相当于 AES-256

开发者不需要去记忆复杂的参数结构,只需像拼积木一样调用。

拒绝“半展开密钥”,将安全做到极致

如果你看源码,会发现 NewPrivateKey 除了传入 params 参数集外,只需要传入一个极短的 seed(种子字节),而不是业内的“半展开密钥(Semi-expanded keys)”。

为什么?Filippo 在讨论中给出了让人拍案叫绝的解释:

“半展开密钥是一个极其糟糕的格式。它不仅占用空间更大,加载速度更慢,而且更危险。我们只会支持基于 Seed 的密钥派生。”

这体现了 Go 始终如一的安全哲学:如果一种格式有被开发者误用的风险,那就从 API 层面彻底物理隔绝它。

巧妙应对“预哈希(External μ)”难题

传统签名时,我们通常先用 SHA256 算个 Hash,再对 Hash 签名。但 ML-DSA 的底层数学机制非常复杂,它要求对 H(H(pubkey) || 0×00 || context || message) 进行极度严苛的处理。

Go 团队没有去破坏原有的 crypto.Signer 接口,而是极其巧妙地发明了一个“虚拟的占位符”:crypto.MLDSAMu。

这个常量虽然属于 Hash 类型,但它不支持被实例化,调用 New() 会直接引发 Panic。它仅仅作为一个“信号标记”传递给 SignerOpts,优雅地实现了向下兼容。

为什么我们还不能在 X.509 证书里用它?

看到这里,很多着急的开发者(尤其是一些政企、军工背景的开发团队,正面临 CNSA 2.0 强制要求在 2025 年升级 PQC 的死命令)在 Issue 里疯狂催问:

“API 都做好了,为什么不顺手把它集成进 crypto/x509 证书解析里?为什么还不让在 TLS 中直接使用 ML-DSA 证书?”

Filippo 的回答,直接揭露了目前后量子时代最尴尬的一个物理瓶颈,也展现了他作为世界级密码学家的极致架构克制

“如果我们现在就把 ML-DSA-87 塞进 TLS,你知道一个 TLS 握手包会变得多大吗?足足 19KB!

大家要知道,传统的 RSA 签名不过几百字节,ECC 签名更是只有几十个字节。我们过去 30 年的互联网协议(如 TCP/IP、TLS),都是建立在“签名数据极小、传输成本几乎为零”的物理假设上的。

如果你用 ML-DSA 给证书签名,证书链上一叠加,一次最普通的 HTTPS 握手,瞬间需要传输几十 KB 的数据。在移动网络弱网环境下,这会导致大规模的丢包、延迟飙升,甚至是全球互联网的“大塞车”。

为了通过安全审计而罔顾物理性能,这不是高级软件工程,这是在耍流氓。

Go 团队的判断是:我们有时间去设计更好的协议(比如使用 Merkle Tree 证书),而不是现在急功近利地把数万字节的“肥胖签名”强塞进原本轻巧的 TLS 隧道里。

这种“不将就”的架构底线,正是 Go 语言最迷人的地方。

小结:在不确定的未来中,拥抱底层逻辑

图灵奖颁给量子密码学,不仅是对 Bennett 和 Brassard 两位科学先驱的最高致敬,更吹响了全球软件工程界系统升级的冲锋号。

从优先落地对抗 SNDL 攻击的 ML-KEM,到极度克制、优雅设计的 crypto/mldsa,再到坚决抵制“19KB 肥胖握手包”的底线坚守。我们看到的是 Go 语言团队对工程效率、安全性与网络物理特性的深度掌控。

资料链接:

  • https://awards.acm.org/about/2025-turing
  • https://github.com/golang/go/issues/64537
  • https://github.com/golang/go/issues/77626

今日互动探讨

如果在未来两年,为了抗击量子计算机,我们所有的 HTTPS 请求都要变慢 200 毫秒,甚至服务器内存消耗要翻倍,你觉得这个代价值得吗?在你的业务线里,有面临密码学升级的强制合规要求吗?

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


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

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

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


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

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

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

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

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


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

被嘲笑比 Python 还慢?扒开 Go 正则表达式的底层,看看它为了防范“系统猝死”付出了什么

本文永久链接 – https://tonybai.com/2026/03/17/why-is-go-regex-so-slow

大家好,我是Tony Bai。

如果有人问你:在处理纯 CPU 密集型的文本匹配时,Go 和 Python 哪个快?

相信 99% 的 Go 开发者会毫不犹豫地把票投给 Go。毕竟,一门编译型的静态语言,怎么可能输给拖着 GIL 锁的解释型脚本语言?

但现实往往比小说更魔幻。

最近,在 Reddit 的 r/golang 论坛上,一张残酷的 Benchmark 跑分图引发了整个 Go 社区的剧烈震荡。一位开发者,使用极其常见的日志解析正则表达式(提取 IP、时间、URI 等),对各大语言进行了一次横评。

结果令人大跌眼镜:同样的数据集,Rust 跑了 3.9 秒,Zig 跑了 1.3 秒,而 Go 居然跑了整整 38.1 秒!整整比第一名 Zig 慢了接近 30 倍!

如果你再去翻看 Go 官方的 Issue #26623,会看到更绝望的数据:早在2018年的一次正则基准测试中,Go 不仅被 C++ 和 Rust 碾压,甚至连 Python 3、PHP 和 Javascript 都能在正则上把 Go 按在地上摩擦。

一时间,无数 Gopher 信仰崩塌:“为什么 Go 的标准库 regexp 这么慢?”、“连简单的正则都做不好,Go 凭什么做云原生霸主?”

今天,我们就来硬核扒开 Go 语言 regexp 包的底层设计和实现。你会发现,这不是 Go 团队的技术拉跨,而是一场关于“性能、安全与工程哲学”的博弈。

原罪:你以为的慢,其实是替 CGO 负重前行

面对“为什么 Go 的正则比 Python 还慢”的灵魂拷问,Go 核心团队成员 Ian Lance Taylor 给出了第一层解释。

在 Python、PHP 甚至 Node.js 中,你以为你是在运行脚本,其实它们底层都在悄悄“作弊”。这些语言的正则表达式引擎,几乎全部是用高度优化的 C 语言库(主要是 PCRE,Perl Compatible Regular Expressions)编写的。

当你在 Python 里调用 re.match() 时,它瞬间就穿透到了 C 语言的底层,享受着现代 CPU 指令集的极致加速。

那 Go 为什么不用 C?因为 Go 是一门有着“极度洁癖”的语言。

如果 Go 的标准库引入了 C 语言的 PCRE,就必须通过 CGO 来调用。而 CGO 的上下文切换成本极高,更致命的是,它会彻底破坏 Go 引以为傲的“跨平台交叉编译”能力。你再也不能在一个简单的 go build 后,把二进制文件无痛丢到任何 Alpine 容器里了。

因此,Go 团队做出了第一个艰难的决定:完全使用纯 Go 语言,从零手写一个正则表达式引擎。

脱离了 C 语言几十年的底层优化积累,用原生代码去硬刚别人的 C 引擎,这是 Go 看起来“慢”的表层原因。

但这,仅仅是冰山一角。

路线之争:为了防止系统“猝死”,Go 抛弃了速度

真正让 Go 正则变得“慢”的,是算法架构上的降维选择。这牵扯到 Go 语言的缔造者之一、大神 Russ Cox (rsc) 的一段往事。

在正则表达式的底层世界里,存在着两大流派:

  1. 基于回溯(Backtracking)的 NFA 引擎:代表人物是 PCRE(被 Python、Java、PHP 广泛使用)。
  2. 基于 Thompson NFA / DFA 的引擎:代表人物是 RE2(被 Go、Rust 采用)。

PCRE 引擎极快,它支持各种花里胡哨的语法(如前瞻断言 Lookaround、反向引用 Backreferences)。它的算法逻辑是“不撞南墙不回头”的深度优先搜索(DFS)。在匹配正常字符串时,它快如闪电。

但它有一个极其致命的死穴:ReDoS(正则表达式拒绝服务攻击)。

想象一下你写了一个看似无害的正则:

^([a-zA-Z0-9]+\s?)+$

如果黑客故意传入一个极其恶意的字符串:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!(注意最后的感叹号)。

PCRE 引擎会陷入可怕的“灾难性回溯”。它会尝试所有可能的组合,时间复杂度瞬间飙升到 O(2^n) 级。短短几十个字符的输入,能让单核 CPU 满载运行几年都算不出结果!

2019 年,互联网巨头 Cloudflare 就因为在 WAF 防火墙中写错了一个极其简单的正则表达式,CPU资源瞬间耗尽,导致全球80% 的通过 Cloudflare 代理的网站受到影响,陷入瘫痪长达 27 分钟。这就是 PCRE 回溯引擎的恐怖破坏力。

Russ Cox 在设计 Go 的 regexp 包时,定下了一条铁律:系统安全与可预测性,绝对高于单次请求的极限性能。

因此,Go 彻底抛弃了危险的回溯引擎,选择了基于 Thompson NFA 的算法(源自他之前在Google主导设计的 C++ RE2 引擎)。这种算法保证了匹配时间永远是线性复杂度 O(n)

无论黑客传入多么恶意的字符串,Go 的正则引擎绝对不会发生灾难性回溯。它牺牲了在美好情况下的极致快感,换取了在极端恶劣环境下的金身不坏。

这算是 Go 团队最顶级的“克制”吧。

硬核剖析:Go 的正则,时间到底去哪了?

既然算法是 O(n) 的,为什么 Go 依然比同样采用 RE2/DFA 思想的 Rust 慢那么多呢?

如果你去追踪 Go 官方的 Issue #19629Issue #11646,通过 pprof 分析 Go 正则匹配的 CPU 耗时,你会看到几个令人头疼的瓶颈:

1. 沉重的 UTF-8 解析税

Rust 和 C 的很多正则引擎,底层是直接在“字节(Byte)”级别游走的。而 Go 为了贯彻它对 Unicode 的原生支持,regexp 包在内部极其频繁地将输入流解码为 Rune(Go 的 Unicode 字符单位)。这种逐个解析 Rune 的操作,带来了巨大的计算开销。

2. NFA 虚拟线程的内存震荡

在 Go 的底层源码中,你可以看到耗时最高的两个函数是 (machine).add 和 (machine).step。

Go 是通过维护两个“状态队列(稀疏集)”来模拟 NFA 的并行推进的。每读取一个字符,引擎就要把所有可能的状态添加到下一个队列中。这导致了海量的内存重分配(Allocation)和切片拷贝。哪怕是匹配一个简单的长字符串,底层都在疯狂地挪动内存。

既然这么慢,为什么不把 C++ RE2 里那个极速的 DFA(确定性有限状态自动机)移植到 Go 里呢?

Issue #11646 记录了这次尝试。开发者 Michael Matloob 曾经试图将 RE2 的 DFA 移植过来,但被 Russ Cox 拦下了。原因很直接:DFA 虽然快,但它在运行时会动态生成大量的状态,如果不加以严格限制,极易引发内存耗尽(OOM)。在 Go 带有 GC 的内存模型下,频繁创建和销毁庞大的 DFA 状态缓存,会让垃圾回收器不堪重负。

于是,Go 的标准库在“安全、内存、性能”的三角博弈中,选择了妥协于现状。

社区的探索:SIMD 降维打击与 100倍加速的 coregex

官方的克制固然令人敬佩,但对于身处一线的业务开发者来说,由于正则太慢导致的 CPU 告警,是实实在在的痛点。

“既然官方不愿意改,那我们就自己造轮子!”

在近期的 Issue #26623 中,一位名为 kolkov 的开发者带着他的开源库 coregex 杀入了战场,向 Go 标准库发起了直接的挑战。

coregex 是一个完全用纯 Go 编写的正则库,它的出现直接将 Go 的正则性能拉到了与 Rust 并驾齐驱,甚至在某些场景下超越 Rust 的境地。

它是怎么做到的?它在底层祭出了几个大杀器:

  1. SIMD 预过滤(Prefilters):它使用了手写的汇编代码(AVX2/SSSE3 指令集),将正则中的静态字符串提取出来,利用 CPU 的向量化指令,一次性对比 32 个字节。像匹配 .*.txt 这种正则,速度直接飙升了 1500倍
  2. 带缓存的 Lazy DFA:它绕过了标准库每次都重算 NFA 的毛病,在运行时动态构建 DFA 缓存,大幅消除了内存分配。
  3. 写时复制(COW)的捕获组:标准库在处理提取子串时会疯狂分配切片。coregex 通过切片状态共享,让内存分配直接减少了 50%。

在 kolkov 提供的 CI 跑分中,在 6MB 的输入下,coregex 处理邮箱、URI 的耗时仅为 1.5 毫秒,而标准库耗时高达 260 毫秒。足足快了 170 倍!

然而,这段极其硬核的改进,依然很难入Go团队法眼,更不用谈在短期内被合并进 Go 的标准库。

一方面,Go 官方目前正在推进自己的内建 SIMD 方案(Issue #73787),不想接入手写的汇编代码;另一方面,社区大牛 Ben Hoyt 在使用 coregex 时发现,如果开启 Longest() 模式(最长匹配模式),这个库的性能会发生严重退化。

这再次印证了标准库开发的残酷:在某几个特定场景下跑到全宇宙第一很容易,但要在一套 API 里无死角地兜底全世界所有的奇葩正则输入,难如登天。

在 Go 中写正则的正确姿势

大致了解了底层原理,回到日常开发中,我们该如何应对 Go 正则的性能瓶颈?作为高级 Go 开发者,请务必将以下三条军规刻在脑子里:

第一条:能不用正则,就坚决不用

如果你只是想检查字符串是否包含子串,或者进行简单的前后缀匹配,永远优先使用 strings.Contains()、strings.HasPrefix() 等内置函数。 它们底层有优化的实现,在这样简单场景下,速度是 regexp 包不可比拟的。

第二条:将编译前置,远离循环

如果你翻看新手代码,最常见的低级错误就是在 for 循环或者每次 HTTP 请求里调用 regexp.Compile()。

正则的编译过程(生成 NFA 字节码)极其消耗 CPU。请永远在全局变量或 init() 函数中使用 regexp.MustCompile(),将其编译好并复用。Go 的 Regexp 对象是并发安全的,随便多 Goroutine 调用。

第三条:在极端性能要求下,打破“洁癖”

如果你的核心业务(比如高频日志清洗、海量数据 ETL)确实被 regexp 卡住了脖子,不要硬抗。

你可以选择引入通过 CGO 调用 PCRE的Go binding库(比如https://github.com/GRbit/go-pcre),但要注意防范 ReDoS 攻击,或google/re2的Go binding(比如https://github.com/wasilibs/go-re2),又或是在业务侧尝试社区的野路子 coregex。在生存面前,架构的“洁癖”是可以适当妥协的。

小结

“为什么 Go 的正则这么慢?”

这并非一个简单的工程失误。它是一道分水岭,隔开了“追求跑分好看的玩具代码”与“守护千万级并发集群的生产级设计”。

Russ Cox 宁愿忍受整个开源界的群嘲,也没有为了刷榜而去引入危险的回溯引擎。这或许就是 Go 语言能够成为云原生时代头部语言的原因:不盲目追求上限的巅峰,而是死死守住安全下限。

参考资料

  • https://www.reddit.com/r/golang/comments/1rr2evh/why_is_gos_regex_so_slow/
  • https://github.com/golang/go/issues/26623
  • https://github.com/golang/go/issues/19629
  • https://github.com/golang/go/issues/11646
  • https://swtch.com/~rsc/regexp/

今日互动探讨:

在你的日常开发中,有没有被由于“写了糟糕的正则表达式”而导致 CPU 飙升 100% 的惨痛经历?你又是如何排查和优化的?

欢迎在评论区分享你的血泪史


认知跃迁:读懂底层机制,才能看透系统架构的本质

从放弃 CGO 选择纯 Go 实现,到防范 ReDoS 采用 NFA,再到社区为了榨干 CPU 性能而引入 SIMD。Go 语言的每一个看似“不合理”的设计背后,都隐藏着深邃的系统级考量。

然而,令人遗憾的是,很多开发者写了五六年的 Go 代码,遇到性能瓶颈依然只能靠“瞎猜”和“重启”。他们对 Go 的内存逃逸、Goroutine 调度机制以及标准库的底层数据结构一无所知。

如果你渴望突破“熟练调包侠”的瓶颈,想要像 Russ Cox 这样的顶级大厂架构师一样,看透 Go 语言背后的底层逻辑,建立起自己坚不可摧的技术护城河——

我的极客时间专栏 Tony Bai·Go语言进阶课 正是为你量身定制。

在这 30+ 讲极其硬核的内容中,我不仅带你剥开语法糖,深挖 Goroutine 调度、Channel 哲学;更会带你全面吃透 Go 的工程化实践,把底层性能调优背后的逻辑一次性讲透。

目标只有一个:助你完成从“Go 熟练工”到“能做顶级架构决策的 Go 专家”的蜕变!

扫描下方二维码,加入专栏。不要用战术上的勤奋,掩盖战略上的懒惰。让我们一起用架构师的视角,重新认识 Go 语言。


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

img{512x368}


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

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言进阶课 AI原生开发工作流实战 从 0 开始构建 Agent Harness Go语言精进之路1 Go语言精进之路2 Go语言第一课 Go语言编程指南
商务合作请联系bigwhite.cn AT aliyun.com
这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats