← Voltar para o blog
go golang release go15

Go 1.5: Novidades e Recursos

Descubra as principais novidades do Go 1.5, incluindo novos recursos, melhorias de performance e mudancas na biblioteca padrao.

Go 1.5: Uma Virada Significativa no Ecossistema Go

O Go 1.5, lançado em 19 de agosto de 2015, representou um marco fundamental na evolução da linguagem Go. Esta versão introduziu mudanças significativas na implementação do compilador, no garbage collector e no suporte a concorrência, além de diversas melhorias na biblioteca padrão. O impacto do Go 1.5 foi profundo, pavimentando o caminho para o Go se tornar uma linguagem ainda mais robusta e eficiente para o desenvolvimento de aplicações de alta performance.

O Fim do Compilador C: Nascendo o Compilador Go Auto-Hospedado

Uma das maiores mudanças introduzidas no Go 1.5 foi a remoção completa do compilador C (gc) e a adoção de um compilador Go auto-hospedado. Anteriormente, o compilador Go era escrito em C, o que introduzia uma dependência externa e dificultava a otimização e manutenção. Com o Go 1.5, o compilador passou a ser escrito em Go, compilado pelo próprio Go.

Benefícios do Compilador Auto-Hospedado:

  • Independência: Eliminação da dependência do compilador C, simplificando o processo de construção e distribuição do Go.
  • Otimização: A capacidade de otimizar o compilador usando as próprias ferramentas e técnicas do Go, resultando em melhorias de performance.
  • Manutenção: Facilidade de manutenção e evolução do compilador, permitindo que a comunidade Go contribua diretamente para o seu desenvolvimento.
  • Portabilidade: Maior facilidade de portar o compilador para novas arquiteturas e sistemas operacionais.

A transição para o compilador auto-hospedado foi um projeto ambicioso que exigiu um esforço considerável da equipe de desenvolvimento do Go. O resultado, no entanto, valeu a pena, impulsionando a linguagem para um novo nível de maturidade.

Garbage Collector Concorrente e Incremental

O Go 1.5 introduziu um garbage collector (GC) concorrente e incremental. Nas versões anteriores, o GC do Go era do tipo “stop-the-world”, o que significava que a execução do programa era interrompida enquanto o GC realizava a coleta de lixo. Essas pausas podiam ser significativas, especialmente em aplicações com grande alocação de memória, afetando a performance e a responsividade.

O GC concorrente e incremental do Go 1.5 minimiza essas pausas, permitindo que o GC execute parte do seu trabalho enquanto o programa continua a ser executado. O GC incremental divide o trabalho de coleta de lixo em pequenas partes e as executa em intervalos regulares, evitando pausas longas e abruptas. O GC concorrente permite que o GC execute simultaneamente com o código do usuário, utilizando núcleos de processamento ociosos para realizar a coleta de lixo em segundo plano.

Impacto do GC Concorrente e Incremental:

  • Redução das Pausas do GC: Diminuição significativa das pausas do GC, resultando em melhorias de performance e responsividade, especialmente em aplicações com alta carga de trabalho.
  • Melhor Utilização dos Recursos: Utilização eficiente dos recursos do sistema, permitindo que o GC execute em segundo plano sem interromper a execução do programa.
  • Escalabilidade: Melhor escalabilidade para aplicações que lidam com grandes quantidades de dados e alta concorrência.

O Go 1.5 introduziu a variável de ambiente GOGC, que permite controlar a frequência com que o GC é executado. O valor padrão de GOGC é 100, o que significa que o GC é executado quando a quantidade de memória alocada dobra em relação à última execução do GC. Ajustar o valor de GOGC pode ser útil para otimizar a performance do GC em diferentes cenários.

Suporte Aprimorado para Paralelismo e Concorrência: O internal/cpu

O Go 1.5 introduziu o pacote internal/cpu, que fornece informações detalhadas sobre a arquitetura do processador em tempo de execução. Este pacote permite que os desenvolvedores escrevam código que se adapte automaticamente às características do processador, aproveitando ao máximo os recursos disponíveis.

O pacote internal/cpu expõe informações como:

  • Número de Núcleos: Número de núcleos físicos e lógicos disponíveis no processador.
  • Suporte a Instruções SIMD: Detecção de suporte a instruções SIMD (Single Instruction, Multiple Data), como SSE e AVX, que permitem executar operações em múltiplos dados simultaneamente.
  • Cache: Informações sobre os tamanhos e tipos de cache disponíveis no processador.

Com essas informações, os desenvolvedores podem otimizar o código para explorar o paralelismo e a concorrência de forma mais eficiente. Por exemplo, é possível usar instruções SIMD para acelerar o processamento de vetores e matrizes, ou ajustar o número de goroutines para corresponder ao número de núcleos disponíveis.

Exemplo de Uso do internal/cpu:

package main

import (
	"fmt"
	"runtime"
	_ "unsafe" // required to import internal/cpu

	_ "internal/cpu" // Import for side effects of initializing cpu features
)

func main() {
	fmt.Printf("Número de CPUs: %d\n", runtime.NumCPU())
	fmt.Printf("Suporte a AVX: %t\n", cpu.X86.HasAVX)
	fmt.Printf("Suporte a AVX2: %t\n", cpu.X86.HasAVX2)
}

Observação: O pacote internal/cpu está localizado no diretório internal, o que significa que ele não faz parte da API pública do Go e pode ser alterado ou removido em versões futuras. No entanto, ele é amplamente utilizado em bibliotecas e frameworks Go para otimizar a performance.

Remoção do “Vendor Experiment” e Introdução do GO15VENDOREXPERIMENT

O Go 1.5 introduziu um experimento de “vendor” que permitia incluir as dependências de um projeto dentro do próprio projeto, evitando a necessidade de depender de um gerenciador de pacotes externo. Este experimento foi controlado pela variável de ambiente GO15VENDOREXPERIMENT.

O objetivo do “vendor experiment” era simplificar o processo de gerenciamento de dependências e garantir que as dependências de um projeto fossem sempre as mesmas, independentemente do ambiente em que o projeto fosse construído. No entanto, o experimento também introduziu algumas complexidades e problemas de compatibilidade.

Com o Go 1.6, o “vendor experiment” foi desativado por padrão e posteriormente removido completamente. A funcionalidade de “vendor” foi integrada diretamente ao comando go build e ativada automaticamente quando um diretório vendor é encontrado na raiz do projeto.

Como Usar o Vendor no Go 1.5:

Para ativar o “vendor experiment” no Go 1.5, é necessário definir a variável de ambiente GO15VENDOREXPERIMENT=1 antes de executar o comando go build.

export GO15VENDOREXPERIMENT=1
go build

Embora o “vendor experiment” tenha sido removido, o conceito de “vendor” continua sendo uma parte importante do ecossistema Go. Ele permite que os desenvolvedores controlem as dependências de seus projetos e evitem conflitos de versão.

Pequenas Melhorias e Correções na Biblioteca Padrão

Além das grandes mudanças mencionadas acima, o Go 1.5 também incluiu diversas pequenas melhorias e correções na biblioteca padrão. Algumas das mudanças notáveis incluem:

  • Melhorias no Pacote net/http: Adição de suporte para HTTP/2, permitindo que os servidores Go sirvam conteúdo usando o protocolo HTTP/2, que oferece melhorias de performance em relação ao HTTP/1.1.
  • Novas Funções no Pacote math: Adição de novas funções matemáticas, como Log2 e Ilogb, que fornecem operações logarítmicas mais eficientes.
  • Melhorias no Pacote time: Adição de novas funções para trabalhar com fusos horários, como LoadLocationFromFS, que permite carregar informações de fuso horário a partir de um sistema de arquivos virtual.

Estas pequenas melhorias, somadas às grandes mudanças, contribuíram para tornar o Go 1.5 uma versão mais completa e robusta da linguagem.

Como Atualizar para o Go 1.5

A atualização para o Go 1.5 é um processo relativamente simples. A maneira mais comum de atualizar é baixar o pacote de instalação apropriado para o seu sistema operacional no site oficial do Go (https://go.dev/dl/) e seguir as instruções de instalação.

Passos para a Atualização:

  1. Baixe o Pacote de Instalação: Baixe o pacote de instalação para o seu sistema operacional no site oficial do Go.
  2. Desinstale a Versão Anterior: Remova a versão anterior do Go do seu sistema. Em sistemas Linux, isso geralmente envolve remover o diretório /usr/local/go.
  3. Instale a Nova Versão: Execute o pacote de instalação e siga as instruções na tela.
  4. Configure as Variáveis de Ambiente: Certifique-se de que as variáveis de ambiente GOROOT e PATH estejam configuradas corretamente para apontar para a nova instalação do Go. GOROOT deve apontar para o diretório onde o Go está instalado (por exemplo, /usr/local/go) e PATH deve incluir o diretório $GOROOT/bin.

Verificação da Instalação:

Após a instalação, você pode verificar se a atualização foi bem-sucedida executando o comando go version no terminal. Este comando deve exibir a versão do Go instalada no seu sistema.

go version

Conclusão

O Go 1.5 foi uma versão transformadora que solidificou a posição do Go como uma linguagem poderosa e eficiente para o desenvolvimento de aplicações modernas. A remoção do compilador C, a introdução do garbage collector concorrente e incremental e o suporte aprimorado para paralelismo e concorrência foram marcos importantes que impulsionaram a linguagem para um novo patamar. As pequenas melhorias e correções na biblioteca padrão também contribuíram para tornar o Go 1.5 uma versão mais completa e robusta. Apesar de ser uma versão antiga, entender as mudanças introduzidas no Go 1.5 é crucial para apreciar a evolução da linguagem e as decisões de design que moldaram o Go como o conhecemos hoje. As Release Notes oficiais (https://go.dev/doc/go1.5) fornecem uma visão ainda mais detalhada das mudanças e melhorias introduzidas no Go 1.5.