Lançamento do Go 1.22

Foi lançado o Go 1.22, uma linguagem de programação desenvolvida pela Google em colaboração com a comunidade, que combina a alta performance das linguagens compiladas com as vantagens das linguagens de script, como a facilidade de escrita de código, rapidez de desenvolvimento e proteção contra erros. O código do projeto é distribuído sob a licença BSD.

A sintaxe do Go é baseada em elementos familiares da linguagem C, com algumas adoções da linguagem Oberon. A linguagem é bastante concisa, mas o código é fácil de ler e entender. O código em Go é compilado em arquivos executáveis binários separados, que são executados nativamente, sem o uso de uma máquina virtual (componentes de profiling, debugging e outros subsistemas de detecção de problemas são integrados como componentes em tempo de execução), o que permite atingir uma performance comparável a programas em C.

O projeto foi inicialmente desenvolvido com foco em programação concorrente e eficiência em sistemas multicore, fornecendo, incluindo, ferramentas para organizar computações paralelas e interação entre métodos executados em paralelo. A linguagem também fornece mecanismos integrados de proteção contra acesso a áreas de memória alocadas e inclui um coletor de lixo.

Entre as mudanças na nova versão:

• O loop 'for' agora suporta a definição de intervalos de números inteiros, como por exemplo, para iterar valores de 0 a 9, pode-se usar o loop 'for i := range 10 {…}'.
• Foi adicionada uma funcionalidade experimental (GOEXPERIMENT=rangefunc) ao loop 'for', permitindo especificar uma função como iterador. Por exemplo, 'for i, x := range slices.Backward(s) {…}'.
• Foi resolvido um problema antigo com loops 'for', que fazia com que, ao chamar goroutines, houvesse compartilhamento de variáveis do loop em diferentes iterações. Por exemplo, o código values := []string{"a", "b", "c"} for _, v := range values { go func() { fmt.Println(v) done <- true }() } agora irá imprimir 'a', 'b' e 'c', e não apenas 'c', como acontecia antes.
• Uma otimização foi realizada no gerenciamento de memória em tempo de execução, resultando em um aumento de performance de 1-3% e uma redução no consumo de memória na maioria das aplicações de 1%.
• O trabalho foi continuado na implementação de otimizações no compilador baseadas nos resultados de perfilamento de código (PGO — Profile-guided optimization), permitindo levar em conta características determinadas durante a execução do programa. Na nova versão, o compilador utiliza ferramentas de desvirtualização para substituir chamadas indiretas de diversos métodos pela execução de blocos inline expandidos.
• Com a ativação do PGO, a mudança adicionada permitiu aumentar o desempenho da maioria dos programas em 2-14%.
• Uma implementação experimental melhorada do mecanismo de expansão (inlining) de chamadas foi adicionada ao compilador (GOEXPERIMENT=newinliner), utilizando heurísticas para separar operações importantes de secundárias.
• Um novo pacote, "math/rand/v2", foi adicionado à biblioteca padrão, oferecendo uma API mais coesa e utilizando algoritmos mais rápidos para a geração de números pseudo-aleatórios.
• Foi adicionada ao pacote net/http.ServeMux a capacidade de especificar métodos e máscaras em padrões; por exemplo, o padrão "GET /static/{id}/" será aplicado a requisições com o método HTTP "GET" e manterá o valor do segundo segmento do caminho solicitado no identificador "id".
• O pacote database/sql agora suporta o tipo Null[T], que permite escanear colunas que podem ter o valor NULL. O pacote slices ganhou a função Concat para mesclar vários slices de qualquer tipo.
• Nas instruções para trabalhar com espaços de trabalho (coleções de módulos), foi oferecida a possibilidade de usar o diretório "vendor", que contém dependências para o conteúdo do espaço de trabalho. O diretório é criado ao executar o comando "go work vendor" e utilizado em comandos de build ao configurar a opção "-mod=vendor" (ativada por padrão na presença do diretório vendor).

Mudanças no comportamento das utilitários.

• O comando go get não é mais suportado fora do módulo no modo GOPATH obsoleto (ou seja, com GO111MODULE=off). Outros comandos de build, como go build e go test, continuarão a funcionar para programas GOPATH obsoletos por um período indefinido.
• O comando go mod init não tenta mais importar as exigências dos módulos a partir dos arquivos de configuração de outras ferramentas de fornecedores (como Gopkg.lock).
• O comando go test -cover agora imprime um resumo da cobertura para pacotes cobertos que não possuem arquivos de teste próprios. Até o Go 1.22, o comando go test -cover para tal pacote reportaria? mymod/mypack [no test files]

  E agora, com o Go 1.22, funções no pacote são consideradas não cobertas: mymod/mypack coverage: 0.0% das instruções. Observe que, se um pacote não contiver código executável, não podemos relatar uma porcentagem significativa de cobertura; para pacotes assim, o go test continuará a relatar a ausência de arquivos de teste.

• A interface web da ferramenta trace foi ligeiramente atualizada como parte do suporte ao novo rastreador, resolvendo alguns problemas e melhorando a legibilidade de várias páginas. A interface web agora suporta a exploração de rastros em uma visão orientada a fluxo. O visualizador de rastreamento agora também exibe a duração total de todas as chamadas do sistema. Essas melhorias são aplicáveis apenas à visualização de rastros criados por programas compilados no Go 1.22 ou mais recente. Em futuras versões, algumas dessas melhorias serão aplicadas a rastros criados por versões anteriores do Go.
• O ambiente de execução agora armazena metadados de coleta de lixo com base nos tipos mais próximos de cada objeto na heap. Essa mudança também reduz o custo de memória da maioria dos programas Go em cerca de 1% através da deduplicação de metadados redundantes. Em alguns programas, a melhoria pode ser menor, uma vez que esta alteração corrige os limites de classe do tamanho do alocador de memória, fazendo com que alguns objetos possam ser movidos para uma classe de tamanho superior. Como consequência dessa mudança, os endereços de alguns objetos, que antes eram sempre alinhados em uma borda de 16 bytes (ou mais), agora serão alinhados apenas em uma borda de 8 bytes. Alguns programas que utilizam instruções de assembly requerendo que os endereços de memória estejam alinhados em tamanhos superiores a 8 bytes e dependem do comportamento anterior do alinhador de memória, podem falhar, mas esperamos que tais programas sejam raros. Esses programas podem ser criados com GOEXPERIMENT=noallocheaders, com a possibilidade de retornar ao antigo modelo de metadados e restaurar o comportamento anterior de alinhamento, mas os proprietários de pacotes devem atualizar seu código em assembly para evitar assumir alinhamento, já que esse contorno será removido na próxima versão.
• Como mencionado nas notas de lançamento do Go 1.20, o Go 1.22 agora requer a versão final do Go 1.20 ou mais recente para a construção inicial. Esperamos que o Go 1.24 exija a versão final do Go 1.22 ou uma versão posterior para a construção inicial.
  Original (go.dev)

Fonte: linux.org.ru