Blog

Esta série será uma descrição dos meus estudos sobre a linguagem de programação Go, também conhecida como GoLang. A intenção é abordar os conceitos da linguagem e organizar o aprendizado.

Breve Histórico

A linguagem Go foi proposta em 2007 pelo gold team da Google, composto por Robert Griesemer, Rob Pike, e Ken Thompson, com o início dos trabalhos em janeiro de 2008 por Ken Thompson e o lançamento oficial do projeto em novembro de 2009 sob uma licença BSD-like, com disponibilidade inicial para as plataformas Linux e macOS.

A internet oferece uma vasta documentação sobre o desenvolvimento do Go. Para uma introdução mais aprofundada, recomendo o livro de acesso livre “The Way To Go – A Thorough Introduction To The Go Programming Language” de Ivo Balbaert.

Motivação

A linguagem Go foi inspirada nas linguagens C++, Java, e C#, amplamente utilizadas pelos desenvolvedores iniciais do projeto. A motivação principal foi criar uma linguagem mais eficiente para solucionar os desafios enfrentados pela equipe da Google com as linguagens tradicionais.

As linguagens convencionais foram desenvolvidas em um contexto onde a maioria dos computadores possuía apenas um núcleo e o limite de clock dos processadores ainda não tinha sido alcançado pela indústria de semicondutores. Elas atendiam bem às demandas da época.

No entanto, a linguagem Go emergiu em um cenário onde o aumento na frequência dos processadores era mais lento, enquanto os processadores de múltiplos núcleos tornaram-se a norma. Grandes parques computacionais montados em clusters se tornaram viáveis e a integração e distribuição de processamento em redes se estabeleceram como práticas padrão na computação moderna, facilitando a criação de diversos serviços e nuvens.

Neste contexto, onde a comunicação em rede e o processamento concorrente e paralelo são cruciais, surgiu a necessidade de uma linguagem de programação que otimizasse a distribuição de carga e o aproveitamento de processadores multicore. A linguagem Go foi projetada e desenvolvida com foco nestes aspectos.

Como qualquer linguagem moderna, o Go prioriza características como simplicidade, portabilidade e desempenho, abdicando de alguns aspectos das linguagens tradicionais para manter o foco em seus objetivos principais. Entre suas características principais, destacam-se:

• Sintaxe similar à do C, facilitando o aprendizado;
• Código limpo e de fácil leitura;
• Tipagem estática;
• Compilação eficiente, focada no desempenho;
• Desenvolvimento com ênfase no uso eficiente de recursos de rede e processadores multicore;
• Suporte nativo e simplificado para concorrência e paralelismo;
• Uso limitado de ponteiros para minimizar problemas de gerenciamento de memória;
• Suporte restrito à orientação a objetos;
• Compilação de todo o programa em um único arquivo binário.

Instalação e Configuração do Go

A instalação do Go é simples e rápida. No terminal, execute o seguinte comando para instalar:

rudson@suzail:~$ sudo apt install golang

Isso deve instalar a versão mais recente para a sua distribuição Debian-like. Se desejar instalar a versão mais recente da linguagem, acesse a página do projeto https://go.dev/ e clique no botão “Downloads“. Em seguida, escolha o pacote adequado para o seu sistema. Para Linux, escolha a opção goX.XX.X.linux-amd64.tar.gz, que no momento da escrita deste texto é a versão 1.21.6.

Em um diretório de sua preferência, execute os seguintes comandos para instalar o pacote compilado:

rudson@suzail:Downloads$ wget https://go.dev/dl/go1.21.6.linux-386.tar.gz
rudson@suzail:Downloads$ sudo tar -C /usr/local/lib/ -xvf go1.21.6.linux-386.tar.gz
…
rudson@suzail:Downloads$ sudo ln -s /usr/local/lib/go/bin/go /usr/local/bin/go
rudson@suzail:Downloads$ sudo ln -s /usr/local/lib/go/bin/gofmt /usr/local/bin/gofmt

Configuração do Ambiente Go

O próximo passo é configurar a variável de ambiente GOPATH, que indica a localização da sua Workspace do Go. A Workspace é uma pasta onde o Go armazenará pacotes de terceiros, executáveis instalados e desenvolvidos, além de ser o local para desenvolver seus próprios projetos, embora não seja a minha escolha preferida. Recomenda-se utilizar o caminho padrão $HOME/go. Para configurar isso, execute os comandos a seguir:

alves@arabel:~$ mkdir -p $HOME/go/{bin,pkg,src}
alves@arabel:~$ echo 'export GOPATH=$HOME/go' >> ~/.bashrc
alves@arabel:~$ echo 'export GOBIN=$GOPATH/bin' >> ~/.bashrc
alves@arabel:~$ echo 'export PATH=$PATH:$GOBIN' >> ~/.bashrc
alves@arabel:~$ . ~/.bashrc

Esses comandos realizam os seguintes passos:

1. Criam a estrutura de diretórios necessária na pasta Go, onde bin é para programas compilados, pkg para bibliotecas em formato de pacotes, e src para suas fontes e desenvolvimento de código.
2. O comandos echo a seguir adicionam ao final do script ~/.bashrc as declarações:
   • GOPATH – declara a Workspace para o Go;
   • GOBIN – declara um diretório para os aplicativos compilados no Go;
   • PATH – adiciona ao PATH do sistema a localização dos binários compilados no Go.
3. Por fim o script ~/.bashrc é executado para aplicar as alterações ao terminal ativo.

A pasta $HOME/go/src pode ser um local para desenvolver seus códigos, e possui até algumas conveniências para isto, no entanto prefiro usar uma pasta externa para este fim.

Caso deseje colocar o Workspace em uma pasta diferente, basta alterar o GOPATH para apontar para a localização correspondente.

Visual Studio Core

O Visual Studio Code é um poderoso e leve editor de código-fonte desenvolvido pela Microsoft, com versões para Windows, macOS e Linux. Ele possui suporte integrado para JavaScript, TypeScript e Node.js, além de um rico ecossistema de extensões para diversas outras linguagens, incluindo o Go. Também oferece ótima integração com o Github.

Na minha opinião, é uma boa opção para desenvolver código em Go. Outra opção interessante é o editor de texto Vim, caso você tenha disposição para aprender. O Vim possui excelente produtividade, uma vez que todos os comandos são executados via teclado, dispensando o uso do mouse na edição se seu código. Se estiver interessado, sugiro a leitura de um excelente artigo de Douglas Diniz: Configurando o Vim e Neovim do Zero em 2022. Produtividade Suprema.

O Visual Studio Code (VS Code) pode ser instalado diretamente pelo sistema usando o apt, como de costume:

alves@arabel:~$ sudo apt install code
...
alves@arabel:~$ code

Em seguida, execute o comando code no terminal ou abra o aplicativo no menu do seu sistema. Isso deve abrir uma tela semelhante à mostrada a seguir.

Clique no ícone com os quatro blocos para instalar duas extensões, indicadas como 1 em um círculo vermelho.

Em seguida, digite a palavra “go” na caixa de pesquisa (1) e clique no botão “install” (2) em azul para instalar a extensão do Go. Repita o processo para instalar a extensão “Code Runner“.

Após a conclusão, limpe a caixa de pesquisa e seu VS Code deve ter uma aparência semelhante à figura a seguir.

Agora, selecione o ícone de arquivos (1) e, em seguida, o botão “Open Folder“. Vamos supor que a pasta escolhida seja algo como ~/Documentos/Estudos/Go.

Quando você passar o mouse sobre a opção Go (1), verá um conjunto de ícones. Crie uma pasta chamada “hello” e, dentro dela, crie o arquivo “hello.go“.

Logo após criar o “hello.go“, você verá duas mensagens (possivelmente em abas diferentes) na parte inferior da janela do VS Code, pedindo para instalar algumas extensões. Pressione “Install All” para ambas. Algum tempo depois, uma mensagem informando que as extensões foram instaladas deve aparecer na janela de OUTPUT.

Neste ponto, você pode começar a escrever seu código para o clássico “Hello World“.

package main

func main() {
  fmt.Println("Hello World!!!)
}

Após terminar de escrever o código, pressione CTRL+S para salvar. Neste momento, o VS Code irá adicionar import "fmt" no início do código, como mostrado abaixo:

package main

import "fmt"

func main() {
  fmt.Println("Hello World!!!)
}

O programa é simples, mas alguns comentários são necessários. Na primeira linha, a declaração package define a qual pacote de código este arquivo pertence. Nos exemplos iniciais, os códigos sempre pertencem ao pacote main, que indica o ponto de entrada do programa.

Na linha 3, a declaração import importa o pacote fmt, que faz parte da biblioteca padrão. O pacote fmt fornece funções para formatação de strings e impressão.

A linha 5 declara a função main(), por onde o programa inicia a execução, neste caso, apenas para imprimir a mensagem.

Para executar o programa no VS Code, basta pressionar CTRL+ALT+N, e a saída padrão será exibida na parte inferior da janela (1).

Outra forma de executar é pelo terminal. Clique na aba “TERMINAL” (2) e execute os comandos a seguir:

Observe que ao abrir o terminal, ele será direcionado para a pasta da sua Workspace, que é o diretório ~/Documentos/Estudos/Go. Você precisará entrar na pasta “hello” para executar o comando go run.

O comando go run program.go executará o programa através de um interpretador Go. Se você quiser compilar o programa, use o comando build:

alves@arabel:hello$ go build hello.go
alves@arabel:hello$ ls -lah
total 1,7M
drwxrwxr-x 2 rudson rudson 4,0K abr 14 17:05 .
drwxrwxr-x 3 rudson rudson 4,0K abr 13 21:49 ..
-rwxrwxr-x 1 rudson rudson 1,7M abr 14 17:05 hello
-rw-rw-r-- 1 rudson rudson   75 abr 14 17:02 hello.go
alves@arabel:hello$ ./hello
Hello World!!!

O último comando ./hello é usado para executar o programa compilado.

Instalando o Aplicativo hello

Você também pode compilar e instalar o seu “hello” na pasta $GOPATH/bin. Para isso, execute o comando go com a opção install:

alves@arabel:hello$ go install hello.go
alves@arabel:hello$ ls -lah ~/go/bin/
total 82M
drwxrwxr-x 2 alves alves 4,0K abr 15 10:33 .
drwxrwxr-x 5 alves alves 4,0K abr 14 22:44 ..
-rwxrwxr-x 1 alves alves  16M abr 14 22:51 dlv
-rwxrwxr-x 1 alves alves 3,2M abr 14 22:50 gomodifytags
-rwxrwxr-x 1 alves alves 3,1M abr 14 22:50 go-outline
-rwxrwxr-x 1 alves alves 6,6M abr 14 22:50 goplay
-rwxrwxr-x 1 alves alves  25M abr 14 22:52 gopls
-rwxrwxr-x 1 alves alves 9,7M abr 14 22:50 gotests
-rwxrwxr-x 1 alves alves 1,7M abr 15 10:33 hello
-rwxrwxr-x 1 alves alves 5,5M abr 14 22:50 impl
-rwxrwxr-x 1 alves alves  12M abr 14 22:52 staticcheck
alves@arabel:hello$ hello
Hello World!!!

Observe na linha destacada que o programa “hello” foi instalado na pasta ~/go/bin. Para executá-lo, basta chamar “hello” no prompt de comando. Se durante a execução do go install você receber a mensagem go install: no install location for .go files listed on the command line (GOBIN not set), adicione $GOBIN ao seu arquivo .bashrc com os comandos a seguir:

alves@arabel:hello$ echo 'export GOBIN=$GOPATH/bin' >> ~/.bashrc
alves@arabel:hello$ . ~/.bashrc

Isso pode ser necessário para as versões 1.17 e anteriores do Go.

Entrada com o Pacote fmt

Para aprimorar um pouco o aplicativo, vamos fazer uma entrada de dados antes de imprimir a mensagem final. Para isso, utilizaremos a função fmt.Scan(&nome) para aguardar a entrada do teclado até que seja pressionada a tecla Enter (\n).

Crie uma nova pasta chamada scan e, dentro dela, crie o arquivo scan.go.

Dentro do arquivo scan.go, adicione o seguinte código:

package main

import "fmt"

func main() {
	var nome string
	fmt.Print("Entre com o seu nome: ")
	fmt.Scan(&nome)
	fmt.Printf("Seja bem-vindo %s\n", nome)
}

Como este programa captura a entrada do teclado, aconselho a não executá-lo diretamente pelo VS Code. Caso o faça, você precisará interromper o programa com CTRL+ALT+M. No entanto, antes de executar este código, permita-me fazer alguns comentários.

Na linha 6, é feita a declaração da variável nome. Como o Go é uma linguagem tipada, todas as variáveis devem ser declaradas antes de serem usadas. A declaração de variáveis e seus tipos serão abordados em um próximo artigo.

Na linha 7, usamos fmt.Print() em vez de fmt.Println() como no exemplo anterior. A função fmt.Println() adiciona uma quebra de linha após a impressão, enquanto fmt.Print() não faz isso, permitindo que a entrada do nome seja feita na mesma linha da mensagem.

A leitura do teclado ocorre na linha 8, onde a função fmt.Scan(&nome) recebe o endereço da variável “nome” (&nome). Isso é necessário para que o conteúdo da variável seja alterado pela função fmt.Scan(), como veremos em um artigo futuro sobre funções e métodos.

Por fim, na linha 9, executamos uma impressão formatada, em que %s será substituído pelo conteúdo armazenado na variável nome. Este método se assemelha à função printf em C.

Para executar o programa scan.go, abra um terminal na pasta onde o código está localizado e execute os seguintes comandos:

Como você pode ver, o pacote fmt implementa tanto a entrada quanto a saída padrão do terminal, semelhante às funções print e scan em C. A documentação da biblioteca padrão do Go pode ser encontrada em Golang Standard library, e eu recomendo consultá-la sempre que você usar novos métodos.

A primeira vista, isso pode parecer um pouco estranho, mas é importante se acostumar com a sintaxe da linguagem. Neste momento, o objetivo era apenas ilustrar um código em Go, e mais detalhes serão abordados em artigos futuros. No entanto, apenas por curiosidade, observe a sintaxe da função Scan:

Neste caso, a entrada é a ...any, que corresponde aos endereços de uma variável de qualquer tipo cujo conteúdo será alterado pela função. Esta função retorna duas saídas:

• n int com o número de itens lidos. Neste caso, será 1 ou 0. Mesmo se você tentar inserir nomes completos como “Albert Einstein“, a função retornará apenas “Albert“. Somente em uma segunda chamada da função ela retornaria “Einstein”.
• err error com uma mensagem de erro, caso ocorra, ou nil (nada) se estiver tudo bem.

Se você quiser coletar essas informações, faça as alterações no código como mostrado abaixo e execute novamente:

package main

import "fmt"

func main() {
	var nome string
	fmt.Print("Entre com o seu nome: ")
	n, err := fmt.Scan(&nome)
	fmt.Printf("Seja bem-vindo %s\n", nome)
	fmt.Println("n: ", n, " Erro:", err)
}

Experimente fazer algumas entradas e veja os resultados.

Considerações Finais

Esta foi apenas uma introdução, e há muito mais a ser explorado sobre o que foi apresentado aqui. No entanto, esses tópicos serão abordados em artigos futuros.

Para finalizar, aqui estão algumas dicas de pacotes para instalar no Go e preparar melhor o seu sistema. Execute os seguintes comandos no console:

alves@arabel:hello$ go get -u github.com/go-sql-driver/mysql
alves@arabel:hello$ go install golang.org/x/tools/cmd/goimports@latest
alves@arabel:hello$ go install golang.org/x/tools/cmd/godoc@latest
alves@arabel:hello$ go install golang.org/x/tools/cmd/guru@latest
alves@arabel:hello$ go install golang.org/x/lint/golint@latest
alves@arabel:hello$ go install github.com/nsf/gocode@latest
alves@arabel:hello$ go env -w GO111MODULE=auto

Estes são alguns dos pacotes mais úteis, mas existem muitos outros disponíveis. À medida que você desenvolve em Go, pode encontrar pacotes específicos para suas necessidades.

Espero que este guia inicial tenha sido útil para você começar a programar em Go. No futuro, vamos aprofundar vários tópicos, incluindo estruturas de controle, funções, pacotes e outros conceitos avançados. Fique à vontade para fazer perguntas e compartilhar suas experiências na seção de comentários.

Lembre-se de que a prática é a chave para se tornar um programador eficiente, então experimente escrever seu próprio código e divirta-se programando em Go!