python和go前景

为什么 Stream 这家公司要从 Python 迁移到 Go？他们看中 Go 语言的哪些特性？

Stream 最近将其后端核心服务从 Python 改成了 Go。虽然他们的某些模块仍然在使用 Python，但是公司已决定从现在开始使用 Go 来编写对性能要求较高的代码。文中，Stream 的 CEO 兼创始人 Thierry Schellenbach 将解释他们决定转向 Go 的原因。

影响项目或者产品编程语言选型的因素有很多。与任何技术决策一样，选择编程语言时同样需要多方面权衡，即使这样，最终的选择结果都很难是完美的。我们最近将后端的核心服务从 Python 改成了 Go，原因有很多，好处也很多。

为了理解这一变化的重要性，需要先了解我们的产品。Stream 是一套用于构建、伸缩、定制化新闻源和活动流的 API。每个月为 3 亿多用户提供约 10 亿次 API 请求。我们尤其关注性能和可靠性，这两点因素决定了我们制定的每项技术决策。

下面容大教育为大家介绍一下Go语言的五大特性

1、性能更优

Go 最大的卖点在于它的性能，无论在运行还是编译时它都有突出的性能优势。它与 Java 或者 C++ 的运算速度几乎相当。在实际使用中，我们发现它比 Python 大约快 30 倍。

选择快速工具对提升系统性能非常重要，因此我们对 Cassandra、PostgreSQL、Redis 以及其他一些技术进行了优化。然而，很多时候我们发现系统仍然存在瓶颈，而瓶颈正好在于我们的编程语言 Python。Python 在执行序列化、排序和聚合等计算密集型任务时需要花费很长的时间，有时比从网络上存取和检索数据花费的时间更长。我们知道这个时间是可以优化的。从 Python 切换到 Go 就可以缩短时间，这样一来，应用程序代码就更像是服务之间的粘合剂，而不再是优化中的主要瓶颈。

用 Go 编写的 Go 编译器也非常快。Stream 中最复杂的微服务就采用 Go 编写，它的编译时间仅仅需要 6 秒，Java 和 C++ 等工具链则慢得多，快则一分钟，慢则数小时。

2、名副其实的简单

简单是 Go 的重要特征！我敢向你保证，阅读 Go 语言的代码明显感觉更加简单。我们已经从多个 Python 代码库中迁移出来，我们发现这些 Python 代码的风格和框架会因为作者的不同而风格各异，往往带有很多作者个性化的东西。而 Go 恰恰相反，它推崇干净的代码风格，同时要求作者编写代码时严格遵守规范，禁止作者“自作聪明”。虽然这样有时候会使用更加冗长的代码，牺牲了代码的简洁性，但是却让代码更容易阅读和理解了。这样一来，Go 才得以加快开发人员阅读他人代码的速度，同时，阅读自己曾经编写的代码也更容易。

3、原生并发性

Go 在语言层面通过 goroutine 和 channel 支持了并发。此概念源自 Tony Hoare 的 CSP 模式，它让程序员处理并发变得不再困难。

goroutine 类似于操作系统的线程，但其运行消耗的系统资源更小，每个 goroutine 仅需几 KB 的堆栈空间。Go 运行时可以在操作系统线程之上处理多路 goroutine。虽然在后台执行，但它对于程序员来说是可见的。单个程序拥有数千个 goroutine 也并不罕见。比如，net/http 软件包中的服务器程序针对每个 HTTP 请求都会创建一个 goroutine。

在 Go 中启动 goroutine 非常简单，只需通过 go 关键字添加一个函数调用，即可启动一个 goroutine，并让该函数运行在自己的 goroutine 中。

Go 有一句重要的格言，即：不要通过共享内存来通信，相反，通过通信来共享内存 。Goroutine 之间通过 channel 进行通信，channel 的使用方法与 goroutine 一样简单。Channel 拥有类型，可以通过直观的箭头语法轻松实现 goroutine 之间的数据传递。尽管 channel 使用简单，但是其功能非常强大。在设计时只要预先稍作考虑，与传统的系统相比，使用 Go 便能够轻而易举地开发大规模并发系统。

使用简单的并发工具可以解决那些经常导致错误的问题。Go 内置了竞态条件检测器，可以更轻松地检测异步代码中的竞争状态。

4、语言生态

跟 C++ 和 Java 这样已经高度普及的传统语言相比，Go 仍然是编译语言领域的新手。虽然目前大约只有 5％的程序员知道 Go，但是得益于它的易用性，这个数字在不断增长。虽然 Go 语言速度快且功能强，但它只有 25 个保留字。相比于 C++ 的 92 个保留字，以及 Java 的 53 个保留字，Go 显得非常简洁。过多的保留字会增加程序员的学习成本。

由于 Go 上手非常容易，因此组建 Go 开发团队相比其他语言来说更容易。Go 初学者可以很快入门并精通该语言。这使得雇主甚至可以招聘其他背景的开发人员，然后加以短期培训即可使其成为合格的 Go 工程师。

Go 提供的内置库开箱即用且功能强大。使用“net/http”仅需几行代码即可实现 HTTP 服务器，并且还支持 http/2、TLS 和 websocket。Go 社区软件包的生态系统也很出色，已经出现了很多与 Redis、RabbitMQ、PostgreSQL、模板以及 RocksDB 相关的库，它们运行稳定且更新频繁。

5、其他优势

在前文中我提到了 Go 并不鼓励程序员“自作聪明”，它并没有提供可能会节省时间的功能，比如可嵌套的三元运算符。

Go 采用另一种方式来节省时间，它既没有选择制表符也没有选择空格，而是转而使用了 gofmt。它是一种命令行工具，可与大多数编辑器集成并自动将代码格式化为特定的格式。即使格式不正确代码仍会编译，但是拉取请求会被忽略，除非代码通过 gofmt 并且能够保持整个代码库格式一致。这使得代码评审人员能够专注在代码上，而不必在格式上浪费时间。

Go 有助于开发微服务。谷歌的 protobuf 和 gRPC 是微服务间通信的基础，Go 对它们提供了很好的支持。作为开发人员，我们只需在清单文件中定义一项服务，工具便会自动生成客户端和服务器端代码，并且保证代码的高性能以及很低的网络负载。此外，清单文件还可以被其他语言用来生成他们自己的客户端和服务器端代码。所以，如果我们决定用其他技术来替代部分架构，之后的任务会更加简单。

Python vs. Go

Stream 服务强大功能之一是 feed 排名。feed 排名允许我们的用户为 feed 指定一个评分函数，以便控制排序方式。评分算法可以提供很多变量来确定排名，其中基于流行度的一个例子可能是这样的：

为了支持这种排名方法，Python 和 Go 代码都需要解析表达式计算得分。在这种情况下，我们需要将字符串 “ simple_gauss（time）* popular ” 变成一个函数，它将活动数据作为输入，并输出分数。基于 JSON 配置创建部分功能。例如，我们希望“simple_gauss”以五天的时间窗、一天的偏移量以及 0.3 的衰减因子来调用“decay_gauss”。解析“默认”配置，以便在活动数据中发现未定义的字段时进行回退。使用步骤 1 中的功能对 feed 中的所有活动数据进行评分。

开发 Python 版本的排名代码需要花费大约三天时间，包括编写代码、单元测试和编写文档。接下来，团队需要大约两周的时间来优化代码。其中一项优化是将分数表达式 （simple_gauss（time）* popular ）转换为抽象语法树。该团队还实施了高速缓存逻辑，预先计算了将来某些时间的分数。

相比之下，开发这些代码的 Go 版本大约花费了四天时间，并且不需要再对其性能实施进一步的优化。虽然 Python 用来开发初期版本更快，但是整体来说使用 Go 开发的工作量要小得多。

Go 的语言特性使得在优化代码时能够节省大量的时间。使用 Python 时，我们不得不将表达式解析为抽象语法树，并优化和剖析每一个函数。由于 Go 比 Python 快得多，因此我们不需要花太多精力优化代码。最终的结果是，Go 代码的执行速度比精心优化的 Python 代码大约快 40 倍。

用 Go 来构建 Stream 系统中的某些组件相比用 Python 花费了更多的时间。总体来说，开发 Go 代码要花费更多的精力，但团队用来优化代码性能的时间则更少。

结 论

Go 非常适用于开发微服务。它的速度非常快，具有原生并发原语，完美支持多种现有工具，并且开发起来乐趣无穷。与 Ruby 或 Python 等脚本语言相比，编写 Go 代码可能需要更长的时间，但其维护成本要低得多，加之其代码无需太多优化，因此你可以节省大量的时间。

需要注意的是，对于某些适合使用 Python 开发的模块，Stream 仍然使用 Python。例如，我们的仪表板、网站以及用于个性化订阅的机器学习都使用 Python 实现，因为 Python 提供的这些工具更好用。我们不会马上完全弃用 Python，但是对于性能要求较高的代码，我们今后会使用 Go 来编写。

以下问题讨论：

你认为 Stream 进行迁移的理由充分吗？在你看来，Go 语言哪些特性相比 Python 是更受你推崇的？既然 Python 有诸多不足，为什么它最近反而还越来越火了？

欢迎在文章底部留言，大家一起讨论。

机器之心整理

机器之心编辑部

Go 语言在工业上有非常多的应用，包括分布式系统和云计算平台等。而 Go 语言并行性能高、部署方便和简单便捷等特性令其在一些应用上超过了 Python，机器之心也曾讨论过由 Python 转向 Go 的 9 大原因。近日在 Go 语言的开发峰会上，谷歌发布了 Go 2 的设计草案，包括对泛型、错误处理和错误值语义等发展的讨论。

在昨天的 Go contributor 年度峰会上，与会者对错误处理和泛型的设计草案有了一个初步的了解。Go 2 的开发项目是去年宣布的，今天谷歌公布了这一语言的更新。

欲快速了解相关内容，请看谷歌在 Gophercon 2018 上播放的视频：

作为 Go 2 设计进程的一部分，谷歌发布了这些设计草案，以激发社区关于以下三个话题的讨论：泛型（generics）、错误处理和错误值语义（error value semantics）。

这些设计草案不算 Go 提案流程意义上的提案。它们只是激发讨论的引子，最终目的是给出足够好的设计并将其转变为实际提案。每种设计草案都附带一个「问题概述」，其作用是：（1）提供语境；（2）为包含更多设计细节的实际设计文档做准备；（3）推动关于设计框架和说明的讨论。问题概述会提供背景、目标、非目标、设计约束、设计的简要总结、对重点关注领域的简短讨论以及与先前方法的比较。

再次重申，这些只是设计草案，不是官方提案。现在没有相关提案事宜。谷歌希望 Go 的所有用户都能够帮助其改进草案并将草案完善为 Go 提案。为此，谷歌创建了一个 wiki 页面来收集并组织关于每个话题的反馈。谷歌希望用户帮助其更新这些页面，包括添加用户自己的反馈链接。

简介

本概览及附带的细节草案是《Go 2 设计草案》（Go 2 Draft Designs）文档的一部分。Go 2 的总体目标是为 Go 无法扩展到大型代码库和大量开发人员这一问题提供最重要的解决方式。

Go 编程无法成功扩展的一大原因在于错误检查和错误处理代码的编写。总体来看，Go 编程代码检查错误太多，但处理这些错误的代码却非常不足（下文将给出解释）。该设计草案旨在通过引入比当前惯用的「赋值和 if 语句」（assignment-and-if-statement）组合更轻量级的错误检查语法来解决这个问题。

作为 Go 2 的一部分，谷歌还考虑对错误值的语义进行更改，这是一个单独的关注点，但是本文档仅涉及错误检查和处理。

在 Go 开源之前，Go 团队成员——尤其是 Ian Lance Taylor——就一直在研讨「泛型」的可能设计（即参数多态，parametric polymorphism）。谷歌从 C++ 和 Java 的经验中得知，这一话题非常丰富、复杂，要想考虑透彻并设计出一个良好的解决方案将花费很长时间。谷歌一开始并没有尝试这一做法，而是将时间花在了更直接适用于 Go 网络系统软件（现在的「云软件」）这一初始目标的功能上，例如并发性、可扩展构建和低延迟垃圾收集。

Go 1 发布之后，谷歌继续探索泛型的多种可能设计。2016 年 4 月，谷歌发布了这些早期设计（https://go.googlesource/proposal/+/master/design/15292-generics.md#）。作为 Go 2 再次进入「设计模式」的一部分，Go 团队再次尝试探索泛型的设计，希望泛型能与 Go 语言融合，为用户提供足够的灵活性和表达性。

在 2016 和 2017 年的 Go 用户调查中，某种形式的泛型是最迫切的两个功能需求之一（另一个是包管理）。Go 社区维护一份「Go 泛型讨论摘要」（Summary of Go Generics Discussions）文档。

许多人错误地以为 Go 团队的立场是「Go 永远不会有泛型」。但这并非事实，谷歌知道泛型的潜力，它能让 Go 更加灵活、强大、复杂。如果要增加泛型，谷歌想在尽量不增加 Go 复杂度的前提下努力提高其灵活度，并使其更加强大。

错误处理：问题概览

为了扩展至大型代码库，Go 程序必须是轻量级的，没有不适当的重复，且具备稳健性，能够优雅地处理出现的错误。

在 Go 的设计中，我们有意识地选择使用显性的错误结果和错误检查。而 C 语言通常主要使用对隐性错误结果的显性检查，而很多语言（包括 C++、C#、Java 和 Python）中都出现的异常处理表示对隐性结果的隐性检查。

目标

对于 Go 2，我们想使错误检查更加轻量级，减少用于错误检查的 Go 程序文本量。我们还想更加方便地写处理错误的程序，提高编程人员处理错误的可能性。

错误检查和错误处理必须是显性的，即在程序文本中可见。我们不想重复异常处理的缺陷。

现有代码必须能够继续运行，且和现在一样有效。任何改变都必须能够实现对现有代码的互操作。

如前所述，该设计的目标不是改变或增强错误的语义。

错误值：问题概览

大程序必须能够以编程的方式测试错误和作出反应，还要报告这些错误。

由于错误值是实现 error 接口的任意值，Go 程序中有四种测试特定错误的传统方式。一，程序可以使用 sentinel error（如 io.EOF）测试它们的等价性。二，程序能够使用 Type assertions 或 type switch 检查错误实现类型。三，点对点检查（如 os.IsNotExist）检查特定种类的错误，进行有限的解包。四，由于当错误被封装进额外的上下文中时，这些方法通常都不奏效，因此程序通常在 err.Error() 报告的错误文本中进行子字符串搜索。很明显，最后一种方法最不可取，即使是在出现任意封装的情况下，支持前三种方法更好。

目标

我们有两个目标，分别对应两个主要问题。一，我们想使检查程序错误的过程更加简单，出现的错误更少，从而改善错误处理和真实程序的稳健性。二，我们想以标准格式打印出具备额外细节的错误。

任何解决方案必须能够使现有代码正常运行，且适合现有的源树。尤其是，必须保留使用 error sentinel（如 io.ErrUnexpectedEOF）对比是否相等以及测试特定种类的错误这些概念。必须继续支持现有的 error sentinel，现有代码不必改变成返回不同错误类型。即扩展函数（如 os.IsPermission）来理解任意封装而不是固定集是可行的。

在考虑打印额外错误细节的解决方案时，我们偏好于使用 golang.org/x/text/message 使定位和翻译错误成为可能，或至少避免不可能。

包必须继续轻松定义其错误类型。定义新的通用「真实错误实现」是不可接受的，且使用这种实现需要所有代码。对错误实现添加很多额外要求也是不可接受的，这些错误实现只涉及到几个包。错误还必须能够高效创建。错误并非异常。在程序运行期间，生成、处理、丢弃错误都是很平常的事。

很多年前，谷歌一个用基于异常（exception-based）的语言写的程序被发现一直生成异常。最后发现，深层嵌套堆栈上的函数尝试打开文件路径固定列表中的每个路径去寻找配置文件。每个失败的打开操作就会导致一个异常；异常的生成浪费了大量时间记录这个深层执行堆栈；之后调用器丢弃了所有这些工作，继续进行循环。在 Go 代码中错误的生成必须保持固定的开销，不管堆栈深度或其他语境如何。（延迟的处理程序在堆栈解开之前运行也是由于同样的原因：关心堆栈上下文的处理程序能够检查活跃的堆栈，无需昂贵的 snapshot 操作。）

泛型：问题概览

为了推广 Go 语言的大型代码库和开发者的贡献，提高代码的复用性就显得非常重要。实际上，Go 语言早期的关注点只是确保能快速构建包含很多独立软件包的程序，因此代码的复用成本并不是很高。Go 语言的关键特征之一是它的接口方式，这种方式同样也直接定位于提高代码复用性。具体来说，这种接口可以写一个算法的抽象实现，从而消除不必要的细节。例如，container/heap 在 heap.Interface 操作上以普通函数的方式提供了堆维护（heap-maintenance）的算法，这使得 container/heap 适用于任何备用储存，而不仅仅只是一些值。接口的这些属性令 Go 非常强大。

与此同时，大多数希望获取优先级序列的编程器并不希望为算法实现底层存储，然后再调用堆算法。这些编程器更愿意让实现自行管理它的数组，但是 Go 不允许以 type-safe 的方式表达它。最接近的是创建 interface{} 值的优先序列，并在获取每一个元素后使用类型断言。

多态变成不仅仅是数据容器。我们可能希望将许多通用算法实现为朴素的函数，它们能应用各种类型，但是我们现在在 Go 中写的函数都只能应用于单个类型。泛型函数的示例可能为如下：

// Keys returns the keys from a map.func Keys(m map[K]V) []K// Uniq filters repeated elements from a channel,// returning a channel of the filtered data.func Uniq(<-chanT) <-chanT// Mergemergesalldatareceivedonanyofthechannels,// returningachannelofthemergeddata.funcMerge(chans...<-chanT) <-chanT// SortSlicesortsasliceofdatausingthegivencomparisonfunction.funcSortSlice(data []T, lessfunc(x, yT) bool)目标

谷歌的目标是通过带有类型参数的参数多态性来解决 Go 语言库的编写问题，这些问题抽象出了不必要的类型细节（如上所述）。

除了预料之中的容器类型外，谷歌还希望能编写有用的库来操作任意的 map 和 channel 值，理想的方案是编写能在 []byte 和 string 值上运算的多态函数。

允许其它类型的参数化并不是谷歌的目标，例如通过常数值进行参数化等。此外允许多态定义的专有化实现也不是目标，例如使用比特包装（bit-packing）定义一个通用的 vector 和特定的 vector。

我们希望能从 C++和 Java 的泛型问题中学习经验。为了支持软件工程，Go 语言的泛型必须明确记录对类型参数的约束，以作为调用者和实现之间的明确强制协议。但调用者不满足这些约束或实现本身就超出了约束时，编译器报告明确的错误也非常重要。

在没有棘手的特殊情况和没有暴露实现细节的前提下，Go 语言里的多态性必须平滑地适应到环境语言中。例如，将类型参数限制到机器表征为单个指针或单个词汇的情况中是不可接受的。还有另一个例子，一旦以上考虑的通用 Keys(map[K]V) []K 函数被初始化为 K=int 和 V=String，它必须和手写的非泛型函数在语义上同等地处理。特别是，它必须可分配给类型变量 func(map[int]string) []int。

Go 语言中的多态性应该要在编译时和运行时实现，因此用于实现策略的决策还可以用于编译器，并与其它任何编译器优化一视同仁。这种灵活性将解决泛型困境。Go 语言在很大程度上都是一种直观且易于理解的语言，如果我们要添加多态性，就必须保留这一点。

参考内容：

https://go.googlesource/proposal/+/master/design/go2draft.md

https://news.ycombinator/item?id=17859963

转向一门新的语言不是个容易的决定,尤其是当你要抛弃的是如日中天的Python。那么这次要给大家安利的新欢是谁呢?

【IT168 资讯】Stream公司最近将其核心服务的后端从Python切换成了Go，虽然他们内部还在使用Python，但是公司已经决定从现在开始在Go中编写所有性能密集型代码。本文，Stream首席执行官和创始人Thierry Schellenbach解释了公司的这一决定。

选择项目或产品的编程语言会受到许多因素驱动，与所有技术决策一样，没有完美的答案足以解决所有问题。Stream之所以这么做，是因为感受到了Go语言的巨大好处。

这与Stream的产品有关。Stream是用于构建，缩放、个性化新闻源和活动流的API。每月为3亿多用户提供约10亿次API请求。因此，性能和可靠性是Stream制定每项技术决策的最重要原因。

Python和GO：性能对比!

Go最大的卖点可能就是性能，无论是运行时间还是编译时间。它在大多数计算基准测试中与Java或C ++相当。在Stream的实际使用中，GO比Python快大约30倍。

选择性能优秀的工具非常重要(Stream已经优化了Cassandra，PostgreSQL，Redis和许多其他技术)。然而，有时发现系统中的瓶颈确实是Python引起的，像序列化，排序和聚合等计算繁重的任务有时会比从网络数据存储检索数据花费更长的时间。

Go编译器(本身是用Go编写的)也非常快。使用Go编写的Stream中最复杂的微服务只需要6秒即可编译完成，与Java和C ++等工具链相比，这是一个重大胜利。

此外，阅读Go语言代码往往非常简单，GO干净的风格让读取和推理更容易。

本地并发

通过goroutines和channel将并发性融入到语言中。Goroutines在概念上类似于操作系统线程，但非常便宜——每个成本只有几KB的堆栈空间。Go运行时可以处理智能多路复用goroutines，这一切对程序员来说是透明的。单个程序拥有数千个goroutines并不罕见。例如，net / http软件包中的服务器为每个传入的HTTP请求创建一个goroutine。

在真正的Go语言中，goroutine非常简单：只需在“go”关键字前添加一个函数调用，让它运行在自己的goroutine中即可。

Go世界的传统观点是“不通过共享内存来交流，相反的是，通过通信来共享内存“。在goroutines之间进行通信的原语是channel，它们与goroutines一样易于使用。channel有一个类型，可以通过直观的箭头语法轻松地在goroutine之间传递数据。虽然简单，但channel非常强大。通过预先考虑，与传统系统相比，制作大规模并发系统是一件轻而易举的事情。

使用简单的并发工具，可以解决那些经常导致错误的复杂问题。Go随附内置竞速检测器，可以更轻松检测异步代码中的竞争状态。

生态系统

Go仍然是编译语言环境的新手，远比不上C ++和Java等传统语言的普及程度。虽然只有大约5%的程序员知道Go，但是这个数字还在不断增长，而且这种增长是由于语言的易用性所致。虽然语言快速且功能强大，但该语言只有25个保留字(与C ++ 92或Java 53相比)，对于大多数开发人员来说，它只会引入很少的新概念。

建立一个Go开发团队比大多数语言更容易，因为它更容易学习。

随Go提供的内置库在开箱即用，功能强大。使用`net / http`包制作HTTP服务只需要几行代码，并且本地支持http / 2，TLS和websocket等。社区软件包的生态系统也很出色，适用于Redis，RabbitMQ，PostgreSQL和RocksDB等。

其他福利

Go节省时间的另一种方式是使用Gofmt。它是一个命令行工具，可与大多数编辑器集成并自动将代码格式化为事实标准。如果格式不正确，代码仍会编译，但除非通过gofmt运行代码以保持整个代码库格式一致，否则将不会查看pull请求。这使代码审查人员能够专注于代码而不是花时间挑剔格式。

Go有助于开发微服务架构，gRPC和Google的协议缓冲区是管理微服务之间通信的好方法，Go有一流的支持。

Python与Go

Stream服务中的一个强大功能是排名提要。排名提要允许用户为提要指定一个评分函数，以便控制提取时的排序方式。评分算法可以提供很多变量来确定排名，但基于流行度的一个很好的例子可能是这样的：

1.要支持这种排名方法，Python和Go代码都需要：

解析分数的表达式。在这种情况下，我们想将字符串“simple_gauss(time)* popular”变成一个函数，它将一个活动作为输入并返回一个分数作为输出。

2.根据JSON配置创建部分函数。例如，我们希望“simple_gauss”以五天的刻度，一天的偏移量和0.3的衰减因子来调用“decay_gauss”。

3.如果在活动中没有定义某个字段，则应对“默认值”配置进行压缩，以便进行回退。

4.使用步骤1中的功能对Feed中的所有活动进行评分。

开发Python版本的示例花了大约三天的时间编写代码，单元测试和文档。接下来，团队花了大约两周的时间来优化代码。其中一项优化是将分数表达式(simple_gauss(time)* popular)转换为抽象语法树。该团队还实施了高速缓存逻辑，预先计算了将来某些时间的分数。

相比之下，开发此代码的Go版本需要大约四天的时间，并且性能不需要任何进一步的优化。虽然Python的开发初期看来更快，但Go版本最终需要的工作量大大减少。

在优化代码库时节省的时间归功于Go语言的特点。使用Python，程序员不得不将表达式解析为抽象语法树，并优化/剖析通过排名公开的每个函数。

结论

Go是编写微服务的伟大语言。它的速度非常快，具有原生并发原语，对现有工具的卓越支持，并且开发起来非常有趣。与Ruby或Python等脚本语言相比，Go语言可能需要更长的时间，但维护成本要低得多，而且将节省大量时间优化代码。

重要的是，Stream仍然在使用Python，它是有意义的。例如，仪表板，网站和个性化订阅源的机器学习使用Python，因为工具更好。Stream不会马上告别Python，但是今后会在Go中编写所有性能密集型代码。

　　2017 年上半年哪家编程语言流行呢?当然非Python莫属，Python可是今年上半年最流行的语言。

　　根据IEEE Spectrum 的记者挖掘的数据，由10 个在线来源组合了 12 种指标给 48 种语言进行排名，结果评出了2017 年十大流行编程语言。如下图所示:

　　不难看出，Python、C、Java 和 C++是目前非常流行的语言。需要提及的是，被 Swift 取代的 Objective-C 排名下降至26 名。

　　不过，我们仍然可以看到“世界上最好的语言”PHP排名也是比较靠前。

　　1、为什么Python成为最流行的语言?

　　Python起源于一种脚本语言，用于科学计算，如今是越来越流行起来，向Web和商业等技术领域不断地渗透。这些技术领域可是由一些大公司(Java，C#，C++)在背后推动，有大量的资金支持。

　　同样的，在web方面，PHP和Ruby也名噪一时。

　　而以开发工程师的角度看来，Python 的优雅和简洁无疑是最大的吸引力。

　　对于运维工程师而言，用 Python 替代让人痛苦的 Shell，做一些复杂的任务，可以说是一种解放。不会Python的运维工程师，有可能就会被淘汰。

　　2、关于其他的一些语言的流行趋势

　　最近报道，Java被斯坦福大学定为入门语言，主要是因为这个编程语言已经“老化”。

　　所以，会用JavaScript代替Java。但是，IEEE Spectrum 2017最新的研究报告，Java仍然是招聘者中最受欢迎的技能之一。

　　此外，Go 语言今年一路飙升，本月终于进入前10名，2016年同期可是才55名。为何GO语言有如此之快的增长速度呢?这或许跟大数据人工智能发展趋势有关。

　　因此，照目前各大流行趋势看来,GO语言具有相当大的潜力。如果Go 语言一直保持上升势头的话，那么在2017年，Python 和java两大明星语言有望和GO语言成为本年度最流行语言。

点击上方“ CSDN ”，选择“置顶公众号”

关键时刻，第一时间送达！

你知道我们一共有多少种编程语言吗？

根据维基百科数据统计（ https://en.wikipedia.org/wiki/List_of_programming_languages ），一共有 600 余种不同的编程语言。对于五花八门的开发语言，每门语言都有自己的优缺点。而励志成为一名博学多广的开发者，术业也有专攻，怎奈何也不会学习完百余种语言。

在这些语言中，Java 作为 22 年的常青藤，无论是新爆发的 Kotlin 还是 C、C++、Python、JavaScript 等老牌语言想要在短期之间撼动其地位也是不大现实，相信这一点毋庸置疑。吃完I安从近几个月的 TIOBE 编程语言排行榜来看，继 Java 之后，C、C++、C# 使用率虽有所下降，但依旧稳坐排行榜的前五名。

除了以上四种头牌语言，还有一种即 Python（蟒蛇）。随着人工智能、物联网、数据科学等领域的兴起，Python 迅速升温，成为诸多开发者的首选入门语言。然而就在一片追随声中，不少开发者从 Python 转向了 Go 语言，这究竟是什么原因？接下来，来自 Stream 团队的 Thierry Schellenbach 给出了九大理由，并对比了 Python，解析优缺点，希望对更多的开发者有所助益。

为什么开始使用 Go 语言？

原因 1 ——性能

Go 极其地快，其性能与 Java 或 C++ 相似。在我们的使用中，Go 一般比 Python 要快 30 倍。以下是 Go 与 Java 之间的基准比较：

原因 2：语言性能很重要

对很多应用来说，编程语言只是简单充当了其与数据集之间的胶水。语言本身的性能常常无关轻重。

但是 Stream 是一个 API 提供商，服务于世界 500 强以及超过 2 亿的终端用户。数年来我们已经优化了 Cassandra、PostgreSQL、Redis 等等，然而最终抵达了所使用语言的极限。

Python 非常棒，但是其在序列化／去序列化、排序和聚合中表现欠佳。我们经常会遇到这样的问题：Cassandra 用时 1ms 检索了数据，Python 却需要 10ms 将其转化成对象。

原因 3：开发者效率&不要过于创新

看一下绝佳的入门教程《开始学习 Go 语言》（http://howistart.org/posts/go/1/）中的一小段代码：

package main

type openWeatherMap struct{}

func (w openWeatherMap) temperature(city string) (float64, error) {

resp, err := http.Get("http://api.openweathermap.org/data/2.5/weather?APPID=YOUR_API_KEY&q=" + city)

if err != nil {

return 0, err

}

defer resp.Body.Close()

var d struct {

Main struct {

Kelvin float64 `json:"temp"`

} `json:"main"`

if err := json.NewDecoder(resp.Body).Decode(&d); err != nil {

log.Printf("openWeatherMap: %s: %.2f", city, d.Main.Kelvin)

return d.Main.Kelvin, nil

如果你是一个新手，看到这段代码你并不会感到吃惊。它展示了多种赋值、数据结构、指针、格式化以及内置的 HTTP 库。

当我第一次编程时，我很喜欢使用 Python 的高阶功能。Python 允许你创造性地使用正在编写的代码，比如，你可以：

在代码初始化时，使用 MetaClasses 自行注册类别

置换真假

添加函数到内置函数列表中

通过奇妙的方法重载运算符

毋庸置疑这些代码很有趣，但也使得在读取其他人的工作时，代码变得难以理解。

Go 强迫你坚持打牢基础，这也就为读取任意代码带来了便利，并能很快搞明白当下发生的事情。

注意：当然如何容易还是要取决于你的使用案例。如果你要创建一个基本的 CRUD API，我还是建议你使用 Django + DRF，或者 Rails。

原因 4：并发性&通道

Go 作为一门语言致力于使事情简单化。它并未引入很多新概念，而是聚焦于打造一门简单的语言，它使用起来异常快速并且简单。其唯一的创新之处是 goroutines 和通道。Goroutines 是 Go 面向线程的轻量级方法，而通道是 goroutines 之间通信的优先方式。

创建 Goroutines 的成本很低，只需几千个字节的额外内存，正由于此，才使得同时运行数百个甚至数千个 goroutines 成为可能。你可以借助通道实现 goroutines 之间的通信。Go 运行时间可以表示所有的复杂性。Goroutines 以及基于通道的并发性方法使其非常容易使用所有可用的 CPU 内核，并处理并发的 IO——所有不带有复杂的开发。相较于 Python/Java，在一个 goroutine 上运行一个函数需要最小的样板代码。你只需使用关键词「go」添加函数调用：

import (

"fmt"

"time"

)

func say(s string) {

for i := 0; i < 5; i++ {

time.Sleep(100 * time.Millisecond)

fmt.Println(s)

func main() {

go say("world")

say("hello")

https://tour.golang.org/concurrency/1

Go 的并发性方法非常容易上手，相较于 Node 也很有趣；在 Node 中，开发者必须密切关注异步代码的处理。

并发性的另一个优质特性是竞赛检测器，这使其很容易弄清楚异步代码中是否存在竞态条件。下面是一些上手 Go 和通道的很好的资源：

https://gobyexample/channels

https://tour.golang.org/concurrency/2

http://guzalexander/2013/12/06/golang-channels-tutorial.html

https://golang-book/books/intro/10

https://goinggo/2014/02/the-nature-of-channels-in-go.html

原因 5：快速的编译时间

当前我们使用 Go 编写的最大微服务的编译时间只需 6 秒。相较于 Java 和 C++呆滞的编译速度，Go 的快速编译时间是一个主要的效率优势。我热爱击剑，但是当我依然记得代码应该做什么之时，事情已经完成就更好了。

Go 之前的代码编译

原因 6：打造团队的能力

首先，最明显的一点是：Go 的开发者远没有 C++和 Java 等旧语言多。据知，有 38% 的开发者了解 Java，19.3% 的开发者了解 C++，只有 4.6% 的开发者知道 Go。GitHub 数据表明了相似的趋势：相较于 Erlang、Scala 和 Elixir，Go 更为流行，但是相较于 Java 和 C++ 就不是了。

幸运的是 Go 非常简单，且易于学习。它只提供了基本功能而没有多余。Go 引入的新概念是「defer」声明，以及内置的带有 goroutines 和通道的并发性管理。正是由于 Go 的简单性，任何的 Python、Elixir、C++、Scala 或者 Java 开发者皆可在一月内组建成一个高效的 Go 团队。

原因 7：强大的生态系统

对我们这么大小的团队（大约 20 人）而言，生态系统很重要。如果你需要重做每块功能，那就无法为客户创造收益了。Go 有着强大的工具支持，面向 Redis、RabbitMQ、PostgreSQL、Template parsing、Task scheduling、Expression parsing 和 RocksDB 的稳定的库。

Go 的生态系统相比于 Rust、Elixir 这样的语言有很大的优势。当然，它又略逊于 Java、Python 或 Node 这样的语言，但它很稳定，而且你会发现在很多基础需求上，已经有高质量的文件包可用了。

原因 8：GOFMT，强制代码格式

Gofmt 是一种强大的命令行功能，内建在 Go 的编译器中来规定代码的格式。从功能上看，它类似于 Python 的 autopep8。格式一致很重要，但实际的格式标准并不总是非常重要。Gofmt 用一种官方的形式规格代码，避免了不必要的讨论。

原因 9：gRPC 和 Protocol Buffers

Go 语言对 protocol buffers 和 gRPC 有一流的支持。这两个工具能一起友好地工作以构建需要通过 RPC 进行通信的微服务器（microservices）。我们只需要写一个清单（manifest）就能定义 RPC 调用发生的情况和参数，然后从该清单将自动生成服务器和客户端代码。这样产生代码不仅快速，同时网络占用也非常少。

从相同的清单，我们可以从不同的语言生成客户端代码，例如 C++、Java、Python 和 Ruby。因此内部通信的 RESET 端点不会产生分歧，我们每次也就需要编写几乎相同的客户端和服务器代码。

使用 Go 语言的缺点

缺点 1：缺少框架

Go 语言没有一个主要的框架，如 Ruby 的 Rails 框架、Python 的 Django 框架或 PHP 的 Laravel。这是 Go 语言社区激烈讨论的问题，因为许多人认为我们不应该从使用框架开始。在很多案例情况中确实如此，但如果只是希望构建一个简单的 CRUD API，那么使用 Django/DJRF、Rails Laravel 或 Phoenix 将简单地多。

缺点 2：错误处理

Go 语言通过函数和预期的调用代码简单地返回错误（或返回调用堆栈）而帮助开发者处理编译报错。虽然这种方法是有效的，但很容易丢失错误发生的范围，因此我们也很难向用户提供有意义的错误信息。错误包（errors package）可以允许我们添加返回错误的上下文和堆栈追踪而解决该问题。

另一个问题是我们可能会忘记处理报错。诸如 errcheck 和 megacheck 等静态分析工具可以避免出现这些失误。虽然这些解决方案十分有效，但可能并不是那么正确的方法。

缺点 3：软件包管理

Go 语言的软件包管理绝对不是完美的。默认情况下，它没有办法制定特定版本的依赖库，也无法创建可复写的 builds。相比之下 Python、Node 和 Ruby 都有更好的软件包管理系统。然而通过正确的工具，Go 语言的软件包管理也可以表现得不错。

我们可以使用 Dep 来管理依赖项，它也能指定特定的软件包版本。除此之外，我们还可以使用一个名为 VirtualGo 的开源工具，它能轻松地管理 Go 语言编写的多个项目。

Python vs Go

我们实施的一个有趣实验是用 Python 写排名 feed，然后用 Go 改写。看下面这种排序方法的示例：

{

"functions": {

"simple_gauss": {

"base": "decay_gauss",

"scale": "5d",

"offset": "1d",

"decay": "0.3"

},

"popularity_gauss": {

"scale": "100",

"offset": "5",

"decay": "0.5"

"defaults": {

"popularity": 1

"score": "simple_gauss(time)*popularity"

Python 和 Go 代码都需要以下要求从而支持上面的排序方法：

解析得分的表达。在此示例中，我们想要把 simple_gauss(time)*popularity 字符串转变为一种函数，能够把 activity 作为输入然后给出得分作为输出。

在 JSON config 上创建部分函数。例如，我们想要「simple_gauss」调用「decay_gauss」，且带有的键值对为"scale": "5d"、"offset": "1d"、"decay": "0.3"。

解析「defaults」配置，便于某个领域没有明确定义的情况下有所反馈。

从 step1 开始使用函数，为 feed 中的所有 activity 打分。

开发 Python 版本排序代码大约需要 3 天，包括写代码、测试和建立文档。接下来，我么花费大约 2 周的时间优化代码。其中一个优化是把得分表达 simple_gauss(time)*popularity 转译进一个抽象语法树。我们也实现了 caching logic，之后会预先计算每次的得分。

相比之下，开发 Go 版本的代码需要 4 天，但之后不需要更多的优化。所以虽然最初的开发上 Python 更快，但 Go 最终需要的工作量更少。此外，Go 代码要比高度优化的 python 代码快了 40 多倍。

以上只是我们转向 Go 所体验到的一种好处。当然，也不能这么做比较：

该排序代码是我用 Go 写的第一个项目；

Go 代码是在 Python 代码之后写的，所以提前理解了该案例；

Go 的表达解析库质量优越。

Elixir vs Go

我们评估的另一种语言是 Elixir。Elixir 建立在 Erlang 虚拟机上。这是一种迷人的语言，我们之所以想到它是因为我们组员中有一个在 Erlang 上非常有经验。

在使用案例中，我们观察到 Go 的原始性能更好。Go 和 Elixir 都能很好地处理数千条并行需求，然而，如果是单独的要求，Go 实际上更快。相对于 Elixir，我们选择 Go 的另一个原因是生态系统。在我们需求的组件上，Go 的库更为成熟。在很多案例中，Elixir 库不适合产品使用。同时，也很难找到／训练同样使用 Elixir 的开发者。

结论

Go 是一种非常高效的语言，高度支持并发性。同时，它也像 C++和 Java 一样快。虽然相比于 Python 和 Ruby，使用 Go 建立东西需要更多的时间，但在后续的代码优化上可以节省大量时间。在 Stream，我们有个小型开发团队为 2 亿终端用户提供 feed 流。对新手开发者而言，Go 结合了强大的生态系统、易于上手，也有超快的表现、高度支持并发性，富有成效的编程环境使它成为了一种好的选择。Stream 仍旧使用 Python 做个性化 feed，但所有性能密集型的代码将会用 Go 来编写。

-------- 热闻回顾 --------

一个 38 岁程序员的中年危机

Wi-Fi 爆重大安全漏洞，Android、iOS、Windows 等所有无线设备都不安全了

从程序员之死看 IT 人士如何摆脱低情商诅咒

你正在开发一个企业应用程序，并试图决定使用哪种语言？看看Go和Python的比较。

Golang vs Python的性能在开发人员和业务最终用户中是一个备受争议的话题。一个企业只有与其提供的服务一样好，以及它如此迅速而高效地完成工作，这就是Golang与Python的问题出现的原因。几乎每个企业的每一个方面都依赖于其技术备份。数据安全，入侵检测，虚拟专用网络和存储只是企业开发人员需要处理的几个问题中的一部分。鉴于这种情况，大多数企业更倾向于外包他们的IT服务，以便专注于他们最擅长的事情。然而，大多数顶级管理人员忽视了极端重要的是监督IT服务公司用于开发程序，Web应用程序，数据分析等的编程语言。

尽管您选择将IT服务外包给大多数公司，但以您的名义作出此决定; 总是最好是一个消息灵通的新手。对于企业开发，一些最常用的编程语言是Python，Java，Golang，Perl，PHP等。当您在众多选项中进行选择时，您可能需要考虑一个事实，即“Google Golang击败Java，C ，Python到年度冠军的编程语言。“

Python是Golang的紧密竞争对手。因此，我们帮助您理解为什么Golang仍然是Python满足您所有企业需求的更好选择。我们来讨论Go vs Python：

去与Python：语言之战

1.可扩展的业务

任何现代企业需要的首要事情之一就是可扩展性。企业迅速增长，IT系统支持这种增长势在必行。这里值得一提的是，基于Python的Web应用程序很难在单个机器上跨多个内核进行扩展。这是由于全球解释器锁（GIL）的局限性。

另一方面，Golang拥有许多内置功能，可处理多个“并发Web请求”，这反过来又使其成为编译程序的高效语言，而不是Python。当语言能够处理多个并发请求时，它自动也具有很高的可伸缩性。随着企业的发展，所使用的程序将需要同时做许多事情。因此，随着Golang对其后端程序的支持，任何不断增长的业务都将能够更好地处理可伸缩性问题。

2.更快的性能和并发性

在Golang和Python之间，Golang执行起来要快得多（有时快2倍或3倍）是一个确定的事实。这是因为与Python相比，Golang更节约资源。Python使用资源要求较高的线程，而Golang使用独立的goroutine，这有助于节省CPU和内存等资源。这种资源效率不仅有助于提高性能，还能带来成本效益。

3.安全

由于每个变量必须具有与之相关的类型，因此Golang是一种非常安全的语言。这意味着开发人员不能跳过可能导致错误的细节。因此，企业可以节省搜索错误并最终调试的时间和成本。因此，在敏捷性非常重要且给企业带来竞争优势的时代和时代，编程语言中的优秀调试工具是一个非常重要的优势。

4.清除语法

由于其语法清晰，Golang网络编程非常简单，其中包含零不必要的组件。由于实用程序是Golang的关键组件，开发人员现在可以自由地专注于开发本身。这有助于缩短上市时间，并可避免最终纠错的成本。

所有这些因素汇集在一起，都有助于Golang的巨大普及，甚至与Python所建立的语言相比。尽管不能排除Python的优势，但可以肯定地说Golang是企业应用程序开发的一种优秀语言。

转向一门新的语言不是个容易的决定,尤其是当你要抛弃的是如日中天的Python。那么这次要给大家安利的新欢是谁呢?