
Bem-vindo ao curso! Nesta aula, faço uma apresentação geral sobre o conteúdo que você vai aprender nas próximas sessões.
Você vai entender:
- A importância de Go no mercado atual e suas aplicações em sistemas de alta performance
- Visão geral de todos os tópicos que serão abordados no curso
- Meu background como engenheiro de software e criador do curso "Aprenda Golang do zero"
Este é o ponto de partida ideal para especializar-se em Go e dominar conceitos avançados que você não encontra em qualquer lugar.
Nesta aula, você aprenderá como instalar Go no seu sistema operacional. Cobrimos os três principais: Windows, Mac e Linux.
O que você vai aprender:
- Qual versão do Go baixar (sempre a mais atualizada)
- Como baixar Go do site oficial (go.dev)
- Instruções específicas para cada sistema operacional
- Como configurar variáveis de ambiente (especialmente importante para Mac e Linux)
- Como verificar se a instalação foi bem-sucedida
- Alternativa: instalação via Homebrew no Mac
Dicas importantes:
- Sempre baixe a versão mais recente do Go
- Compatibilidade é mantida entre versões
- No Mac, você precisa verificar o tipo do seu processador (Apple Silicon ou Intel)
- No Linux, você precisará extrair o arquivo zip manualmente
- Certifique-se de adicionar Go à variável PATH do seu sistema
Recomendação: Assista até o final mesmo se já tiver Go instalado, para entender as configurações de variáveis de ambiente que podem evitar problemas futuros.
Nesta aula, você aprenderá como instalar e configurar o Visual Studio Code (VS Code), a IDE recomendada para o curso.
O que você vai aprender:
- Como baixar VS Code do site oficial
- Instruções de instalação para Windows, Mac e Linux
- Como adicionar VS Code à variável PATH do seu sistema
- Alternativas de instalação (Homebrew no Mac, snap no Linux)
- Como instalar a extensão Go para VS Code
- Como instalar ferramentas complementares (linters, formatadores, debugging)
Informações importantes por sistema:
- Windows: instalação simples via .msi
- Mac: necessário adicionar ao PATH após instalação (usando comando shell ou manualmente)
- Linux: várias opções (instalador gráfico, terminal, snap) dependendo da distribuição
Dica importante: A extensão Go do VS Code traz vários componentes úteis como linters, autocomplete, formatação automática de código e suporte a testes. Quando solicitado, instale todos os componentes oferecidos.
Nesta aula, você aprenderá como obter ajuda durante o curso e as melhores práticas para compartilhar código quando tiver problemas.
O que você vai aprender:
- Como usar a sessão de perguntas e respostas do Udemy
- Quando e como compartilhar seu código para obter ajuda
- Ferramentas para compartilhar código: Go Playground para arquivos únicos
- Como criar repositórios no GitHub, GitLab ou BitBucket para projetos maiores
- Dicas para resolver problemas de código de forma eficiente
Informações importantes:
Para dúvidas conceituais:
- Use a sessão de perguntas e respostas da Udemy.
Para problemas com código:
- Arquivos únicos (um main.go): Use Go Playground (go.dev/play) e compartilhe o link
- Projetos com múltiplos arquivos: Crie um repositório público no GitHub, GitLab ou BitBucket
- Alternativa: Compacte seus arquivos e compartilhe via Google Drive público
Por que isso importa: Ao enviar o código completo, consigo executar localmente, entender o problema e oferecer soluções mais precisas.
Nesta aula, você aprenderá como criar um script em Go que automatiza a atualização do arquivo go.work conforme você adiciona novos módulos ao projeto.
O que você vai aprender:
- Como criar um script utilitário em Go sem módulo explícito
- Usar filepath.Walk para iterar recursivamente por diretórios
- Como o append funciona com slices
- Usar os.Stat para verificar se arquivos existem
- Executar comandos do sistema operacional (go work init/use) via exec.Command
- Redirecionar stdout e stderr de comandos
- Compilar código Go com go build
- Como contornar validações do go work com GO111MODULE=off
Conceitos abordados:
- Slices de strings: armazenar e gerenciar listas dinâmicas
- filepath.Walk: recursivamente processar diretórios
- os.Stat e os.IsNotExist: verificação de existência de arquivos
- exec.Command: executar comandos no sistema operacional
- Redirecionamento de stdout e stderr
Compilação do script:
Para compilar o arquivo source, use: GO111MODULE=off go build -o update-go-work update-go-work.go
Nota para Windows/PowerShell: use $env:GO111MODULE="off" ao invés de GO111MODULE=off
O script pode ser compilado uma única vez e então usado como binário executável ao longo de todo o curso para manter o go.work atualizado automaticamente.
Nesta aula, você aprenderá a diferença crucial entre Slices e Arrays, e como o Go gerencia a capacidade dinâmica de Slices.
O que você vai aprender:
- A diferença fundamental entre Slices e Arrays
- Como declarar Arrays (tamanho fixo) e Slices (tamanho dinâmico)
- As funções len() e cap() para medir tamanho e capacidade
- Como usar append() para adicionar elementos a um Slice
- Por que Arrays e Slices são tipos diferentes no Go
- Como Slices funcionam internamente: fatias de um Array subjacente
- Estratégia de alocação de capacidade do Go
Conceitos-chave:
Arrays:
- Tamanho fixo declarado no tipo
- Não pode adicionar/remover elementos
- Não funciona com append()
- Exemplo: [5]int
Slices:
- Tamanho dinâmico
- Pode crescer com append()
- Na verdade, uma "fatia" de um Array interno
- Exemplo: []int
Capacidade vs Tamanho:
- len(): número de elementos no Slice
- cap(): capacidade total do Array subjacente
- Quando você ultrapassa a capacidade, Go cria um novo Array maior
Por que isso importa:
Entender essa distinção é crucial para evitar problemas ao copiar Slices e trabalhar com referências de dados.
Nesta aula, você aprenderá por que copiar um Slice de forma ingênua causa problemas, e como fazer cópias seguras usando a função copy().
O que você vai aprender:
- Por que copiar com simples atribuição (slice2 = slice1) não funciona como esperado
- Como Slices compartilham o Array interno subjacente
- Por que modificar um Slice pode afetar outro inesperadamente
- A função make() para criar Slices com tamanho específico
- A função copy() para fazer cópias seguras e independentes
- Como a capacidade dinâmica dos Slices afeta compartilhamento de memória
- Ignorar retornos de funções com _ (blank identifier)
O Problema - Cópia Insegura:
- slice2 := slice1 // Ambos apontam para o mesmo Array interno!
- slice1[0] = 10 // slice2 também é afetado
A Solução - Cópia Segura:
- slice4 := make([]int, len(slice3))
- copy(slice4, slice3) // Agora são independentes
Por que funciona:
- make() cria um novo Array interno
- copy() transfere dados para esse novo Array
- Modificações em um não afetam o outro
Detalhes importantes:
- copy() funciona mesmo com tamanhos diferentes (copia o mínimo)
- O Slice de destino precisa ter espaço suficiente
- Valores vazios são preenchidos com o valor zero do tipo
Nesta aula, você descobrirá por que a função copy() não é suficiente para matrizes (listas de listas) e enfrentará um desafio para resolver o problema de Deep Copy.
O que você vai aprender:
- Como declarar e trabalhar com matrizes (Slices de Slices)
- Sintaxe para acessar elementos em estruturas aninhadas
- Por que copy() não funciona completamente para matrizes
- A diferença entre Shallow Copy e Deep Copy
O Problema - Matrizes Compartilham Sub-slices:
- matriz2 := make([][]int, len(matriz1))
- copy(matriz2, matriz1) // Isso copia os Slices internos, mas...
- matriz2[0][0] = 99 // ...afeta também matriz1!
Por que acontece:
- copy() copia apenas o nível superior da matriz
- Os Slices internos ainda apontam para os mesmos Arrays internos
- Alterações nos elementos afetam ambas as matrizes
DESAFIO:
Encontre uma forma de copiar completamente uma matriz de forma segura (Deep Copy) usando apenas o que foi aprendido nas aulas anteriores. Pense sobre como iterar pela estrutura e copiar cada slice interno individualmente.
Dicas:
- O que aprendemos em aulas anteriores pode ser reutilizado
- Pense em loops e na função copy() aplicada de forma diferente
- Submeta sua solução nos comentários do curso!
Nesta aula, você aprenderá por que o copy() superficial falha com matrizes e como implementar um Deep Copy correto.
O que você vai aprender:
- Por que copy() cria apenas Shallow Copy (cópia superficial) com matrizes
- A diferença entre Shallow Copy e Deep Copy
- Como os Arrays internos são compartilhados entre Slices
- Implementar uma função deepCopy() que copia todos os níveis
- Por que iterar e copiar cada slice interno funciona
O Problema - Shallow Copy:
copy(matriz2, matriz1) // Copia apenas o nível superior
// Os slices internos ainda apontam para os mesmos Arrays internos!
A Solução - Deep Copy:
func deepCopy(matriz [][]int) [][]int {
destino := make([][]int, len(matriz))
for i, slice := range matriz {
destino[i] = make([]int, len(slice))
copy(destino[i], slice)
}
return destino
}
Como funciona:
1. Cria uma nova matriz de destino com make()
2. Itera por cada slice interno
3. Cria um novo slice de destino para cada um
4. Usa copy() para cada slice independentemente
5. Retorna a matriz completamente independente
Por que isso importa:
- Shallow Copy: compartilha Arrays internos (alterações afetam ambas)
- Deep Copy: cria Arrays internos novos (alterações são isoladas)
- Entender a diferença evita bugs sutis em aplicações reais
Conceitos reforçados:
- Arrays internos e como Go os gerencia
- Loops com range
- Funções que retornam tipos complexos
- Iteração profunda de estruturas aninhadas
Nesta aula você aprenderá o que são ponteiros, como usá-los corretamente, e por que seu uso inadequado causa problemas críticos em aplicações.
O que você vai aprender:
- Como declarar ponteiros e a diferença entre o operador & (address) e * (dereference)
- Por que o valor zero de um ponteiro é nil e como isso pode derrubar sua aplicação
- Como verificar se um ponteiro está inicializado antes de usá-lo
- Usar ponteiros em structs para representar campos opcionais
- Receivers com ponteiro em métodos para modificar valores originais
- Padrão de encapsulamento: esconder ponteiros internos e expor tipos normais
- Quando usar ponteiros é apropriado e quando não usar
Erros comuns:
- Tentar derefernciar um nil pointer: panic: invalid memory address
- Não verificar se ponteiro != nil antes de usar
- Usar ponteiros "por performance" sem necessidade real
Casos de uso apropriados:
- Diferenciar zero value de não inicializado (nil check)
- Permitir que métodos modifiquem a struct original
- Compartilhar valores entre pacotes
- Passar grandes estruturas sem cópia (performance real)
Padrão recomendado:
Esconda ponteiros internos em structs e crie métodos que retornam tipos normais, protegendo usuários do seu código de problemas com nil pointers.
Aprender como realizar deep copy seguro com ponteiros em structs.
A aula demonstra o problema de compartilhamento de referências quando ponteiros são incluídos em estruturas e como evitar modificações indesejadas.
Implementa a função toPointer para criar novos endereços de memória e deepCopy para copiar structs completas.
Aborda desafios ao copiar listas de structs com ponteiros e apresenta a função deepCopyList para garantir que cada elemento da lista aponte para endereços de memória distintos. Reforça a importância de usar ponteiros conscientemente, considerando o esforço necessário para contornar problemas de concorrência e compatibilidade.
Implementação de uma função Filter customizada e dinâmica para slices usando tipos genéricos específicos.
A aula explica como criar métodos que aceitam funções como parâmetros para avaliar condições de filtro. Demonstra como a estrutura do código permite reutilização com diferentes lógicas de filtro sem replicação de código.
Mostra exemplos práticos como filtragem de números pares, maiores que um valor específico ou divisíveis por outro número. Introduz conceitos de funções de primeira classe e encadeamento de métodos que retornam o mesmo tipo.
Demonstração completa das funções Map e Reduce para transformação e redução de dados em slices.
Explica como Map aplica transformações a cada elemento mantendo o tamanho do slice original, enquanto Reduce combina múltiplos elementos em um único valor. Aborda a sintaxe especial do Reduce com dois parâmetros de função e explica o papel do acumulador.
Mostra como lidar com casos especiais como multiplicação que requer um valor inicial diferente de zero.
Demonstra encadeamento de Filter, Map e Reduce para operações complexas em dados.
Introdução completa à estrutura de dados Maps no Go, explicando sua natureza chave-valor e diferenças em relação a Structs.
Demonstra a declaração de Maps com diferentes combinações de tipos, incluindo o comum Map[string]interface{}. Explica como o Go organiza Maps internamente usando buckets e funções de hash para performance. Importante: iteração sobre Maps não garante ordem das chaves.
Mostra cenários comuns de panic com Maps, como tentar escrever em um Map com valor nil e acessar chaves inexistentes. Apresenta a sintaxe "ok" para validar se uma chave existe e fazer casting seguro sem risco de panic.
Conceituação profunda de Race Condition, explicando que ocorre apenas quando duas ou mais goroutines acessam o mesmo dado e pelo menos uma delas executa uma escrita. Diferencia cenários seguros (múltiplas leituras sem escrita) de cenários perigosos (escrita + leitura ou múltiplas escritas).
Demonstra como Maps no Go detectam e causam panic quando race conditions são identificadas com "concurrent map writes" ou "concurrent map read and write". Reforça que esse é um problema silencioso em tempo de compilação que explode em tempo de execução, tornando essencial implementar mecanismos de sincronização.
Primeira solução para Race Conditions usando Mutex. Explica como lock e unlock garantem que apenas uma goroutine execute um bloco crítico de cada vez. Demonstra uso prático com 100 goroutines escrevendo simultaneamente em um Map com proteção de Mutex.
Introduz sync.WaitGroup como padrão para controlar execução de múltiplas goroutines. Reforça que Mutex deve ser compartilhado entre goroutines, nunca criado dentro delas. Mostra uso de defer com unlock para garantir liberação mesmo em caso de erro. Importante: Mutex é flexível e funciona com qualquer estrutura que necessite sincronização.
Apresentação de sync.Map como alternativa ao Mutex especificamente para Maps. Explica que sync.Map já possui sincronização embutida, eliminando necessidade de lock/unlock manual. Mostra diferenças na API: use Store() para escrever, Load() para ler, e Range() com closure para iteração.
Aborda trade-offs: sync.Map oferece melhor performance em cenários de alta concorrência mas é um tipo diferente do Map padrão, perdendo compatibilidade com funções que esperam Map convencional. Recomenda-se usar quando há muitas leituras, escrita única ou múltiplos acessos em chaves diferentes. Para maioria dos casos, Mutex com Map comum é mais versátil.
Implementação prática de um cache em memória usando Mutex para sincronização.
Implementa métodos Set e Get com lock/unlock apropriados. Demonstra funcionamento seguro mesmo com múltiplas goroutines lendo e escrevendo simultaneamente. Mostra como o padrão de lock/unlock garante leitura de dados atualizados e escrita consistente. Inclui exemplo com cinco goroutines de escrita e cinco de leitura sem problemas de concorrência.
Serve como base para entender sincronização em estruturas de dados compartilhadas.
Refatoração do cache anterior para usar sync.Map em vez de Mutex. Demonstra como as mudanças internas (Store ao invés de atribuição, Load ao invés de leitura direta) são transparentes para a função main graças ao encapsulamento.
O método Range() substitui iteração tradicional. Mostra como a mesma interface externa funciona com implementação totalmente diferente internamente. Discute quando escolher sync.Map (alto volume, muitas chaves diferentes com acesso frequente) vs Mutex comum (melhor compatibilidade geral). Conclui sessão de Maps reforçando importância de escolher ferramenta adequada para cada cenário.
Introdução fundamental a Channels como mecanismo de comunicação entre goroutines. Explica que Channels são bloqueantes por padrão: envio aguarda recebimento e vice-versa. Demonstra funções Enviar e Receber com sintaxe de seta para direção.
Cria cenário com múltiplas goroutines comunicando-se através de Channel único. Explica conceito crítico de deadlock: programa trava se houver desequilíbrio entre envios e recebimentos. Mostra que operações de Channel são síncronos e garantem ordem de processamento. Reforça que Channels são preferíveis ao Mutex quando há necessidade genuína de comunicação entre goroutines.
Evolução de Channels introduzindo buffer que permite armazenar múltiplos valores antes de bloquear. Explica que buffer diferencia Channels bloqueantes (sem buffer) de assíncronos (com buffer). Demonstra comportamento onde até N valores podem ser enviados sem bloqueio se buffer não estiver cheio.
Compara execução com e sem buffer mostrando diferença no timing e logs. Fornece regra de decisão: use Channels sem buffer para sincronização rigorosa, com buffer para processamento mais flexível de filas. Mostra que tamanho de buffer deve ser determinado considerando trade-off entre flexibilidade e limite de recursos.
Introdução ao conceito de direções directions para limitar operações permitidas. Mostra sintaxe `<-` para especificar se uma função pode enviar ou receber.
Introdução a sync.errgroup como alternativa a sync.WaitGroup com suporte nativo a tratamento de erros. Requer importação external de golang.org/x/sync/errgroup. Mostra como eg.Go() automaticamente incrementa contador de goroutines sem necessidade de eg.Add().
Demonstra eg.Wait() que retorna erro da primeira goroutine que falhou. Inclui feature de limite de goroutines ativas simultaneamente através de eg.SetLimit(). Diferencia de WaitGroup: ErrorGroup é melhor quando funções retornam erros que precisam ser tratados. Reforça padrão de validação de erro após eg.Wait().
Padrão de concorrência para distribuir carga de trabalho entre múltiplos channels (fan-out) e depois consolidar resultados em channel único (fan-in).
Demonstra com exemplo de processamento de lista de números dividida entre três channels paralelos. Implementa função produtor que popula channel de entrada e função fan-out que distribui entre múltiplos channels.
Mostra uso de channel closure para sinalizar fim de envios. Implementa fan-in que lê de múltiplos channels e envia para saída única. Padrão útil para consolidar dados de múltiplas fontes ou distribuir carga computacional. Exemplifica com multiplicação de números como operação simulada.
Padrão de esteira de processamento onde dados passam por múltiplas etapas sequencialmente, porém cada etapa processa diferentes itens simultaneamente.
Diferencia de Fan-Out: enquanto fan-out divide dados, pipeline mantém ordem de processamento através de estágios. Demonstra com três estágios (população, transformação, saída) onde dados fluem continuamente.
Vantagem: ganho de performance sem perder ordenação do resultado, diferente de fan-out que pode desorganizar. Implementa usando múltiplos channels conectados sequencialmente com goroutines processando cada estágio.
Construtor nativo do Go para monitorar múltiplos channels simultaneamente, parecido com switch mas para channels. Sintaticamente similar ao switch mas com cases que aguardam dados em channels específicos.
Demonstra com dois channels enviando mensagens em intervalos diferentes. Mostra execução selecionando qual channel tem dados disponíveis primeiro. Inclui timeout usando time.After() para detectar inatividade prolongada. Reforça que Select processa uma mensagem por iteração, se múltiplos channels tiverem dados, apenas um case executa. Muito útil para implementar timeout e monitoramento de múltiplas fontes.
Proposta de exercício prático: implementar agendador de tarefas usando Select e time.Ticker em vez de time.Sleep. Ticker envia sinais em intervalos regulares através de channel interno (Ticker.C).
Desafio encoraja pensamento crítico e implementação independente antes de ver solução. Menciona que solução requer criatividade na estrutura do código e entendimento profundo de channels. Serve como ponto de avaliação do aprendizado sobre padrões de concorrência.
Solução do desafio mostrando implementação de agendador robusto. Cria estrutura Agendar que recebe intervalo, função a executar e channels de controle.
Proposta de segundo exercício: implementar padrão Broadcast que envia mesma mensagem para múltiplos channels.
Diferencia de Fan-Out: broadcast envia dados idênticos para todos, fan-out divide dados entre channels. Desafio com nível de dificuldade menor que anterior, mas reforça compreensão de padrões. Encoraja implementação independente com comparação posterior de soluções.
Solução do desafio implementando o padrão Broadcast.
Introdução a sync.RWMutex para cenários com muitas leituras e poucas escritas. Permite múltiplas leituras simultâneas (RLock/RUnlock) enquanto bloqueia completamente durante escritas (Lock/Unlock). Demonstra com exemplo prático: duas goroutines lendo simultaneamente com sucesso, mas terceira goroutine escrevendo espera ambas leituras terminarem.
Usa função de log com timestamp para visualizar linha do tempo de locks. Reforça cuidado crítico: RLock deve ser pareado com RUnlock, não usar combinações erradas. Performance superior para cenários leitura-pesada comparado a Mutex comum.
Estrutura sync.Once que garante bloco de código execute apenas uma vez, independente de quantas goroutines o chamem.
Caso de uso clássico: inicialização de recurso compartilhado como conexão com banco de dados. Implementa função que abre conexão apenas na primeira chamada, bloqueia outras goroutines até conclusão, depois retorna recurso sem reinicializar.
Crítico: Once deve ser compartilhado globalmente, nunca criado dentro de funções/goroutines. Demonstra que múltiplas chamadas subsequentes não reexecutam bloco. Útil para lazy initialization thread-safe.
Estrutura sync.Cond para sincronização baseada em estado compartilhado, permitindo goroutines aguardarem mudanças.
Demonstra cenário produtor-consumidor: goroutine produz itens em lista, goroutine consumidora aguarda via Wait() até Signal() indicar novos itens. Cond funciona com Mutex para proteger estrutura de dados. Padrão: sempre usar for ao invés de if com Wait() para garantir segurança em cenários de múltiplas goroutines. Implementação simples mas poderosa para comunicação entre goroutines baseada em condições lógicas.
Aplicação prática de Cond gerenciando pool de conexões com limite. Cria estrutura que mantém lista de conexões disponíveis.
Funcionalidade Broadcast de Cond (diferente de padrão Broadcast de channels) que desperta todas as goroutines aguardando versus Signal que desperta apenas uma.
Usando Broadcast() ao invés de Signal() ao liberar recurso garante que todas as goroutines aguardando sejam notificadas simultaneamente. Útil quando múltiplas goroutines precisam reagir ao mesmo evento. Demonstra diferença de semântica: Signal para notificação de uma goroutine específica, Broadcast para notificação em massa.
Introdução a sync.Pool para reutilização de objetos alocados reduzindo garbage collection.
Pool armazena objetos não utilizados que podem ser reutilizados, economizando alocações. Implementação requer Get() para recuperar objeto existente ou criar novo, Put() para devolver ao pool.
Garbage collector pode limpar pool a qualquer momento, então não deve ser usado para persistência. Útil para objetos temporários alocados frequentemente (buffers, conexões efêmeras). Padrão performance-driven que reduz pressão no garbage collector.
Comparação de performance entre estruturas que usam Pool versus as que não usam.
Usa benchmarks para medir diferença em tempo de alocação e garbage collection. Demonstra ganho significativo de performance ao reutilizar objetos via Pool em operações frequentes. Mostra como Pool reduz pausas de GC ao minimizar alocações. Importante notar que ganhos variam conforme padrão de uso e carga da aplicação.
Introdução a operações atômicas via sync/atomic para incremento/decremento de contadores sem locks tradicionais.
Atomic.AddInt64 e Atomic.LoadInt64 garantem operações indivisíveis sem Mutex. Menos overhead que Mutex para operações simples.
Caso de uso: contadores compartilhados que precisam alta performance. Restrição: funciona apenas com tipos numéricos específicos (int32, int64, uint32, uint64, uintptr). Para estruturas complexas, Mutex continua sendo necessário.
Comparação de performance entre Atomic e Mutex para operações de contagem.
Benchmarks mostram que Atomic é significativamente mais rápido para operações simples de incremento. No entanto, Atomic é limitado a valores numéricos, enquanto Mutex funciona com qualquer tipo. Trade-off: performance versus flexibilidade. Para contadores de alta contention, Atomic é escolha melhor. Para estruturas complexas ou múltiplas operações, Mutex é apropriado.
Fundamentos de interfaces em Go como abstrações comportamentais. Interfaces definem contratos de métodos sem especificar implementação.
Aplicação prática de interfaces com processamento de XML. Cria interface para tipos que podem ser serializados/desserializados. Demonstra como diferentes tipos podem implementar mesma interface de diferentes formas. Mostra parsing de XML usando reflect para estruturas dinâmicas. Aplicação real: APIs que precisam suportar múltiplos formatos de dados.
Aprofundamento em interface{} como tipo universal que aceita qualquer valor. Explica como Go permite armazenar qualquer tipo em interface{}. Para usar valor original, é necessário type assertion ou type switch. Demonstra padrão de verificação com ok para validar tipo antes de usar. Importante para funções genéricas que precisam aceitar múltiplos tipos. Reforça que interfaces vazias sacrificam type safety pela flexibilidade.
Introdução a pacote reflect para introspecção de tipos e valores em runtime. Demonstra reflect.TypeOf() e reflect.ValueOf().
Permite inspecionar estrutura de tipos, campos, métodos. Casos de uso: serialização genérica, validação, mapeamento de estruturas. Reforça que reflect adiciona overhead e deve ser evitado em código crítico. Muito útil para frameworks que precisam trabalhar com tipos desconhecidos em runtime.
Comparação de performance entre reflect e type casting explícito.
Casting é significativamente mais rápido pois é compile-time. Reflect é bem mais custoso.
Via de Regra: evite reflect em código crítico de performance, use para casos onde tipo é realmente desconhecido. Demonstra que trade-off entre flexibilidade e performance deve ser levado em consideração.
Introdução a Generics no Go (1.18+) para criar funções e tipos reutilizáveis mantendo type safety.
Generics diminuem a necessidade de interface{} e reflect para muitos casos. Reforça que Generics resolvem problema de código duplicado quando mesmo algoritmo vale para múltiplos tipos. Funciona com tipos customizados e tipos nativos.
Exploração de constraints predefinidas para tipos numéricos em Generics. Go fornece constraints como int, float64, integer, etc.
Permite escrever funções que aceitam múltiplos tipos numéricos mantendo type safety. Exemplo: função que soma qualquer tipo numérico sem duplicar código para int, int64, float64. Reforça que constraints podem ser unions de tipos (int | int32 | int64). Útil para operações matemáticas genéricas.
Exploração de constraints predefinidas pelo Go
Permite escrever algoritmos genéricos como busca ou ordenação que funcionam com qualquer tipo que implemente constraint.
Exemplo: função busca que funciona para strings, inteiros, ou qualquer tipo comparável. Reforça poder de Generics para eliminar duplicação de código mantendo eficiência de tipos específicos.
Proposta de desafio: implementar função genérica de busca usando Generics com constraints apropriados.
Solução implementando função Busca genérica com constraint comparable.
Implementação de cache genérico usando Generics em vez de interface{}.
Permite cache de qualquer tipo mantendo type safety. Solução mais elegante que versão anterior com map[string]interface{}
Introdução ao pacote Context para propagação de valores, deadlines e signals de cancelamento através de goroutines.
Exploração de context.WithCancel() para sinalizar cancelamento entre goroutines.
Implementação de timeouts usando context.WithTimeout() e context.WithDeadline().
Timeout é relativo (próximos X segundos), deadline é absoluto (até hora específica).
Context automaticamente cancela quando tempo expira.
Padrão: usar context.WithTimeout() em chamadas de função que podem ser lentas.
Exemplo: timeout em requisições HTTP. Reforça que contexts garantem operações não ficarão presas indefinidamente.
Aplicação prática usando context com requisições HTTP.
Cria requisição HTTP com context que tem timeout. Se requisição demorar mais que timeout, context cancela automaticamente. Padrão usado em APIs reais para evitar requisições travadas.
Demonstra integração de context com http.NewRequestWithContext(). Reforça uso de timeouts como boa prática em I/O de rede.
Proposta de implementar graceful shutdown: aplicação aguarda goroutines terminarem antes de sair. Usa context para sinalizar shutdown para goroutines.
Solução implementando graceful shutdown de aplicação.
Criação de contextos derivados de contextos existentes, formando uma hierarquia.
Criação de tipos customizados que implementam a interface Context
Introdução a profiling para otimização de performance. Pacote pprof permite coletar dados de uso de CPU. Demonstra como adicionar profiling a aplicação e analisar resultados.
Mostra quais funções consomem mais tempo de processamento. Essencial para identificar gargalos em aplicações. Reforça que otimização sem profiling é especulação.
Profiling de uso de memória focando em heap (alocações) e allocs (número de alocações). Pprof mostra quais estruturas e funções alocam mais memória. Importante para identificar memory leaks ou alocações excessivas.
Profiling específico do número de goroutines ativas. Pprof mostra quantas goroutines estão rodando em qualquer momento. Útil para detectar goroutine leaks onde goroutines nunca terminam.
Profiling de threads do sistema operacional. Distingue entre goroutines (user-level) e threads (OS-level).
Profiling de Mutex mostrando tempo gasto aguardando locks.
Ferramenta identifica quais Mutexes têm contenção alta. Útil para encontrar bottlenecks de concorrência.
Ferramenta de tracing que registra todos eventos de execução (goroutines criadas, channels, etc). Trace viewer mostra linha do tempo de execução de toda aplicação.
Muito útil para entender comportamento de aplicações concorrentes. Demonstra como visualizar interações entre goroutines. Mais detalhado que profiling simples, bom para debugging de problemas de concorrência.
Exposição de profiling endpoints via HTTP server.
Pprof fornece handler que pode ser registrado em mux HTTP. Permite profiling de aplicação em produção sem parar. Endpoints disponíveis para CPU, heap, goroutines, etc. Padrão usado em microserviços para diagnosticar problemas.
Criação de perfis customizados para monitoria de métricas específicas da aplicação.
Fundamentos de testes unitários em Go
Utilização do pacote Testify para asserções mais simples e legíveis.
Criação de mocks para isolar código sendo testado. Demonstra como criar mocks que automaticamente implementam interfaces.
Permite controlar comportamento de dependências em testes.
Exemplo: mock de conexão com banco de dados para testar sem banco real. Pacotes como testify/mock ajudam. Reforça que testes devem ser rápidos e determinísticos, então mocks evitam dependências externas.
Testes de funções que usam context.
Demonstra como criar contexts com timeouts para testar comportamento de timeout. Mostra como testar cancelamento de context. Importante: sempre respeitar deadline do context em testes para evitar testes travarem. Padrão: usar context.Background() para testes que não precisam de timeout específico.
Fuzz testing que gera inputs aleatórios para encontrar casos de falha. Go tem suporte nativo a fuzzing a partir de 1.18+
Quick oferece um jeito simplificado de testar inputs aleatórios.
Ambos são úteis para encontrar bugs em edge cases não imaginados. Exemplo: gerar strings aleatórias para testar parser. Reforça que testes tradicionais podem não cobrir todos os casos.
Testes de performance usando funcionalidade integrada de benchmark em Go
Este não é mais um curso introdutório de Go. Se você já sabe o básico e quer parar de escrever código que "funciona" e começar a escrever código que você entende de verdade, este curso foi feito pra você.
São mais de 21 horas de conteúdo prático, organizado em 10 módulos independentes, cobrindo os temas que separam um desenvolvedor Go comum de um desenvolvedor Go bom de verdade:
Concorrência avançada com channels, goroutines e os padrões que você vai encontrar em sistemas reais
Sincronização avançada com RWMutex, sync.Once, sync.Cond, sync.Pool e operações atômicas, com benchmarks reais mostrando a diferença entre cada abordagem.
Sistema de tipos completo: Interfaces, Reflection, Generics e constraints customizadas.
Gerenciamento de ciclo de vida com Context: cancelamento, timeout, deadline, encadeamento e contextos customizados.
Profiling com pprof do jeito certo, para você saber exatamente onde sua aplicação está sofrendo.
Testes avançados utilizando testify, mocks, fuzz testing, property-based testing e benchmarking.
E de brinde, esse curso também cobre algo que a maioria ignora: o papel real da Inteligência Artificial no desenvolvimento de software. Não com hype. Com embasamento.
O módulo extra sobre Inteligência Artificial é sustentado por 10 estudos científicos e relatórios acadêmicos que mostram o que acontece quando desenvolvedores dependem cegamente de ferramentas como ChatGPT e GitHub Copilot. Você vai sair daqui sabendo usar IA como ferramenta — não como muleta.
Este curso começa onde os outros terminam.