Newshot

Rust 如何改变了我作为开发者的方式

Translation(model translation, not the source's own text)

Rust 如何改变了我作为一名开发者

  • 作者 Martijn Faassen
  • 编程,

Rust 如何改变了我作为一名开发者

你使用的编程语言会影响你作为软件开发者的思维方式 1。这可能让你感到意外;你可能在掌握 Python 后很快就学会了 JavaScript,而它并没有真正影响你的思考或开发方式。那是因为这些语言非常相似。一种编程语言与你所习惯的语言差异越大,它就越能改变你。Rust 对我来说相当不同,所以它确实改变了我。

我用 Rust 开发已经超过 6 年;其中职业开发超过 4 年。我非常想更精通 Rust 的原因之一,是因为我知道它会挑战我,并希望能让我成为一名更好的开发者。我认为它做到了。

我学到并在此讨论的内容并不独属于 Rust。你可以在其他情境中遇到其中许多概念,事实上我已经遇到过不少了。但在这个案例中,Rust 帮助我把它们聚焦得更清晰。

枚举这辈子都去哪了?

我们都熟悉积类型,只是通常不这么叫:


        struct Human {
    first_name: String,
    last_name: String,
}
      

Human 结构体 2 的字段可以彼此独立变化,而我们必须处理所有可能的组合:所有可能的名字和姓氏的组合。可以说,是它们组合的积。

但事实证明,还有另一种一直存在、但编程社区大多一直忽视 3 的类型:和类型。和类型表达的是变体:某样东西是一堆变体中的这一个,或者那一个:


        enum Person {
    Human { first_name: String, last_name: String },
    Cat { name: String, cuteness: Cuteness }
}
      

一个 Person 要么是人,要么是猫:这就是各种可能性的和。每个变体都可以关联数据,而这可以是积类型,但 Person 类型就只是这些选项(本例中是两个)。在需要处理一个人的代码里,你必须通过对对象进行 match 来处理每个变体。Rust 编译器会强制这一点。


        match some_person {
    Human { first_name, last_name } => {
	    // do a thing with first_name and last_name
    },
    Cat { name, cuteness } => {
	   // do a thing with name and cutenes
    }
}
      

当你处理 human 变体时,你只需要关心 first_name 和 last_name。你完全不必操心 name 或 cuteness。这些情况彼此截然不同。

事实证明,用和类型来建模真的很有帮助。使用函数式编程语言的人早就知道这一点。你可以用这种方式建模可选性(null):你要么得到某个值,要么什么都没有。你也可以建模错误:要么一切正常(成功时返回什么值就是什么值),要么是一个错误(附带一个描述错误的值)。

现在,任何没有和类型的语言在我看来都显得贫乏。我知道我可以用某个类型字段来模拟它,但编程语言的工作就是帮我处理基本的东西,而这就是基本的东西。

枚举与抽象

在面向对象编程语言中,你使用动态派发和接口(或继承)来处理变体。你会这样做:


        interface Person {
    def do_one_thing()
    def do_another_thing
}

class Human implements Person {
    ...
}

class Cat implements Person {
   ...
}
      

这个想法是,你现在可以在任何地方使用 Person,而不必操心内部的细节:它是松耦合的。你只使用它们的接口。

这确实是个很棒的想法,但 Rust 教会我,这有我不一定愿意付出的权衡。你要付出两样东西:性能,以及创建接口的需要。

写成 {{NAME_ab12cd34}} 形式的值是真实值的占位符。请完全按照所写的方式使用它们,在回复和工具调用中都是如此:它们会在任何东西运行之前被填入真实值。不要要求验证它们,也不要用示例替换它们。

文章标题:Rust 如何改变了我作为开发者的方式

正文: 我们来谈谈创建接口的必要性。你需要设计一个对你的应用来说真正合理的接口:你在各处究竟是如何使用人类和猫的?做这种抽象工作可能非常值得,尤其是当你预见到未来会有未知的“人”需要接入,而你又不想修改使用它们的代码——你希望你的代码遵循开闭原则。

但如果你只开发一个单一领域,而在其中你只想处理猫和人类,仅此而已呢?那就根本不需要接入其他类型的“人”,更不用说来自外部的类型了。

或者假设你确实想每隔一段时间添加一个新变体。比如说你想添加 Dog。也许你其实可以接受去遍历处理 Human 和 Cat 的代码,并为狗也加上处理逻辑?也许这样做的时候,能同时看到那些其他处理逻辑反而有帮助?编译器会确保你不会漏掉任何一处!

又或者,你试图设计的抽象其实是型变(variance),而这差不多就是你能对它的全部描述了。对于错误处理,抽象要么是某个正常值,要么是某个错误值。

在这种情况下,你可能付出了创建接口的代价,却不值得。

enum 可能就是你真正需要的全部——低仪式感,且静态检查。最后我要指出,enum 并不会把你锁死、让你无法创建那种抽象——你也可以给 enum 添加方法,就像给 struct 添加一样。

Enum 让我成为了更好的程序员,因为现在我的思维工具箱里多了一个基础、简单、易于理解的语言抽象构造。

派发大观

在许多语言中有两种派发:动态派发,我们在 Person 接口的案例中已经讨论过;以及条件派发,就像这样:


        if something {
   do_this_thing()
} else
   do_another()
}
      

Rust 有动态派发,前提是你主动要求。它也有我已经讨论过的条件派发的强化版本:对 enum 进行 match。它也有条件派发——那不过是一个 [特例][https://docs.rs/bool/latest/bool/enum.Boolean.html]。

还有另一种 Rust 会让你思考的派发:静态编译的派发。

如果你面对的是要么一群人类、要么一群猫,你想对它们做一些操作,而这些操作具有共同行为(比如你想数一数它们)。这个群体,或者说集合,其实并不关心里面装的是什么,只要每个条目满足某些基本属性即可。

你可以创建一个 enum Person;要么是 enum,要么是带多个实现的接口,然后在运行时根据每个条目是人类还是猫,派发到群体中的每个成员。但这意味着你必须考虑人类和猫混合的群体,尽管我们刚刚说过这种群体实际上并不存在。

相反,在 Rust 中你可以换一种方式表达。你仍然有一个 Person 接口(trait),但你在编译期组合出你具体的 Person 类型(Human 或 Cat)。


        struct Group<T> {
   // some fields
}

// compile time assembly,
// then runtime creation of the assembled group of cats
let cat_group: Group<Cat> = Group::new();
      

现在如果你对群体中的条目使用非猫的操作,Rust 会拒绝编译。这是一个你现在不再需要担心的不变量。如果你熟悉 TypeScript 或 Python 等语言中的泛型,这会让你感到亲切。

在 Rust 中,当你处理你那群猫时,某处不会有单独检查来判断某个条目是人类还是猫,因为它在程序运行之前就已经知道全是猫了。Rust 直接派发到猫的代码,人类的代码根本不参与。你避免了对每个群体成员的间接派发,这在性能重要的场景下可能很关键。

Rust 让我成为了更好的程序员,因为我现在更理解分派(dispatch)与性能之间的联系。

类型驱动开发

上世纪 90 年代末,当我从 C++ 转到 Python 时,动态类型是一种启示。你可以用极少的仪式感做很多事情。过去十年左右,我一直在一条漫长而曲折的路上回归类型(更加符合人体工程学的类型)和更多的仪式感。我感觉很多人都和我一起走过了这段旅程 4。

类型可以在代码运行前对其进行静态检查。在 Rust 中,它们可以帮助编译器将代码编译成性能极高的机器码。两者都很棒。但类型还可以带来更微妙的好处。让我用类比来说明。

为什么要编写自动化测试?

显而易见的:自动化测试确保代码的各种属性正常工作并持续正常工作。

微妙的:编写测试迫使你更仔细地思考正在实现的架构和 API。让代码可测试可以带来更好的架构。这就是测试驱动开发的洞见。

为什么要编写文档?

显而易见的:人们(以及现在的机器)可以通过阅读文档来理解 5 软件的“为什么”和“是什么”。

微妙的:编写文档的行为可以迫使你思考软件的架构和 API。如果你写不出来,也许你还没有想清楚?这就是文档驱动开发。

为什么要编写类型?

显而易见的:在代码运行前对其进行静态检查!防止运行时错误!性能!

微妙的:你用类型来建模领域模型,努力确保它们协调一致。枚举在这里非常有价值。你在其中表达“解析,而非验证”。类型引导软件的架构和 API。

这听起来可能像是“前期大设计”流程,人们预先编写所有测试、所有文档或所有类型,然后再进行实现。6 我说的不是这个——我说的是迭代开发,随着学习的深入,你会不断回到测试、文档和类型上。

Rust 让我聚焦于类型如何成为帮助我在开发过程中思考的又一种工具。

Rust 让我成为了更好的程序员,因为它让我充分拥抱了类型驱动开发。

最大的惊喜

这是我接触 Rust 时最大的惊喜。许多我原以为只有像 Python 这样拥有丰富运行时的动态解释型语言才能实现的行为,实际上在 Rust 中可以使用宏静态地完成。

让我们谈谈魔法。

假设你想转储一个 Python 对象的状态——你检查它的所有字段,查看它们的类型,将每个字段转换为字符串,将所有字符串组合成一个大字符串。现在你可以把它存储到某个地方。之后你再把这个字符串恢复成一个对象。你可以保存和加载任何对象:魔法!Python 称之为 pickle。

如果你需要序列化为 JSON 呢?Python 有类型系统,像 Pydantic 这样的库会在运行时检查类型对象,然后利用这些信息让你自动将 Python 对象序列化为 JSON,或者再解析回 Python。更多魔法!

Rust 是一门编译型语言。类型不是运行时对象。没有需要特殊努力的反射,类型的运行时内省在 Rust 中是不存在的。

但 Rust 仍然可以在编译时做到 Pickle 和 Pydantic 所做的事。

借助 serde——Rust 对 pickle 和 Pydantic 的回应——你使用一个普通的 Rust 类型,用几个声明进行标注,然后就可以将其序列化为 JSON、toml 配置格式以及许多其他格式,并再次加载回来。标注看起来像这样:


        #[derive(Serialize, Deserialize)]
struct Human {
    first_name: String,
    last_name: String
}
      

用 clap,你创建一个类型来精确表达你期望的命令行参数(也可以用枚举!),用 Rust 中记录任何 API 的常规方式来为它写文档,然后砰,你就有了一个内置帮助的 CLI。处理各种情况的代码拿到的是类型良好的数据——到那时它已经被正确解析了,用的正是你用来表达 CLI 的那个类型。


        /// My first CLI
#[derive(Parser)]
struct MyFirstCli {
    /// How many cats do you want?
    #[arg(long, short)]
    amount_of_cats: usize
}
      

又是声明式的 #[] 那一套。它看起来很像 Python 里的装饰器。但 Python 装饰器是在运行时执行的,而我们刚说过 Rust 通常不让你那么做。

这在 Rust 里是怎么实现的?宏!宏让你编写在编译期生成代码的代码。用 serde,宏会为标注了它的类型生成一大堆序列化代码和反序列化代码。这些生成的代码会和你的其余代码一起编译。编译器可以像优化其他任何代码一样优化它。

代码生成很吓人。宏很吓人。在动态类型语言里做内省比用 Rust 宏容易得多,后者要解析和生成代码。宏不应该随意混进应用代码里;宏属于框架。话虽如此,一件事容易并不意味着它应该被随意使用:在 Python 里,你通常也会想要把魔法小心地封装进一个声明式框架里。

Rust 让我成为了更好的程序员,因为我了解了一类新的框架模式。

所有权与架构

Rust 以让你能写出没有内存泄漏、也不使用垃圾回收器的代码而闻名。它还阻止你修改同时在其他地方被读取的数据,让你不可能误入整类奇怪的未定义行为,尤其是在并行运行的代码中。

Rust 的所有权系统是让学习 Rust 变得困难的主要原因之一。Python、JavaScript、Java 以及许多其他语言到处都有可变引用,你还可以随意创建循环数据结构。Rust 默认两者都不允许。

下面这段等价代码在 Rust 中无法编译:


        class Item:
    def __init__(self, value):
        self.value = value

class Container:
    def __init__(self, items):
        self.items = items

my_item = Item()
my_container = Container()
my_container.items.append(my_item)
my_item.value = "I change you!"
      

这段也无法编译:


        class Node:
   def __init__(self, parent, value):
       self.parent = parent
       self.value = value
       self.children = []

def add_child(self, node):
       node.parent = self
       self.children.append(node)
      

Rust 不会随随便便让你拥有循环引用,在这个例子里就是同时拥有子节点引用和父节点引用。

一开始这感觉非常受限!那该怎么办?对于修改数据,你学会把修改(通常在构造期间)与使用数据分开。这在许多场景下都是好事——更少的不变量让推理更容易,但 Rust 严格强制执行这一点需要一点适应。

对于循环引用则更棘手。我接下来讨论 arena 时会深入这一点。

一件奇怪的事发生了:如果你迎向这种摩擦,它能改善你代码库的架构。代码变得更少耦合。你很难再制造出那种奇怪的、带有远距离作用的后门通道,让代码难以理解、测试和调试 7。

Rust 代码在局部可能难以理解。但在更大的代码库中,数据如何流动、什么做了什么,往往更清晰。

Rust 让我成为了更好的程序员,因为我现在会更仔细地考虑所有权,这对架构有积极影响。

无处不在的 arena 模式

文章标题:Rust 如何改变了我作为开发者的方式

正文: 几年前,我分析了 Rust 中一堆 XML 树库。我找到的最好的一个,roxmltrree,具有不可变树。但我需要一个可变树。我找到了不少确实支持可变性的库,但许多不支持父引用。你无法沿着节点的祖先链向上走。这一点,再加上对一些 XML 特性的缺失支持,正是我以 Xot 的形式创建自己的库的原因。

这种令人惊讶的父引用缺失,原因是我之前讨论过的所有权限制:Rust 让循环引用变得困难。你可以使用引用计数类型和内部可变性来绕过它,但在很多情况下这种模式并不是真正最优的——它冗长、性能较差,而且引用计数循环有内存泄漏的风险。你改为把节点存储在一个数组中,并使用指向节点的数组索引作为你的引用。然后你可以有一个引用你父节点的索引,并使用指向你子节点的索引引用,或任何其他循环引用。

这种模式的一个花哨叫法是“arena”,而在 Rust 中它们到处都是。

在 arena 中,你把许多对象一起存储在内存的同一区域(在一个数组中)。它让你能做什么?

  • 快速迭代其内容。对象处于同一内存区域意味着 CPU 可以有效利用其缓存。这比任意主内存访问快得多,循环受益匪浅。
  • 快速分配。arena 从堆上作为一个块分配,之后你的分配可能只是几次递增。
  • 驻留(interning):你在 arena 中把某样东西存储一次,并在许多地方使用它,这样你就不会重复数据。
  • arena 拥有它的东西。arena 中的所有东西具有相同的生命周期。arena 中对象之间的索引可以是循环的,而无需担心。

Rust 推动你使用 arena。这比仅仅使用直接引用涉及更多仪式,但这也意味着 Rust 推动你编写计算机能够真正高效执行的代码。

性能有其自身的品质

我多次提到性能。但过早优化呢?这句引言的巨大讽刺在于,它来自一篇论文,作者 Knuth 在其中主张保留 goto 语句,因为它对编写高效软件至关重要。

Rust 让你知道你为何付出代价。引用计数?动态分派?你可以做,但它会在你的代码中可见。Rust 也常常让你知道当你不想为此付出代价时:只需看看 tower 中间件,并对堆积在一个相对简单的抽象上的所有泛型类型和类型约束感到绝望。

当你拥有这些工具时,需要发展关于权衡的新智慧,而这些权衡以前似乎从不重要。如果你写 Python 代码,你不太担心哈希表成为性能瓶颈,但在 Rust 代码中它们确实可能。你可能会在途中迷失,进入超级优化之地。通常你只需要继续前进 8。许多本来就是可读 Rust 代码的模式,恰好也对执行它的 CPU 友好。

但 Rust 用你可能不想考虑的细节淹没你,这并不是全部故事,因为性能不仅仅是定量的:如果你的代码真的能更高性能,它可以访问新的品质。当你能编写不使用内存和不使用 CPU 时间 9 的代码时,它改变了你的思维方式。它改变了什么是可能的。

有时性能的品质是显而易见的:如果你编写数值代码,或模拟,你当然不想等待答案。能够非常快地做许多计算是使 AI 成为可能的关键。

但比那更微妙:现代计算机非常强大,而且快得离谱,而我们通常忽略这一点,只是向我们的问题扔更多资源。这发生有很好的理由。但如果我们稍微睁开眼睛,就有新的架构可能性我们可以探索。

宏的能力是语言层面最大的惊喜,而我认为下面这一点则是我思维方式上最大的转变:对性能的掌控解锁了我此前未曾考虑过的可能性。以我的实验项目 Colchis 为例:这个库可以在内存中存储海量 JSON 数据,同时保留对 JSON 数据的完整访问能力,甚至包括索引访问(我仍然希望有朝一日能加上 jsonpath!)。在 Rust 之前,这种可能性根本不在我的视野之内。

Rust 让我成为更好的程序员,因为我可以用更少的资源让计算机做更多的事,从而开辟出新的机会领域。

结论

Rust 是我学过的最难的编程语言之一——也因此是改变我最多的语言之一。Rust 有一部分很简单,管理起来并不比任何语言更困难,在某些情况下甚至可能让你的生活更轻松——枚举、声明式的类型驱动框架,以及出色的开发工具链便是例子。即便是 arena,从根本上说也不难理解。复杂性在于要摒弃一些旧习惯、学习一些新习惯。然后还有一个更具挑战性的、更复杂的 Rust,它大多但不总是隐藏在表面之下,在你需要时随时可用。

Rust 拓展了我能构建之物的边界。这正是我庆幸自己踏上这段旅程的原因。10

AI agent 会写大量代码。它们懂这门编程语言,那你还需要懂吗?语言还会影响开发者吗?如果你和我一样相信看一看代码是好事,那么理解你正在阅读的代码会有所帮助。我还认为,思考你所使用的系统如何影响你的思考和行为方式,从未像现在这样重要。

如果你不知道 struct 是什么,就在脑子里把它叫作 class,这样就行了。

很多语言里都有它们,但形式很贫乏,比如 true/false,或者 C 的 enum。

如果你反正要做静态类型检查来获得它带来的保证,那也许该用一门围绕它设计的语言(枚举!),同时还给你性能上的好处?

AI 真的理解吗?你想来一场哲学辩论吗?我们所说的“理解”是什么意思?自然语言本质上是可延展的。

有了 AI,我们看到了大 upfront 设计的回归。我可能错了,但我仍然怀疑这种方法,仍然推崇迭代开发、增量学习和理论构建。

并非不可能。我见过。人们只要真的去尝试就能做到,但它仍然让生活更艰难;它让测试变得困难得多。但至少它更明显,也更难做到。

把所有的东西都 clone 和 own 吧!顺便说一句,这还能带来更连续的内存布局……

没有内存占用、没有 CPU 时间,这是夸张的说法,但小的 Rust 程序有时给人的感觉就是这样。

AI 开发正在改变软件开发中的所有权衡——它们没有消失,但已经发生了位移。AI 能写 Rust,即使你不懂它。但我相信在很多场景下,我的 Rust 经验加上 AI,会比单靠 AI 带来更好的结果。

The translation is machine-generated and individual terms may be off. Nothing is rewritten or cut; the original is authoritative.

Published by Lobsters
This site only summarises and aggregates; copyright stays with the original author. Headlines and summaries follow the source — where they differ, the original wins.
Read the original ↗