O objetivo deste plano de estudos é te fornecer um caminho que possibilite ter um norte e referências para que você possa no médio prazo dominar a linguagem Go.

Para tal irei além de apenas mostrar conteúdos que você deve consumir: vou te mostrar uma estratégia, que já adotamos aqui na itexto e que funcionou bem que vai mesclar prática com teoria.

Isto vai te possibilitar decorar pela prática o que é necessário e entender pela teoria os conceitos fundamentais da linguagem e também do seu ecossistema. Também vou mostrar os pontos que você deve levar em consideração de acordo com seu background.

O plano é composto por três partes:

• A estratégia prática - vou te mostrar dois projetos para que você treine Go sem te dar qualquer referência de conteúdo a ser consultado.
• Os conteúdos que recomendo para que você possa aprender a linguagem.
• Os pontos de atenção que você deve levar em consideração.

A parte prática

Sendo assim o ideal é começar tendo dois projetos: o primeiro para pegar o jeito na linguagem, o segundo para, se for o seu caso, implementar um backend web que seja o mais simples possível, mas tendo como base o primeiro projeto.

Primeiro projeto - importação de dados

Seu objetivo aqui consistirá em ler uma planilha no formato Excel e importar seu conteúdo para um banco de dados relacional. Caso não tenha muita ideia do que usar, segue um exemplo de planilha na qual teremos uma lista de contatos:

Use o banco de dados de sua preferência, mas leve em consideração os seguintes pontos neste projeto:

• Sua aplicação será de linha de comando, sendo assim você precisará projetar uma interface de parâmetros que seja útil. Seguem alguns exemplos:
  • importador [arquivo xlsx] [host do banco de dados] [usuário do banco de dados] [ senha do usuário de banco de dados] [nome do banco de dados]
  • importador [arquivo xlsx] (e todos os dados de acesso ao banco de dados definidos por variáveis de ambiente)
• Implemente validações simples nesta planilha
  • Todos os campos foram preenchidos?
  • O e-mail é realmente um e-mail?
  • Há registros duplicados?
• Garanta a unicidade de registros na tabela que receberá seus contatos. Ele pode ser o campo de e-mail, por exemplo
• Escreva testes com diferentes versões da planilha de contatos para validar diferentes cenários:
  • Algum campo não foi preenchido
  • Mais de um contato com mesmo e-mail ou telefone
  • Arquivo que não é uma planilha

Este primeiro projeto, apesar de ser bem simples, tem a complexidade necessária para te ensinar coisas que serão a base para o seu dia a dia profissional:

• Quais são as estruturas de controle da linguagem (muita atenção ao "for" do Go, há pegadinhas ali).
• Como realizar operações de I/O ao ler o arquivo Excel.
• Como buscar bibliotecas e usá-las em seus projetos (por isto sugeri o uso do arquivo Excel e não um CSV).
• Como tratar erros na execução do seu programa (se você vêm de uma linguagem que usa try... catch já adianto: tenha paciência aqui)
• O uso de structs para definir tipos de dados (se você vêm de uma linguagem que tenha uma forte base em orientação a objetos, tenha paciência aqui).
• Como organizar seu código em módulos, arquivos, funções e estruturas de dados.
• O uso da API de acesso a banco de dados relacionais do Go, inclusive aqui você terá de se virar na documentação do driver do seu SGBD para entender como se dá a instalação.

Evolua o projeto: lide com arquivos maiores

Se quiser ir um pouco além no primeiro projeto para aprender alguns recursos avançados da linguagem, você pode pensar na seguinte situação: como você lidaria com uma planilha que contivesse um milhão de linhas? Implemente uma versão alternativa do primeiro projeto com esta situação. Com isto você vai poder aprender mais algumas coisas:

• Como usar os recursos de paralelização da linguagem (Goroutines) para dividir em blocos o processamento do arquivo.
• O uso de um pool de conexões para não exaurir seu SGBD.

Segundo projeto - uma API REST

Executado o primeiro projeto, agora você sentirá mais segurança em relação à linguagem e suas ferramentas. Reaproveite então seu conhecimento (e talvez o código) obtido no projeto anterior e implemente uma API REST que realize tanto a consulta (GET) quanto a edição, inserção e remoção de registros de contatos na sua base de dados.

Tal como no primeiro projeto, este também pode ser implementado em duas etapas. A primeira vai consistir em ter os quatro endpoints abaixo para as operações básicas de CRUD:

• GET /contacts - Retorna a lista de contatos. Implemente este endpoint com paginação e a busca por parâmetros que representem os campos da planilha importada.
• POST /contacts - Para a criação de um novo registro de contato. Leve em consideração as mesmas validações usadas no primeiro projeto
• PUT /contacts/{id} - Para a edição de um registro de contato levando em consideração as mesmas regras de validação.
• DELETE /contacts/{id} - Para a remoção de um contato

Aqui você pode usar tanto a biblioteca padrão da linguagem como algum framework de sua preferência. Recomendo o Gin (https://gin-gonic.com/) pois é bem fácil de usar.

Com isto você vai aprender:

• Como implementar endpoints web com Go
• Como realizar o roteamento de requisições para seu código fonte.
• Qual organização você deve adotar no seu código fonte para que não termine com uma gigantesca macarronada.
• Como realizar o parseamento de conteúdo JSON para structs (importantíssimo).
• Lembra do pool de conexões? Ele vai ser muito valioso aqui caso queira realizar um teste de carga.
• Como lidar com exceções de tal modo que seu usuário receba mensagens de erro interessantes e não um congelamento da sua aplicação.

Evolua o projeto: inclua autenticação e autorização

Agora as coisas vão ficar bem mais interessantes. Implemente autenticação no seu projeto. Sugiro que você o faça pra começar usando uma API Key fictícia enviada pelo header HTTP "X-API-Key".

Seus endpoints que realizam alterações no banco de dados deverão ser executados APENAS se a API Key for validada. Isto te permitirá aprender mais algumas coisas importantes:

• Como implementar middlewares (interceptadores/filtros) para suas requisições.
• Como configurar o acesso a estes endpoints (ainda não existe algo tão bom quanto um Spring Security em Go - olha aí uma oportunidade legal pra você)

Se quiser dar um passo além, recomendo que você tente uma implementação de autenticação baseada em JWT usando um endpoint de autenticação (POST /auth) no qual o usuário forneça um login e senha.

Bibliografia rápida e comentada

Você deve estar se sentindo perdido com o exercício acima, né? Agora então seguem os recursos para que você saiba aonde encontrar as respostas.

Opte por focar na documentação oficial para começar, clicando sobre o link “Learn” do site oficial (https://go.dev). Aqui você verá as três opções expostas no print abaixo:

Começando pelo Tour of Go – https://go.dev/tour

Tem a profundidade de uma moeda mas te prepara para dar os primeiros passos na linguagem pois ao contrário da documentação oficial, é linear. É um destes tutoriais interativos nos quais há uma explicação do lado esquerdo e código para você experimentar do lado direito.

Em aproximadamente uma hora (no máximo duas se você estiver brincando com a linguagem no processo). Recomendo que você faça inteiro (preferencialmente experimentando ao máximo).

Há tradução para o Português do Brasil, mas se você sabe inglês recomendo que evite esta tradução pois encontrei algumas coisas como as expostas nos prints abaixo:

Caminho alternativo ao Tour of Go – vídeo

Não gosto de vídeos para estes primeiros contatos com linguagens mas a documentação oficial indica este vídeo (em inglês) cheio de chavões (musiquinha feliz, introdução enche linguiça…) que talvez possa te ajudar. Não é ruim, mas pessoalmente não gosto (me falta paciência).

Indo para a documentação oficial – https://go.dev/doc/

Após ter seguido os tutorias básicos (ao menos o interativo) a documentação oficial fornece o aprofundamento que precisava para poder entender os detalhes da linguagem que farão toda a diferença. Seguem aqui então os links da documentação que mais me ajudaram.

Um dos pontos fotes do Go é o modo como lida com concorrência. Dado que este é apenas seu primeiro contato e os projetos iniciais são bem simples, não irei tocar nestes assuntos (busque por “goroutines” ;) ).

O básico sobre módulos

Se você vêm do Java ou .net o conceito de pacotes do Go pode te parecer confuso: não por ser complexo, mas por ser simples. Então leia estes dois links na sequência:

• Tutorial: getting started – é um Hello World que vai ser usado adiante, faça só pra treinar.
• Tutorial: Create a Go Module – você vai criar seu primeiro módulo
• Getting started with multi-module workspaces – você definitivamente vai sentir falta de não conhecer o conceito de workspaces do Go quando for implementar seus projetos maiores (sofri um pouco com isto), então preste muita atenção neste link.

Organizando seu código

Você que vêm do Java vai sentir saudades do Maven em seu primeiro contato. Ao escrever sua primeira aplicação que envolva mais de um arquivo esta saudade irá apertar. Este link (How to Write Go Code) te ensina como seu código fonte deve estar organizado e também tornará mais clara a distinção entre módulo (module) e pacote (package). (um módulo contém pacotes ;) )

Outro link que vai ajudar é este: Organizing a Go module.

Effective Go e FAQ

Vai te ajudar bastante também conhecer as convenções adotadas pela linguagem. O link “Effective Go” me ajudou a responder diversas dúvidas simples mas que podem tomar bastante seu tempo, tais como: quando uso ponto e vírgula? Como lido com erros? E estas funções que retornam mais de um valor como resultado?

O FAQ também tem coisas úteis. Não acho que você deva lê-lo de cabo a rabo, mas pelo menos dar uma passada de olhos pelo índice já ajuda a descobrir dúvidas que você ainda não sabe que tem.

Biblioteca padrão – https://pkg.go.dev/std

Em diversos momentos você lerá na documentação que a biblioteca padrão é bastante rica e bla bla bla. Então é interessante ver os módulos que compõem a biblioteca pra se ter uma noção do que de fato está ali. E tem coisas muito legais, tais como funções para se gerar HTML, JSON, funções de hash, logging, testes, etc.

Fica bem claro que é possível, por exemplo, escrever uma aplicação web sem um framework externo.

Bibliotecas importantes: fmt, database, io, net/http, os

Material para desenvolvimento web

Frameworks

Na prática são todos muito parecidos, lembrando muito micro frameworks como Flask, por exemplo, e pelo que pude aprender até agora todos usam inclusive como base a biblioteca padrão do Go para tal.

Gin Web Framework – https://gin-gonic.com/

O framework que adotei para o segundo objetivo foi o Gin e por uma razão bem boba: segui o tutorial que estava presente na própria documentação oficial da linguagem que pode ser acessado neste link: Tutorial: Developing a RESTful API with Go and Gin.

A documentação do Gin é ruim, e você pode acessar neste link. Você encontrará um quickstart extremamente básico com um “hello world” e não muito mais além disto.

Infelizmente os autores do framework acreditam que uma boa forma de se ensinar é a partir de exemplos, então você terá de navegar por eles, que podem ser vistos neste link.

Um vídeo interessante

Minha impressão de que os frameworks que vi eram basicamente sempre a mesma coisa se confirmou neste vídeo: https://www.youtube.com/watch?v=JECZTdEJnOI

Pontos importantes a levar em consideração

Ferramentas

O VS Code como IDE vai te atender muito bem no primeiro momento (e mesmo depois).

Facilite a vida instalnado Go usando o asdf com o plugin golang. O Asdf nos permite ter instalações concorrentes de basicamente todas as ferramentas de desenvolvimento que você pode imaginar.

Gerencie todas (ou quase) ferramentas de desenvolvimento com asdf

No meu dia a dia peciso lidar com diferentes instalações de Node.js, Java, Maven, PHP, Rust, Ant (só eu uso?), .net, Go, Grails, Ruby e com o tempo isto vai se tornando uma tarefa acidentalmente complexa. Há gerenciadores de versão para estes diversos ambientes de desenvolvimento, claro: de imediato

itexto InsightsHenrique Lobo Weissmann

As ferramentas de linha de comando do Go nos permitem também fazer tudo o que precisamos é como se o Maven tivesse um filho com o Cargo do Rust:

• Gerenciar dependências (muito parecido com o Cargo do Rust).
• Compilar os projetos (óbvio!)
• Executar testes
• Criar módulos
• Buscar erros no projeto
• Instalar ferramentas adicionais (há várias!)

A velocidade do compilador impressiona. É muito rápido.

Sobre a linguagem

Orientação a objetos?

Go não é orientado a objetos tal como estamos acostumados no caso do Java ou C# por exemplo.

Há sim "objetos", mas não há classes ou herança: a norma claramente é programação procedural/funcional. E sabe de uma coisa? Confesso que ao aprender senti alívio enquanto escrevia meus mini projetos e via como é possível escrever código muito mais simples para estes contextos (aplicações simples) sem orientação a objetos (o Kico de dez anos atrás também me cutucou aqui).

(Orientação a Objetos não é uma boa prática de desenvolvimento: é um paradigma de programação que tem seu lugar de aplicação. Infelizmente isto não é claro pra muita gente ainda hoje…)

Há polimorfismo, e o conceito de interfaces aqui é muito interessante. É vista como algo implícito (você não precisa daquelas instruções implements). Duck typing basicamente.

Simples!

Não é exagero dizer que se você terminar o Tour of Go vai ter o ferramental necessário para implementar tudo o que me propus nesta imersão. A linguagem é realmente muito simples e torna simples coisas que são complexas em outras.

• Um modelo de strings simples. Não é algo complicado como o que temos em C ou ainda mais complicado como o que temos em Rust (este vídeo sobre strings em Rust é muito útil).
• Você tem ponteiros que são fáceis de entender.
• Um esquema de pacotes e módulos simples de entender (ao contrário do que temos em Rust que apesar de poderoso leva um tempo até pegar o jeito).
• Um modelo de dados muito básico: os tipos numéricos que precisamos (inclusive unsigned, algo que sempre senti muita falta no Java (pense em integrações de baixo nível que você vai me entender), um único tipo de string, structures (que só entraram no Java recentemente), maps, slices (como listas) e ponteiros (que já falei)

A sintaxe também é muito simples. Me lembra Groovy, mas ainda mais simples, o que me leva a outro ponto importante.

Curva de aprendizado

Em um dia usando apenas a documentação oficial você provavelmente conseguirá resolver a maior parte dos desafios envolvendo o primeiro projeto deste plano de estudos.

Tendo tido o primeiro contato com os pontos de aprendizado do primeiro projeto você verá que a escrita de APIs web com Gin é realmente muito simples e fácil de entender.

Testes

Go trás as funcionalidades necessárias para que você possa escrever seus testes unitários e integrados. Tem inclusive recursos bem legais como por exemplo a escrita de benchmarks, fuzzing (passagem de valores aleatórios para funções) e algumas outras funcionaliddes.

Se você ler a documentação oficial encontrará links como este (Add a test no Tutorial dos módulos que indico no início). Mas sabe o que não está incluído nas bibliotecas? Asserções! Você terá de usar projetos como este para que sejam incluídas em seus testes.

Aqui está o ink para a documentação do módulo testing, que é o oficial para a execução de testes.

Acesso a bases de dados relacionais

Na biblioteca padrão o módulo database (dividido nos pacotes sql e sql/driver) me chamaram a atenção. Temos ali padronizadas todas as interfaces a serrem seguidas pelos fornecedores de bases de dados relacionais usando um modelo muito parecido com o que temos no JDBC do Java.

Este é um diferencial importante em relação ao Rust que, até onde sei, ainda não tem algo similar padronizado na própria linguagem. E por que isto é importante? Por que facilita muito a adoção da linguagem no ambiente corporativo no qual não raro o SGBD relacional é Rei.

Começando

É interessante também ver como outras pessoas trabalham com Go. Neste caso, recomendo que você acompanhe algum curso online (desde que seja barato, não vale à pena pagar mais de 40 reais pro básico) para descobrir novas ferramentas e aprender algumas dicas. Mas se você focar apenas na documentação oficial seguindo este guia é enorme a probabilidade de em pouquíssimo tempo se sentir seguro com a linguagem.

Siga com projetos práticos pra decorar o que é necessário e leia a documentação pra entender os conceitos fundamentais. Não tem erro. Sucesso!