对Go 1.16 io/fs设计的第一感觉:得劲儿!

1. 设计io/fs的背景

Go语言的接口是Gopher最喜欢的语法元素之一,其隐式的契约满足和“当前唯一可用的泛型机制”的特质让其成为面向组合编程的强大武器,其存在为Go建立事物抽象奠定了基础,同时也是建立抽象的主要手段。

Go语言从诞生至今,最成功的接口定义之一就是io.Writer和io.Reader接口:

type Writer interface {
    Write(p []byte) (n int, err error)
}

type Reader interface {
    Read(p []byte) (n int, err error)
}

这两个接口建立了对数据源中的数据操作的良好的抽象,通过该抽象我们可以读或写满足这两个接口的任意数据源:

  • 字符串
r := strings.NewReader("hello, go")
r.Read(...)
  • 字节序列
r := bytes.NewReader([]byte("hello, go"))
r.Read(...)
  • 文件内数据
f := os.Open("foo.txt") // f 满足io.Reader
f.Read(...)
  • 网络socket
r, err :=  net.DialTCP("192.168.0.10", nil, raddr *TCPAddr) (*TCPConn, error)
r.Read(...)
  • 构造HTTP请求
req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader([]byte("hello, go"))
  • 读取压缩文件内容
func main() {
    f, err := os.Open("hello.txt.gz")
    if err != nil {
        log.Fatal(err)
    }

    zr, err := gzip.NewReader(f)
    if err != nil {
        log.Fatal(err)
    }

    if _, err := io.Copy(os.Stdout, zr); err != nil {
        log.Fatal(err)
    }

    if err := zr.Close(); err != nil {
        log.Fatal(err)
    }
}

… …

能构架出io.Reader和Writer这样的抽象,与Go最初核心团队的深厚的Unix背景是密不可分的,这一抽象可能深受“在UNIX中,一切都是字节流”这一设计哲学的影响。

Unix还有一个设计哲学:一切都是文件,即在Unix中,任何有I/O的设备,无论是文件、socket、驱动等,在打开设备之后都有一个对应的文件描述符,Unix将对这些设备的操作简化在抽象的文件中了。用户只需要打开文件,将得到的文件描述符传给相应的操作函数,操作系统内核就知道如何根据这个文件描述符得到具体设备信息,内部隐藏了对各种设备进行读写的细节。

并且Unix还使用树型的结构将各种抽象的文件(数据文件、socket、磁盘驱动器、外接设备等)组织起来,通过文件路径对其进行访问,这样的一个树型结构构成了文件系统。

不过由于历史不知名的某个原因,Go语言并没有在标准库中内置对文件以及文件系统的抽象!我们知道如今的os.File是一个具体的结构体类型,而不是抽象类型:

// $GOROOT/src/os/types.go

// File represents an open file descriptor.
type File struct {
        *file // os specific
}

结构体os.File中唯一的字段file指针还是一个操作系统相关的类型,我们以os/file_unix.go为例,在unix中,file的定义如下:

// file is the real representation of *File.
// The extra level of indirection ensures that no clients of os
// can overwrite this data, which could cause the finalizer
// to close the wrong file descriptor.
type file struct {
        pfd         poll.FD
        name        string
        dirinfo     *dirInfo // nil unless directory being read
        nonblock    bool     // whether we set nonblocking mode
        stdoutOrErr bool     // whether this is stdout or stderr
        appendMode  bool     // whether file is opened for appending
}

Go语言之父Rob Pike对当初os.File没有被定义为interface而耿耿于怀

不过就像Russ Cox在上述issue中的comment那样:“我想我会认为io.File应该是接口,但现在这一切都没有意义了”:

但在Go 1.16的embed文件功能设计过程中,Go核心团队以及参与讨论的Gopher们认为引入一个对File System和File的抽象,将会像上面的io.Reader和io.Writer那样对Go代码产生很大益处,同时也会给embed功能的实现带去便利!于是Rob Pike和Russ Cox亲自上阵完成了io/fs的设计

2. 探索io/fs包

io/fs的加入也不是“临时起意”,早在很多年前的godoc实现时,对一个抽象的文件系统接口的需求就已经被提了出来并给出了实现:

最终这份实现以godoc工具的vfs包的形式一直长期存在着。虽然它的实现有些复杂,抽象程度不够,但却对io/fs包的设计有着重要的参考价值。

Go语言对文件系统与文件的抽象以io/fs中的FS接口类型和File类型落地,这两个接口的设计遵循了Go语言一贯秉持的“小接口原则”,并符合开闭设计原则(对扩展开放,对修改关闭)。

// $GOROOT/src/io/fs/fs.go
type FS interface {
        // Open opens the named file.
        //
        // When Open returns an error, it should be of type *PathError
        // with the Op field set to "open", the Path field set to name,
        // and the Err field describing the problem.
        //
        // Open should reject attempts to open names that do not satisfy
        // ValidPath(name), returning a *PathError with Err set to
        // ErrInvalid or ErrNotExist.
        Open(name string) (File, error)
}

// A File provides access to a single file.
// The File interface is the minimum implementation required of the file.
// A file may implement additional interfaces, such as
// ReadDirFile, ReaderAt, or Seeker, to provide additional or optimized functionality.
type File interface {
        Stat() (FileInfo, error)
        Read([]byte) (int, error)
        Close() error
}

FS接口代表虚拟文件系统的最小抽象,它仅包含一个Open方法;File接口则是虚拟文件的最小抽象,仅包含抽象文件所需的三个共同方法(不能再少了)。我们可以基于这两个接口通过Go常见的嵌入接口类型的方式进行扩展,就像io.ReadWriter是基于io.Reader的扩展那样。在这份设计提案中,作者还将这种方式命名为extension interface,即在一个基本接口类型的基础上,新增一到多个新方法以形成一个新接口。比如下面的基于FS接口的extension interface类型StatFS:

// A StatFS is a file system with a Stat method.
type StatFS interface {
        FS

        // Stat returns a FileInfo describing the file.
        // If there is an error, it should be of type *PathError.
        Stat(name string) (FileInfo, error)
}

对于File这个基本接口类型,fs包仅给出一个extension interface:ReadDirFile,即在File接口的基础上增加了一个ReadDir方法形成的,这种用扩展方法名+基础接口名来命名一个新接口类型的方式也是Go的惯用法。

对于FS接口,fs包给出了一些扩展FS的常见“新扩展接口”的样例:

以fs包的ReadDirFS接口为例:

// $GOROOT/src/io/fs/readdir.go
type ReadDirFS interface {
    FS

    // ReadDir reads the named directory
    // and returns a list of directory entries sorted by filename.
    ReadDir(name string) ([]DirEntry, error)
}

// ReadDir reads the named directory
// and returns a list of directory entries sorted by filename.
//
// If fs implements ReadDirFS, ReadDir calls fs.ReadDir.
// Otherwise ReadDir calls fs.Open and uses ReadDir and Close
// on the returned file.
func ReadDir(fsys FS, name string) ([]DirEntry, error) {
    if fsys, ok := fsys.(ReadDirFS); ok {
        return fsys.ReadDir(name)
    }

    file, err := fsys.Open(name)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    dir, ok := file.(ReadDirFile)
    if !ok {
        return nil, &PathError{Op: "readdir", Path: name, Err: errors.New("not implemented")}
    }

    list, err := dir.ReadDir(-1)
    sort.Slice(list, func(i, j int) bool { return list[i].Name() < list[j].Name() })
    return list, err
}

我们看到伴随着ReadDirFS,标准库还提供了一个helper函数:ReadDir。该函数的第一个参数为FS接口类型的变量,在其内部实现中,ReadDir先通过类型断言判断传入的fsys是否实现了ReadDirFS,如果实现了,就直接调用其ReadDir方法;如果没有实现则给出了常规实现。其他几个FS的extension interface也都有自己的helper function,这也算是Go的一个惯例。如果你要实现你自己的FS的扩展,不要忘了这个惯例:给出伴随你的扩展接口的helper function

标准库中一些涉及虚拟文件系统的包在Go 1.16版本中做了对io/fs的适配,比如:os、net/http、html/template、text/template、archive/zip等。

以http.FileServer为例,Go 1.16版本之前建立一个静态文件Server一般这么来写:

// github.com/bigwhite/experiments/blob/master/iofs/fileserver_classic.go
package main

import "net/http"

func main() {
    http.ListenAndServe(":8080", http.FileServer(http.Dir(".")))
}

Go 1.16 http包对fs的FS和File接口做了适配后,我们可以这样写:

// github.com/bigwhite/experiments/blob/master/iofs/fileserver_iofs.go
package main

import (
    "net/http"
    "os"
)

func main() {
    http.ListenAndServe(":8080", http.FileServer(http.FS(os.DirFS("./"))))
}

os包新增的DirFS函数返回一个fs.FS的实现:一个以传入dir为根的文件树构成的File System。

我们可以参考DirFS实现一个goFilesFS,该FS的实现仅返回以.go为后缀的文件:

// github.com/bigwhite/experiments/blob/master/iofs/gofilefs/gofilefs.go

package gfs

import (
    "io/fs"
    "os"
    "strings"
)

func GoFilesFS(dir string) fs.FS {
    return goFilesFS(dir)
}

type goFile struct {
    *os.File
}

func Open(name string) (*goFile, error) {
    f, err := os.Open(name)
    if err != nil {
        return nil, err
    }
    return &goFile{f}, nil
}

func (f goFile) ReadDir(count int) ([]fs.DirEntry, error) {
    entries, err := f.File.ReadDir(count)
    if err != nil {
        return nil, err
    }
    var newEntries []fs.DirEntry

    for _, entry := range entries {
        if !entry.IsDir() {
            ss := strings.Split(entry.Name(), ".")
            if ss[len(ss)-1] != "go" {
                continue
            }
        }
        newEntries = append(newEntries, entry)
    }
    return newEntries, nil
}

type goFilesFS string

func (dir goFilesFS) Open(name string) (fs.File, error) {
    f, err := Open(string(dir) + "/" + name)
    if err != nil {
        return nil, err // nil fs.File
    }
    return f, nil
}

上述GoFilesFS的实现中:

  • goFilesFS实现了io/fs的FS接口,而其Open方法返回的fs.File实例为我自定义的goFile结构;
  • goFile结构通过嵌入*os.File满足了io/fs的File接口;
  • 我们重写goFile的ReadDir方法(覆盖os.File的同名方法),在这个方法中我们过滤掉非.go后缀的文件。

有了GoFilesFS的实现后,我们就可以将其传给http.FileServer了:

// github.com/bigwhite/experiments/blob/master/iofs/fileserver_gofilefs.go
package main

import (
    "net/http"

    gfs "github.com/bigwhite/testiofs/gofilefs"
)

func main() {
    http.ListenAndServe(":8080", http.FileServer(http.FS(gfs.GoFilesFS("./"))))
}

通过浏览器打开localhost:8080页面,我们就能看到仅由go源文件组成的文件树!

3. 使用io/fs提高代码可测性

抽象的接口意味着降低耦合,意味着代码可测试性的提升。Go 1.16增加了对文件系统和文件的抽象之后,我们以后再面对文件相关代码时,我们便可以利用io/fs提高这类代码的可测试性。

我们有这样的一个函数:

func FindGoFiles(dir string) ([]string, error)

该函数查找出dir下所有go源文件的路径并放在一个[]string中返回。我们可以很轻松的给出下面的第一版实现:

// github.com/bigwhite/experiments/blob/master/iofs/gowalk/demo1/gowalk.go

package demo

import (
    "os"
    "path/filepath"
    "strings"
)

func FindGoFiles(dir string) ([]string, error) {
    var goFiles []string
    err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
        if info.IsDir() {
            return nil
        }

        ss := strings.Split(path, ".")
        if ss[len(ss)-1] != "go" {
            return nil
        }

        goFiles = append(goFiles, path)
        return nil
    })
    if err != nil {
        return nil, err
    }

    return goFiles, nil
}

这一版的实现直接使用了filepath的Walk函数,它与os包是紧绑定的,即要想测试这个函数,我们需要在磁盘上真实的构造出一个文件树,就像下面这样:

$tree testdata
testdata
└── foo
    ├── 1
    │   └── 1.txt
    ├── 1.go
    ├── 2
    │   ├── 2.go
    │   └── 2.txt
    └── bar
        ├── 3
        │   └── 3.go
        └── 4.go

按照go惯例,我们将测试依赖的外部数据文件放在testdata下面。下面是针对上面函数的测试文件:

// github.com/bigwhite/experiments/blob/master/iofs/gowalk/demo1/gowalk_test.go
package demo

import (
    "testing"
)

func TestFindGoFiles(t *testing.T) {
    m := map[string]bool{
        "testdata/foo/1.go":       true,
        "testdata/foo/2/2.go":     true,
        "testdata/foo/bar/3/3.go": true,
        "testdata/foo/bar/4.go":   true,
    }

    files, err := FindGoFiles("testdata/foo")
    if err != nil {
        t.Errorf("want nil, actual %s", err)
    }

    if len(files) != 4 {
        t.Errorf("want 4, actual %d", len(files))
    }

    for _, f := range files {
        _, ok := m[f]
        if !ok {
            t.Errorf("want [%s], actual not found", f)
        }
    }
}

FindGoFiles函数的第一版设计显然可测性较差,需要对依赖特定布局的磁盘上的文件,虽然testdata也是作为源码提交到代码仓库中的。

有了io/fs包后,我们用FS接口来提升一下FindGoFiles函数的可测性,我们重新设计一下该函数:

// github.com/bigwhite/experiments/blob/master/iofs/gowalk/demo2/gowalk.go

package demo

import (
    "io/fs"
    "strings"
)

func FindGoFiles(dir string, fsys fs.FS) ([]string, error) {
    var newEntries []string
    err := fs.WalkDir(fsys, dir, func(path string, entry fs.DirEntry, err error) error {
        if entry == nil {
            return nil
        }

        if !entry.IsDir() {
            ss := strings.Split(entry.Name(), ".")
            if ss[len(ss)-1] != "go" {
                return nil
            }
            newEntries = append(newEntries, path)
        }
        return nil
    })

    if err != nil {
        return nil, err
    }

    return newEntries, nil
}

这次我们给FindGoFiles增加了一个fs.FS类型的参数fsys,这是解除掉该函数与具体FS实现的关键。当然demo1的测试方法同样适用于该版FindGoFiles函数:

// github.com/bigwhite/experiments/blob/master/iofs/gowalk/demo2/gowalk_test.go
package demo

import (
    "os"
    "testing"
)

func TestFindGoFiles(t *testing.T) {
    m := map[string]bool{
        "testdata/foo/1.go":       true,
        "testdata/foo/2/2.go":     true,
        "testdata/foo/bar/3/3.go": true,
        "testdata/foo/bar/4.go":   true,
    }

    files, err := FindGoFiles("testdata/foo", os.DirFS("."))
    if err != nil {
        t.Errorf("want nil, actual %s", err)
    }

    if len(files) != 4 {
        t.Errorf("want 4, actual %d", len(files))
    }

    for _, f := range files {
        _, ok := m[f]
        if !ok {
            t.Errorf("want [%s], actual not found", f)
        }
    }
}

但这不是我们想要的,既然我们使用了io/fs.FS接口,那么一切实现了fs.FS接口的实体均可被用来构造针对FindGoFiles的测试。但自己写一个实现了fs.FS接口以及fs.File相关接口还是比较麻烦的,Go标准库已经想到了这点,为我们提供了testing/fstest包,我们可以直接利用fstest包中实现的基于memory的FS来对FindGoFiles进行测试:

// github.com/bigwhite/experiments/blob/master/iofs/gowalk/demo3/gowalk_test.go
package demo

import (
    "testing"
    "testing/fstest"
)

/*
$tree testdata
testdata
└── foo
    ├── 1
    │   └── 1.txt
    ├── 1.go
    ├── 2
    │   ├── 2.go
    │   └── 2.txt
    └── bar
        ├── 3
        │   └── 3.go
        └── 4.go

5 directories, 6 files

*/

func TestFindGoFiles(t *testing.T) {
    m := map[string]bool{
        "testdata/foo/1.go":       true,
        "testdata/foo/2/2.go":     true,
        "testdata/foo/bar/3/3.go": true,
        "testdata/foo/bar/4.go":   true,
    }

    mfs := fstest.MapFS{
        "testdata/foo/1.go":       {Data: []byte("package foo\n")},
        "testdata/foo/1/1.txt":    {Data: []byte("1111\n")},
        "testdata/foo/2/2.txt":    {Data: []byte("2222\n")},
        "testdata/foo/2/2.go":     {Data: []byte("package bar\n")},
        "testdata/foo/bar/3/3.go": {Data: []byte("package zoo\n")},
        "testdata/foo/bar/4.go":   {Data: []byte("package zoo1\n")},
    }

    files, err := FindGoFiles("testdata/foo", mfs)
    if err != nil {
        t.Errorf("want nil, actual %s", err)
    }

    if len(files) != 4 {
        t.Errorf("want 4, actual %d", len(files))
    }

    for _, f := range files {
        _, ok := m[f]
        if !ok {
            t.Errorf("want [%s], actual not found", f)
        }
    }
}

由于FindGoFiles接受了fs.FS类型变量作为参数,使其可测性显著提高,我们可以通过代码来构造测试场景,而无需在真实物理磁盘上构造复杂多变的测试场景。

4. 小结

io/fs的加入让我们易于面向接口编程,而不是面向os.File这个具体实现。io/fs的加入丝毫没有违和感,就好像这个包以及其中的抽象在Go 1.0版本发布时就存在的一样。这也是Go interface隐式依赖的特质带来的好处,让人感觉十分得劲儿!

本文中涉及的代码可以在这里下载。https://github.com/bigwhite/experiments/tree/master/iofs


“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}

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

Rust vs. Go:为什么强强联合会更好

本文翻译自乔纳森·特纳(Jonathan Turner)和史蒂夫·弗朗西亚(Steve Francia)的文章《Rust vs. Go: Why They’re Better Together》

史蒂夫·弗朗西亚(Steve Francia):在过去的25年里,Steve Francia建立了一些最具创新性和成功的技术和公司,这些技术和公司已经成为云计算的基础,被全世界的企业和开发者所接受。他目前是谷歌Go编程语言的产品和战略负责人。他是Hugo、Cobra、Viper、spf13-vim和许多其他开源项目的创建者,拥有领导世界上最大的五个开源项目的独特荣誉。

乔纳森-特纳(Jonathan Turner)在开源领域工作了20多年,从小型项目到大型项目,包括帮助微软向开源转型。他是创建TypeScript团队的一员,并作为项目经理和设计团队的负责人帮助其成长。他还作为Rust社区成员和Mozilla Rust团队的一员参与Rust的工作,包括共同设计Rust的错误信息和IDE支持。

虽然其他人可能认为RustGo是竞争性的编程语言,但Rust和Go团队却都不这么认为。恰恰相反,我们的团队非常尊重其他团队正在做的事情,并认为这两种编程语言是相辅相成的,有着共同的愿景,即在整个行业内实现软件开发状态的现代化。

在本文中,我们将讨论Rust和Go的优缺点、它们如何相互补充和支持以及我们对每种语言的最佳使用时机的建议。

一些公司正在发掘采用这两种语言的价值以及它们的互补价值。为了从我们的观点转向用户的实际体验,我们采访了三家这样的公司,DropboxFastlyCloudflare,讲述了他们共同使用Go和Rust的经验。他们的经验之谈将被引用并贯穿本文,为大家提供更进一步的观点。

1. 语言比较

编程语言 Go Rust
创建时间 2009 2010
创建于 谷歌 Mozilla
知名项目 Kubernetes,Docker,Github CLI,Hugo,Caddy,Drone,Ethereum,Syncthing,Terraform Firefox, ripgrep, alacritty, deno, Habitat
典型用途 APIs, Web Apps, CLI apps, DevOps, Networking, Data Processing, cloud apps IoT, processing engines, security-sensitive apps, system components, cloud apps
开发者采用 8.8%(第12名) 5.1%(第19名)
开发者最爱 62.3%(第5名) 86.1%(第1名)
开发最想要 17.9%(第3名) 14.6%(第5名)

2. 相似之处

Go和Rust有很多共同点。两者都是现代软件语言,都是出于为影响软件开发的问题提供一个安全和可扩展的解决方案的需要而诞生的。两者都是为了应对创建者在行业内现有语言中遇到的缺点而创建的,尤其是开发者生产力、可扩展性、安全性和并发性方面的缺点。

当今流行的大多数语言都是30多年前设计的。当这些语言被设计出来的时候,与今天有五个关键的区别:

  • 摩尔定律被认为是永恒不变的。
  • 大多数软件项目都是由小团队编写的,并且经常一个人单干。
  • 大多数软件有相对较少的依赖性,大多数是专有的。
  • 安全性是次要的考虑因素……或者根本不是考虑因素。
  • 软件通常是为单一平台编写的。

相比之下,Rust和Go都是为今天的世界而写的,并都采取了相似的方法来设计一种适合今天开发需求的语言。

1) 性能和并发

Go和Rust都是专注于生产高效代码的编译语言。它们还可以方便地使用当今机器的多个处理器,使它们成为编写高效并行代码的理想语言。

“使用Go使得MercadoLibre公司将他们用于这项服务的服务器数量减少到原来的八分之一(从32台服务器减少到4台),另外,每台服务器可以用更少的功率运行(原来是4个CPU核,现在减少到2个CPU核)。有了Go,该公司省去了88%的服务器,并将剩余服务器上的CPU削减了一半–产生了巨大的成本节约。”–“MercadoLibre与Go一起成长”

“在我们严格管理的环境中,在我们运行Go代码的环境中,我们看到CPU减少了大约百分之十[与C++相比],代码更干净,更可维护。” – Bala Natarajan,Paypal

“在AWS,我们也很喜欢Rust,因为它能帮助AWS编写高性能、安全的基础设施级网络和其他系统软件。亚马逊第一个用Rust构建的重要产品Firecracker于2018年公开发布,它提供了开源虚拟化技术,为AWS Lambda和其他无服务器产品提供动力。但我们也使用Rust来提供亚马逊简单存储服务(Amazon S3)、亚马逊弹性计算云(Amazon EC2)、Amazon CloudFront、Amazon Route 53等服务。最近,我们推出了基于Linux的容器操作系统Bottlerocket,它是用Rust编写的。” – Matt Asay,亚马逊网络服务

我们”看到我们的速度非凡地提高了1200-1500%! 我们从实现了较少解析规则的Scala的模式下的300-450ms,到实现了更多解析模式的Rust模式下的25-30ms!” – Josh Hannaford,IBM

2) 团队可扩展—-可审查

今天的软件开发是由团队建立的,这些团队不断成长和扩大,经常使用源码控制以分布式的方式进行协作。Go和Rust都是针对团队的工作方式而设计的,通过消除不必要的担忧,如格式(比如go的gofmt)、安全和复杂的组织,来改善代码审查。这两种语言都需要相对较少的上下文来理解代码的工作,使审查人员能够更快速地使用其他人编写的代码,并审查团队成员的代码和你团队以外的开源开发人员贡献的代码。

“我早期的职业生涯有Java和Ruby的背景,构建Go和Rust代码对我来说就像卸下了无法承受的重担。当我在Google时,遇到用Go编写的服务让我很欣慰,因为我知道它易于构建和运行。Rust的情况也是如此,尽管我只是在更小的工作范围内使用了它。我希望无限可配置的构建系统的日子已经过去了,而语言都有自己的专用构建工具,开箱即用。”– Sam Rose,CV合伙人

“用Go写服务的时候,我往往会松一口气,因为与动态语言相比,Go的静态类型系统非常简单,易于推理,并发性是一等公民,Go的标准库既无比精致强大,又切中要害。安装一个标准的Go,再使用一个grpc库和一个数据库连接器,你在服务器端几乎不需要其他的东西,每个工程师都能看懂代码,看懂库。在用Rust编写模块时,Dropbox工程师在2019年Async-await稳定下来之前,感受到了Rust在服务器端的成长之痛,但从那时起,crate(译注:Rust中的概念)正在趋向于使用它,我们得到了Async模式并从并发中受益。” – Daniel Reiter Horn,Dropbox

3) 开放源码意识

今天一般软件项目所使用的依赖关系数量是惊人的。长达几十年的软件重用目标在现代开发中已经实现,今天的软件可能是复用了100多个项目而构建的。为此,开发人员使用软件仓库,这越来越成为软件开发的主旋律,并在越来越广泛的领域应用。开发者所包含的每一个软件包,又有自己的依赖关系。为今天的编程环境而设计出的编程语言需要毫不费力地处理这种复杂性。

Go和Rust都有包管理系统,允许开发人员列出一个简单的清单,列出他们想要构建的包,语言工具就会自动为他们获取和维护这些包,这样开发人员就可以把更多的精力放在自己的代码上,而不是放在对其他包的管理上。

4) 安全性

Go和Rust都很好地解决了当今应用的安全问题,保证了用这些语言构建的代码在运行时不会让用户暴露在各种经典的安全漏洞中,比如缓冲区溢出、use-after-free(内存释放后还使用)等。通过消除这些顾虑,开发者可以专注于手头的问题,并在默认情况下构建更安全的应用程序。

“Rust编译器在解决您遇到的错误时确实能助您一臂之力。这样一来,您就可以专注于自己的业务目标,而不必寻找错误或解密隐秘消息。” -Josh Hannaford,IBM

简而言之,Rust的灵活性,安全性和安全性带给我们的益处超过了必须遵循严格的lifetime,borrow(rust中的概念)和其他编译器规则甚至缺乏垃圾收集器所带来的任何不便。这些功能是云软件项目中非常需要的功能,将有助于避免其中常见的许多错误。” —微软高级泰勒·托马斯(Taylor Thomas)

“Go是强静态类型化的,没有隐式转换,但语法开销还是小得惊人。这是通过赋值中简单的类型推理与非类型化的数值常量一起实现的。这使得Go比Java(有隐式转换)具有更强的类型安全性,但代码读起来更像Python(有非类型变量)。” – Stefan Nilsson,计算机科学教授

“当我们在Dropbox构建用于存储块数据的Brotli压缩库时,我们将自己限制在Rust的安全子集上,而且,也限制在核心库(no-stdlib)上,分配器指定为通用。这样使用Rust的子集,使得在客户端从Rust调用Rust-Brotli库,以及在服务器上使用Python和Go的C FFI变得非常容易。这种编译模式也提供了大量的安全保障。经过一些调整,Rust Brotli的实现尽管是100%安全的、经过数组边界检查的代码,但仍然比C语言中相应的原生Brotli代码快。” – Daniel Reiter Horn,Dropbox

5) 真正的可移植性

在Go和Rust中,写一个软件,在许多不同的操作系统和架构上运行是很容易的。”一次编写,随处编译”。此外,Go和Rust都原生支持交叉编译,消除了旧编译语言常见的”build farm”的需要。

“Go在生产优化方面拥有很好的特质,比如拥有较小的内存占用,这支持其在大型项目中被用于构建模块,以及开箱即用,易于交叉编译到其他架构。由于Go代码被编译成单一的静态二进制,我们可以轻松将其容器化,并且通过扩展,我们可以很轻松地将Go部署到任何高可用环境(如Kubernetes)中。” – Dewet Diener,Curve

“当你看一个基于云的基础设施时,通常你会使用类似Docker容器这样的东西来部署你的工作负载。通过在Go中构建的静态二进制,你可以拥有一个10、11、12兆字节的Docker文件,而不是带来整个Node.js生态系统,或像Python或Java那样动辄数百兆字节大小的Docker镜像文件。所以,交付那个微小的二进制文件是很神奇的。” – Brian Ketelsen,微软

“有了Rust,我们将拥有一个高性能和可移植的平台,我们可以轻松地在Mac、iOS、Linux、Android和Windows上运行。” – Matt Ronge,Astropad

3. 差异

在设计中,总是要做出一些取舍。虽然Go和Rust大约在同一时间出现,目标相似,但由于他们决策时选择了不同的取舍,使得这两种语言在关键的方面有所区别。

1) 性能方面

Go开箱即有出色的性能。在设计上,几乎没有预留任何旋钮或开关可以让你从Go中榨取更多的性能。Rust的设计是为了让您能够从代码中榨取每一滴性能;在这方面,您确实无法找到比Rust更快的语言。然而,Rust的性能提升是以额外的复杂性为代价的。

“值得注意的是,在编写Rust版本时,我们只在优化方面投入了非常基本的思考。即使只做了基本的优化,Rust的性能也能超过超手工调整的Go版本。这极大地证明了用Rust编写高效的程序是多么容易,相比之下,我们不得不对Go进行深挖。” – Jesse Howarth,Discord

“Dropbox工程师通过将行对行的Python代码移植到Go中,往往可以看到5倍的性能提升和延迟下降,与Python相比,内存使用率往往会大幅下降,因为没有GIL,进程数可能会减少。然而,当我们的内存受限时,比如在桌面客户端软件或某些服务器进程中,我们会转而使用Rust,因为Rust中的手动内存管理效率大大高于Go GC。” – Daniel Reiter Horn,Dropbox

2) 适应性/交互性

Go快速迭代的优势让开发人员可以快速尝试各种想法,并磨合出能解决手头任务的工作代码。通常情况下,这就足够了,可以让开发者腾出手来处理其他任务。另一方面,与Go相比,Rust的编译时间更长,导致迭代时间更慢。这就导致了Go在一些场景中能更好地工作,因为更快的周转时间能让开发人员适应不断变化的需求,而Rust则在一些场景中茁壮成长,因为在这些场景中,可以给予更多的时间来做出更精致、更高性能的实现。

“Go类型系统的天才之处在于调用者可以定义Interface,允许库返回仅需满足小接口但却支持扩展的结构。Rust类型系统的天才设计在于匹配语法与Result<>的结合,你可以静态地确定每一种可能性都会被处理,永远不必发明空值来满足未使用的返回参数。” – Daniel Reiter Horn,Dropbox

“(我)如果你的用例离客户更近,更容易受到需求变化的影响,那么用Go就会好很多,因为持续重构的成本要便宜很多。这就是你能多快地表达新的需求并尝试它们。” – Peter Bourgon,Fastly

3) 可学性

简单来说,真的没有比Go更“平易近人”的语言了。有很多团队能够在几周内采用Go并将Go服务/应用投入生产的故事。此外,Go在语言中是比较独特的,它的语言设计和实践在它10多年的生命中是相当一致的。所以,投入到学习Go上的时间可以保持很长一段时间的价值。相比之下,Rust由于其复杂性,被认为是一门难学的语言。一般来说,学习Rust需要几个月的时间才能感觉到自如,但这种额外的复杂性也带来了精确的控制和性能的提高。

“当时,没有一个团队成员知道Go,但在一个月内,每个人都在用Go写作”–Jaime Garcia,Capital One

“Go与其他编程语言不同的地方在于认知负担。你可以用更少的代码做更多的事情,这使得你更容易推理和理解你最终编写的代码。大多数Go代码最终看起来都很相似,所以,即使你在使用一个全新的代码库,你也可以很快上手并运行。” – Glen Balliet 美国运通忠诚度平台工程总监 美国运通使用Go进行支付和奖励

“然而,与其他编程语言不同,Go是为了最大限度地提高用户效率而创建的。因此,具有Java或PHP背景的开发人员和工程师可以在几周内获得使用Go的高级技能和培训–根据我们的经验,他们中的许多人最终都喜欢上了Go。” – Dewet Diener,Curve

4) 精确控制

也许Rust最大的优势之一就是开发者对如何管理内存、如何使用机器的可用资源、如何优化代码以及如何制作问题解决方案的控制。与Go相比,这并不是没有很大的复杂度成本,因为Go的设计并不是为了这种精确的制作,而是为了更快的探索时间和更快的周转时间。

“随着我们对Rust经验的增长,它在另外两个轴上显示出了优势:作为一种具有强大内存安全性的语言,它是边缘处理的好选择;作为一种具有巨大热情的语言,它成为了重写组件的流行语言。” – John Graham-Cumming,Cloudflare。

3. 总结/主要收获

Go的简单性、性能和开发人员的生产力使Go成为创建面向用户的应用程序和服务的理想语言。快速的迭代让团队能够快速地作出反应以满足用户不断变化的需求,让团队有办法将精力集中在灵活性上。

Rust更精细的控制允许更多的精确性,使得Rust成为低级操作的理想语言,这些低级操作不太可能发生变化,并且会从比Go略微提高的性能中受益,特别是在非常大的规模部署时。

Rust的优势在最接近“金属”(指底层机器)的地方。Go的优势是在离用户更近的地方最有利。这并不是说两者都不能在对方的空间里工作,但这样做会增加摩擦。当你的需求从灵活性转变为效率时,用Rust重写库的理由就更充分了。

虽然Go和Rust的设计有很大的不同,但它们的设计发挥了兼容的优势,而且–当一起使用时–既可以有很大的灵活性,又可以有很好的性能。

4. 我们的建议

对于大多数公司和用户来说,Go是正确的默认选择。它的性能很强,Go很容易采用,而且Go的高度模块化特性使它特别适合需求不断变化或发展的情况。

随着你的产品逐渐成熟,需求趋于稳定,可能会有机会从性能的边际增长中获得巨大的胜利。在这些情况下,使用Rust来最大限度地提高性能可能很值得你进行初始投资。


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

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

欢迎各位Gopher加入!

Go技术专栏“改善Go语⾔编程质量的50个有效实践”正在慕课网火热热销中!本专栏主要满足广大gopher关于Go语言进阶的需求,围绕如何写出地道且高质量Go代码给出50条有效实践建议,上线后收到一致好评!欢迎大家订阅!目前该技术专栏正在新春促销!关注我的个人公众号“iamtonybai”,发送“go专栏活动”即可获取专栏专属优惠码,可在订阅专栏时抵扣20元哦(2021.2月末前有效)。

我的网课“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语言第一课 Go语言精进之路1 Go语言精进之路2 Go语言编程指南
商务合作请联系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
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats