No caminho para o Go 2.0
Published: 2023-04-12 20:51:11

**Go** está na versão **1.12.7** e caminhando para versão 2.0, este post é para apresentar um pouco deste caminho que está sendo construído pela comunidade e equipe de desenvolvimento do **Go**. Estamos todos a caminho para o **Go 2.0** juntos, mas ninguém ainda sabe exatamente para onde ele irá nos levar.

![Não foi fornecido texto alternativo para esta imagem](https://media.licdn.com/dms/image/C4D12AQHz1NTARqEdyQ/article-inline_image-shrink_1000_1488/0/1565195119784?e=1686182400&v=beta&t=O2TunHQZ18x-v2Ll1M7ZhTdEGA9kelfIQ1D7DWHGze0 align="left")

Uma forma que a equipe de Go encontrou para melhorar ainda mais seu processo evolutivo da linguagem foi experimentando e colocando em prática a própria linguagem. [***Russ Cox***](https://www.linkedin.com/in/swtch/) descreveu: *"Utilizamos e experimentamos o Go como ele existe agora, para entende-lo melhor, aprender o que funciona bem e o que não funciona. Então, experimentamos possíveis mudanças, para entendê-las melhor, novamente aprendendo o que funciona bem e o que não funciona. Com base no que aprendemos com esses experimentos, simplificamos. E então nós experimentamos novamente. E então nós simplificamos novamente. E assim por diante. E assim por diante."*

### Os quatro R's da simplificações

Durante esse processo, a equipe de desenvolvimento **Go** apresentou quatro maneiras principais de simplificar a experiência geral de escrever programas **Go**: ***remodelando, redefinindo, removendo e restringindo.***

**Simplifique remodelando**

A primeira maneira que simplificamos é reformular o que existe em uma nova forma, que acaba sendo mais simples no geral.

Cada programa Go que escrevemos serve como uma experiência para testar o próprio Go. Nos primeiros dias do Go, nota-se que aprendem rapidamente a escrever código como essa **addToList**:

```go
func addToList(list []int, x int) []int {
    n := len(list)
    if n+1 > cap(list) {
        big := make([]int, n, (n+5)*2)
        copy(big, list)
        list = big
    }
    list = list[:n+1]
    list[n] = x    
    return list

}
```

Basta conferir o código que percebe-se que escreveria o mesmo código para slices de bytes e slices de strings, e assim por diante. Estes programas eram muito complexos, porque o **Go** era muito simples.

Então, a equipe que desenvolve Go pegou as muitas funções, como addToList, e as transformou em uma função fornecida pelo próprio **Go**. A adição **append** tornou a linguagem Go um pouco mais complexa, mas, no geral, tornou a experiência geral de escrever programas Go mais simples, mesmo depois de contabilizar o custo do aprendizado append.

Adicionaram código e complexidade à distribuição Go, mas no final simplificamos a experiência de escrever programas Go. A nova estrutura também criou espaço para outros experimentos interessantes, que veremos mais adiante.

**Simplifique redefinindo**

Uma segunda maneira que eles encontraram para simplificar é redefinir a funcionalidade que já temos, permitindo que ela faça mais. Como simplificar remodelando, simplificar redefinindo torna os programas mais simples de escrever, mas agora sem nada de novo para aprender.

Por exemplo, append foi originalmente definido para ler somente slices. Ao anexar a uma slice de byte, você poderia acrescentar os bytes de outra slice de byte, mas não os bytes de uma string. Nós redefinimos acrescentar para permitir acrescentar uma string, sem adicionar nada de novo ao idioma.

```go
var b []byte
var more []byte
b = append(b, more...) // ok


var b []byte
var more string
b = append(b, more...) // ok later

```

**Simplifique Removendo**

Uma terceira maneira que encontraram para simplificar é removendo a funcionalidade quando ela se tornou menos útil ou menos importante do que esperavam. Remover a funcionalidade significa menos uma coisa para aprender, uma coisa a menos para corrigir erros, uma coisa a menos para se distrair ou usar incorretamente. Evidentemente, a remoção também força os usuários a atualizar os programas existentes, talvez tornando-os mais complexos, para compensar a remoção. Mas o resultado geral ainda pode ser que o processo de escrever programas **Go** se torne mais simples.

Um exemplo disso é quando removeram as formas booleanas de operações de canal sem bloqueio do idioma:

```go
ok := c <- x  // before Go 1, was non-blocking send
x, ok := <-c  // before Go 1, was non-blocking receive

```

Essas operações também foram possíveis de usar select, tornando confuso precisar decidir qual forma usar. Removê-los simplificou a linguagem sem reduzir seu poder.

**Simplifique restringindo**

Também perceberam outra forma de simplificar restringindo o que é permitido. Desde o primeiro dia, o Go restringiu a codificação dos arquivos-fonte do Go: eles devem ser o UTF-8. Essa restrição faz com que todo programa que tenta ler os arquivos de origem do Go seja mais simples. Esses programas não precisam se preocupar com arquivos de código-fonte Go codificados em Latin-1 ou UTF-16 ou UTF-7 ou qualquer outra coisa.

Outra restrição importante é gofmt para formatação do programa. Nada rejeita o código Go que não é formatado usando gofmt, mas nós estabelecemos uma convenção de que as ferramentas que reescrevem os programas Go as deixam em gofmt. Se você mantiver seus programas em gofmt também, eles não farão nenhuma alteração de formatação. Quando você compara antes e depois, os únicos diffs que você vê são mudanças reais. Esta restrição simplificou reescrever e levou a experiências bem sucedidas, como goimports, gorename, e muitos outros.

### Processo de desenvolvimento Go

Este ciclo de experiência e simplificação é um bom modelo que os integrantes da equipe de desenvolvimento do Go tem feito nos últimos dez anos. mas tem um problema: é simples demais. Não contiveram em apenas experimentar e simplificar.

Tiveram que enviar os resultados, disponibilizá-los para usar. É claro que usá-lo permite mais experimentos e, possivelmente, mais simplificação, e o processo avança e continua.

![Não foi fornecido texto alternativo para esta imagem](https://media.licdn.com/dms/image/C4D12AQHUrbN9KrUWmg/article-inline_image-shrink_1000_1488/0/1565197084080?e=1686182400&v=beta&t=AnHYrlDuedETdDQmdOB-slCHY7yGBlT8iZKsXPCZpIY align="left")

Go foi liberado para todos pela primeira vez em **10 de novembro de 2009**. Então, com ajuda de todos da comunidade, enviaram Go 1.0 em **março de 2012**. E já lançaram doze lançamentos **Go** desde então. Todos esses foram marcos importantes, para permitir mais experimentações, toda comunidade colaborou e ajudou a aprender mais sobre o **Go** e, é claro, para disponibilizar o Go para uso em produção.

Quando lançaram o **Go 1**, explicitamente mudaram internamente toda equipe que desenvolveu Go o foco para o uso do Go, para que conseguissem entender melhor a versão da linguagem antes de tentar mais simplificações envolvendo alterações de idioma. Precisavam de um tempo para experimentar, para realmente entender o que funciona e o que não funciona.

Eles estão o tempo todo testando e experimentando, simplificando e atualizando novas versões. Estão bem mais concentrados em maneiras de simplificar o desenvolvimento do Go sem alterações significativas na linguagem e sem interromper os programas existentes do Go. Por exemplo, o Go 1.5 tivemos o primeiro coletor de lixo **(GC)** simultâneo e, em seguida, os seguintes releases o aprimoraram, simplificando o desenvolvimento do Go, removendo os tempos de pausa como uma preocupação constante.

Na Gophercon em 2017, anunciaram que após cinco anos de experimentação, era hora de pensar novamente em mudanças significativas que simplificariam o desenvolvimento do Go. O caminho para o Go 2 é realmente o mesmo que o caminho para o Go 1: experimentar e simplificar e liberar, em direção a um objetivo geral de **simplificar o desenvolvimento do Go.**

Para o Go 2, os tópicos concretos que eles consideram mais importantes e o que são abordados nos posts são: *manipulação de erros*, *generics e dependências*. Desde então, percebe-se que outro tópico importante é o desenvolvimento de ferramentas.

### Conclusão

Foi apresentando um pouco do *ciclo de desenvolvimento* que a equipe responsável por manter a linguagem Go fazem, isto é explícito para toda comunidade. Toda evolução da linguagem é comunicada pela equipe e abrem um canal de comunicação direto com a comunidade e isto vem dando certo, diversas propostas são lançadas e discutidas a fundo, isto é muito legal e muito positivo. A linguagem cresce dia após dia tornando-se cada vez mais popular e poderosa. O mais bacana de tudo é que não estão preocupados com funcionalidades surrealistas ou apenas para agradar um público específico, eles estão caminhando um passo de cada vez, mantendo o designer inicial que a linguagem propunha, e focando no que realmente importa que é cada vez mais torna a **linguagem simples para os que forem desenvolver em Go**. Neste cenário percebe-se claramente que no designer de Go *"Menos é exponencialmente Mais"* a equipe de desenvolvedores do **Go** dizem que sua criação é uma tentativa de tornar os programadores mais produtivos e estão cada vez mais próximo deste objetivo. Os caminhos para o **Go 2.0** são os mesmos que utilizaram até o momento e o foco será *manipulação de erros*, *generics e dependências*.