标签 Windows 下的文章

Go语言之禅

本文翻译自Go社区知名Gopher和博主Dave Cheney的文章《The Zen of Go》

img{512x368}

本文来自我在GopherCon Israel 2020上的演讲。文章很长:) 如果您希望阅读精简版,请移步到the-zen-of-go.netlify.com

该演讲视频还未上线。如上线,我会把它更新到本文中的。

我应该如何编写出好代码?

我最近一直在思考很多事情,每当反思自己的工作成果时,眼前常会出现一行字幕:我该如何编写出好代码? 主观上,没人愿意去编写糟糕的代码,那么问题来了:你是怎么知道你编写出好的Go代码了呢?

如果好与坏之间存在连续性,那么我们怎么知道哪些是好的部分?它的特性、属性、标志、模式和惯用法又是什么呢?

Go语言惯用法(idiomatic Go)

img{512x368}

这让我走进Go惯用法。说某种东西是惯用的,就是说它遵循了时代的风格。如果某些东西不是惯用的,那它没有遵循流行的风格,感觉不时髦。

更重要的是,对某人说他们的代码不复合惯用法并不能解释为什么这些代码不符合惯用法。为什么会这样?像所有真相一样,答案可以在词典中找到:

idiom (noun): a group of words established by usage as having a meaning not deducible from those of the individual words.
惯用法(名词):一组由用法确定的且其含义无法从单个单词的含义中推导出来的单词。

惯用法是共享价值观(value)的标志。Go惯用法不是您从书本中学到的东西,而是通过成为社区的一部分而获得的

img{512x368}

Go惯用法字样用多了,便形成了“口头禅”,这引起我的担忧:这种口头禅在许多方面它可能是具有排他性的。比如:有人说“你不能和我们坐在一起。” 但毕竟这不是我们批评某人的代码不符合惯用法时的索要表达的意思,是吧?他们只是没有做对,看起来不对,它没有遵循流行的风格而已。

我认为Go惯用法不是教如何编写好的Go代码的合适机制,因为从根本上说,它仍然告诉某人做错了(译注:这容易引起对方反感)。如果在他们最愿意接受建议的时候,我们给出让他们不感觉疏远的建议是否会更好些?

谚语(Proverbs)

摆脱有问题的惯用法,Gopher们还有哪些其他的文化手工艺品吗?也许我们可以转向Rob Pike精彩的Go 谚语。这些谚语是合适的教学工具吗?它们会告诉Go新手如何编写好的Go代码吗?

总的来说,我不这么认为。这并不是要驳斥Rob Pike的作品。只是像濑越宪作(Segoe Kensaku)的原著一样,Go谚语只是观察,而不是价值观的陈述。我们再次搬出字典:

proverb (noun): a short, well-known pithy saying, stating a general truth or piece of advice.
谚语(名词):简短而众所周知的俗语,陈述一般的真理或一段忠告。

Go Proverbs的目的是揭示有关语言设计的更深层次的真理,但是像empty interface says nothing这样的建议对于一个来自商没有结构化类型的语言的新手来说有什么用呢?

重要的是要认识到,在一个不断发展的社区中,任何时候学习Go语言的人的数量都远超过那些声称掌握了该语言的人的数量。因此,在这种情况下,谚语可能也不是最佳的教学工具。

工程价值观

丹·卢(Dan Luu)找到了马克·卢科夫斯基(Mark Lucovsky)关于Windows团队在Windows NT-Windows 2000开发阶段时的工程文化的演讲。我之所以提到它,是因为卢科夫斯基将一种文化描述为一种评估设计和权衡取舍的常用方法。

img{512x368}

讨论文化的方法有很多,但是就工程文化而言,Lucovsky的描述是恰当的。其中心思想是在未知的设计空间中用价值观指导决策。Windows NT团队的价值观是:可移植性,可靠性,安全性和可扩展性。粗略地说工程价值观就是在这里完成工作的方式。

Go的价值观

Go的显式价值观是什么呢?定义Go程序员解释世界方式的核心信念或哲学又是什么?他们如何发布宣传?他们怎么传授?如何执行?它们又是如何随着时间变化的?

作为新Go程序员,您将如何被灌输Go的工程价值观?或者,你是一位经验丰富的Go专家,你如何将你的价值观传播给“下一代”?就像我们知道的那样,知识传递的过程不是一个可选项。没有新的血液和新的观念,我们的社区将变得短视和枯萎。

其他语言的价值观

为了给我所要了解的场景做铺垫,我们可以先看看其他语言,我们看看它们的工程价值观。

例如,C++(包括其扩展:Rust)认为程序员不必为自己不使用的特性付费。如果程序未使用该语言的某些计算成本昂贵的特性,则不应强迫该程序承担该特性的成本。该价值观从语言扩展到其标准库,并用作判断所有用C++编写的代码设计的标准。

在Java,Ruby和Smalltalk中,一切都是对象的核心价值观驱动着围绕着消息传递,信息隐藏和多态的程序设计风格。在程序中采用过程式或函数式设计风格会被认为是错误的,或者按照Gophers的说法,是不符合惯用法的。

回到我们自己的Go社区,烙印在Go程序员心中的工程价值观是什么呢?在我们社区中的讨论是很容易引战的,因此要从第一条原则衍生出一套价值观念将是一个巨大的挑战。共识很关键,但随着讨论贡献者数量的增加,难度就成倍增加。但是,如果有人已经为我们完成了这些艰苦的工作了呢?

~~Python~~ Go之禅

几十年前,蒂姆·彼得斯(Tim Peters)坐下来写下了PEN-20(Python之禅)。Peters试图记录他认为Guido van Rossum(Python之父)在Python社区扮演的BDFL(仁慈的独裁者)角色时所应用的工程价值观。

在本文的剩余部分中,我将着眼于Python之禅,并问问大家:是否有什么可以用来揭秘Go程序员的工程价值观的?

一个好的package始于一个好名字

让我们从香辛的东西开始

“Namespaces are one honking great idea–let’s do more of those!” The Zen of Python, Item 19
“命名空间是一个很棒的主意-让我们多做些吧!” Python之禅,条款19

这是相当明确的,Python程序员应该使用命名空间,多多益善。

package就是Go语言的命名空间。我怀疑是否有人质疑将组件分组到程序包中利好设计和潜在重用。但关于这么做的正确方法的困惑肯定会有的,尤其是你拥有另一门语言10年的使用经验。

在Go中,每个程序包都应有一个目的/用途,而了解程序包目的/用途的最佳方法是通过其名字-一个名词。包的名字描述了它提供的内容。因此,这里重新解释一下Peters的话:每个Go软件包(package)都应该仅有一个单一的目的/用途。

这不是一个新主意,我已经说了一段时间了,但是为什么要这样做而不是使用将软件包用于细粒度分类的方法呢?为什么,因为变化(change)。

“Design is the art of arranging code to work today, and be changeable forever.” - Sandi Metz
“设计是安排代码以使其至今天仍然可以工作并且永远可以更改的艺术。” - 桑迪·梅斯

变化是我们所从事的游戏的名称(译注:这里的游戏指代程序开发工作)。作为程序员,我们要做的就是管理变变化。当我们做得很好时,我们称之为设计或架构。当我们做得不好时,我们称其为技术债务或遗留代码。

如果你编写的程序对于一组固定的输入可以一次性地完美地工作,那么没人会在乎代码的好坏,因为最终程序的输出才是企业和业务所关心的。

但这是不正确的。软件具有缺陷(bug),需求变更,输入变更,并且很少有程序被编写为仅执行一次,因此您的程序会随着时间而变化。可能是您要为此承担任务,更有可能是其他人,但是必须更改该代码。有人必须维护该代码。

那么,如何使程序更改变得容易呢?无所不在的接口?使一切变得易于mock?邪恶的依赖注入(译注:作者对DI似乎很排斥,用了带有感情色彩的词汇)?好吧,也许,对于某类程序,但不是很多,这些技术将很有用。但是,对于大多数程序而言,预先设计一些灵活的方法要比工程设计更为重要。

相反,如果我们采取的立场是取代组件而不是增强组件,该怎么办?知道何时需要更换某些物品的最佳方法是什么时候该物品没有按照锡盒/罐头盒上的说明进行操作。

一个好的包始于选择一个好的名字。把你的包名字想象成电梯游说(Elevator pitch,即用极具吸引力的方式简明扼要地阐述自己的观点), 仅用一个词就可以描述包的内容。当名字不再符合要求时,请查找替代名字。

简单性很重要

“Simple is better than complex.” - The Zen of Python, Item 3
“简单胜于复杂。” - Python之禅,条款3

PEP-20说:简单胜于复杂,我完全同意。几年前,我发布了这条推文:

大多数编程语言开始都是为了简单,但最终只是为了功能强大而努力。— Dave Cheney(@davecheney)2014年12月2日

至少在当时,我的观察是,我想不出一生中使用的哪门语言不标榜着简单。每种新语言都为其固有的简单性提供了理由和诱因。但是,当我研究时,我发现简单性并不是与Go语言同时代的许多现代语言的核心价值观。也许这只是一个便宜的镜头1,但是可能是这些语言不是很简单,或者它们不认为自己很简单。他们不认为简单是其核心价值观。

但是什么时候简单变得过时了?为什么商业软件开发行业会忘记这个基本原则?

“There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.” - C. A. R. Hoare, The Emperor’s Old Clothes, 1980 Turing Award Lecture

“构建软件设计的方式有两种:一种方式是使其变得如此简单,以至于显然没有缺陷,另一种方式是使得它变得如此复杂以至于没有明显的缺陷。第一种方法要困难得多。” - CAR Hoare,皇帝的旧衣,1980年图灵奖演讲

我们知道:简单并不意味着容易。通常,使某些东西易于使用而不是易于构建需要更多的工作。

“Simplicity is prerequisite for reliability.” - Edsger W Dijkstra, EWD498, 18 June 1975
“简单性是可靠性的前提。”-  埃兹格·迪克斯特拉(Essger W Dijkstra),EWD498,1975年6月18日

我们为什么要追求简单?为什么Go程序简单很重要?简单并不意味着粗糙,它意味着可读性和可维护性。简单并不意味着“不复杂”,它意味着可靠,有共鸣且易于理解。

“Controlling complexity is the essence of computer programming.” - Brian W. Kernighan, Software Tools (1976)
“控制复杂性是计算机编程的本质。” - Brian W. Kernighan,软件工具  (1976)

Python是否遵守其简单性的说法尚有争议,但Go坚持将简单性作为核心价值观。我认为我们都可以认同,就Go而言,简单代码比聪明代码更可取

避免包级别状态

“Explicit is better than implicit.” - The Zen of Python, Item 2
“显式胜于隐式。” - Python的禅宗,第2项

我认为彼得斯在这个地方的抱负胜于实际。Python中的许多内容并不明确;装饰器,dunder方法(译注:不知此为何物)等。毫无疑问,这些特性的功能强大,存在这些特性是有原因的。每个特性都是因某人非常关心的事情,尤其是复杂的特性。但是大量使用这些特性使读者很难预测操作的成本。

好消息是,像Go程序员一样,我们可以选择显式代码。显式可能意味着很多事情,也许您可能认为显式只是一种表达官僚主义和漫长风气的好方法,但这只是肤浅的解释。只关注页面的语法、烦恼行长和自制表达式是一种错误的说法。在我看来,更有价值的地方是与耦合和状态有关。

耦合(coupling)是衡量一件东西依赖另一件东西的数量的方法。如果两件事紧密结合,它们就会一起运动。影响其中一个事物的行为会直接反映在另一个事物中。想象一下,一列火车,每个车厢连在一起;发动机行驶到哪里,车厢就跟随到哪里。

描述耦合的另一种方法是内聚(cohesion)一词。内聚衡量两件事自然地在一起的程度。当我们进行一个内聚的争论,或者一个内聚的团队,它们的所有零件都可以自然装配在一起,就像设计的一样。

为什么耦合很重要?因为就像火车一样,当您需要更改一段代码时,与之紧密相关的所有代码都必须更改。一个再适合不过的例子:有人发布了他们的API的新版本,现在您的代码无法通过编译了。

API是不可避免的耦合源,但是存在更多隐蔽的耦合形式。显然,每个人都知道,如果API的原型发生更改,则该调用的传入和返回数据都会发生变化。就在函数原型中;我采用这些类型的值,并返回其他类型的值。但是,如果API以其他方式传递数据怎么办?如果每次调用此API的结果都是基于上次调用该API的结果,即使您没有更改参数该怎么办?

这是状态,状态管理是计算机科学中的问题。

package counter

var count int

func Increment(n int) int {
        count += n
        return count
}

假设我们有这个简单的counter包。您可以调用Increment以增加计数器,即便传入0,你也可以得到返回值。

假设您必须测试此代码,那么每次测试后如何重置计数器?假设您想并行运行这些测试,可以吗?现在,假设您要为每个程序进行不止一个计数,您可以这样做吗?

不,当然不行。显然,答案是将count变量封装为类型。

package counter

type Counter struct {
        count int
}

func (c *Counter) Increment(n int) int {
        c.count += n
        return c.count
}

现在想象一下,这个问题不局限于计数器,还包括应用程序的主要业务逻辑。您可以单独测试吗?您可以并行测试吗?您一次可以使用多个实例吗?如果回答那些问题为否,则原因是软件的包级别状态。

避免包级别状态。通过提供一种类型需要的依赖项作为该类型上的字段,而不是使用包变量,来减少耦合和怪异的行为。

为失败而计划,而不是成功而计划

“Errors should never pass silently.” - The Zen of Python, Item 10
“错误绝不能默默传递。” - Python之禅,条款10

有人说过,支持异常处理的语言遵循武士原则(Samurai principle)。要么全胜归来,要么(失败)全不回来。在基于异常的语言中,函数仅返回有效结果。如果他们没有成功,那么控制流程将采纳完全不同的路径。

未检查的异常显然是不安全的编程模型。当您不知道哪些语句可能引发异常时,如何在存在错误的情况下编写健壮的代码?Java尝试通过引入checked exception的概念来使异常更安全,据我所知,这种checked exception在另一种主流语言中没有被引入。有很多使用异常的语言,但是除了Java,所有语言都使用未经检查的各种异常(unchecked exception)。

显然,Go选择了不同的路径。Go程序员认为,健壮的程序是由处理失败情况的片段组成的,然后再处理happy path。在Go设计的空间中:服务器程序,多线程程序,处理网络输入的程序,如果要构建可靠的程序,那么处理意外数据、超时、连接失败和损坏的数据必须是程序员的首要任务。

“I think that error handling should be explicit, this should be a core value of the language.” - Peter Bourgon, GoTime #91
“我认为错误处理应该是显式的,这应该是语言的一个核心价值观。” - 彼得·布尔贡(Peter Bourgon),GoTime#91

我想回应彼得的主张,因为这是本文的动力。我认为Go的成功很大程度上归功于显式的处理错误的方式。Go程序员首先考虑失败情况。我们首先解决如果...怎么办的情况。这导致程序在编写时处理故障,而不是在生产中处理故障。

反复出现的下面代码片段:

if err != nil {
    return err
}

所付出的成本已基本被在故障发生时刻意处理每个故障情况的价值超过了(译者注:上面的重复代码段也是利大于弊)。关键还在于显式处理每个错误的文化价值观。

早点返回,而不是深层嵌套

“Flat is better than nested.” - The Zen of Python, Item 5
“扁平比嵌套更好。” - Python的禅宗,条款5

这是一个明智的建议,而且它来自以缩进作为控制流主要形式的语言。我们如何用Go来解释这个建议呢?gofmt控制Go程序的整体风格(空白与缩进),因此无需执行任何额外操作。

我之前写过关于package名字的文章,这里可能有一些建议:避免复杂的软件包层次结构。以我的经验,程序员越努力细分和分类Go代码库,他们越有可能陷入包导入循环的死角。

我认为第5项条款建议的最佳应用是函数内的控制流。简而言之,避免需要控制流缩进过深。

“Line of sight is a straight line along which an observer has unobstructed vision.” - May Ryer, "Code: Align the happy path to the left edge" https://medium.com/@matryer/line-of-sight-in-code-186dd7cdea88

“代码行展现给观察者的视觉效果应该是一条畅通的直线。- May Ryer, “代码:将快乐路径对齐到左边缘”

Mat Ryer将这种想法描述为视线编码(line of sight coding )。视线编码意味着:

  • 如果不满足前提条件,则使用保护子句尽早返回。
  • 将成功的return语句放在函数的末尾,而不是放在条件代码块中。
  • 通过提取函数和方法来降低函数的整体缩进级别。

该建议的关键是您所关心的事情,功能所要做的事情永远不会有在屏幕右侧滑出视线的危险。这种风格有一个额外的副作用,您可以避免团队中对行长度的毫无意义的争论。

每次缩进时,都会向程序员堆栈添加另一个先决条件,从而消耗他们的7±2个短期内存插槽之一(译注:7±2指的是人类能短期记忆的事件数量大约是7,±2是个体差异)。将函数的成功执行路径贴近屏幕左手侧,不要深入嵌套。

如果你认为它性能差,请通过基准测试证明

“In the face of ambiguity, refuse the temptation to guess.” - The Zen of Python, Item 12
“面对模棱两可,拒绝猜测的诱惑。” - Python之禅,条款12

编程基于数学和逻辑,这两个概念很少涉及机会元素。但是,作为程序员,我们每天都在猜测许多事情。这个变量有什么作用?此参数有什么作用?如果我在这类传入nil会怎样?如果我调用Register两次会怎样?实际上,现代编程中存在很多猜测,尤其是在使用不是你编写的库时。

“APIs should be easy to use and hard to misuse.”  - Josh Bloch
“API应该易于使用并且不容易被滥用。” - 乔什·布洛赫(Josh Bloch)

我知道的帮助程序员避免猜测的最好方法之一是在构建API时,应专注于默认用例。使调用者尽可能轻松地执行最常见的事情。但是,我过去写过很多关于API设计的文章,所以我对第12项的解释是:不要猜测性能

尽管您可能考虑到Knuth的建议,但Go语言成功的推动力之一是其高性能的执行。您可以在Go中编写高性能的程序,因此人们会因此选择Go。关于性能有很多误解,所以我的要求是,当您希望对代码进行性能调优时,或者遇到一些教条式的建议时,例如defer缓慢,CGO昂贵,或者始终使用原子操作而不是互斥锁时,请不要猜。

不要因为过时的教条而使您的代码复杂化,并且,如果您认为某些事情很慢,请首先使用基准测试进行证明。Go提供了出色的基准测试和性能分析工具,这些工具均可免费获得。使用它们来找出您程序中的性能瓶颈。

在启动goroutine之前,请知道它何时会停止

在这一点上,我认为我已经从PEP-20中挖掘了有价值的要点,并且可能扩展其重新解释的范围。我认为很好,因为尽管这是一种有用的修辞手法,但最终我们还是在谈论两种不同的语言。

“You type go, a space, and then a function call. Three keystrokes, you can’t make it much shorter than that. Three keystrokes and you’ve just started a sub process.” - Rob Pike, Simplicity is Complicated, dotGo 2015

“您键入go,一个空格和一个函数调用。三次按键,您不能做到比这还短了。三次按键,您就启动了一个子过程。” - 罗伯·派克(Rob Pike),Simplicity is Complicated,dotGo,2015年

接下来的两个建议,我将专注于goroutines。Goroutines是语言的标志性功能,这是我们给出的关于一等公民(first class)并发的答案。它们非常易于使用,只需将单词go放在语句前面,即可异步启动该函数。非常简单,没有线程,没有堆栈大小,没有线程池执行程序(thread pool executor),没有ID,没有跟踪完成状态。

Goroutines代价很低。由于运行时(runtime)能够将goroutine多路复用到一个小的线程池中(您不必管理),因此可以轻松容纳数十万,数百万个goroutine。这开创了在竞争性并发模型(例如线程或事件回调)下不可行的设计。

但是,即便如goroutine一样便宜,但它们也不是免费的。至少它们的堆栈有几千字节,当您启动10^6个goroutine时,它们的确开始累加。这并不是说就不应该使用数百万个goroutine,如果你的设计需要,可以做。但是当您这样做时,请务必对其进行跟踪,因为10^6数量级的任何东西累计可能消耗的资源都不是少量的。

Goroutines是Go中资源所有权的关键。为了程序有用,goroutine必须做一些事情,这意味着它几乎总是持有对资源的引用或所有权:锁、网络连接、带有数据的缓冲区、channel的发送端。当该goroutine处于活动状态时,将持有锁,保持网络连接打开,保留缓冲区,并且channel的接收器将继续等待更多数据。

释放这些资源的最简单方法是将它们与goroutine的生命周期相关联-当goroutine退出时,资源释放。因此,尽管开始执行goroutine几乎是微不足道的,但在进行三次按键(go+空格)前,请确保您对以下问题有答案:

  • goroutine在什么情况下会停止? Go没有办法告诉goroutine退出。没有停止或终止功能,这是有充分的理由的。如果我们无法命令goroutine停止,则必须礼貌地对其提出要求。这几乎总是归结于channel操作。当channel关闭时,针对一个channel的range loop将退出循环。如果一个channel关闭,它将变为可选(selectable)。从一个goroutine到另一个goroutine的信号最好表示为一个关闭的channel。

  • 出现这种情况需要什么? 如果channel既是在goroutines之间进行通讯的工具,又是它们传达完成信号的机制,那么程序员面临的下一个问题就是,谁将关闭channel,何时会发生?

  • 您将使用什么信号知道goroutine已停止? 当您发出信号告知goroutine要停止时,在将来的某个时间gouroutine停止动作会发生。就人类的感知而言,它可能很快发生,但是计算机每秒执行数十亿条指令,并且从每个goroutine的角度来看,它们的指令执行是不同步的。解决方案通常是使用channel发应答信号或fan-in方法需要的waitgroup。

将并发留给调用者

在您编写的任何严肃的Go程序中,都可能涉及并发。这就提出了一个问题,我们编写的许多库和代码都采用每个连接一个goroutine或采用工作者(worker)模式。您将如何管理这些goroutine的生命周期?

net/http是一个很好的例子。关闭拥有监听套接字的server相对来说是直截了当的,但是从该接受套接字产生的goroutines呢?net/http确实在请求对象中提供了一个上下文(context)对象,该上下文对象可用于向正在监听的代码发出信号,表明应该取消请求(cancel),从而终止goroutine,但是尚不清楚如何知道何时完成所有这些操作。一种方法是调用context.Cancel,知道取消已经完成是另一回事。2

我想说明的一点net/http是,它是良好实践的反例。由于每个连接都是由net/http.Server类型内部产生的goroutine处理的,因此驻留在程序net/http包外部的程序无法控制接受套接字产生的goroutine。

这是一个仍在不断发展的设计领域,例如go-kitrun.Group和Go团队等努力ErrGroup提供了执行,取消和等待异步运行功能的框架。

这里更大的设计准则是针对库编写者的,或者是任何编写可以异步运行的代码的人,将使用goroutine的责任留给调用者。让调用者选择他们希望如何启动,跟踪和等待函数执行。

编写测试以锁定包API的行为

也许您希望从我这里读到一篇我不咆哮测试的文章。可悲的是,今天不是那天。

测试是关于您的软件做什么和不做什么的契约。程序包级别的单元测试应锁定程序包API的行为。他们用代码描述了程序包承诺要做的事情。如果针对每个输入排列组合都有一个单元测试,那么您已经定义了代码将在代码(而不是文档)中执行的约定 。

通过简单的输入go test,您就可以断言代码是否遵守契约。在任何阶段,您都可以高度自信地知道人们在更改之前所依赖的行为在更改之后将继续有效。

测试会锁定api行为。添加,修改或删除公共api的任何更改都必须包括对其测试的更改。

适度是一种美德

Go是一种简单的语言,只有25个关键字。在某些方面,这使该语言内置的功能脱颖而出。同样,这些是语言销售的功能,轻量级并发,结构化类型。

我想我们所有人都经历过尝试立即使用Go的所有功能所带来的困惑。谁对使用channel如此兴奋以至于他们尽可能多地,尽可能多地使用它们?就我个人而言,我发现结果很难测试,脆弱且最终过于复杂。只有我一个人吗?

我在goroutines上经历了相同的经历,试图将工作分解成很小的单元,我创建了一群难以管理的goroutines,最终观察到我的大多数goroutines总是阻塞等待–代码最终是顺序的,我增加了很多复杂性,几乎没有给现实世界带来任何好处。谁经历过这样的事情?

我在嵌入机制方面(embedding)也有同样的经历。最初,我将其误认为是继承。然后,我通过将已经承担多个职责的复杂类型组合成更复杂的巨大类型重现了创建脆弱的基类问题。

这可能是最不可行的建议,但我认为这一点很重要。建议始终是相同的,所有事情都要适度,Go的特性也不例外。如果可以的话,请不要寻求goroutine或channel,也不要嵌入结构,匿名函数,过渡用package,为每样东西建立接口(interface),要用简单方法而不是聪明的方法。

可维护性很重要

我想谈谈关于PEP-20的最后一项,

“可读性很重要。” - Python之禅,条款7
“Readability Counts.” - The Zen of Python, Item 7

关于可读性的重要性已经被谈论了很多,不仅在Go语言中,而且在所有编程语言中。像我这样的人,倡导在Go的舞台上使用简单,可读性,清晰度,生产力等词,但最终它们都是一个词的同义词- 可维护性

真正的目标是编写可维护的代码。原始作者之后的代码可以存活下了。存在的代码不仅可以作为时间点投资,而且可以作为未来价值的基础。不是可读性并不重要,而是可维护性更重要。

Go并不是为聪明人而优化的语言。Go不是一种为了在程序中编写最少行数而进行优化的语言。我们没有针对磁盘上源代码的大小进行优化,也没有针对将程序键入编辑器花费的时间进行优化。而是,我们希望优化我们的代码以使读者清晰(clear)。因为需要维护此代码的人正是读者。

如果您是为自己编写程序,则也许只需要运行一次,或者您是唯一会看到该程序的人,然后程序为您工作。但是,如果这是一个将由多个人贡献的软件,或者将由人们使用足够长的时间以致其需求,功能或运行环境可能发生变化,那么您的目标必须是针对程序的可维护性。如果无法维护软件,则它将被重写;那可能是您的公司最后一次投资Go。

你离开后,您努力实现东西可以维护吗?您今天该如何做才能使某人明天更容易维护您的代码?



我的网课“Kubernetes实战:高可用集群搭建、配置、运维与应用”在慕课网上线了,感谢小伙伴们学习支持!

我爱发短信:企业级短信平台定制开发专家 https://51smspush.com/
smspush : 可部署在企业内部的定制化短信平台,三网覆盖,不惧大并发接入,可定制扩展; 短信内容你来定,不再受约束, 接口丰富,支持长短信,签名可选。

著名云主机服务厂商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

微信赞赏:
img{512x368}

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


  1. 演讲的这一部分具有Ruby,Swift,Elm,Go,NodeJS,Python,Rust的网站登录页面的几个屏幕截图,展示了该语言如何描述自己。 

  2. 我倾向于选择net/http很多东西,但这并不是因为它很糟糕,实际上是相反的,它是Go代码库中最成功,最古老,最常用的API。因此,它的设计,发展和缺点已被彻底地接受。你可以认为这是奉承,而不是批评。 

Go正走在成为下一个企业级编程语言的轨道上

发展演化了十年的Go语言已经被证明了是云计算时代的首选编程语言,但Go的用武之地显然不局限于此。Kevin Goslar近期在Hacker Noon发表了一篇名为:《Go is on a Trajectory to Become the Next Enterprise Programming Language》的文章,阐述了Go可能成为下一个企业编程语言的理由,这里是那篇文章的中文译文,分享给大家。

img{512x368}

摘要

Go是一种专门为大规模软件开发而设计的编程语言。它提供了强大的开发体验并避免了现有编程语言存在的许多问题。这些因素使其成为最有可能在未来替代Java主导企业软件平台的候选者之一。对于那些寻求在未来几十年内构建大规模云基础架构的安全和前瞻性技术的公司和开源计划而言,我建议它们将Go视为其主要的编程语言。Go的优势如下:

  • 基于现实世界的经验
  • 专注于大型工程
  • 专注于可维护性
  • 保持简单明了
  • 使事情显式且明显
  • 很容易学习
  • 仅提供了一种做事方式
  • 支持简单地内置并发
  • 提供面向计算的语言原语
  • 使用OO – 好的部分
  • 拥有现代化的标准库
  • 强制执行标准化格式
  • 有一个非常快的编译器
  • 使交叉编译变得容易
  • 执行得非常快
  • 需要较小的内存占用
  • 部署规模小
  • 部署完全独立
  • 支持vendor依赖
  • 提供兼容性保证
  • 鼓励提供良好的文档
  • 商业支持的开源

请继续阅读有关上述每个优势点的更多详细信息。然而,在进入Go之前,你应该注意:

  • 不成熟的库
  • 即将到来的改变
  • 没有“硬实时”支持

简介

Go是Google开发的一种编程语言,在过去几年中取得了很大的成功。大部分现代云计算,网络和DevOps平台都是Go语言编写的,例如:DockerKubernetesTerraformETCDistio等。许多公司也将它用于通用软件开发。Go所具备的功能让这些项目吸引了大量用户,而Go的易用性也使得这些项目有了很多的贡献者。

Go的优势来自于简单和经过验证的想法的结合,同时避免了其他语言中出现的许多问题。这篇博客文章概述了Go背后的一些设计原则和工程智慧,并展示它们是如何结合在一起的 – 它们使Go成为下一代大型软件开发平台的优秀候选者。许多编程语言在个别领域都比较强大,但是在将所有领域都结合起来时,没有其他语言能够如此一致地“得分”,特别是在大型软件工程方面。

基于现实世界的经验

Go是由经验丰富的软件行业资深人士创建的,他们长期以来一直感受到现有语言的缺点带来的痛苦。几十年前,Rob PikeKen Thompson在Unix,C和Unicode的发明中发挥了重要作用。在实现了用于JavaScript和Java的V8和HotSpot虚拟机之后,Robert Griesemer在编译器和垃圾收集方面拥有着数十年的经验。在太多次的不得不等待他们的谷歌规模的C++/Java代码库的编译过程的推动下,他们开始着手创建一门新的编程语言,这门语言中凝聚了他们通过编写半个世纪代码过程中所学到的一切。

专注于大型工程

几乎任何编程语言都可以成功构建小型工程项目。当成千上万的开发人员在数十年的持续时间压力下在包含数千万行代码的大量代码库上进行协作时,真正痛苦的问题就会发生。这会导致以下问题:

  • 超长的编译时长会中断开发过程
  • 代码库由几个人/团队/部门/公司拥有,混合了不同的编程风格
  • 该公司雇佣了数千名工程师,架构师,测试人员,Ops专家,审计员,实习生等,他们需要了解代码库,但需要具有广泛的编码经验
  • 依赖于许多外部库或运行时,其中一些不再以其最初的形式存在
  • 每行代码在代码库的生命周期内平均被重写了10次,留下了疤痕,瑕疵和技术偏移
  • 文档不完整

Go专注于减轻这些大规模的工程难题,有时是以使小型工程变得更加繁琐为代价,例如在这里和那里需要一些额外的代码。

专注于可维护性

Go强调尽可能多地将工作转交到自动代码维护工具中。Go工具链提供了最常用的功能,如格式化代码和自动package导入、查找符号的定义和用法、简单的重构以及代码味道的识别。由于标准化的代码格式化和单一的惯用方式,机器生成的代码更改看起来非常接近Go中人为生成的更改。并而使用类似的模式,使得人和机器的协作更加无缝。

保持简单直接

初级程序员为简单问题创建简单的解决方案。高级程序员为复杂问题创建复杂的解决方案。伟大的程序员找到复杂问题的简单解决方案。-  查尔斯康奈尔

很多人都对Go不包含他们喜欢的其他语言概念感到惊讶。Go确实是一种非常小而简单的语言,只包含最少的正交和经过验证的概念。这鼓励开发人员以最少的认知开销编写最简单的代码,以便许多其他人可以理解并使用它。

使事情显式而明显

良好的代码是显而易见的,避免聪明,模糊的语言功能,扭曲的控制流和间接性。

许多语言都致力于使编写代码变得高效。然而,在其生命周期中,人们将花费大约(100倍)的时间阅读代码,而不是首先编写所需的代码。例如,审查,理解,调试,更改,重构或重用它。在查看代码时,通常只能看到并理解它的一小部分,通常没有对整个代码库的完整理解。为了解释这一点,Go将一切都显式化了。

一个例子是错误处理。让异常在各个点中断代码并使沿着调用链处理可能会更容易。Go需要手动处理或返回每个错误。这使得它可以准确地显示代码可以被中断的位置以及如何处理或包装错误。总的来说,这使得错误处理更容易编写,但更容易理解。

简单易学

Go非常小而且简单,可以在短短几天内研究整个语言及其基本概念。根据我们的经验,经过不超过一周的培训(与其他语言的以月为单位相比),初学者可以理解Go专家编写的代码,并为此做出贡献。为了方便大量人群,Go网站提供了所需的所有教程和深入的文章。这些教程在浏览器中运行,允许人们在将Go安装到本地计算机上之前学习和使用Go。

一种做事方式

Go语言通过个人自我表达赋予团队合作能力。

在Go(和Python)中,所有语言特征都是正交的并且彼此互补,通常做某事只有一种方法。如果您要求10位Python或Go程序员解决问题,您将获得10个相对类似的解决方案。不同的程序员在彼此的代码库中感觉更有家的感觉。在查看其他人的代码时,每分钟的WTF更少,而且人们的工作更好地融合在一起,从而形成一个人人都为之骄傲并且喜欢工作的一致性。这避免了大规模的工程问题,例如:

  • 开发人员将良好的工作代码视为“混乱”,并要求在他们可以使用之前重写它,因为他们不会像原作者那样思考。
  • 不同的团队成员在该语言的不同子集中编写相同代码库的部分内容。

img{512x368}
来源:https://www.osnews.com/story/19266/wtfsm

简单,内置并发

Go专为现代多核硬件而设计。

目前使用的大多数编程语言(Java,JavaScript,Python,Ruby,C,C ++)都是在20世纪80年代到2000年代设计的,当时大多数CPU只有一个计算核心。这就是为什么它们本质上是单线程的,并将并行化视为事后增加的边缘情况,通过诸如线程和同步点之类的附加组件实现,这些附加组件既麻烦又难以正确使用。第三方库提供了更简单的并发形式,如Actor模型,但总有多个选项可用,导致语言生态系统碎片化。今天的硬件拥有越来越多的计算内核,软件必须并行化才能在其上高效运行。Go是在多核CPU时代编写的,并且在语言中内置了简单,高级的CSP风格的并发特性。

面向计算的语言原语

在基础层面上,计算机系统接收数据,处理它(通常经过几个步骤),并输出结果数据。例如,Web服务器从客户端接收HTTP请求,并将其转换为一系列数据库或后端调用。一旦这些调用返回,它就会将接收到的数据转换为HTML或JSON并将其输出给调用者。Go的内置语言原语直接支持这种范例:

  • 结构体代表数据
  • reader和writer代表流式IO
  • 函数处理数据
  • goroutines提供(几乎无限制的)并发
  • 通道用于管理并发处理步骤之间的数据

由于所有计算原语都是由语言以直接的形式提供的,因此Go源代码可以更直接地表达服务器执行的操作。

OO – 好的部分

img{512x368}
在基类中改变某些东西的副作用

面向对象非常有用。这几十年OO的应用是富有成效的,并且让我们了解它的哪些部分比其他部分可以更好地扩展。基于这些认知,Go采用面向对象的新方法。它保留了封装和消息传递等优点。Go避免了继承,因为它现在被认为是有害的,Go为组合提供头等的支持

现代标准库

许多当前使用的编程语言(Java,JavaScript,Python,Ruby)是在互联网成为当今无处不在的计算平台之前设计的。因此,这些语言的标准库仅为未针对现代互联网优化的网络提供相对通用的支持。Go是十年前创建的,当时互联网已经全面展开。Go的标准库允许在没有第三方库的情况下创建更复杂的网络服务。这可以防止使用第三方库的常见问题:

  • 碎片化:实现相同功能的总有多种选择
  • 膨胀:库通常实现的不仅仅是它们的用途
  • 依赖地狱:库通常依赖于特定版本的其他库
  • 质量未知:第三方代码可能具有可疑的质量和安全性
  • 未知支持:第三方库的开发可以随时停止
  • 意外更改:第三方库通常不像标准库那样进行严格的版本管理

Russ Cox的更多背景信息。

标准化格式

Gofmt的风格是没有人喜欢的,但gofmt是每个人的最爱。 – Rob Pike

Gofmt是一种以标准化方式格式化Go代码的程序。它不是最漂亮的格式化方式,而是最简单,最不讨厌的方式。标准化的源代码格式化具有惊人的积极影响:

  • 重点讨论重要主题:它消除了围绕标签与空格,缩进深度,每行长度,空行,花括号放置等的一系列无意义的争论
  • 开发人员在彼此的代码库中感到宾至如归,因为其他代码看起来很像他们编写的代码。每个人都喜欢自由地按照自己喜欢的方式格式化代码,但如果其他人冒昧地按照他们自己喜欢的方式格式化>代码,那么每个人都讨厌它。
  • 自动代码更改不会弄乱手写代码的格式,例如通过引入意外的空白更改。

许多其他语言社区现在正在开发gofmt等价物。当构建为第三方解决方案时,通常会有几种竞争格式标准。例如,JavaScript世界提供PrettierStandardJS。可以一起使用其中之一或两者。许多JS项目都没有采用它们,因为这是一个额外的决定。Go的格式化程序内置于该语言的标准工具链中,因此只有一个标准,每个人都在使用它。

快速编译

img{512x368}
来源:https://xkcd.com/303

大型代码库的长编译时间是引发Go语言起源的一个微小的原因。Google主要使用C++和Java,与Haskell,Scala或Rust等更复杂的语言相比,它可以相对快速地编译。尽管如此,当编译大型代码库时,即使是少量的慢速也会把人激怒,编译工作流中断导致编译延迟。Go是从头开始设计的,以使编译更有效,因此编译器速度非常快,几乎没有编译延迟。这为Go开发人员提供了类似于脚本语言的即时反馈,并具有静态类型检查的额外好处。

交叉编译

由于语言运行时非常简单,因此它已被移植到许多平台,如macOS,Linux,Windows,BSD,ARM等。Go可以开箱即用于编译所有这些平台的二进制文件。这使得我们可以轻松地从一台机器来进行部署。

快速执行

Go有着接近C的速度。与JITed(即时编译)语言(Java,JavaScript,Python等)不同,Go二进制文件不需要启动或预热时间,因为它们作为已编译和完全优化的本机代码提供。Go垃圾收集器仅以微秒的指令引入可忽略的暂停。在其快速的单核性能上面,Go使得利用所有的CPU内核更容易

小内存占用

像JVM,Python或Node这样的运行时不仅仅在运行时加载程序代码。它们还会加载大型且高度复杂的基础架构,以便在每次运行时编译和优化程序。这使得它们的启动时间变慢并导致它们使用大量(数百MB)的RAM。Go进程的开销较小,因为它们已经完全编译和优化,只需要运行。Go还以非常节省内存的方式存储数据。这在内存有限且昂贵的云环境中以及在开发期间非常重要,在开发期间我们希望在单个机器上快速启动整个堆栈,同时为其他软件留下内存。

小部署规模

Go二进制文件的大小非常简洁。Go应用程序的Docker镜像通常比用Java或Node编写的等效文件小10倍,因为它不需要包含编译器,JIT,并且需要更少的运行时基础结构。这在部署大型应用程序时很重要。想象一下,将一个简单的应用程序部署到100个生产服务器上 使用Node / JVM时,我们的docker仓库必须提供100个docker镜像@ 200 MB = 20 GB(总共)。这需要镜像仓库耗费一些时间来服务。想象一下,我们希望每天部署100次。使用Go服务时,Docker镜像仓库只需提供100个Docker镜像@ 20 MB = 2 GB。可以更快,更频繁地部署大型Go应用程序,从而允许重要更新更快地实现生产。

自包含部署

Go应用程序部署为包含所有依赖项的单个可执行文件。不需要安装特定版本的JVM,Node或Python运行时。不必将库下载到生产服务器上。不需要对运行Go二进制文件的机器进行任何更改。甚至不需要将Go二进制文件包装到Docker中来共享它们。您只需将Go二进制文件拖放到服务器上,无论该服务器上运行的是什么,它都会在那里运行。上述描述的唯一例外是使用net和os/user包时的动态链接glibc库时。

vendor依赖关系

Go故意避免使用第三方库的中央存储库。Go应用程序直接链接到相应的Git存储库,并将所有相关代码下载(vendor保存)到他们自己的代码库中。这有很多好处:

  • 我们可以在使用之前查看,分析和测试第三方代码。此代码与我们自己的代码一样,是我们应用程序的一部分,应符合相同的质量,安全性和可靠性标准。
  • 无需永久访问存储依赖项的各个位置。可以一次性的从任何地方(包括私人Git仓库)获取您的第三方库,并永久拥有它们。
  • 在checkout后编译代码库不需要进一步下载依赖项。
  • 如果互联网上某处的代码存储库突然提供不同的代码,也不会造成surprises。
  • 即使软件包存储库服务性能变慢或托管软件包不再存在,部署也不会中断。

兼容性保证

Go团队承诺,现有的程序将继续适用于新版本语言。这使得即使是大型项目也可以轻松升级到更新编译器的版本,并从新版本带来的许多性能和安全性改进中受益。同时,由于Go二进制文件包含了他们需要的所有依赖项,因此可以在同一服务器计算机上并行运行使用不同版本的Go编译器编译的二进制文件,而无需进行复杂的设置多个版本的运行时或虚拟化。

文档

在大型工程中,文档对于使软件易于访问和维护非常重要。与其他功能类似,Go中的文档简单实用:

  • 它嵌入在源代码中,因此两者可以同时维护。
  • 它不需要特殊的语法 – 文档只是普通的源代码注释。
  • 可运行的单元测试通常是最好的文档形式,所以Go允许你将它们嵌入到文档中
  • 所有文档实用程序都内置在工具链中,因此每个人都使用它们。
  • Go linter需要导出元素的文档,以防止“文档债务”的积累。

商业支持的开源

当商业实体在公开场合发展时,一些最流行和最全面设计的软件就会发生。这种设置结合了商业软件开发的优势 – 一致性和优化,使系统健壮,可靠,高效 – 具有开放式开发的优势,如来自许多行业的广泛支持,来自多个大型实体和许多用户的支持,以及长期支持,即使商业支持停止。Go就是这样开发的。

缺点

当然,Go并不完美,每种技术选择总是有利有弊。在进入Go之前,这里有一小部分需要考虑的方面。

未成熟

虽然Go的标准库在支持HTTP/2服务器推送等许多新概念方面处于行业领先地位,但与JVM生态系统中存在的相比,用于外部API的第三方Go库可能还不那么成熟。

即将到来的变化

Go团队知道几乎不可能改变现有的语言元素,因此只有在完全开发后才会添加新功能。在经历了10年稳定的故意阶段后,Go团队正在考虑对语言进行一系列更大的改进,作为Go 2.0之旅的一部分。

没有硬实时

虽然Go的垃圾收集器只引入了非常短的中断,但支持硬实时需要没有垃圾收集的技术,例如Rust。

结论

这篇博客文章给出了一些明智的背景知识,但往往没有那么明显的选择进入Go的设计,以及当他们的代码库和团队成数量级增长时,他们将如何从许多痛苦中拯救大型工程项目。总的来说,他们将Go定位为寻求Java之外的现代编程语言的大型开发项目的绝佳选择。


我的网课“Kubernetes实战:高可用集群搭建、配置、运维与应用”在慕课网上线了,感谢小伙伴们学习支持!

我爱发短信:企业级短信平台定制开发专家 https://51smspush.com/
smspush : 可部署在企业内部的定制化短信平台,三网覆盖,不惧大并发接入,可定制扩展; 短信内容你来定,不再受约束, 接口丰富,支持长短信,签名可选。

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

我的联系方式:

微博:https://weibo.com/bigwhite20xx
微信公众号:iamtonybai
博客:tonybai.com
github: https://github.com/bigwhite

微信赞赏:
img{512x368}

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

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! 图片广告位1 图片广告位2 图片广告位3 商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats