Curso de Aprendendo Programação em Go

1. Introdução ao Go

• O que é o Go (Golang)?
• História e filosofia de design do Go
• Go como linguagem de programação web e de sistemas
• Principais características:
  • Tipagem estática
  • Simplicidade e legibilidade
  • Compilação rápida
  • Concorrência nativa
  • Coleção de lixo (Garbage collection)
  • Compilação multiplataforma
• Casos de uso comuns para o Go
• Vantagens e limitações do Go
• Comparação do Go com C/C++, JavaScript, Ruby, Python e Java
• Compreensão do ecossistema Go
• Visão geral da biblioteca padrão do Go
• Módulos Go e gerenciamento de dependências
• Anatomia de um aplicativo Go
• Prática: Examinar e executar um programa Go simples

2. Configurando o Ambiente de Desenvolvimento Go

• Instalando o Go
• Compreendendo a cadeia de ferramentas (toolchain) do Go
• Configurando variáveis de ambiente
• Escolhendo um IDE ou editor de código
• Usando a linha de comando com o Go
• Criando um espaço de trabalho (workspace) Go
• Compreendendo a estrutura de projeto do Go
• Inicializando um projeto com Módulos Go
• Usando go mod init
• Gerenciando dependências com go get
• Atualizando e inspecionando dependências
• Formatando o código-fonte com gofmt
• Executando programas com go run
• Construindo (build) aplicativos com go build
• Instalando aplicativos Go
• Compilação cruzada de aplicativos
• Prática: Criar e configurar um projeto Go dentro de um container

3. Variáveis, Constantes e Tipos em Go

• Declarando variáveis
• Tipos explícitos versus tipos 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 tipos
• Trabalhando com Unicode e UTF-8
• Runes e bytes
• Atribuição múltipla de variáveis
• Compreendendo a segurança de tipos
• Exercício: Construir um pequeno programa de linha de comando para processamento de dados

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 inteiros e de ponto flutuante
• Evitando erros comuns de conversão de tipos
• Exercício: Implementar lógica de cálculos e validação

5. Datas, Horas e Formatação

• Usando o pacote time
• Criando e manipulando datas
• Obtendo a hora atual
• Fusos horários e locais
• Parse de datas e horas
• Formatando datas e horas
• Calculando durações
• Trabalhando com timestamps Unix
• Lidando com timeouts (tempos limite)
• Exercício: Adicionar 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
• Adicionando (append) elementos
• Copiando slices
• Comprimento e capacidade de slices
• Fatiando slices (slicing)
• Armadilhas 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 para JSON

• Prática: Modelar 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 (default)
• Type switches
• Exercício: Implementar 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
• Funções aninhadas (Closures)
• Recursão
• Passando funções como argumentos
• Funções que retornam erros
• Design de funções pequenas e reutilizáveis
• Exercício: Refatorar 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 nulos (Nil pointers)
• Quando usar ponteiros
• Semântica de valor versus referência
• Compreendendo o gerenciamento de memória e a coleta de lixo do Go
• Erros comuns com ponteiros
• Prática: Modificar 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 (manipuladores)
• Processando dados de formulário
• Servindo arquivos estáticos
• Trabalhando com templates HTML
• Variáveis e estruturas de controle em templates
• Estruturando um aplicativo web
• Prática: Construir um servidor web básico em Go

11. Construindo um Serviço Web RESTful

• Fundamentos da arquitetura REST
• Design de 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
• Separando handlers da lógica de negócio
• Prática: Construir uma API REST CRUD

12. Runtime Go, Compilação e Build de Projetos

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

13. Trabalhando com Arquivos e a Web

• Abrindo e fechando arquivos
• Lendo arquivos
• Escrevendo 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 de saída
• Tratando erros de cliente HTTP
• Timeouts e cancelamento
• Processando respostas de API
• Prática: Recuperar dados de uma API externa e persisti-los localmente

14. Tratamento de Erros e Depuração

• Abordagem do Go para erros
• Retornando erros de funções
• Verificando erros
• Criando erros personalizados
• Encapsulando (wrapping) erros
• Adicionando contexto aos erros
• errors.Is e errors.As
• Panic e recovery
• Quando usar panic
• Depurando problemas comuns do Go
• Logando a atividade do aplicativo
• Usando ferramentas de depuração do Go
• Exercício: Diagnosticar e corrigir 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
• Afirmações de tipo (Type assertions)
• Type switches
• Implementações por ponteiro versus por valor
• Design de pequenas interfaces
• Inversão de dependências
• Usando interfaces para testes
• Reduzindo o acoplamento do aplicativo
• Prática: Introduzir 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 do aplicativo
• Pacotes internos (Internal packages)
• Gerenciando dependências com Módulos Go
• Versionamento semântico
• Usando pacotes de terceiros
• Evitando dependências circulares
• Design de projetos Go mantíveis
• Exercício: Refatorar o aplicativo em pacotes separados

17. Concorrência com Goroutines

• O que é concorrência?
• Goroutines
• Iniciando goroutines
• Compreendendo a execução concorrente leve
• Desafios de sincronização
• Estado compartilhado
• Condições de corrida (Race conditions)
• Usando sync.WaitGroup
• Mutexes e mutexes de leitura/escrita
• Operações atômicas
• Prática: Converter uma tarefa sequencial em processamento concorrente

18. Canais (Channels)

• Compreendendo canais
• Enviando e recebendo valores
• Canais com buffer versus sem buffer
• Comportamento bloqueante
• Encerrando canais
• Iterando sobre canais (Ranging over channels)
• Canais direcionais
• Comunicação baseada em canais
• Enunciados Select
• Timeouts e cancelamento
• Padrões de pool de trabalhadores (Worker-pool patterns)
• Padrões de produtor/consumidor
• Prática: Construir um sistema de trabalhadores concorrente

19. Contexto e Gerenciamento de Requisições

• Por que contextos são importantes em aplicativos web
• context.Context
• Contexto com escopo de requisição
• Cancelamento
• Prazos (Deadlines)
• 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: Adicionar cancelamento de requisições e timeouts ao aplicativo web

20. Testando Aplicativos Go

• Por que o teste automatizado importa
• Escrevendo testes unitários
• O pacote testing
• Funções de teste
• Convenções de nomenclatura de testes
• Testes dirigidos por tabela (Table-driven tests)
• 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
• Prática: Criar 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 sobre banco de dados e rede
• Perfilamento de aplicativos
• Benchmarks e testes de desempenho
• Usando ferramentas de perfilamento do Go
• Exercício: Perfilar e otimizar um aplicativo deliberadamente ineficiente

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

• Validando a entrada do usuário
• Processamento 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 e atualização de dependências
• Limites de recursos e timeouts de requisição
• Exercício: Revisar e fortalecer a API de exemplo

23. Log de Aplicativos 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 (Health-check)
• Diagnosticando problemas de produção
• Prática: Adicionar log estruturado e verificações de saúde

24. Containerização do Aplicativo Go

• Por que usar containers?
• Aplicativos Go e containerização
• Escrevendo um Dockerfile
• Builds multiestágio (Multi-stage builds)
• 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
• Prática: Empacotar 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 sobre HTTPS/TLS
• Verificações de saúde do aplicativo
• Desligamento gracioso (Graceful shutdown)
• Lidando com sinais do sistema operacional
• Escala de aplicativos web Go
• Escala horizontal versus vertical
• Solução de problemas básica de implantação
• Prática: Implantar o aplicativo web de exemplo

26. Projeto de Conclusão (Capstone): Aplicativo Web Completo em Go

Os participantes unem os conceitos desenvolvendo um aplicativo completo.

O projeto pode incluir:

• Inicialização do projeto com Módulos Go
• 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 Boas Práticas

• Revisão da sintaxe central do Go
• Convenções de codificação do Go
• Escrevendo Go idiomático
• Mantendo o código simples
• Design de pacotes eficaz
• Boas práticas de tratamento de erros
• Princípios de design de interfaces
• Boas práticas de concorrência
• Estratégias de teste
• Considerações de desempenho
• Mantibilidade e legibilidade
• Erros comuns feitos 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
• Solução de problemas de cenários comuns do mundo real
• Próximos passos recomendados para o desenvolvimento em Go
• Bibliotecas Go adicionais e recursos do ecossistema
• Oportunidades adicionais para construir serviços Go de nível de produção