超越平台：Vercel 的野心是定义编程语言的未来吗？

Vercel 近期推出的新功能，其意义远不止于平台优化。它们甚至在挑战 JavaScript 的核心语义，为我们揭示了编程新时代的冰山一角。尽管这些变化引发了诸多争议，但其背后隐藏着一个更宏大、更具雄心的愿景。

Vercel 正在推动一个核心理念：下一代编程语言应当原生支持对现代应用程序复杂性的管理，这包括异构运行时、透明网络、多层缓存和任务持久化等。

本文将深入探讨编程语言的演进方向：未来，它将不仅仅是管理业务逻辑，而是要全面掌控分布式系统中数据与计算的完整生命周期。这一演进正通过三个核心语言概念被悄然地原型化：可序列化闭包 (Serializable Closures) 、代数效应 (Algebraic Effects) 和 增量计算 (Incremental Computation)。

Vercel 为分布式世界打造的新原语

要理解未来，我们必须先审视 Vercel 当下正在解决的问题。现代 Web 应用程序正变得日益复杂，其主要特点包括：

多重运行时 (Multiple Runtimes): 代码需要在客户端（浏览器）、服务器（Node.js）以及边缘（WebAssembly）等不同环境中执行。
分散式数据 (Dispersed Data): 状态（State）散落在内存、CDN、数据库以及文件存储等各个角落。

为了解决这一难题，Vercel 与 React 团队联手推出了一系列强大的新功能。这些功能与其说是对库的补充，不如说是全新的语言级构件。

Server Actions：统一客户端与服务器逻辑

Server Actions 允许客户端组件直接调用在服务器上执行的异步函数，从而无缝地消除了客户端和服务器代码之间的边界。

tsx 复制代码

// server.ts
"use server";
export async function createNote() {
  await db.notes.create();
}

// client.ts
"use client";
// 这个 import 在编译时被转换为一个引用：
// {$$typeof: Symbol.for("react.server.reference"), $$id: 'createNote'}
import {createNote} from './server';

function EmptyNote() {
  return (
    <button onClick={() => createNote()}>创建笔记</button>
  );
}

若没有 Server Actions，实现相同功能需要手动设置 API 端点、编写 fetch 请求，并处理数据的序列化与反序列化。Server Actions 则将所有这些繁琐工作完全抽象，让远程过程调用（RPC）如调用本地函数般简单。

'use cache' 指令：语言级的缓存

'use cache' 指令是一个强大的工具，用于对函数及其结果进行记忆化（Memoization）。它的缓存键（cache key）会根据函数的参数及其闭包值（即函数从其定义作用域中"捕获"的变量）自动生成。

ts 复制代码

export async function Bookings({ type = 'haircut' }: BookingsProps) {
  'use cache'
  async function getBookingsData() {
    const data = await fetch(`/api/bookings?type=${encodeURIComponent(type)}`);
    return data;
  }
  return //...
}

这是一个真正意义上的语言级特性。因为它需要检查函数的闭包环境，所以无法通过简单的库 API 实现，否则开发者就必须手动声明所有依赖项。

'use workflow' 指令：持久化、可恢复的函数

要确保异步任务的可靠性，通常需要一套复杂的架构，包括消息队列、重试逻辑和持久化层。而 'use workflow' 指令的目标，就是让持久化成为一个原生的语言概念。

所谓工作流（Workflow），就是一个函数，它的执行状态能在应用重启、系统故障或长时间中断后得以保持。无论它被中断了数秒还是数月，它都能从上次中断的地方精确地恢复执行。

ts 复制代码

export async function aiAgentWorkflow(query: string) {
  "use workflow";
  const response = await generateResponse(query);
  const facts = await researchFacts(response);
  const refined = await refineWithFacts(response, facts);
  return { response: refined, sources: facts };
}

工作流的核心特性：

持久性 (Durable): 通过基于事件日志的确定性重放（Deterministic Replays），工作流可以在应用部署和系统崩溃后幸存下来。

可恢复性 (Resumable): 执行过程可以在任何 await 点被暂停和恢复。

确定性 (Deterministic): 它们在一个沙箱环境中运行，其中非确定性的 API（如 Math.random 或 Date.now）会受到控制，以确保可重放性。

通过一个简单的 'use workflow' 指令，语言本身就集成了持久化能力，极大地简化了底层复杂的基础设施。

编程语言的历史演进

你可能对 JavaScript 的这些新变化感到不安。毕竟，它们在很大程度上改变了这门语言的语义。然而，回顾编程语言的发展史，我们会发现一个清晰的脉络：语言的每一次进化，都是为了更好地驾驭日益增长的系统复杂性。

编程语言的每一次进化都是为了驾驭新的抽象层和复杂性：

汇编语言 管理原始的 CPU 指令。
C 语言 抽象了寄存器和控制流。
Java 实现了内存的自动管理。
Go 为多核处理器简化了并发编程。

在这条演进路径上，下一个合乎逻辑的步骤，便是着手解决数据管理的复杂性。我们面临的挑战不再仅仅是管理内存或线程，而是管理计算发生的位置、数据如何流动，以及如何确保数据访问是快速、持久且可靠的。

目前，这些问题通常由框架、库和外部系统来解决。开发者需要深入理解序列化、RPC、缓存策略和消息队列。而 Vercel 的新功能则预示着一个未来：在那里，这些问题将由语言本身来解决。

驱动这一愿景的语言特性

Vercel 的新指令之所以备受争议，恰恰是因为它们改变了 JavaScript 的语义。但如果我们换一个角度看，这些新特性的背后，是计算机科学中几个强大的理论基石，它们足以构建出一种新型编程语言。

可序列化闭包 (Serializable Closures)

闭包是一个能够"记住"其创建时所在环境的函数。而可序列化闭包 则是指一个可以被完整打包------包括其代码和所记住的环境------并通过网络发送、存储在数据库中，或在未来某个时间点执行的闭包。这实际上允许我们在系统边界之间传递计算，而不仅仅是数据。

ts 复制代码

function serlializeClosure(fn) {
  const { closureData, fnCode } = extractClosedOverVariables(fn);
  return {
    code: fnCode,
    closure: closureData
  };
}

Server Actions 是一个绝佳的例子。createNote 函数在服务端被序列化，作为一个引用发送到客户端，当客户端调用它时，它的执行会被重新在服务器上触发。

ts 复制代码

// 简化概念：
// 1. 在服务器上，函数及其闭包被捕获。
const { closure, code } = serializeClosure(createNote);
const fnId = storeCodeOnServer(code);

// 2. 一个引用被发送到客户端。
sendToClient({ fnId, closure });

// 3. 客户端使用该引用在服务器上调用函数。
invokeServerFunction({ fnId, closure, fnArgs: [...] });

'use cache' 依赖序列化来创建一个唯一的缓存键。函数的代码、其闭包值以及参数被一同哈希计算。

ts 复制代码

function getCacheKey(fn, args) {
  const { closure, code } = serializeClosure(createNote);
  return hash(fnCode, closureData, args);
}

Workflows 可以看作一个由序列化闭包构成的链条，在每个 await 点暂停。函数的状态及其"续体"（Continuation，即函数的剩余部分）被序列化并持久化，以便后续恢复。

例如，aiAgentWorkflow 函数的执行过程可以看作是在每一步都创建并传递一个序列化闭包：

ts 复制代码

// 伪代码表示
function aiAgentWorkflow(query: string) {
  return generateResponse(query, (response) => {
    // 序列化闭包 1
    researchFacts(response, (facts) => {
      // 序列化闭包 2
      refineWithFacts(response, facts, (refined) => {
        // 序列化闭包 3
        return { response: refined, sources: facts };
      });
    });
  })
}

代数效应 (Algebraic Effects)

可序列化闭包虽然强大，但也带来了一个严峻的挑战：你如何安全地在另一个环境中执行一段代码？一个为服务器设计的函数，在被移动到浏览器后，显然无法访问数据库。

这就是代数效应 发挥作用的地方。代数效应是一种编程语言特性，它将一个函数做什么 （它的副作用，如访问数据库或生成随机数）与如何实现这些副作用分离开来。

当一个"效应"（Effect）被触发时，调用栈上层的某个"效应处理器"（Effect Handler）会决定如何解释和处理它。

'use workflow' 的环境就是一个完美的例子。像 Math.random 和 Date.now 这样的 API 必须表现出确定性。一个效应处理器可以拦截对 Date.now 的调用，并返回工作流事件日志中的时间戳，而不是系统当前时间，从而保证了可重放性。

在一种假设的支持一等公民效应的语言中，你可以为客户端和服务器上下文定义不同的处理器：

ts 复制代码

// 定义一个数据库访问效应
function dbAccessEffect(userQuery) {
  const user =
    yield* db.fetchEffect<User, Error, ServerContext>(userQuery);
  return user;
}

// 在服务器上，处理器提供了数据库上下文
const user = serverHandler.runEffect(dbAccessEffect, query); // OK

// 在客户端，由于没有数据库可用，处理器会抛出错误
// clientHandler.runEffect(dbAccessEffect, query); // Throws Error

这提供了一种安全可靠的方式来控制可移动闭包能够访问哪些资源。

这个概念在 JavaScript 社区并不陌生。像 Effect 这样的库和 Koka 这样的语言已经探索代数效应多年。但是，利用效应来管理不同的执行环境和资源访问，是这一概念新颖而强大的应用。

增量计算 (Incremental Computation)

在分布式系统中，缓存不仅是一种优化，更是性能的关键。增量计算的核心原则是：只重新计算那些受数据变化影响的输出，而不是从头开始计算所有东西。

这个概念早已无处不在：

React 的虚拟 DOM diff 算法就是一种增量计算。
记忆化（Memoization）和像 'use cache' 这样的指令是它的显式形式。
像 Turbopack 和 Bazel 这样的构建系统利用它来避免重复构建未变化的代码。

如果将增量计算提升为一等公民的语言概念，未来的语言就能够自动管理跨不同渲染策略（CSR, SSR, SSG, ISR）、构建系统和数据层的缓存与数据依赖，从而极大地提高效率。

实际上，"use cache" 可以被看作是增量计算的一种简单形式。一个更先进的系统可以在更细的粒度上跟踪依赖，当只有部分数据变化时，实现局部重新计算。这个想法在 JavaScript 世界中也已有探索，例如 skiplabs 和 Skip langs 等项目。

"Vercel 语言" 的黎明？

Vercel 不仅仅是在构建一个平台，它正在将一个强大的编程模型直接嵌入到开发体验中。通过引入面向分布式系统的语言级构造，他们正在拓展开发者能够构建的应用的边界，并极大地降低了构建的难度。

这是好事吗？争论仍在继续，但方向已经明确。这种范式还可以被推向更远。想象一下，在一种新的语言里：

错误监控由平台管理。 函数可以声明其潜在的错误，语言和平台可以自动提供监控和警报。 数据隐私和安全由编译器强制执行。 通过效应系统跟踪数据流，语言可以强制执行访问控制，防止敏感数据泄露。 可观测性是内置的。 效应系统可以管理对数据库等资源的访问，无需手动埋点就能提供深入的性能洞察。

下一代编程语言本身就能够理解和管理现代应用的分布式特性，将开发者从基础设施的泥潭中解放出来，让他们能真正专注于业务逻辑。