标签 泛型 下的文章

Go泛型真的要来了!最早在Go 1.17版本支持

Go官博今晨发表了Go核心团队两位大神Ian Lance Taylor和Go语言之父之一的Robert Griesemer撰写的文章“The Next Step for Generics”,该文介绍了Go泛型(Go Generics)的最新进展和未来计划。

2019年中旬,在Go 1.13版本发布前夕的GopherCon 2019大会上,Ian Lance Taylor代表Go核心团队做了有关Go泛型进展的介绍。自那以后,Go团队对原先的Go Generics技术草案做了进一步精化,并编写了相关工具让社区gopher体验满足这份设计的Go generics语法,返回建议和意见。经过一年多的思考、讨论、反馈与实践,Go核心团队决定在这份旧设计的基础上另起炉灶,撰写了一份Go Generics的新技术提案:“Type Parameters”。与上一份提案最大的不同在于使用扩展的interface类型替代“Contract”用于对类型参数的约束。

parametric polymorphism((形式)参数多态)是Go此版泛型设计的基本思想。和Go设计思想一致,这种参数多态并不是通过像面向对象语言那种子类型的层次体系实现的,而是通过显式定义结构化的约束实现的。基于这种设计思想,该设计不支持模板元编程(template metaprogramming)和编译期运算。

注意:虽然都称为泛型(generics),但是Go中的泛型(generics)仅是用于狭义地表达带有类型参数(type parameter)的函数或类型,这与其他编程语言中的泛型(generics)在含义上有相似性,但不完全相同。

从目前的情况来看,该版设计十分接近于最终接受的方案,因此作为Go语言鼓吹者这里就和大家一起看看最早将于Go 1.17版本(2021年8月)中加入的Go泛型支持究竟是什么样子的。由于目前关于Go泛型的资料仅限于这份设计文档以及一些关于这份设计的讨论贴,本文内容均来自这些资料。另外最终加入Go的泛型很可能与目前设计文档中提到的有所差异,请各位小伙伴们了解。

1. 通过为type和function增加类型参数(type parameters)的方式实现泛型

Go的泛型主要体现在类型和函数的定义上。

  • 泛型函数(generic function)

Go提案中将带有类型参数(type parameters)的函数称为泛型函数,比如:

func PrintSlice(type T)(s []T) {
    for _, v := range s {
        fmt.Printf("%v ", v)
    }
    fmt.Print("\n")
}

其中,函数名PrintSlice与函数参数列表之间的type T即为类型参数列表。顾名思义,该函数用于打印元素类型为T的切片中的所有元素。使用该函数的时候,除了要传入要打印的切片实参外,还需要为类型参数传入实参(一个类型名),这个过程称为泛型函数的实例化。见下面例子:

// https://go2goplay.golang.org/p/rDbio9c4AQI
package main

import "fmt"

func PrintSlice(type T)(s []T) {
    for _, v := range s {
        fmt.Printf("%v ", v)
    }
    fmt.Print("\n")
}

func main() {
    PrintSlice(int)([]int{1, 2, 3, 4, 5})
    PrintSlice(float64)([]float64{1.01, 2.02, 3.03, 4.04, 5.05})
    PrintSlice(string)([]string{"one", "two", "three", "four", "five"})
}

运行该示例:

1 2 3 4 5
1.01 2.02 3.03 4.04 5.05
one two three four five

但是这种每次都显式指定类型参数实参的使用方式显然有些复杂繁琐,给开发人员带来心智负担和不好的体验。Go编译器是聪明的,大多数使用泛型函数的场景下,编译器都会根据函数参数列表传入的实参类型自动推导出类型参数的实参类型(type inference)。比如将上面例子改为下面这样,程序依然可以输出正确的结果。

// https://go2goplay.golang.org/p/UgHqZ7g4rbo
package main

import "fmt"

func PrintSlice(type T)(s []T) {
    for _, v := range s {
        fmt.Printf("%v ", v)
    }
    fmt.Print("\n")
}

func main() {
    PrintSlice([]int{1, 2, 3, 4, 5})
    PrintSlice([]float64{1.01, 2.02, 3.03, 4.04, 5.05})
    PrintSlice([]string{"one", "two", "three", "four", "five"})
}
  • 泛型类型(generic type)

Go提案中将带有类型参数(type parameters)的类型定义称为泛型类型,比如我们定义一个底层类型为切片类型的新类型:Vector:

type Vector(type T) []T

该Vector(切片)类型中的元素类型为T。和泛型函数一样,使用泛型类型时,我们首先要对其进行实例化,即显式为类型参数赋一个实参值(一个类型名):

//https://go2goplay.golang.org/p/tIZN2if1Wxo

package main

import "fmt"

func PrintSlice(type T)(s []T) {
    for _, v := range s {
        fmt.Printf("%v ", v)
    }
    fmt.Print("\n")
}

type Vector(type T) []T

func main() {
    var vs = Vector(int){1, 2, 3, 4, 5}
    PrintSlice(vs)
}

泛型类型的实例化是必须显式为类型参数传参的,编译器无法自行做类型推导。如果将上面例子中main函数改为如下实现方式:

func main() {
    var vs = Vector{1, 2, 3, 4, 5}
    PrintSlice(vs)
}

则Go编译器会报如下错误:

type checking failed for main
prog.go2:15:11: cannot use generic type Vector(type T) without instantiation

这个错误的意思就是:未实例化(instantiation)的泛型类型Vector(type T)无法使用。

2. 通过扩展了的interface类型对类型参数进行约束和限制

1) 对泛型函数中类型参数的约束与限制

有了泛型函数,我们来实现一个“万能”加法函数:

// https://go2goplay.golang.org/p/t0vXI6heUrT
package main

import "fmt"

func Add(type T)(a, b T) T {
    return a + b
}

func main() {
    c := Add(5, 6)
    fmt.Println(c)
}

运行上述示例:

type checking failed for main
prog.go2:6:9: invalid operation: operator + not defined for a (variable of type T)

什么情况!这么简单的一个函数,Go编译器居然报了这个错误:类型参数T未定义“+”这个操作符运算

在此版Go泛型设计中,泛型函数只能使用类型参数所能实例化出的任意类型都能支持的操作。比如上述Add函数的类型参数type T没有任何约束,它可以被实例化为任何类型。那么这些实例化后的类型是否都支持“+”操作符运算呢?显然不是。因此,编译器针对示例代码中的第六行报了错!

对于像上面Add函数那样的没有任何约束的类型参数实例,Go允许对其进行的操作包括:

  • 声明这些类型的变量;
  • 使用相同类型的值为这些变量赋值;
  • 将这些类型的变量以实参形式传给函数或从作为函数返回值;
  • 取这些变量的地址;
  • 将这些类型的值转换或赋值给interface{}类型变量;
  • 通过类型断言将一个接口值赋值给这类类型的变量;
  • 在type switch块中作为一个case分支;
  • 定义和使用由该类型组成的复合类型,比如:元素类型为该类型的切片;
  • 将该类型传递给一些内置函数,比如new。

那么,我们要让上面的Add函数通过编译器的检查,我们就需要限制其类型参数所能实例化出的类型的范围。比如:仅允许实例化为底层类型(underlying type)为整型类型的类型。上一版Go泛型设计中使用Contract来定义对类型参数的约束,不过由于Contract与interface在概念范畴上有交集,让Gopher们十分困惑,于是在新版泛型设计中,Contract这个关键字被移除了,取而代之的是语法扩展了的interface,即我们使用interface类型来修饰类型参数以实现对其可实例化出的类型集合的约束。我们来看下面例子:

// https://go2goplay.golang.org/p/kMxZI2vIsk-
package main

import "fmt"

type PlusableInteger interface {
    type int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64
}

func Add(type T PlusableInteger)(a, b T) T {
    return a + b
}

func main() {
    c := Add(5, 6)
    fmt.Println(c)
}

运行该示例:

11

如果我们在main函数中写下如下代码:

    f := Add(3.65, 7.23)
    fmt.Println(f)

我们将得到如下编译错误:

type checking failed for main
prog.go2:20:7: float64 does not satisfy PlusableInteger (float64 not found in int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64)

我们看到:该提案扩展了interface语法,新增了类型列表(type list)表达方式,专用于对类型参数进行约束。以该示例为例,如果编译器通过类型推导得到的类型在PlusableInteger这个接口定义的类型列表(type list)中,那么编译器将允许这个类型参数实例化;否则就像Add(3.65, 7.23)那样,推导出的类型为float64,该类型不在PlusableInteger这个接口定义的类型列表(type list)中,那么类型参数实例化将报错!

注意:定义中带有类型列表的接口将无法用作接口变量类型,比如下面这个示例:

// https://go2goplay.golang.org/p/RchnTw73VMo
package main

type PlusableInteger interface {
    type int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64
}

func main() {
    var n int = 6
    var i PlusableInteger
    i = n
    _ = i
}

编译器会报如下错误:

type checking failed for main
prog.go2:9:8: interface type for variable cannot contain type constraints (int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64)

我们还可以用interface的原生语义对类型参数进行约束,看下面例子:

// https://go2goplay.golang.org/p/hyTbglTLoIn
package main

import (
    "fmt"
    "strconv"
)

type StringInt int

func (i StringInt) String() string {
    return strconv.Itoa(int(i))
}

type Stringer interface {
    String() string
}

func Stringify(type T Stringer)(s []T) (ret []string) {
    for _, v := range s {
        ret = append(ret, v.String())
    }
    return ret
}

func main() {
    fmt.Println(Stringify([]StringInt{1, 2, 3, 4, 5}))
}

运行该示例:

[1 2 3 4 5]

如果我们在main函数中写下如下代码:

func main() {
    fmt.Println(Stringify([]int{1, 2, 3, 4, 5}))
}

那么我们将得到下面的编译器错误输出:

type checking failed for main
prog.go2:27:2: int does not satisfy Stringer (missing method String)

我们看到:只有实现了Stringer接口的类型才会被允许作为实参传递给Stringify泛型函数的类型参数并成功实例化。

我们还可以结合interface的类型列表(type list)和方法列表一起对类型参数进行约束,看下面示例:

// https://go2goplay.golang.org/p/tchwW6mPL7_d
package main

import (
    "fmt"
    "strconv"
)

type StringInt int

func (i StringInt) String() string {
    return strconv.Itoa(int(i))
}

type SignedIntStringer interface {
    type int, int8, int16, int32, int64
    String() string
}

func Stringify(type T SignedIntStringer)(s []T) (ret []string) {
    for _, v := range s {
        ret = append(ret, v.String())
    }
    return ret
}

func main() {
    fmt.Println(Stringify([]StringInt{1, 2, 3, 4, 5}))
}

在该示例中,用于对泛型函数的类型参数进行约束的SignedIntStringer接口既包含了类型列表,也包含方法列表,这样类型参数的实参类型既要在SignedIntStringer的类型列表中,也要实现了SignedIntStringer的String方法。

如果我们将上面的StringInt的底层类型改为uint:

type StringInt uint

那么我们将得到下面的编译器错误输出:

type checking failed for main
prog.go2:27:14: StringInt does not satisfy SignedIntStringer (uint not found in int, int8, int16, int32, int64)

2) 引入comparable预定义类型约束

由于Go泛型设计选择了不支持运算操作符重载,因此,我们即便对interface做了语法扩展,依然无法表达类型是否支持==!=。为了解决这个表达问题,这份新设计提案中引入了一个新的预定义类型约束:comparable。我们看下面例子:

// https://go2goplay.golang.org/p/tea39NqwZGC
package main

import (
    "fmt"
)

// Index returns the index of x in s, or -1 if not found.
func Index(type T comparable)(s []T, x T) int {
    for i, v := range s {
        // v and x are type T, which has the comparable
        // constraint, so we can use == here.
        if v == x {
            return i
        }
    }
    return -1
}

type Foo struct {
    a string
    b int
}

func main() {
    fmt.Println(Index([]int{1, 2, 3, 4, 5}, 3))
    fmt.Println(Index([]string{"a", "b", "c", "d", "e"}, "d"))
    pos := Index(
        []Foo{
            Foo{"a", 1},
            Foo{"b", 2},
            Foo{"c", 3},
            Foo{"d", 4},
            Foo{"e", 5},
        }, Foo{"b", 2})
    fmt.Println(pos)
}

运行该示例:

2
3
1

我们看到Go的原生支持比较的类型,诸如整型、字符串以及由这些类型组成的复合类型(如结构体)均可以直接作为实参传给由comparable约束的类型参数。comparable可以看成一个由Go编译器特殊处理的、包含由所有内置可比较类型组成的type list的interface类型。我们可以将其嵌入到其他作为约束的接口类型定义中:

type ComparableStringer interface {
    comparable
    String() string
}

只有支持比较的类型且实现了String方法,才能满足ComparableStringer的约束。

3) 对泛型类型中类型参数的约束

和对泛型函数中类型参数的约束方法一样,我们也可以对泛型类型的类型参数以同样方法做同样的约束,看下面例子:

// https://go2goplay.golang.org/p/O-YpTcW-tPu

// Package set implements sets of any comparable type.
package main

// Set is a set of values.
type Set(type T comparable) map[T]struct{}

// Make returns a set of some element type.
func Make(type T comparable)() Set(T) {
    return make(Set(T))
}

// Add adds v to the set s.
// If v is already in s this has no effect.
func (s Set(T)) Add(v T) {
    s[v] = struct{}{}
}

// Delete removes v from the set s.
// If v is not in s this has no effect.
func (s Set(T)) Delete(v T) {
    delete(s, v)
}

// Contains reports whether v is in s.
func (s Set(T)) Contains(v T) bool {
    _, ok := s[v]
    return ok
}

// Len reports the number of elements in s.
func (s Set(T)) Len() int {
    return len(s)
}

// Iterate invokes f on each element of s.
// It's OK for f to call the Delete method.
func (s Set(T)) Iterate(f func(T)) {
    for v := range s {
        f(v)
    }
}

func main() {
    s := Make(int)()

    // Add the value 1,11,111 to the set s.
    s.Add(1)
    s.Add(11)
    s.Add(111)

    // Check that s does not contain the value 11.
    if s.Contains(11) {
        println("the set contains 11")
    }
}

运行该示例:

the set contains 11

这个示例定义了一个数据结构:Set。该Set中的元素是有约束的:必须支持可比较。对应到代码中,我们用comparable作为泛型类型Set的类型参数的约束。

4) 关于泛型类型的方法

泛型类型和普通类型一样,也可以定义自己的方法。但泛型类型的方法目前不支持除泛型类型自身的类型参数之外的其他类型参数了。我们看下面例子:

// https://go2goplay.golang.org/p/JipsxG7jeCN

// Package set implements sets of any comparable type.
package main

// Set is a set of values.
type Set(type T comparable) map[T]struct{}

// Make returns a set of some element type.
func Make(type T comparable)() Set(T) {
    return make(Set(T))
}

// Add adds v to the set s.
// If v is already in s this has no effect.
func (s Set(T)) Add(v T) {
    s[v] = struct{}{}
}

func (s Set(T)) Method1(type P)(v T, p P) {

}

func main() {
    s := Make(int)()
    s.Add(1)
    s.Method1(10, 20)
}

在这个示例中,我们新定义的Method1除了在参数列表中使用泛型类型Set的类型参数T之外,又接受了一个类型参数P。执行该示例:

type checking failed for main
prog.go2:18:24: methods cannot have type parameters

我们看到编译器给出错误:泛型类型的方法不能再有其他类型参数。目前提案仅是暂时不支持额外的类型参数(如果支持,会让语言规范和实现都变得异常复杂),Go核心团队也会听取社区反馈的意见,直到大家都认为支持额外类型参数是有必要的,那么后续会重新添加。

5) type *T Constraint

上面我们一直采用的对类型参数的约束形式是:

type T Constraint

假设调用泛型函数时某类型A要作为T的实参传入,A必须实现Constraint(接口)。

如果我们将上面对类型参数的约束形式改为:

type *T Constraint

那么这将意味着类型A要作为T的实参传入,*A必须满足Constraint(接口)。并且Constraint中的所有方法(如果有的话)都仅能通过*A实例调用。我们来看下面示例:

// https://go2goplay.golang.org/p/g3cwgguCmUo
package main

import (
    "fmt"
    "strconv"
)

type Setter interface {
    Set(string)
}

func FromStrings(type *T Setter)(s []string) []T {
    result := make([]T, len(s))
    for i, v := range s {
        result[i].Set(v)
    }
    return result
}

// Settable is a integer type that can be set from a string.
type Settable int

// Set sets the value of *p from a string.
func (p *Settable) Set(s string) {
    i, _ := strconv.Atoi(s) // real code should not ignore the error
    *p = Settable(i)
}

func main() {
    nums := FromStrings(Settable)([]string{"1", "2"})
    fmt.Println(nums)
}

运行该示例:

[1 2]

我们看到Settable的方法集合是空的,而*Settable的方法集合(method set)包含了Set方法。因此,*Settable是满足Setter对FromStrings函数的类型参数的约束的。

而如果我们直接使用type T Setter,那么编译器将给出下面错误:

type checking failed for main
prog.go2:30:22: Settable does not satisfy Setter (missing method Set)

如果我们使用type T Setter并结合使用FromStrings(*Settable),那么程序运行会panic。

https://go2goplay.golang.org/p/YLe2d78aSz-

3. 性能影响

根据这份技术提案中关于泛型函数和泛型类型实现的说明,Go会使用基于接口的方法来编译泛型函数(generic function),这将优化编译时间,因为该函数仅会被编译一次。但是会有一些运行时代价。

对于每个类型参数集,泛型类型(generic type)可能会进行多次编译。这将延长编译时间,但是不会产生任何运行时代价。编译器还可以选择使用类似于接口类型的方法来实现泛型类型,使用专用方法访问依赖于类型参数的每个元素。

4. 小结

Go泛型方案的即将定型即好也不好。Go向来以简洁著称,增加加泛型,无论采用什么技术方案,都会增加Go的复杂性,提升其学习门槛,代码可读性也会下降。但在某些场合(比如实现container数据结构及对应算法库等),使用泛型却又能简化实现。

在这份提案中,Go核心团队也给出如下期望:

We expect that most packages will not define generic types or functions, but many packages are likely to use generic types or functions defined elsewhere

我们期望大多数软件包不会定义泛型类型或函数,但是许多软件包可能会使用在其他地方定义的泛型类型或函数。

并且提案提到了会在Go标准库中增加一些新包,已实现基于泛型的标准数据结构(slice、map、chan、math、list/ring等)、算法(sort、interator)等,gopher们只需调用这些包提供的API即可。

另外该提案的一大优点就是与Go1兼容,我们可能永远不会使用Go2这个版本号了。

go核心团队提供了可实践该方案语法的playground:https://go2goplay.golang.org/,大家可以一边研读技术提案,一边编写代码进行实验验证。


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

我爱发短信:企业级短信平台定制开发专家 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

微信赞赏:
img{512x368}

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

Go语言联合作者Rob Pike专访:Go确实已成为云基础架构的语言

尽管看到Docker,Kubernetes和用Go编写的云计算的许多其他组件令人欣喜和重要,但也许并不奇怪。Go确实已经成为云基础架构的语言。- Rob Pike,Go编程语言的联合作者

本文翻译自《Rob Pike interview: “Go has indeed become the language of cloud infrastructure”》

img{512x368}

简介

我们与Go编程语言之父Rob Pike(以下称Rob)谈谈跨越整整40年的职业生涯、过去10年来Go语言的变化,以及未来Go语言的演化方向。

专访

Evrone:您与今天的许多开发人员不同,您数十年前就在Bell Labs开始了您的职业生涯。以您的阅历和认知,您认为我们开发软件时最大变化是什么?

Rob:今天的软件规模(scale)更大。不仅是计算机和网络,还有程序本身。所有Unix版本6(大约1975年)的程序都可以顺利地安装在单个RK05磁盘包上,该磁盘包的存储量刚刚超过2MB,还为用户软件留出了很大的空间。那是一个很好的计算环境,或者至少在当时看起来是一个。当然,尽管我可以解释其中的大部分增长,但令人惊讶的是,也许并不是所有的增长都是合理的。

Evrone:鉴于“变革的阻力”和“兼容性的承诺”,您如何看待Go编程语言及其生态系统在未来十年的发展?您认为的该技术的最佳未来是什么呢?

Rob:尽管还不确定,但经过十多年的努力,一个看起来更像是针对参数多态性的设计即我们俗称泛型(具有误导性)的东西将在未来一两年内问世。找到一个可以在现有语言中运行并且感觉好像属于它的设计是一个非常困难的问题,但是伊恩·泰勒(Ian Taylor)在该问题中投入了巨大的精力,看来现在已经找到了答案。我也非常渴望看到该设计会如何影响库、生态系统和社区的。

Evrone:随着“渐进类型”引入“动态类型”语言以及“类型推断”引入“静态类型”,两者之间的界限现在变得越来越模糊。您对现代编程语言的类型系统有何看法?

Rob:我非常喜欢静态类型,因为它带来了稳定性和安全性。

我也非常喜欢动态打类型,因为它带来的乐趣和轻巧的感觉。

我不喜欢类型驱动的编程、类型层次结构、类以及继承。尽管已经通过这些方式构建了许多非常成功的项目,但我认为这种方法将重要的决策过早地推到了设计阶段,而经验并没有影响到它。换句话说,我更喜欢组合而不是继承。

但是,我对那些喜欢使用继承来构造程序的人说:不必在意我的观点,请继续使用对你们有用的东西。

Evrone:有时候人们以奇怪的方式使用技术。例如,要从高级PythonRuby代码生成高效的Go代码(是的,我们已经看到了!)多年来,您看到过最奇怪,最有创意或有趣的Go用法了吗?最让您惊讶的是什么?

Rob:最大的惊喜是当我们得知Go被用于编写恶意软件时(译注:手动允悲)。您无法控制谁将使用您的作品或他们将如何使用它。

Evrone:您设计和实现了许多文本编辑器。您如何看待Visual Studio Code?通过LSP之类的技术,“文本编辑器”和IDE之间的界限现在变得模糊了。您是否认为软件开发人员需要功能强大的IDE(如GoLand)或使用VSCode很好?

Rob:我来自IDE之前的时代。但是在项目的早期,有人谈到Go是否需要IDE才能成功。但是,团队中没有人拥有这方面的技能,因此我们没有尝试去创建一个(Go专属IDE)。但是,我们确实创建了用于解析和打印Go代码的核心库,这为各种编辑器和IDE快速创建了高质量的插件提供了极大的便利,这也算是一个偶然的成功。

最近,我们一直在努力为Go开发LSP服务器,该服务器称为gopls,支持该协议的任何编辑器或IDE均可使用该服务器,以改善使用该语言的体验。

也许是因为我们对使用简单的编辑器形式感到满意,所以我们确保大家无需背负沉重的编程环境搭建负担即可轻松地使用Go工作。但是,IDE当然可以提供帮助:我今天看到的大多数使用Go IDE或至少使用具有自定义Go支持的编辑器的开发人员都能从中获得很多价值。

使用哪种编辑器风格的问题取决于您的口味,并随您所用语言的文化而变化。

Evrone:软件开发人员倾向于给事物打标签,例如Dart是一种“前端语言”,而C是一种“系统底层语言”,等等。就目前的Go语言的功能集和用法,您现在如何称呼它?

Rob: Go是一种通用编程语言。编写您想要的任何内容,不必担心将语言或与此相关的任何其他技术固定到单个问题域。

Evrone:您个人还喜欢哪些其他现代编程语言?

Rob:Go的经验告诉我,人们喜欢对语言发表意见,这可能比我们领域中的几乎任何其他要素都要多。我当然也是这样做的。但是我对经常导致的消极情绪感到厌倦,所以现在我尽量避免评判那些事情。

在很少有新的语言问世并获得成功的一段时间之后,在过去的十多年中,语言设计才有了真正的复兴。很高兴看到这一点及其带来的创新。

Evrone:成为Google员工是如何帮助您开发和引导Go语言的?能够在Twitter上问“告诉我们您如何使用我们的语言”并获得全球最大公司的回应有多重要?它只是语言开发的一个不错的补充还是必不可少的一部分?Google如何为您提供帮助的?

Rob: Google非常支持Go项目,对此我深表感谢。当然,创建该语言是因为我们认为Google需要它。所谓的“云计算”需要一种具有对并发性和易于部署等方面良好支持的语言。但是Google并没有以任何重要方式指导该项目。它支持我们,让我们做我们认为最好的事情。

对于其他公司和其他用户,社区的投入对于理解项目的进展至关重要,我的意思是语言,编译器,工具,运行时,库,环境(所有这些)的发展。

Evrone:经过10年的Go开发以及对其使用方式的观察,您能说出该语言最大的设计成功和最大的失败是什么?分别是最强点和最弱点?

Rob:我要说两件事,一是技术问题,一是政治问题。

技术上是对并发计算的原生(first-class)支持。Go仅仅存在了十年左右,但是当它被开发时,“线程”和并发在编程社区中并未得到广泛认可。实际上,创建Go的主要原因是当时很难用C++进行并发计算。并发支持在发布后不久就很明显成为了该语言的一个主要吸引力,可以弥补一些人认为该语言其他部分的缺点。并发动了大家的神经。一旦人们开始使用并发功能,他们便开始探索有关该语言的其他内容,并发现那里(Go语言中)存在的东西超出了他们最初的想象。支持并发是(进入Go语言世界)的网关。

正如CloudflareJohn Graham-Cumming所说:“我为实现简单的并发而来,而为实现简单的组合而留下来”

Go改变了有关如何对多核计算机进行编程的讨论。

Go语言在政治上的成功是坚定的执行了关于Go1兼容性的承诺。曾经我们和社区一旦使用Go几年,我们就有了很长的清单需要修复,但是变化是破坏性的。因此,我们仔细设计了更新程序,并使用了“go fix”命令来推动社区发展。完成这些后,我们不仅停了下来,而且还承诺会保持这种“停止”状态。这种稳定性 – 2012年编写的Go程序今天仍可以编译并完美运行 – 是促进增长的巨大推动力。公司可以放心使用我们,因为我们不会破坏其软件。在Go 1.0版本及其兼容性承诺出现之后,Go的采用率急剧上升。而且,从那以后,尽管我们有许多我们想改变的东西,但是我们不能破坏现有的程序,对此,我们感觉很好。

Evrone:您的工作与生活平衡如何?现在有很多关于“倦怠”的话题,这种流行病根本没有帮助。以你40年的阅历,您对新一代开发者有何提醒?

Rob:避免倦怠的最佳方法是在支持您的环境中做自己真正喜欢的事情。在整个职业生涯中,我一直很幸运,但是我意识到并不是每个人都如此幸运。如果您因工作而感到压力,则应随时休息或改变方向,尤其是在当前情况下。

Evrone:事后看来,许多技术的普及归功于使它们流行的所谓“杀手级应用”。您能为Go编程语言列举出这样的“杀手级应用程序”吗?您整体上对这种“杀手级应用程序”想法有何看法?

Rob:几年前,Danny Berkholz将Go称为“云基础架构的新兴语言”,这绝非偶然。Go是由Google的工作人员设计的,目的是使编写与Google相关的软件(特别是驻留在网络中的服务器)更容易。就是今天我们所说的“云”。(该设计的某些动机是在我2012年的Splash主题演讲: Go at Google: 软件工程服务中的语言设计

因此,尽管看到用Go语言编写的DockerKubernetes和云计算的许多其他组件很令人高兴且很重要,但也许并不奇怪。Go确实已经成为云基础架构的语言

Evrone:您觉得Go语言的竞争对手是谁?在哪个领域竞争?您对Rust的“无垃圾收集”构想和编译时保证有何看法?

Rob: Rust是一种有趣的语言,我很感兴趣地看着它的发展。除此之外,正如我上面所说,我没有意见。

Evrone:Go在GitHub上已达到7万颗星!您如何看待GitHub,Reddit,Twitter,离线和在线会议,网络研讨会等不同的社交活动对语言的影响?它们对语言的成功重要还是仅仅反映了语言的成功?

Rob:我们通过会议和社交媒体结识的人们一直是Go及其所有元素发展的关键部分。许多许多贡献者以积极的方式影响了开发,包括将Go移植到Windows和许多非x86架构上,工具和库的开发,对技术建议的深入讨论等等。

反过来,Go团队也与社区进行联系并积极讨论,提出问题并寻求帮助和指导。

我认为重要的一件事是,以一种声音与社区互动,以团队而非个人的身份说话。一致的消息更容易理解。

Evrone:成为一种流行的编程语言的作者如何改变了您的生活?

Rob:一个更正:我是合著者,而不是作者。肯·汤普森(Ken Thompson)和罗伯特·格里塞梅尔(Robert Griesemer)与我一起开始了这个项目,其他许多人也做出了巨大贡献。因此,请不要单把我列为“作者”。

为了回答您的问题,Go无疑提高了我的公众形象,并向我介绍了一个新的充满活力的社区,但是除此之外,它并没有太大的作用。我有很长的职业生涯,并取得了其他的成功(以及无数的失败)。

Evrone:想象一下,如果您有机会时光倒流并且给年轻时候的你提出一个建议(只有一个),如果是回到大约在您开始设计Go语言规范时,您会给您自己和您的同事提出什么建议?

Rob:很简单:忽略仇恨者(haters)。只倾听那些能理解和分享您目标的声音;他们是在乎Go的人。并非每个人都认同您在做的事情,这没关系。但是,那些致力于推进您想要做的事情的人可能会成为想法,能量和灵感的绝佳来源。

我们将永远感谢我们充满热情的社区。


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

我爱发短信:企业级短信平台定制开发专家 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

微信赞赏:
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