10 min read

软件开发的最终形态

来源:https://blog.zksecurity.xyz/posts/end-coding/

这篇文章,基本是在给软件开发下句号。

我感觉自己已经摸到了它的最终形态。这里说的“最终”,一方面是历史意义上的最终,另一方面甚至也是范畴论意义上的最终。别担心,读起来还挺有意思。

我现在人在葡萄牙的一家咖啡馆,边喝东西边发呆,pull request 会自己冒出来。它们会自动新增 Lean 定理,或者重构已有的 Lean 证明。CI 一旦是绿的,通常就说明东西是对的。我甚至可以直接在手机上看代码、点 merge。

@pirapira

别告诉我你在用手机做最快的 EVM 实现 😎

@butta_eth

我现在经常直接用手机干这个,一天能产出 200 到 600 个 commit。再往后一点,我甚至觉得连手机都不需要了。当然,agent 有时也会犯错,但只要证明卡住,它们通常自己就能意识到哪里出问题了。

zkVM 需要可靠的 guest program

现在有一类基于 RISC-V 的虚拟机,可以生成 succinct argument of knowledge,也就是 zkVM。它能用密码学方式证明:某个 RISC-V 程序在给定输入下,确实产生了某个输出。

但如果 guest program 本身有 bug,会发生什么?

某一天,验证器接受了一份 zkVM 执行证明,然后系统出了问题。你开始追查到底哪里错了。可你手上通常只有一些公开可见的信息,比如密码学承诺和若干 opening。问题是,这些东西在大多数情况下看起来只是一堆毫无意义的数字。想真正定位 bug 会非常费时间,甚至可能根本做不到。

所以,对 zkVM 来说,最重要的一件事就是:guest program 必须尽可能被证明没有 bug。

我的做法

我的方案是:让 AI agent,目前主要是 Claude Code 的 /loop 命令,去写 RISC-V 汇编,然后再用证明助手 Lean 证明这些汇编代码是正确的。

这里没有 Rust,没有 C,没有 C++。只有 RISC-V 汇编 和 Lean 证明。

这条路其实并不新。直接对汇编做形式化验证,本来就是一个老方向。我现在走的做法,主要受 2013 年那篇论文 *Coq: The world’s best macro assembler?* 启发。

大概十年前我就看过这篇文章,也一直想试。但当时手写 Rocq,也就是原来的 Coq,证明实在太耗人力了,所以始终没真正上手。

到了 2025 年,机器已经开始能在 Rocq、Lean 这类证明助手里写证明了。于是,现在终于可以把 proof assistant 当成 assembler 来用了。

这件事其实比看上去容易。

因为 RISC-V 汇编本身非常容易推理,远比 Rust、C、C++ 简单。你在证明这些高级语言时,需要处理作用域内的变量、内存里的对象、构造与析构、虚方法、带符号整数溢出可能触发 undefined behavior 等等问题。

而 RISC-V 几乎没有这些复杂性,除了寄存器里的值和内存状态,你不需要同时追踪那么多抽象层。

更关键的是,既然 AI agent 自己写了这些汇编,它本来就知道代码在做什么、为什么这么写。这比拿编译器吐出来的一堆优化后机器码再去做侦探工作,简单太多了。

这套方法已经跑起来了。

你可以看看 evm-asm 这个仓库。以太坊虚拟机的一部分已经被写成了 RISC-V 汇编,并且已经有针对这些汇编代码的形式化规格证明。

我的 AI agent 目前还在持续做大规模重构,并且在开发一个更复杂的除法算法。说实话,一旦 zkVM 以后能接受 hint input,我可能就不再需要这么复杂的除法算法了……不过看它们自己折腾,还是挺有意思的。

它长什么样

代码本身其实就是一串指令。下面这段实现的是 EVM 里的 256 位加法:

def evm_add : Program :=
 -- Limb 0 (5 instructions)
 LD .x7 .x12 0 ;; LD .x6 .x12 32 ;;
 ADD .x7 .x7 .x6 ;; SLTU .x5 .x7 .x6 ;; SD .x12 .x7 32 ;;
 -- Limb 1 (8 instructions)
 LD .x7 .x12 8 ;; LD .x6 .x12 40 ;;
 ADD .x7 .x7 .x6 ;; SLTU .x11 .x7 .x6 ;;
 ADD .x7 .x7 .x5 ;; SLTU .x6 .x7 .x5 ;;
 OR' .x5 .x11 .x6 ;; SD .x12 .x7 40 ;;
 -- Limb 2 (8 instructions)
 LD .x7 .x12 16 ;; LD .x6 .x12 48 ;;
 ADD .x7 .x7 .x6 ;; SLTU .x11 .x7 .x6 ;;
 ADD .x7 .x7 .x5 ;; SLTU .x6 .x7 .x5 ;;
 OR' .x5 .x11 .x6 ;; SD .x12 .x7 48 ;;
 -- Limb 3 (8 instructions)
 LD .x7 .x12 24 ;; LD .x6 .x12 56 ;;
 ADD .x7 .x7 .x6 ;; SLTU .x11 .x7 .x6 ;;
 ADD .x7 .x7 .x5 ;; SLTU .x6 .x7 .x5 ;;
 OR' .x5 .x11 .x6 ;; SD .x12 .x7 56 ;;
 -- sp adjustment
 ADDI .x12 .x12 32

它对应的规格大概长这样:

 cpsTriple base (base + 120) code
 (-- Registers + memory
 (.x12 ↦ᵣ sp) ** (.x7 ↦ᵣ v7) ** (.x6 ↦ᵣ v6) ** (.x5 ↦ᵣ v5) ** (.x11 ↦ᵣ v11) **
 evmWordIs sp a ** evmWordIs (sp + 32) b)
 (-- Registers + memory (updated)
 (.x12 ↦ᵣ (sp + 32)) ** (.x7 ↦ᵣ result3) ** (.x6 ↦ᵣ carry3b) **
 (.x5 ↦ᵣ carry3) ** (.x11 ↦ᵣ carry3a) **
 evmWordIs sp a ** evmWordIs (sp + 32) (a + b)) := by

真正重要的点是:原先的 b 会被替换成 a + b,这里的加法是 256 位整数加法。同时 sp 会从 sp 挪到 sp + 32,也就是 EVM stack 上少了一个 word。

在这段规格后面,通常只需要大约 20 行看起来很神秘的 Lean 代码,也就是证明本体。

这些代码唯一的作用,就是说服 Lean kernel:上面的规格在所有情况下都成立。

我自己多少还能读一点 Lean 证明,但老实说,我怀疑这会慢慢变成一种没那么重要的技能。未来你可能直接把证明链接丢给 coding agent,它就能给你解释清楚。

还有别的路吗?

我做程序验证差不多十年了,所以对于“怎样才能真正知道程序没有 bug”,我大概能列出主要选项。

说白了就两件事:

  1. 写出正确的源码
  2. 把它变成正确的机器码

形式化验证编译器

有一个经过形式化验证的 C 编译器叫 CompCert。一种思路是:先形式化验证 C 源码,再把这份正确的 C 丢进 CompCert,编译出正确的 RISC-V 代码。

我觉得这条路是可行的。

问题只在于性能。

CompCert 官方自己给出的说法是:它生成的代码,至少比 gcc -O0 快三陪左右,但相比 gcc -O1 会慢大概 10%,相比 gcc -O2 慢大概 15%,相比 gcc -O3 慢大概 20%。

在一个极度性能导向的场景里,这就是硬伤。因为大家现在想要的是:让 zkVM 在几秒内就给整块以太坊区块出证明。

另一个经过形式化验证的编译器是 CakeML。它可以编译 StandardML,也有 RISC-V 后端。

但 CakeML 生成的 RISC-V 代码会做垃圾回收。而当大家正在拼命压缩 zkVM 的 proving time 时,再去为垃圾回收过程生成证明,听起来就不太讨喜了。

Rust 呢?

Rust 本来就是一群很懂程序验证的人设计出来的语言,它也有不少验证工具。

但真正的瓶颈,似乎还是:怎么把“正确”的 Rust,变成一个正确的汇编程序。

你可以走一条形式化验证编译器的路线,也可以每次编译后人工把汇编和源码对照一遍。但无论哪种,最终麻烦都还在那里。

为什么我这里会给“正确”的 Rust 打引号?

因为我其实并不完全确定,Rust 程序到底“意味着什么”。Rust 的语言规范本身还在持续发展。至少在目前,决定 Rust 程序语义的,实际上是 Rust 编译器本身。

而 Rust 编译器自己又是用 Rust 写的。于是你会得到一个有点绕的局面:Rust 的含义,某种程度上由 Rust 编译器决定,而 Rust 编译器的含义,又还是由 Rust 编译器决定。

所以最后你还是得回到汇编代码,或者机器码。

当然,即便如此,你仍然可以在 proof assistant 里自己定义一套 Rust 语义,把它作为中间层,再一步步把汇编代码形式化验证出来。

从长期看,这也许是更优雅的方向。

但如果你把这一切都放在 Lean 里做,那它最终其实还是会以一种很自然的方式,收敛回“只有汇编代码 + Lean”这条路线。

从范畴论视角看,这就是为什么“汇编 + Lean”才是终态。

C 和 C++ 呢?

C 和 C++ 至少有清晰的语言规范,这些规范相当于编译器和程序员之间的接口。

但这些规范同时也规定了:在某些情况下,程序行为是 undefined 的。

比如:

  • 带符号整数溢出
  • 指针和指针相加
  • 计算出超出数组边界太多的指针
  • 访问了错误的指针
  • 等等

所以,当你去验证 C 或 C++ 程序时,很多精力其实都耗在证明“这些 undefined behavior 永远不会发生”上。

这些 undefined behavior 对编译器特别有用,尤其是在做优化的时候。

但我做了一个取舍:

我不想把大量精力花在证明“不会触发 undefined behavior”上,所以我干脆把编译器这层拿掉了。

现在既然有 LLM,直接生成汇编代码,已经变成了可行选项。

更学院派的项目

还有一些小型语言,也能编译到 RISC-V,比如 bedrock2 和 Jasmin。

这些语言在 Rocq 里有规格定义,也有经过形式化验证的编译器。

Jasmin 更聚焦密码学,也许可以被改造成适合 EVM 实现。

Bedrock2 更通用一些,它的路线其实很有启发性。它最核心的卖点,是软件和硬件的一体化协同验证。

而在 verified zkEVM 这个方向里,zkVM 本身和 guest program 的形式化验证,最好也应该被放在一种更整体化的框架里组织。

evm-asm 里的 program logic,就和 Bedrock2 很接近。

不过,由于 zkVM 的性能特征和真实 RISC-V 硬件差异很大,我们真正想要的汇编代码,很可能也会和普通硬件场景下的最佳汇编非常不一样。

所以我接下来还是会继续直接实验“手写汇编”,或者更准确点说,“让 agent 直接写汇编”。

而且未来我们甚至可能直接改造目标 zkVM,让它偏离标准 RISC-V,比如 给它加更多寄存器。

为什么我觉得这就是软件开发的最终形态

世界上当然还有无数种编程语言、编译器、抽象层和优化技巧。

它们都很优雅,也各有自己的价值。

但关键点在于:所有这些东西,最终都可以被翻译进“汇编 + Lean”这个范式里。

也正因为如此,我才会说:

“汇编 + Lean”就是软件开发的最终形态。


图片由 ChatGPT 生成。语法、文风和摘要生成由 Claude Code 协助完成。