Newshot

可理解性设计

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

文章标题:为可理解性而设计

正文: 这是我在 2025 年 11 月 Google 内部 Code Health Summit 上所做的一次演讲。我把它分享在这里,希望能引发进一步的学习和讨论。

摘要

在一个 LLM 生成我们大部分代码的世界里,理解这些代码比以往任何时候都更加重要。但面对像 Google 代码库这样庞大而复杂的系统,软件工程师很容易陷入一种习得性无助的模式:你所能做的最好的事情就是改改代码,然后祈祷它能通过测试。没有理解,LLM 不过是一台全速运转的复杂性生成机器。

有更好的办法来应对这一切。正如我们的行业已经学会为可测试性而设计软件,我们也可以为可理解性而设计软件。我们可以运用按契约设计、类不变量、模块化等理念,构建出能够让我们一次理解一部分的系统,而不是在大泥球上不断堆砌、寄希望于它不会整个崩塌。

这容易吗?不容易。但值得吗?绝对值得。这些理念并不新鲜,但它们远没有得到应有的广泛传授和充分理解,而掌握它们将引领我们走向一个既能对代码更有信心、又能同时提升开发速度的世界。

幻灯片与文字记录

大家好,感谢邀请我来!我们开始吧。

我想以一个问题开始这次演讲:如果 LLM 能写代码,那么人类软件工程师还剩下什么?

科技行业正迅速寄望于大语言模型来编写我们所有的代码。但你可能会说:写代码不正是我们软件工程师的本职工作吗?这把我们软件工程师的责任置于何地?软件工程师在 LLM 之上所增添的、不可或缺的人类要素是什么?

你们每个人对这个问题都会有不同的答案,这没关系。但以下是我的看法。

那个不可或缺的人类要素就是判断力。判断代码是否可维护。判断它是否健康。

LLM 能够遵循模式,生成看起来像其训练数据的东西。有时它们能针对一段代码给出有用的建议和批评。但那个关键的判断——判断某段代码是否适合它所要完成的任务——仍然取决于你,也就是人类。

因为事情是这样的:如今的 LLM 仍然是一个马虎的实习生。有时它产出的代码不错,但有时它完全跑偏,需要纠正。你不会在未经仔细审查的情况下就把一个马虎实习生的代码并入你的系统,所以对 LLM 的代码你也不应该这么做。

你要对自己代码的质量负责,无论这代码是你让 LLM 生成的,还是你用传统方式用手指敲键盘写出来的。

那么这把我们带到了哪里?如果 LLM 将为我们编写大量代码,那么我们面对的将是一个人类花更少时间写代码、花更多时间阅读和理解代码的未来,以便确保代码达到我们的质量标准。

这意味着,提升理解代码的能力、加快阅读和理解的过程,比以往任何时候都更加重要。

那么:如果你想在某件事上变得更好,为自己设定一个高远的目标是有帮助的。一个高于你当前技能水平、驱动你每天都变得更好的目标。

以下是我提出的目标:我们应该能够在不运行任何测试的情况下,预测每一行代码的行为。

文章标题:为可理解性而设计

正文: 让我再说一遍:我们应该能够预测每一行代码的行为,而无需运行任何一个测试

我知道你现在可能在想:“理解每一行代码?还不测试?你是认真的吗?!有太多的复杂性和遗留代码,我不可能做到这一点!”

你可能会这么想。而如果我们撒手不管、放弃所有控制权,你也许是对的。但我要告诉你,还有更好的办法。

我们可以把代码设计得易于理解。

想想看,一二十年前,我们曾认为为 API 中的每个公共方法编写多个测试是不可行的。这并不是因为我们不想这么做,也不是因为我们没有尝试。而是因为我们还没有把代码设计到能让那个层级的测试成为可能。但渐渐地,在整个软件行业,我们改变了实践,为可测试性而设计。如今,为可测试性而设计已经深深植根于我们的文化之中,以至于做任何其他事情都几乎不可想象。我们也可以为可理解性做同样的事,让我们的代码帮助我们更好地理解它。

我们自己的 Code Health 指南为可理解性提供了有力的论据。它说:“代码要可持续,就必须能被理解。除非开发者知道系统当前提供什么,以及需要改变什么来适应新情况,否则就无法做出变更。因此,代码健康的关键组成部分包括良好的文档、易于理解的错误信息,以及清晰、简单的代码”

为可理解性而设计不仅重要,而且是一项可以学习的技能。它不是那种你要么有、要么没有的神奇能力。你可以采取具体、明确的行动来提高代码的可理解性。

今天我将向你介绍其中的几项。可以把它看作是为可理解性而设计的“入门套件”。我们还会进一步讨论贯穿所有这些实践的一个总体主题,这样到了某个时候,你就能找到更多为可理解性设计代码的方法。

我今天要向你展示的这些想法并不新鲜。但它们没有得到应有的充分传授——甚至往往根本没人教——而且我们大多数人对如何应用它们只有粗略的理解。我今天的目标是把这种理解稍微加深一点,让它稍微更实用一点,这样我们就能启动一个让代码随时间推移变得更易理解的过程。

那么,让我们开始逐一介绍这些“为可理解性而设计”的实践。

第一项是契约式设计。

为了引出这个想法,让我们问一个问题:调用一个方法时,你应该依赖什么行为?

假设我们有这个二分查找方法,但它的文档没什么太大帮助(你以前可能见过类似的东西)。

二分查找的原理还算广为人知,但作为该方法的调用者,我们对这个具体实现有一些问题想问。比如:

  • 返回的索引是否总是第一次出现的位置?
  • 如果找不到 t 会怎样?
  • 如果列表未排序会怎样?

文档没有回答这些问题。那我们能做什么呢?

首先,我们可以猜。但我们很可能会猜错。

其次,我们可以读代码。但这可能要花很长时间,尤其是当我们关心的那个特定行为深埋了好几层的时候。

文章标题:Design for Understandability

正文: 第三,我们可以在一些示例上测试这段代码,看看会发生什么。但仅仅因为它在某些示例上以某种方式工作,并不一定意味着它对所有此类输入都以那种方式工作。此外,即使它现在以那种方式工作,也不能保证它在未来会继续以那种方式工作。

关键在于,如果没有清楚地说明这段代码打算做什么,实现与意图之间就没有区别。想要使用这段代码的 SWE 只能猜测这个方法承诺的是哪种行为,以及哪些行为是可能随时间改变的实现细节。

这就是契约发挥作用的地方。

定义契约有很多种方式,但为了这次演讲,我把它定义为对一次交互中每个参与者所承诺的可观察行为的一种形式化描述。

在现实世界中,一个基本的契约是这样的:“如果我做晚饭,那么你洗碗。”

在编程中,一个例子可能是:“如果调用者提供一个非负整数 n,那么平方根函数返回 n 的平方根”

让我们看看契约如何帮助我们处理二分查找的例子。

这是这个函数可能的一个契约。它说的是:“如果列表已排序,binarySearch 返回 t 在列表中第一次出现的索引,如果未找到则返回 -1。对于未排序的列表,行为未定义。”

我们可以看到,这个契约回答了我们关于它提出的问题:

  • 返回的索引是否总是第一次出现?是的,契约明确说明了这一点。
  • 如果 t 未找到会怎样?契约说 binarySearch 会返回 -1 来表示这种情况。
  • 如果列表未排序会怎样?契约没有说任何内容,所以这个行为被有意留作未定义。这是一个有效的设计选择!可能有性能方面的原因导致不在运行时检查列表是否已排序。所以这个契约告诉用户,如果列表未排序,他们不应该依赖任何特定行为。相反,义务在于调用者在调用 binarySearch 之前检查列表是否已排序。

契约的力量在于,它在作者的意图与实现之间划出了一条清晰的边界。调用者不再需要猜测行为:他们只需阅读契约,如果某个具体的行为细节不在其中,他们就会知道那是未指定的。

在现实中,这并不总是完美的。无论是有意还是无意,我们仍然倾向于最终得到依赖实现细节而非指定行为的代码。但契约至少给了我们一种将这种行为最小化的方法。

既然我们理解了契约是什么样子,接下来让我们谈谈契约如何帮助我们更好地推理和理解我们的代码。

假设你刚写了一个方法。我在这里把这个方法画成一个小圆圈。

你想知道它是否正确。

我将用紫色圆圈代表我们已经读过代码的方法

现在,我们的方法并不是孤立存在的:它调用了一些其他代码。

所以,你想:“好吧,我需要理解那些代码是做什么的。我要去读那些方法的代码。”

嗯,那些方法会调用其他方法,于是我们开始思考这个问题,想办法如何对它们进行推理。到这一步,你大概能看出我要说什么了。

哦不。现在我们不得不阅读整个代码库中大量的代码。

为什么仅仅为了推理一个方法,我们就需要这么多推理?我们想做的不过如此!我们怎么就失控到这种地步了?

所以,让我们退一步重新来过,这次使用契约式设计(Design by Contract)。

你仍然需要阅读自己的代码。这一点我们绕不过去;这正是我们刚刚做出的改变。

而且我们并没有改动代码。它仍然调用那些其他方法。

但现在的诀窍在于,我们只需阅读那些被调用方法的契约,而不必阅读代码。

就是这样!我们可以到此为止。我们不必操心那堆其他代码。契约告诉了我们调用另外这两个方法所需了解的一切。

那部分代码依然存在,但我们不必去思考它。契约抽象掉了所有那些对我们这些这两个方法的调用者来说无关紧要的其他行为。

这就是契约赋予我们推理代码的能力。

最后,我用几条编写契约的建议来结束本节:

第一,记录你愿意承诺的行为。这通常等同于你希望调用者依赖的内容。例如,你大概希望记录方法的返回值。但错误信息中那段人类可读的具体文本呢?就不太必要了。

第二,在契约中描述你的错误处理。契约不是、也不应该只关乎顺利路径。如果你的方法可能以某种方式出错,就告诉调用者在什么条件下可能出错,以及你将如何向调用者发出信号——无论是通过特殊的返回值、异常,还是其他方式。

最后,请记住:你的方法拥有的调用者越多,改动契约就越困难。如果它是一个只被你的团队使用的私有方法?那当然,同时修改契约和调整调用者以匹配,大概是个轻松的活儿。如果它是一个被数百个其他项目使用的流行框架上的公共方法?那么重新协商契约就是一件代价大得多的事,所以在决定这么做之前,你应该仔细权衡成本与收益。

这就是我们“为可理解性而设计”入门套件中的第一个要素。

下一个是数据不变量。

让我用一个小故事来解释这个想法。

在 COVID-19 疫情初期,当我和妻子开始居家办公时,我们怀念办公室里免费的汽水。于是我们养成了在冰箱里存放无糖可乐的习惯。

但有个问题:我们很擅长把易拉罐从冰箱里拿出来,却不太擅长把新的放回去。所以,如果你正辛勤工作,盼着休息一下喝杯冰镇饮料,结果打开冰箱发现一瓶可乐都没有,只能退而喝食品储藏室里常温的汽水,那是相当失望的。

问题在于,我们没有就如何取用无糖可乐以及如何补充冰箱制定任何规则。在没有任何规则约束冰箱访问的情况下,我们最终陷入了一个不想要的状态:在这个例子里,就是空冰箱。

代码里也会发生这种情况。举个例子,假设你有这样一个 proto 来表示客户的订单 [注:“proto”是 Google 的行话,指 Protocol Buffers 消息,类似于 JSON 对象]。如果你收到这个 proto,你有多相信 total 真的表示商品的总金额?

大概不太信,对吧?这个 proto 可能来自你代码的任何地方,所以很容易想象有人忘了正确设置那个字段。

Proto 让你对数据的底层表示拥有完全不受控制的访问权。Proto 非常适合在网络上来回传输数据,但它们不适合你需要排除某些状态的情况。

要解决这类问题,我们可以使用数据不变量。数据不变量是关于某份数据始终为真的一个陈述。

数据不变量是一种有原则的方式,用来在你的数据中强制实施这类有效状态。如果你用得好,就能避免代码中的很多 bug。

让我们看看如何用不变量来解决 Diet Coke 问题,以及你在自己的代码中可能遇到的类似问题。

首先,确定你想维护的不变量。

问问自己:对于这份数据,你想依赖什么属性?代码中哪些地方你会显式校验并在无效时返回错误?或者,哪些地方你假设它是无效的,但实际上并不确定?

在这个例子中,我们想要的不变量是“冰箱里始终有一罐 Diet Coke”。

其次,你需要记录这个不变量。

重要的是要注意这是一个单独的步骤。把不变量放在自己脑子里是一回事。把它写下来,以便传达给其他可能接触这段代码的人,又是另一回事。更不用说,如果你几个月或几年后回到这段代码,你自己可能已经忘了你当初想维护的到底是哪个不变量。

把它写在人们能看到的地方:大概靠近相关的数据成员,或者写在顶部的类级注释里。

第三,在创建时建立不变量。通常这会在构造函数或工厂方法中完成。在这个例子中,我们构造冰箱时已经加了几罐饮料。

第四,每次你修改数据时,都要确保维护这个不变量。

这正是我妻子和我对我们的冰箱没有做到的部分。我们应该做的是建立一条规则:如果你拿走一罐 Diet Coke,就再放一罐回冰箱,确保下一个人还有得喝。

你可以用很多方式维护不变量——那部分由你决定。重要的是你始终维护它。没有它,你就得自己想“等等,冰箱里还会有 Diet Coke 吗?我是不是之前已经把它们拿出去了?让我回去检查所有调用方,看看他们是不是已经这么做了”。而有了不变量,你就直接知道:如果我有一个 Fridge 对象,那么它肯定有 Diet Coke,不管导致这一点的操作序列是什么。

最后,还有最后一步,这可能是最难的一步:你需要在代码演进的过程中维护不变量。为单个版本的代码维护不变量相对容易。但经过数周、数月、数年,复杂性会悄悄渗入,新需求会迫使你修改代码,你可能不小心破坏了不变量,或者忘了自己还有这么一个不变量。

在你的团队中建立这样一种文化:维护不变量就是你该做的事。如果你在代码审查中有一份要检查的事项清单,确保维护不变量也在那份清单上。

那么,数据不变量如何帮助我们为可理解性而设计?让我们先考虑一下,当我们没有不变量时,我们必须做些什么。

文章标题:Design for Understandability

回想一下代码库中所有方法的这种表示方式——它们以各种方式相互调用。假设你有一个基于 proto 的冰箱版本,你想知道里面是否有任何 Diet Coke。因为它是 proto,你无法知道它处于什么状态。

所以,你需要检查当前方法的所有调用者。

然后你进行检查,爬遍整个代码库,发现有一个特定的情况,你没有强制执行它。

当然,你可以随着这些问题逐一出现来修复它们,但所有这些搜索听起来工作量很大,对吧?你认为你总能找到那个特定的 bug 位置的概率有多大?添加到这个代码网络中的新方法能够维持该条件的概率有多大?

相比之下,让我们试试带有 Fridge 类及其不变量的版本。

在这种情况下,该类有一个不变量:无论之前执行过什么操作,或者我们从哪里来,Fridge 始终至少有一个 Diet Coke。通过维护该不变量,我们消除了检查每个调用者所做操作的需要。

这就是数据不变量为你做的事情:它们让你专注于你现在所处的状态,而不是你是如何到达那里的。

数据不变量这一节到此结束。

我今天想讨论的最后一个实践是隔离副作用和对全局状态的依赖。

用一个例子来引出这个想法。假设有一个超市销售点系统,带有这个方法来计算销售税。现在问问自己:这个方法的输入和输出是什么?

看起来很明显,对吧?它接收客户的杂货订单,并将销售税作为整数返回。

但这并不是全部。如果你深入这个方法的实现,你会发现它从单独的文件中读取一组销售税率。这实际上是一个新的输入通道!代码计算税额依赖于该数据,就像它依赖于杂货订单本身的内容一样。

如果你进一步查看,你会发现该方法还将计算出的税额记录到商店的账户数据库中,用于记账目的。这是一个新的输出,但它在类型签名中根本找不到!

所以函数有两种输入和输出:类型签名中可见的,比如订单和计算出的销售税,以及隐藏的,比如税率文件和会计数据库中的条目。

隐藏的输出更常被称为副作用。副作用通常有两种:变更,即修改全局变量或你的输入参数之一;以及进程外部的输出。那将是诸如数据库写入、远程过程调用、打印到控制台等。

我不知道隐藏输入的常见术语,但我会称这些为对全局状态的依赖。同样,有两种:对某个全局变量状态的依赖,或对你的程序运行所在系统状态的依赖。那将是诸如访问数据库的权限、文件系统上给定文件的存在,甚至读取系统时钟的能力。

那么,为什么这些隐藏的输入和输出是个问题?它们使代码难以测试、难以复用、难以推理。

难以测试,因为你必须确保所有必要的依赖都已设置好,然后才能在测试中运行该方法。然后,一旦你运行了该方法,副作用往往迫使测试更多地依赖交互验证而不是状态验证,这可能很脆弱。

文章标题:Design for Understandability

正文: 难以复用,因为代码现在会对你有何种可用资源做出假设。如果你需要在代码库的其他部分复用某个方法,但输入数据需要来自不同的来源,或者你需要把结果存储到不同的地方,那些副作用和全局状态就会在你的计算代码与该计算特定的来源和目的地之间造成紧密耦合,这会让你的日子更难过。

难以推理,因为顾名思义,这些输入和输出是隐藏的!如果你甚至不知道你的方法正在对它运行所在的系统做出这类假设,那么你就会对代码的行为得出一些错误的结论。

我并不是说所有副作用或全局状态都是坏的。我也不是说我们都应该立即改用像 Haskell 这样的纯函数式编程语言。

副作用总得在某个地方发生。没有副作用,计算就只是把金属盒子加热一小会儿的过程(而且就连那点热量也是副作用!尽管通常不是我们在意的那种)。

但默认情况下,我们往往会把它们撒得到处都是,遍布整个代码。需要一些输入?就在你碰巧所在的代码位置直接读取文件。需要存储结果?尽管去做,而且是在你的业务逻辑深处第 4 层的地方做。

如果没有一套有原则的方法来处理副作用和全局状态,我们就会不断遭遇刚刚描述的那些问题。

有一种更好的办法,就是把副作用和对全局状态的依赖隔离开来。我们的很多代码只不过是在数据(一旦我们拿到它)之上做逻辑处理,并据此创建新数据。把你的代码分成两部分:一方面是计算部分,另一方面是处理副作用和全局状态的部分。

有几种常见的模式可以做到这一点。

其中一种是命令/查询分离(Command/Query Separation)。这是一种模式,其中每个方法要么是命令,执行某种副作用;要么是查询,是一个纯函数,把输出作为返回值返回。但你要保持严格的分离,使得没有任何函数同时做这两件事。

另一种模式叫做“函数式核心,命令式外壳”(Functional Core, Imperative Shell)。这是一种架构层面的模式。你让系统的内部模块专注于业务逻辑和计算,不执行副作用——这就是“函数式核心”。外部模块负责协调系统的副作用与那部分计算,从而把副作用的复杂性隔离在那一外层,而你的系统的大部分则因函数式的纯粹性而更简单。

与另外两种实践一样,副作用和全局状态对我们思考代码的方式有很大影响。

例如,你可能正在处理一个方法,需要删除一个文件。你的假设是应该没问题,你认为没有人在用它。

但结果却是,代码库的其他某个部分依赖着它,而你刚刚把它们弄坏了。那段代码离得那么远、那么不相关,你甚至都没想到要去那里检查。

另一方面,如果你把副作用和全局状态隔离开来,使它们只发生在代码中一个已知的区域,那么你就可以确信,你真的不会弄坏任何其他人的东西。

所以,这就是 Design for Understandability 的三项入门实践:契约式设计(Design by Contract)、数据不变量(Data Invariants),以及隔离副作用和对全局状态的依赖。

现在,我把这些作为相互独立的实践来呈现,但实际上它们并没有那么泾渭分明。它们有一个统一的主题。这个主题就是局部推理(local reasoning)。

我说的局部推理是什么意思?

局部推理意味着,你可以只通过查看某一段代码,再加上少量相邻的代码——比如你直接交互的组件的规格说明或契约——就对这段代码得出结论。

文章标题:为可理解性而设计

正文: 这与全局推理相对。全局推理是指,即使要回答一个简单的问题,你也必须阅读代码库的一大块内容,因为答案可能在任何方法、调用栈的任何层级中。

局部推理的好处在于,它为“你需要查看多远才能弄清系统的某件事”设定了一个硬性边界:你需要搜索的范围总是有限的。

所以让我们谈谈我们讨论过的每项实践是如何支持局部推理的。你可能已经注意到我们之前已经讲过了,但让我们回顾一下。

契约式设计定义了调用方和被调用方法的预期行为。这意味着,要理解调用方可以依赖什么行为,或者被调用方法有义务实现什么行为,我们唯一需要查看的地方就是该被调用方法所定义的接口。如果没有它,我们就会退回到全局推理,去寻找代码中所有可能依赖于该方法行为某一方面的部分。

数据不变式通常与契约相伴而行,但它们通常描述的是整个对象,而不是该对象上的单个方法。

如果你有一份数据,想知道它是否有效,比如“这台冰箱里有没有健怡可乐?”,不变式让你能够立即得出结论“有”,而无需查看产生该数据的调用方。

最后,通过隔离副作用和全局状态,你最大程度地减少了代码中“一部分的变更会在完全无关的另一部分引发问题”的位置数量。因此你可以说出这样的话:“这是代码中唯一允许触碰这个文件的部分,所以我确定删除它是安全的。”

看待局部推理的另一种方式是:它最小化了我们推理系统所需的上下文量。

使用全局推理时,你可能需要了解代码库中任意一个部分,因为破坏你假设的部分可能在任何地方。你需要把整个系统装进脑子里才能理解它。

局部推理将你需要装进脑子的内容量保持在一个合理的规模。

你猜还有什么也能从较小的上下文中受益:LLM!

让 LLM 对你的工作有用的一个关键部分,是为 LLM 提供正确的上下文以给出好的建议。但上下文要消耗 token,而你的 token 是有限的。所以 LLM 给了我们另一个使用局部推理、最小化上下文的绝佳动机。

换句话说,如果你想让 LLM 对你有用,那就为可理解性而设计你的系统。保持必要的上下文足够小,让你和你的 LLM 都更容易处理你的代码。

在这次演讲的开头,我把“为可理解性而设计”与“为可测试性而设计”做了比较。我想在此稍作回顾。

在为可测试性而设计成为常态之前,默认的测试方式是应用级测试。我们的代码没有为依赖注入等实践做好准备,所以如果不搭建一大堆依赖,就无法运行你的代码。直到我们开始在设计 and 构建系统时考虑可测试性,才使单元测试变得可行。

可理解性和局部推理也是如此。如果你不提前为此设计,使用局部推理就介于困难与不可能之间。但如果你在设计过程中一路为之考虑,你就能让它行得通。

如果你从未听说过单元测试,那么应用级测试看起来是显而易见、直截了当的。但它对现代软件工程来说是不够的。全局推理也是如此。我认为,是时候让我们把为可理解性而设计变成工作中必不可少的一部分了,就像我们对可测试性所做的那样。

文章标题:可理解性设计

正文: 所以你可能会想:听起来都不错,这些实践在纸面上听起来也不错,但可理解性设计在实践中可行吗?你大概不是在全新的绿地项目里工作。你大概在处理旧代码,带着许多旧毛病和复杂性,情况看起来可能毫无希望。你真的能做到吗?

我在这里要说:是的,这是可行的,只要你一小步一小步地来。我会分享一些入门的建议。

首先,一次只取一小块。不要试图一口吃成胖子。不要说“我们要从正常工作里抽出两周时间,把所有代码都变得完全可理解,然后就大功告成!”那样行不通;你会过得很糟。

相反,试着把这些实践只应用到你新写的方法上。你可能有些旧代码很难改。那就随它去。从新方法开始,积累一些势头。

也要教你的队友。也许可以分享这个演讲,或者找其他方式帮助队友进行可理解性设计。

最后,你可以考虑组织集体编程会议,大家聚在一起讨论:可理解性设计在你的语境中意味着什么?Google 的 Monarch 团队在他们的 Design by Contract 实践中这样做了,对他们很有效。

以下是一些进一步了解可理解性设计的资源。我不打算详细讲,但欢迎你在演讲结束后回头看看幻灯片,并查看这些内容。

[为博客文章在此转载的公开链接:]

  • Intellectual Control
  • The Humble Programmer
  • Parse, Don’t Validate
  • Functional Core, Imperative Shell
  • The Power of Composition

总之:为可理解性而设计你的代码。每当你处理一些代码时,意识到自己退回到了全局推理,就暂停一下。问问自己:我能改用局部推理做到吗?契约或不变量在这里会有帮助吗?或者,如果我把副作用和全局状态移到别处会怎样?又或者,你可能会想到其他适合这里的实践——你可能知道很多局部推理的实践,即使直到今天你还没有术语来这样称呼它。

是时候让可理解性设计像今天的可测试性设计一样,成为软件工程的一部分了。可理解性不仅仅是有帮助——它是至关重要的,尤其是在 Google 规模的系统里。不仅如此,只要你一路为可理解性而设计,让代码变得可理解是可行的。

相信我:你会庆幸自己这么做了。

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 ↗