Go | Tony Bai - Part 106

标签 Go 下的文章

Brooks、Wirth和Go[译]

八月 25, 2021
0 条评论

本文永久链接 – https://tonybai.com/2021/08/25/brooks-wirth-and-go

本文翻译自瑞典程序员Fredrik Holmqvist的博客文章《Brooks, Wirth and Go》。

现在是1975年。

程序员们带着FORTRAN代码回来了，不过使用的是穿孔卡片的形式。

图：记录代码的穿孔卡片(图片来自punchcardreader.com，译者加)

这些穿孔卡片被小心翼翼的送进大型机，它们被输入、读取、编译、链接并由计算机执行。当得到“文件名称规格错误”这个结果时，时间已经过去了两个多星期了。在这个阶段，很多人参与了代码的编写与制作并消耗了几周的工作时间。

与此同时，另一个用Smalltalk和Interlisp编程的工程师正直接在一个控制台中编写并运行他的实现。几秒钟后，他得到了程序的运行结果。接下来，他就在那里修复了错误并完成了这个任务。

上述这两种方法在周转时间上的差异是四个数量级。

忘了“10倍程序员(10X programmer)”吧，“10000倍程序员(10000X programmer)”怎么样？

由于现代计算机的硬件已经发展到比将人类送上月球的计算机快几千亿倍，这些类型的差异已经急剧缩小了。那些即使是简单计算也要等待几个小时出结果的分时的日子已经一去不复返了。即使是手机也足够强大，可以完成人类在20世纪的所有计算结果。

图：摩尔定律(图片来自wikipedia，译者加)

但软件却可能没有这么大的进步。可以说，自ALGOL 68以来，在解决软件危机方面没有发生什么。也许更糟糕的是，我们（集体）从那个时代的巨头那里学到的东西太少。我想举例说明这些巨头中的两位，以及他们可以教给我们的经验。

弗雷德里克·布鲁克斯

1964年，IBM宣布了其迄今为止最雄心勃勃的项目：IBM 360。该项目由Gene Amdahl负责设计，弗雷德里克·布鲁克斯(Frederick Brooks)负责管理。

这是世界上第一台真正的可编程大型计算机，开启了计算机可以被重新编程以适应新问题的概念，而不是被更新的模型所取代。该系统结构引入了许多我们今天仍在使用的标准，如8位字节、32位字(word)等。

也许更有趣的是这个项目本身。该项目……比最初想象的要昂贵得多。它将预算提高了200倍：从2500万美元提高到50亿美元。要知道，当时作为美国国家核武器研究的曼哈顿项目的预算才仅为20亿美元。

该项目遇到了你能想到的所有开发和管理问题。

多年以后，布鲁克斯决定，回答”为什么软件项目经常出错”这个问题的最好方法是把他的经验和IBM的教训写成一本书。那本书就是现在传说中的《人月神话》。

图：《人月神话》(译者加)

这也许是关于软件管理的最佳读物之一。其中有一篇文章是“没有银弹(No Silver Bullet)”，它指出：

无论是技术还是管理技术，都没有任何一种可以在十年内保证在生产力、可靠性和简单性方面有哪怕一个数量级的改进。

鉴于与穿孔卡的前辈相比，现代程序员可以很快纠正他们的错误，布鲁克斯认为，剩下的大部分复杂性是问题本身，而意外的复杂性大部分已经解决了。

这并不是说自60年代以来生产力没有提高，实际上恰恰相反。来看看下面的例子：

自由/开放源码软件
高速硬件
通用计算机
高性能编译器
全球互联网(Internet)

它们一起将我们的整体生产力推到了一个很高的水平。它们也重新引入了许多意外的复杂性，而这些复杂性是我们的前辈们在最初就很努力地消除的。(稍后会有更多关于这方面的内容)

“现在的程序员已经不像以前那样高产了”。

这种将偶然的复杂性降低到最低限度的概念是我们很多问题的关键，没有比尼克劳斯·沃思(Niklaus Wirth)更能体现这一原则的了。

尼克劳斯·沃思

在创造了PASCAL、MODULA和MODULA-2之后，沃思开始着手开发OBERON系列语言，以便在他的Ceres工作站上建立他自己的Oberon操作系统。

如果说沃思在他的职业生涯中完成了很多伟大的事情，那就太轻描淡写了，而上面给出的例子只是他成就的一小部分。

他设法通过遵循一套原则来执行所有这些想法，这些原则可以总结如下：

你必须完全理解你的想法，才能完全实现它。

Oberon语言的出现是出于降低编程语言，特别是针对Modula的复杂性的考虑。这一努力产生了一种非常简洁的语言。Oberon的范围，它的功能和结构的数量，甚至比Pascal小。然而，它的功能却大大增强了。

这个人的结论是：Pascal太复杂了。

利用他发现的新力量，他在自己的硬件上从头开始建立了他的操作系统，这个操作系统仅有12K行源码，占用200K字节的空间资源。我们可以对比一下，Mac OSX拥有86M行源码，占用3GB的空间，并且是由世界上最富有的公司之一建立的。现在，也许OSX比Oberon的功能更完整，但肯定不是40000倍的关系。一路走来，有些东西已经失去了。

布鲁克斯的“没有银弹”的概念和沃思的哲学在这里有交集：

你不能通过增加你的语言的复杂性来减少你的问题的复杂性。

你的语言的表面积越大(译：我理解指语言的设计目标越多)，就会有越多的风沙（译注：风沙指语言的特性）来掩盖其本质。在某些时候，指针已经向前移动到循环开始的地方，因为旧的子集变成了新的，循环再次开始。

这种“少即是多”的概念让我想起了另一位巨人的一句同样性质的话：

有两种构建软件设计的方法：一种是使其简单到明显没有缺陷，另一种是使其复杂到没有明显缺陷 – Tony Hoare

在理论上拒绝沃思的前提，必然会导致走向Hoare观点中的第二个方法。

‘在Objective-C和Swift之间的某个地方，你最终得到了一个来自过去的框架，一个来自未来的框架，以及现在的一个纠结的混乱。

走这条路的代价是什么？

束缚我们的石头

培训

学习一个新的操作系统，与你的技术绑定。
学习一个新的IDE，与你的技术绑定。
学习一个新的框架来取代已经工作的框架。
学习使用你的旧语言的新版本。

你所有的旧技能都得益于你多年的经验，就像特修斯之船一样(译注：特修斯之船是一个思想实验，它提出了一个问题：一个已经更换了所有组件的物体从根本上是否与原物体是相同的)，到了一个时刻，这些技能所占的比重越来越小。经验应该增加价值，而不是减少它。

仓鼠轮(译注：循环往复的重复工作)

以前工作的项目在更新后被破坏。
你所依赖的其他人以前工作的项目在更新后也会被破坏。
筛选几页的文档和StackOverflow的帖子，这些都不再有意义了。
不得不跟上新闻，以便预测你的下一个待命的头痛问题。

被迫修复由你的项目、公司、客户或大陆以外的外部力量产生的问题，对任何人都没有帮助，尤其是对你。

难道就没有人为年轻人着想吗？

这个行业是非常难学的。
除了厨房里的水槽，什么都有，这不是一个介绍新人的好方法。
花在学习工具上的时间本可以用来了解这个项目或学习一般的技能以延续到下一个项目。

你所碰到的大多数后辈都被压倒了，感到困惑，并有压力要跟上不断变化的皇帝的衣服层。

裁缝被封为所有顾问的守护神，因为尽管他榨取了大量的费用，但他始终无法说服他的客户，让他们恍然大悟，他们的衣服没有皇帝。- Tony Hoare

除了老人和可能的内核开发者之外，整个行业往往没有意识到，忽视或拒绝这一前提。相反，轮子的每一次旋转都会到达它开始的地方，并承诺会有新的开始。

幸运的是，也有例外的情况。这里就是其中之一。

Go

这种奇妙的、著名的”停留在70年代”的语言，满足了所有必要的条件，避免了大部分（如果不是全部）的问题，并从古老的语言中获得了灵感，但又颇具现代感。

一蹴而就
- 单一安装，没有许可证/注册/祭祀仪式。
- 可以在任何东西上运行，即使那东西是一台布满灰尘的旧笔记本电脑。
- 语言（相对而言）容易掌握。
- 直接的过程化编程(procedural programming)，不给自己贴上FP(函数式)和OOP(面向对象)标签。
没有IDE的耦合。
- 不需要购买许可证，工程师不会被过期的许可证困扰。
- 不需要重新培训工程师将文本输入文本文件。如果他们有几十年使用一个编辑器的经验，他们就可以使用它。
- 没有解决方案文件或复杂的需要IDE才能工作的构建系统。
即时编译为静态二进制文件。
- 不需要在项目编译时坐着什么都不做(译注：编译速度快，几乎无需等待)。
- 不需要为了把一种文本编译成另一种文本而把自己的所有内核旋转到100%。
- 通过运行一个单一的可执行文件进行部署。
如果十年前能用，现在也能用。
- 停留在70年代意味着自喇叭裤以来就没有突破性的变化。
- 阳光下的一切都包含在自带电池的标准库中。
- 每一行代码都是可检查的，没有闭源库。

它是由Ken Thompson、Rob Pike和Robert Griesemer（沃思的一个学生）设计的。该语言的入门书籍是由Brian Kernighan撰写的。很明显，这种语言是C语言的精神继承者。

图：Go程序设计语言(图片来自gopl.io，译者加)

距离我第一次使用Go已经两年了，我想不出有什么比它更适合通用的软件开发了，尤其是在尊重自己和他人的时间方面。它是为数不多的可以让我自由编程的语言之一，而不需要向互联网咨询，也不需要向在这方面有更多经验的人催促那些应该是不言自明的事情。它没有那么多的魔力，没有那么多的隐藏，这就产生了更多更大的清晰性。没有惊喜，”它只是能工作“。

这并不是说每个人都有这种感觉，恰恰相反。批评是很多的。关于Go缺失功能的讨论（比如，缺乏泛型）已经持续了很多年（到现在已经超过十年了），我只能假设在不可预见的未来还会继续下去。

在这期间，我敦促你去试试这门语言。也许你会喜欢上它。

“Gopher部落”知识星球正式转正（从试运营星球变成了正式星球）！“gopher部落”旨在打造一个精品Go学习和进阶社群！高品质首发Go技术文章，“三天”首发阅读权，每年两期Go语言发展现状分析，每天提前1小时阅读到新鲜的Gopher日报，网课、技术专栏、图书内容前瞻，六小时内必答保证等满足你关于Go语言生态的所有需求！部落目前虽小，但持续力很强。在2021年上半年，部落将策划两个专题系列分享，并且是部落独享哦：

Go技术书籍的书摘和读书体会系列
Go与eBPF系列

欢迎大家加入！

Go技术专栏“改善Go语⾔编程质量的50个有效实践”正在慕课网火热热销中！本专栏主要满足广大gopher关于Go语言进阶的需求，围绕如何写出地道且高质量Go代码给出50条有效实践建议，上线后收到一致好评！欢迎大家订
阅！

img{512x368}

我的网课“Kubernetes实战：高可用集群搭建、配置、运维与应用”在慕课网热卖中，欢迎小伙伴们订阅学习！

img{512x368}

我爱发短信：企业级短信平台定制开发专家 https://tonybai.com/。smspush : 可部署在企业内部的定制化短信平台，三网覆盖，不惧大并发接入，可定制扩展；短信内容你来定，不再受约束, 接口丰富，支持长短信，签名可选。2020年4月8日，中国三大电信运营商联合发布《5G消息白皮书》，51短信平台也会全新升级到“51商用消息平台”，全面支持5G RCS消息。

著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格5$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式：

微博：https://weibo.com/bigwhite20xx
微信公众号：iamtonybai
博客：tonybai.com
github: https://github.com/bigwhite
“Gopher部落”知识星球：https://public.zsxq.com/groups/51284458844544

微信赞赏：
img{512x368}

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

Go 1.17新特性详解：使用基于寄存器的调用惯例

八月 20, 2021
0 条评论

本文永久链接 – https://tonybai.com/2021/08/20/using-register-based-calling-convention-in-go-1-17

除了Go语言特性与go module有重要变化之外，Go编译器与Go运行时也都有着优化与改进，这两方面的变化对Go程序的构建与运行影响巨大。在这个系列的最后一篇中，我们来看看编译器与运行时中那些值得关注的变化。

1. 使用基于寄存器的调用惯例替代基于堆栈的调用惯例

所谓“调用惯例(calling convention)”是调用方和被调用方对于函数调用的一个明确的约定，包括：函数参数与返回值的传递方式、传递顺序。只有双方都遵守同样的约定，函数才能被正确地调用和执行。如果不遵守这个约定，函数将无法正确执行。

Go 1.17版本之前，Go采用基于栈的调用约定，即函数的参数与返回值都通过栈来传递，这种方式的优点是实现简单，不用担心底层cpu架构寄存器的差异，适合跨平台；但缺点就是牺牲了一些性能，我们都知道寄存器的访问速度要远高于内存。

大多数平台上的大多数语言实现都使用基于寄存器的调用约定，通过寄存器而不是内存传递函数参数和返回结果，并指定一些寄存器为调用保存寄存器，允许函数在不同的调用中保持状态。

于是Go在1.17版本决定向这些语言看齐，在amd64架构下率先实现了从基于堆栈的调用惯例到基于寄存器的调用惯例的切换。

在Go 1.17的版本发布说明文档中有提到：切换到基于寄存器的调用惯例后，一组有代表性的Go包和程序的基准测试显示，Go程序的运行性能提高了约5%，二进制文件大小典型减少约2%。

我们来实测一下，下面采用的是之前进阶专栏中的一个多种方法进行字符串连接的benchmark测试，在Go 1.16.5和Go 1.17下面分别运行Benchmark结果如下：

Go 1.16.5：

$go test -bench .
goos: darwin
goarch: amd64
pkg: github.com/bigwhite/demo
cpu: Intel(R) Core(TM) i5-8257U CPU @ 1.40GHz
BenchmarkConcatStringByOperator-8                       12132355            91.51 ns/op
BenchmarkConcatStringBySprintf-8                         2707862           445.1 ns/op
BenchmarkConcatStringByJoin-8                           24101215            50.84 ns/op
BenchmarkConcatStringByStringsBuilder-8                 11104750           124.4 ns/op
BenchmarkConcatStringByStringsBuilderWithInitSize-8     24542085            48.24 ns/op
BenchmarkConcatStringByBytesBuffer-8                    14425054            77.73 ns/op
BenchmarkConcatStringByBytesBufferWithInitSize-8        20863174            49.07 ns/op
PASS
ok      github.com/bigwhite/demo    9.166s

Go 1.17：

$go test -bench .
goos: darwin
goarch: amd64
pkg: github.com/bigwhite/demo
cpu: Intel(R) Core(TM) i5-8257U CPU @ 1.40GHz
BenchmarkConcatStringByOperator-8                       13058850            89.47 ns/op
BenchmarkConcatStringBySprintf-8                         2889898           410.1 ns/op
BenchmarkConcatStringByJoin-8                           25469310            47.15 ns/op
BenchmarkConcatStringByStringsBuilder-8                 13064298            92.33 ns/op
BenchmarkConcatStringByStringsBuilderWithInitSize-8     29780911            41.14 ns/op
BenchmarkConcatStringByBytesBuffer-8                    16900072            70.28 ns/op
BenchmarkConcatStringByBytesBufferWithInitSize-8        27310650            43.96 ns/op
PASS
ok      github.com/bigwhite/demo    9.198s

我们看到，相对于Go 1.16.5跑出的结果，Go 1.17在每一个测试项上都有小幅的性能提升，有些性能提升甚至达到10%左右。这种新版本带来的性能的“自然提升”显然是广大Gopher想看到的。

我们再来看看编译后的Go二进制文件的Size变化。以一个自有的1w行左右代码的Go程序为例，分别用Go 1.16.5和Go 1.17进行编译，得到的结果如下：

-rwxr-xr-x   1 tonybai  staff  7264432  8 13 18:31 myapp-go1.16.5*
-rwxr-xr-x   1 tonybai  staff  6934352  8 13 18:32 myapp-go1.17*

我们看到Go 1.17编译后的二进制文件大小相较于Go 1.16.5版本的减少了约4%。

另外Go 1.17发布说明也提到了：改为基于register的调用惯例后，绝大多数程序不会受到影响。只有那些之前就已经违反unsafe.Pointer的使用规则的代码可能会受到影响，比如不遵守unsafe规则通过unsafe.Pointer访问函数参数，或依赖一些像比较函数代码指针的未公开的行为。

除了改为基于寄存器的调用惯例之外，Go 1.17编译器还支持包含闭包的函数的内联(inline)了！这样一来，一个带有闭包的函数可能会在函数被内联的每个地方产生一个不同的闭包代码指针，因此，Go函数的值不能直接比较！

2. 引入//go:build形式的构建约束指示符，以替代原先易错的// +build形式

Go 1.17之前，我们可以通过在源码文件头部放置+build构建约束指示符来实现构建约束，但这种形式十分易错，并且它并不支持&&和||这样的直观的逻辑操作符，而是用逗号、空格替代，下面是原+build形式构建约束指示符的用法及含义：

这种与程序员直觉“有悖”的形式让Gopher们十分痛苦，于是Go 1.17回归“正规”，引入了//go:build形式的构建约束指示符，这样一方面是与源文件中的其他指示符保持形式一致，比如: //go:nosplit、//go:norace、//go:noinline、//go:generate等。另外一方面，新形式将支持&&和||逻辑操作符，对于程序员来说，这样的形式就是自解释的，我们无需再像上面那样列出一个表来解释每个指示符组合的含义了，如下代码所示：

//go:build linux && (386 || amd64 || arm || arm64 || mips64 || mips64le || ppc64 || ppc64le)
//go:build linux && (mips64 || mips64le)
//go:build linux && (ppc64 || ppc64le)
//go:build linux && !386 && !arm

考虑到兼容性，Go命令可以识别这两种形式的构建约束指示符，但推荐Go 1.17之后都用新引入的这种形式。

gofmt可以兼容处理两种形式，处理原则是：如果一个源码文件只有// +build形式的指示符，gofmt会将与其等价的//go:build行加入。否则，如果一个源文件中同时存在这两种形式的指示符行，那么//+build行的信息将被//go:build行的信息所覆盖。

go vet工具也会检测源文件中同时存在的不同形式的构建指示符语义不一致的情况，比如针对下面这段代码：

// github.com/bigwhite/experiments/tree/master/go1.17-examples/runtime/buildtag.go

//go:build linux && !386 && !arm
// +build linux

package main

import "fmt"

func main() {
    fmt.Println("hello, world")
}

go vet会提示如下问题：

./buildtag.go:2:1: +build lines do not match //go:build condition

3. 运行时栈跟踪输出信息的格式更“可读”

之前写过一篇文章《记一次go panic问题的解决过程》，在那篇文章中，我们探讨了如何解读panic发生后输出的函数栈跟踪信息。

下面的代码示例用于对比运行时栈输出信息的差异：

// github.com/bigwhite/experiments/tree/master/go1.17-examples/runtime/stacktrace.go

package main

type myStruct struct {
    m int
    s string
    p *float64
}

func foo(a int, b string, c []byte, f *myStruct) (int, error) {
    panic("mypanic")
}

func main() {
    f := 3.14
    ms := myStruct{
        m: 17,
        s: "myStruct",
        p: &f,
    }
    a := 11
    b := "hello"
    c := []byte{'a', 'b', 'c'}
    foo(a, b, c, &ms)
}

在这个示例程序中，我们在foo函数中“故意”panic，以便go运行时在程序退出前输出栈跟踪信息（注意编译时关闭内联优化）。针对这个示例程序，Go 1.17之前的版本输出的栈跟踪信息是这样的(go 1.16.5版本):

$go build -gcflags '-N -l' -o stacktrace-go1.16.5 stacktrace.go
$./stacktrace-go1.16.5
panic: mypanic

goroutine 1 [running]:
main.foo(0xb, 0x1073f53, 0x5, 0xc000046715, 0x3, 0x3, 0xc000046758, 0x0, 0x0, 0x0)
    /Users/tonybai/Go/src/github.com/bigwhite/experiments/go1.17-examples/runtime/stacktrace.go:10 +0x4a
main.main()
    /Users/tonybai/Go/src/github.com/bigwhite/experiments/go1.17-examples/runtime/stacktrace.go:23 +0x148

上面输出信息中foo函数后面括号中的各个值与foo函数原型完全对不上。要想知道这些数值的含义究竟是什么，可以参考我上面提到的那篇文章，这里不赘述。

使用Go 1.17版本编译后会是什么样子呢？我们再来看一下：

go 1.17:

$go build -gcflags '-N -l' -o stacktrace-go1.17 stacktrace.go
$./stacktrace
panic: mypanic

goroutine 1 [running]:
main.foo(0xb, {0x10608d4, 0x5}, {0xc00004270d, 0x3, 0x3}, 0xc000042750)
    /Users/tonybai/Go/src/github.com/bigwhite/experiments/go1.17-examples/runtime/stacktrace.go:10 +0x59
main.main()
    /Users/tonybai/Go/src/github.com/bigwhite/experiments/go1.17-examples/runtime/stacktrace.go:23 +0x10f

对照着该示例程序中foo函数的原型：

func foo(a int, b string, c []byte, f *myStruct) (int, error)

这回一目了然了！我们看到Go 1.17改进了当发送未捕获的panic或当runtime.Stack被调动时，运行时输出的栈跟踪信息的格式。Go 1.17版本之前，函数参数被打印成基于内存布局的十六进制值的形式，就像前面那个难于解读的输出信息。Go 1.17版，源码中函数的每个参数都被单独打印，用逗号分隔。聚合类型（结构体、数组、字符串、切片、接口和complex）的参数用大括号分隔。需要注意的是，只存在于寄存器中而没有存储到内存中的参数的值可能是不准确的。函数的返回值（通常是不准确的）不再被打印了。

通过上的输出，我们还可以清晰的看到string、byte切片以及结构体在内存中的表示方式，string本质上是一个拥有两个字段的结构，而切片则是一个三元组表示的结构。