Curso de Aprendendo Programação em Go

1. Introdução ao Go

• O que é Go (Golang)?
• Historia e filosofia de design do Go
• Go como linguagem de programação web e de sistemas
• Características-chave:
  • Tipagem estática
  • Simplicidade e legibilidade
  • Compilação rápida
  • Concorrência integrada
  • Coleta de lixo
  • Compilação multiplataforma
• Casos de uso comuns para Go
• Vantagens e limitações do Go
• Go comparado com C/C++, JavaScript, Ruby, Python e Java
• Compreendendo o ecossistema Go
• Visão geral da biblioteca padrão do Go
• Módulos Go e gerenciamento de dependências
• Anatomia de um aplicativo Go
• Hands-on: Examine e execute um programa Go simples

2. Configurando o Ambiente de Desenvolvimento Go

• Instalando o Go
• Compreendendo a cadeia de ferramentas Go
• Configurando variáveis de ambiente
• Escolhendo uma IDE ou editor de código
• Usando a linha de comando com Go
• Criando um workspace Go
• Compreendendo a estrutura de projeto Go
• Inicializando um projeto com Go Modules
• Usando go mod init
• Gerenciando dependências com go get
• Atualizando e inspecionando dependências
• Formatando código-fonte com gofmt
• Executando programas com go run
• Construindo aplicativos com go build
• Instalando aplicativos Go
• Compilação cruzada de aplicativos
• Hands-on: Crie e configure um projeto Go dentro de um container

3. Variáveis, Constantes e Tipos no Go

• Declarando variáveis
• Tipos explícitos versus inferidos
• Declarações curtas de variáveis
• Constantes
• Valores zero
• Escopo e tempo de vida das variáveis
• Tipos de dados primitivos:
  • Inteiros
  • Números de ponto flutuante
  • Números complexos
  • Booleanos
  • Strings
• Conversões de tipo
• Trabalhando com Unicode e UTF-8
• Runes e bytes
• Atribuição múltipla de variáveis
• Compreendendo a segurança de tipos
• Exercício: Construa um pequeno programa de processamento de dados de linha de comando

4. Operadores e Expressões

• Operadores aritméticos
• Operadores de comparação
• Operadores lógicos
• Operadores de atribuição
• Incremento e decremento
• Precedência de operadores
• Trabalhando com cálculos de inteiros e ponto flutuante
• Evitando erros comuns de conversão de tipo
• Exercício: Implemente lógica de cálculo e validação

5. Datas, Horários e Formatação

• Usando o pacote time
• Criando e manipulando datas
• Obtendo a hora atual
• Fusos horários e locais
• Analise de datas e horários
• Formatação de datas e horários
• Calculando durações
• Trabalhando com timestamps Unix
• Tratando timeouts
• Exercício: Adicione timestamps e cálculos de duração a um aplicativo

6. Arrays, Slices, Maps e Structs

Arrays

• Declarando arrays
• Inicializando arrays
• Iterando sobre arrays
• Arrays multidimensionais

Slices

• Compreendendo slices versus arrays
• Criando slices
• Acrescentando elementos
• Copiando slices
• Comprimento e capacidade de slices
• Fatiamento de slices
• Pegadinhas comuns com slices

Maps

• Criando maps
• Adicionando e removendo entradas
• Verificando se uma chave existe
• Iterando sobre maps
• Maps contendo dados complexos

Structs

• Definindo estruturas

• Campos de structs

• Inicializando structs

• Structs aninhados

• Structs anônimos

• Métodos de structs

• Tags de struct JSON

• Hands-on: Modele usuários, produtos e dados de aplicativo usando structs, slices e maps

7. Lógica Condicional e Laços

• Enunciados if
• else e else if
• Declarações de variáveis dentro de condições
• Laços for
• Laços infinitos
• Condições de laço
• break e continue
• Iterando com range
• Laços aninhados
• Enunciados switch
• Switches baseados em expressões
• Casos múltiplos
• Casos padrão
• Switches de tipo
• Exercício: Implemente lógica de validação e processamento do aplicativo

8. Funções

• Definindo funções
• Parâmetros de função
• Valores de retorno
• Múltiplos valores de retorno
• Valores de retorno nomeados
• Funções variádicas
• Funções anônimas
• Valores de função
• Closures
• Recursão
• Passando funções como argumentos
• Funções que retornam erros
• Projetando funções pequenas e reutilizáveis
• Exercício: Refatore código existente em funções reutilizáveis

9. Ponteiros e Conceitos de Memória

• O que é um ponteiro?
• Operadores de endereço e desreferenciamento
• Ponteiros e parâmetros de função
• Receptores de ponteiro
• Ponteiros para structs
• Ponteiros nil
• Quando usar ponteiros
• Semântica de valor versus referência
• Compreendendo o gerenciamento de memória e coleta de lixo do Go
• Erros comuns com ponteiros
• Hands-on: Modifique dados do aplicativo usando ponteiros

10. Criando um Aplicativo Web em Go

• Visão geral das capacidades web do Go
• Introdução ao pacote net/http
• Criando um servidor HTTP
• Requisições e respostas HTTP
• Métodos HTTP
• URLs de requisição e parâmetros de consulta
• Cabeçalhos HTTP
• Códigos de status HTTP
• Fundamentos de roteamento
• Criando handlers
• Processando dados de formulário
• Servindo arquivos estáticos
• Trabalhando com modelos HTML
• Variáveis de modelo e estruturas de controle
• Estruturando um aplicativo web
• Hands-on: Construa um servidor web Go básico

11. Construindo um Serviço Web RESTful

• Fundamentos da arquitetura REST
• Projetando endpoints de API
• GET, POST, PUT, PATCH e DELETE
• Trabalhando com JSON
• Codificação e decodificação de JSON
• Validação de requisições
• Códigos de status HTTP
• Respostas de erro
• Parâmetros de consulta e parâmetros de caminho
• Estruturas de resposta de API
• Separação de handlers da lógica de negócio
• Hands-on: Construa uma API REST CRUD

12. Runtime do Go, Compilação e Builds de Projeto

• Compreendendo o compilador Go
• Processo de build do Go
• go run
• go build
• go install
• go test
• Flags de build
• Configuração específica de ambiente
• Compilando para diferentes sistemas operacionais e arquiteturas
• Produzindo binários standalone
• Gerenciando a configuração do aplicativo
• Exercício: Compile o aplicativo para múltiplas plataformas

13. Trabalhando com Arquivos e a Web

• Abertura e fechamento de arquivos
• Leitura de arquivos
• Escrita de arquivos
• Criando diretórios
• Metadados de arquivo
• I/O com buffer
• Trabalhando com streams
• Lendo e escrevendo arquivos JSON
• Clientes HTTP
• Fazendo requisições HTTP externas
• Tratando erros do cliente HTTP
• Timeouts e cancelamento
• Processando respostas de API
• Hands-on: Obtenha dados de uma API externa e persista-os localmente

14. Tratamento de Erros e Depuração

• Abordagem do Go para erros
• Retornando erros de funções
• Verificando erros
• Criando erros personalizados
• Envolvendo erros
• Adicionando contexto a erros
• errors.Is e errors.As
• Panic e recovery
• Quando usar panic
• Depurando problemas comuns do Go
• Registrar atividade do aplicativo
• Usando ferramentas de depuração do Go
• Exercício: Diagnostique e corrija erros de aplicativo introduzidos deliberadamente

15. Interfaces e Abstração

• O que é uma interface?
• Implementação implícita de interfaces
• Definindo interfaces
• Valores de interface
• Interfaces vazias / any
• Aserções de tipo
• Switches de tipo
• Implementações por ponteiro versus valor
• Projetando pequenas interfaces
• Inversão de dependências
• Usando interfaces para testes
• Reduzindo o acoplamento do aplicativo
• Hands-on: Introduza interfaces no aplicativo web de exemplo

16. Pacotes e Organização de Projetos

• Criando pacotes
• Convenções de nomenclatura de pacotes
• Identificadores exportados e não exportados
• Importando pacotes
• Inicialização de pacotes
• Organizando camadas de aplicativo
• Pacotes internos
• Gerenciando dependências com Go Modules
• Versionamento semântico
• Usando pacotes de terceiros
• Evitando dependências circulares
• Projetando projetos Go manuteníveis
• Exercício: Refatore o aplicativo em pacotes separados

17. Concorrência com Goroutines

• O que é concorrência?
• Goroutines
• Iniciando goroutines
• Compreendendo execução concorrente leve
• Desafios de sincronização
• Estado compartilhado
• Condições de corrida
• Usando sync.WaitGroup
• Mutexes e mutexes de leitura/escrita
• Operações atômicas
• Hands-on: Converta uma tarefa sequencial em processamento concorrente

18. Canais

• Compreendendo canais
• Enviando e recebendo valores
• Canais com buffer versus sem buffer
• Comportamento bloqueante
• Fechando canais
• Iterando sobre canais
• Canais direcionais
• Comunicação baseada em canais
• Enunciados select
• Timeouts e cancelamento
• Padrões de pool de workers
• Padrões de produtor/consumidor
• Hands-on: Construa um sistema de workers concorrente

19. Contexto e Gerenciamento de Requisições

• Por que contextos são importantes em aplicativos web
• context.Context
• Contexto de escopo de requisição
• Cancelamento
• Prazos
• Timeouts
• Propagando contexto através das camadas do aplicativo
• Cancelando operações de banco de dados ou HTTP
• Evitando o mau uso de contexto
• Exercício: Adicione cancelamento de requisição e timeouts ao aplicativo web

20. Testando Aplicativos Go

• Por que testes automatizados importam
• Escrevendo testes unitários
• O pacote testing
• Funções de teste
• Convenções de nomenclatura de testes
• Testes orientados a tabela
• Testando erros
• Testando handlers HTTP
• Servidores de teste HTTP
• Fixtures de teste
• Cobertura de testes
• Benchmarks
• Testes de exemplo
• Testando interfaces com mocks ou fakes
• Hands-on: Crie uma suíte de testes para o aplicativo de exemplo

21. Otimização de Desempenho

• Compreendendo o desempenho de aplicativos Go
• Identificando gargalos
• Desempenho de CPU versus memória
• Estruturas de dados eficientes
• Reduzindo alocações desnecessárias
• Strings, bytes e buffers
• Gerenciamento de goroutines
• Evitando concorrência excessiva
• Estratégias de cache
• Considerações de banco de dados e rede
• Perfis de aplicativos
• Benchmarks e testes de desempenho
• Usando as ferramentas de perfis do Go
• Exercício: Perfis e otimize um aplicativo deliberadamente ineficiente

22. Segurança e Práticas de Aplicativos Web Robustos

• Validando entrada do usuário
• Tratamento seguro de requisições HTTP
• Prevenindo vulnerabilidades web comuns
• Tratamento seguro de erros
• Conceitos de autenticação e autorização
• Gerenciando segredos e configuração
• Comunicação HTTP segura
• Evitando informações sensíveis em logs
• Gerenciamento de dependências e atualizações
• Limites de recursos e timeouts de requisição
• Exercício: Revise e fortaleça a API de exemplo

23. Log de Aplicativo e Observabilidade

• Fundamentos de log
• Log estruturado
• Níveis de log
• Log de requisições
• Log de erros
• Correlação e IDs de requisição
• Monitorando o comportamento do aplicativo
• Métricas básicas
• Endpoints de verificação de saúde
• Diagnóstico de problemas de produção
• Hands-on: Adicione log estruturado e verificações de saúde

24. Containerizando o Aplicativo Go

• Por que usar containers?
• Aplicativos Go e containerização
• Escrevendo um Dockerfile
• Builds multiestágio
• Construindo uma imagem de runtime mínima
• Gerenciando configuração através de variáveis de ambiente
• Rede de containers
• Expondo portas do aplicativo
• Executando o aplicativo em um container
• Testando o aplicativo containerizado
• Hands-on: Empacote o aplicativo Go de exemplo como um container pronto para produção

25. Implantação

• Preparando um aplicativo para produção
• Construindo binários de produção
• Configuração de ambiente
• Implantação baseada em containers
• Arquitetura de implantação
• Proxies reversos
• Considerações HTTPS/TLS
• Verificações de saúde do aplicativo
• Encerramento gracioso
• Tratando sinais do sistema operacional
• Escala de aplicativos web Go
• Escala horizontal versus vertical
• Resolução básica de problemas de implantação
• Hands-on: Implante o aplicativo web de exemplo

26. Projeto Final: Aplicativo Web Go Completo

Os participantes integram os conceitos desenvolvendo um aplicativo completo.

O projeto pode incluir:

• Inicialização do projeto com Go Modules
• Organização de pacotes
• Roteamento HTTP
• Endpoints de API REST
• Processamento de requisições e respostas JSON
• Validação de entrada
• Tratamento de erros
• Interfaces
• Processamento concorrente
• Comunicação com API externa
• Persistência em arquivo ou banco de dados
• Testes automatizados
• Log
• Considerações de desempenho
• Containerização
• Configuração de produção
• Implantação

27. Revisão e Melhores Práticas

• Revisão da sintaxe central do Go
• Convenções de codificação Go
• Escrevendo Go idiomático
• Mantendo o código simples
• Design eficaz de pacotes
• Melhores práticas de tratamento de erros
• Princípios de design de interfaces
• Melhores práticas de concorrência
• Estratégias de teste
• Considerações de desempenho
• Manutenibilidade e legibilidade
• Erros comuns cometidos por novos desenvolvedores Go
• Abordagens recomendadas para continuar o desenvolvimento em Go

28. Conclusão

• Revisão dos conceitos-chave
• Revisão do aplicativo web concluído
• Perguntas e discussão
• Resolução de problemas em cenários do mundo real comuns
• Próximos passos recomendados para desenvolvimento em Go
• Bibliotecas Go adicionais e recursos do ecossistema
• Oportunidades adicionais para construir serviços Go de nível de produção