🤖 Spec Sistemas com Golang

"A educação é a arma mais poderosa que você pode usar para mudar o mundo." — Nelson Mandela (Adaptado para Tecnologia)

🧭 Atalhos Rápidos

Trilha de Aprendizagem --- Veja o Mapa da Jornada.
Slides Interativos --- Acesse as Apreasentações.
Quizzes de Revisão --- Teste seus Conhecimentos.
Projetos Práticos --- Mão na massa nos Projetos.
Exercícios --- Pratique com Desafios.
Setups --- Configure seu Ambiente.

🗺️ Mapa da Jornada

O curso está dividido em 4 Módulos Estratégicos projetados para uma progressão cognitiva sólida.

Módulo 1: Fundamentos e Conceitos Iniciais.
Módulo 2: Aprofundamento Técnico.
Módulo 3: Prática e Consolidação.
Módulo 4: Especialização e Projeto Final.

Ir para Aula 01

Aulas

Aula 01 - Introdução ao Go e Ecossistema 🐹

Objetivo

Objetivo: Compreender a origem, a filosofia e os diferenciais da linguagem Go, além de configurar o ambiente de desenvolvimento e executar o primeiro programa.

1. O que é Go? 🚀

Desenvolvida pelo Google em 2007 (e lançada em 2009), Go (ou Golang) foi criada para resolver desafios reais de engenharia de software em larga escala. Seus criadores — Robert Griesemer, Rob Pike e Ken Thompson — buscaram uma linguagem que fosse eficiente como C++, mas simples de ler e escrever como Python.

🏛️ Os Pilares da Linguagem

Go não tenta ser a linguagem com mais recursos, mas sim a mais produtiva para sistemas modernos:

Simplicidade: A especificação da linguagem é pequena e fácil de aprender.
Eficiência: Compilada diretamente para código de máquina (sem máquinas virtuais).
Concorrência Nativa: Goroutines e Channels tornam o processamento paralelo simples e leve.
Segurança: Tipagem forte e estática, com gerenciamento automático de memória (Garbage Collector).

2. Por que escolher Go? ⚖️

Característica	🐹 Go	🐍 Python	☕ Java
Velocidade	Ultra-rápida (Compilada)	Lenta (Interpretada)	Média (JIT)
Binário	Único e estático	Precisa de interpretador	Precisa de JVM
Concorrência	Nativa e leve	GIL (limitado)	Threads pesadas
Curva de Aprendizado	Rápida	Muito rápida	Média

Onde o Go brilha? (Mermaid)

mindmap
  root((Ecossistema Go))
    Cloud e Infraestrutura
      Docker
      Kubernetes
      Terraform
    Backend de Alta Performance
      APIs RESTfuk
      gRPC
      Microsserviços
    CLI Tools
      Hugo
      Github CLI
    Data Processing
      Pipeline de Dados
      Streaming

3. Instalação e Setup 🛠️

Para começar a programar em Go, siga estes passos:

Download: Acesse go.dev/dl e baixe a versão para seu SO.
Verificação: Abra o terminal e verifique se o Go foi instalado corretamente.

$ go version
go version go1.22.x windows/amd64

Editor: Recomendamos o Visual Studio Code com a extensão oficial Go (da Google).

4. Estrutura de um Programa Go 📂

Todo arquivo Go deve seguir uma estrutura básica:

package main // 1. Declaração do pacote

import "fmt" // 2. Importação de dependências

// 3. Função principal (ponto de entrada)
func main() {
    fmt.Println("Olá, Gophers! 🐹")
}

package main: Indica que este arquivo é um executável, não uma biblioteca.
func main(): É o primeiro código a ser rodado quando o binário inicia.

5. Seu Primeiro Programa: "Hello, World" 🚀

Vamos criar e rodar seu primeiro código:

# Crie um diretório para seus estudos
$ mkdir estudos-go
$ cd estudos-go

# Inicialize um módulo (gerenciador de dependências)
$ go mod init meu-projeto

# Crie o arquivo principal
$ touch main.go

# (Edite o arquivo com o código acima)

# Execute diretamente sem compilar
$ go run main.go
Olá, Gophers! 🐹

# Ou compile para um binário executável
$ go build main.go
$ ./main  # Ou main.exe no Windows

6. Mini-Projeto: Dashboard do Sistema 📊

Como desafio inicial, crie um programa chamado perfil.go que imprima no console: 1. Seu nome. 2. Sua idade. 3. Uma frase sobre por que você quer aprender Go.

Dica: Use fmt.Println() para cada linha.

7. Exercícios de Fixação 🧠

Quem são os criadores originais da linguagem Go?
Qual a principal diferença entre go run e go build?
Para que serve o comando go mod init?

Próxima Aula: Vamos mergulhar nos Fundamentos da Linguagem, explorando variáveis e tipos! 🧱

Aula 02 - Fundamentos da Linguagem 🧱

Objetivo

Objetivo: Dominar os blocos de construção essenciais do Go: tipos de dados, variáveis, operadores e as estruturas de controle de fluxo.

1. Variáveis e Constantes 📦

Em Go, existem diversas formas de declarar variáveis, mas a linguagem preza pela clareza e tipagem forte.

Declaração Explícita vs Curta

// Forma longa (com tipo)
var nome string = "Gopher"

// Forma curta (inferência de tipo - apenas dentro de funções)
idade := 25 

// Constantes (valores que não mudam)
const Pi = 3.1415

2. Tipos Primitivos 💎

Go possui tipos bem definidos para garantir eficiência de memória:

Inteiros: int, int8, int64, uint (sem sinal).
Decimais: float32, float64.
Booleanos: bool (true, false).
Textos: string (UTF-8 por padrão!).

[!IMPORTANT] Go não faz conversão implícita de tipos. Você não pode somar um int com um float64 sem converter um deles manualmente.

3. Estruturas Condicionais 🚦

O controle de fluxo em Go é simples e direto.

If / Else

Note que não usamos parênteses nos testes condicionais!

if idade >= 18 {
    fmt.Println("Maior de idade")
} else {
    fmt.Println("Menor de idade")
}

Switch

O switch em Go é poderoso e não precisa de break em cada caso (ele para automaticamente).

switch dia {
case "Sábado", "Domingo":
    fmt.Println("Fim de semana! 🎉")
default:
    fmt.Println("Dia de codar! 💻")
}

4. Estruturas de Repetição 🔁

Aqui está uma curiosidade: Go só tem uma palavra-chave para loops: for. Mas ele assume várias formas.

For Tradicional

for i := 0; i < 5; i++ {
    fmt.Println("Contagem:", i)
}

For como "While"

contador := 0
for contador < 3 {
    fmt.Println(contador)
    contador++
}

5. Visualização de Fluxo (Mermaid) 📊

graph TD
    Start([Início]) --> Input[Recebe Idade]
    Input --> Cond{Idade >= 18?}
    Cond -- Sim --> Adult[Pode entrar]
    Cond -- Não --> Minor[Acesso negado]
    Adult --> End([Fim])
    Minor --> End

6. Mini-Projeto: Calculadora de IMC 🚀

Crie um programa imc.go que: 1. Declare variáveis para peso (float64) e altura (float64). 2. Calcule o IMC (peso / (altura * altura)). 3. Use um if/else ou switch para classificar: * IMC < 18.5: Abaixo do peso. * 18.5 a 24.9: Peso normal. * >= 25: Acima do peso.

7. Exercícios de Fixação 🧠

Qual a diferença entre usar var x = 10 e x := 10?
O que acontece se você declarar uma variável em Go e não usá-la? (Dica: tente compilar!)
Como criar um loop infinito em Go?

Próxima Aula: Vamos aprender a organizar nosso código com Funções e Módulos! 🧩🧱🚀

Aula 03 - Funções e Organização do Código 🧩

Objetivo

Objetivo: Aprender a estruturar projetos em Go usando funções, pacotes e entender o conceito fundamental de ponteiros.

1. Funções em Go ⚙️

As funções são cidadãs de primeira classe em Go. Elas podem ser passadas como argumentos, retornadas por outras funções e muito mais.

Sintaxe Básica e Múltiplos Retornos

Diferente de C ou Java, Go permite retornar mais de um valor, o que é muito usado para tratamento de erros.

func dividir(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("divisão por zero")
    }
    return a / b, nil
}

Funções Variádicas

Funções que aceitam um número variável de argumentos (como o próprio fmt.Println).

func somarTudo(numeros ...int) int {
    total := 0
    for _, n := range numeros {
        total += n
    }
    return total
}

2. Ponteiros: Onde mora o dado? 📍

Ponteiros permitem acessar o endereço de memória de uma variável. Em Go, usamos ponteiros principalmente para performance (evitar cópia de dados grandes) ou para modificar um valor dentro de uma função.

&: Operador "endereço de" (onde está?).
*: Operador "valor no endereço" (o que tem lá?).

func dobrar(n *int) {
    *n = *n * 2 // Modifica o valor original na memória
}

3. Organização Profissional: Pacotes e Módulos 📂

Go organiza o código em Pacotes (Pastas).

Exportação: Em Go, se uma função ou variável começa com Letra Maiúscula, ela é pública (exportada). Se começa com minúscula, é privada.
Módulos: Definidos pelo arquivo go.mod, gerenciam as dependências do projeto.

4. Visualização de Estrutura de Projeto (Termynal) 📂

$ tree
.
├── go.mod            # Definição do módulo
├── main.go           # Ponto de entrada
├── calculadora/      # Pacote personalizado
│   └── aritmetica.go # Funções (ex: somar, subtrair)
└── utils/            # Outro pacote
    └── logger.go

5. Fluxo de Execução (Mermaid) 📊

graph LR
    Main[main.go] -->|Importa| Calc[calculadora.Calculo]
    Calc -->|Retorna| Result[Resultado]
    Result -->|Exibe| Console[Tela do Usuário]

6. Mini-Projeto: Conversor de Medidas Modular 🚀

Crie um projeto com a seguinte estrutura: 1. Um pacote conversor com funções exportadas: CelsiusParaFahrenheit e KmParaMilhas. 2. Um arquivo main.go que importa o pacote conversor e exibe os resultados na tela.

7. Exercícios de Fixação 🧠

Como você ignora um dos retornos de uma função em Go?
Qual a diferença entre passar um parâmetro por valor e por ponteiro?
O que define se uma função de um pacote pode ser acessada por outro pacote?

Próxima Aula: Vamos explorar as Estruturas de Dados Avançadas: Slices, Maps e Structs! 🗄️

Aula 04 - Estruturas de Dados Avançadas 🗄️

Objetivo

Objetivo: Entender como Go gerencia conjuntos de dados usando Arrays, Slices e Maps, além de criar tipos personalizados com Structs.

1. Arrays vs Slices 🍕

Embora parecidos, eles funcionam de forma muito diferente em Go.

Arrays (Tamanho Fixo)

Raramente usados diretamente em Go, pois seu tamanho faz parte do tipo.

var notas [3]int = [3]int{10, 8, 9}

Slices (Tamanho Dinâmico)

O "queridinho" do Go. É uma abstração poderosa sobre o Array.

// Criando um slice vazio
frutas := []string{"Maçã", "Banana"}

// Adicionando elementos
frutas = append(frutas, "Uva")

// Fatiando (Slicing)
subFrutas := frutas[0:2] // Pega do índice 0 até o 1

2. Maps: Chave e Valor 🗝️

Maps são coleções desordenadas de pares chave-valor (semelhante a Dicionários no Python ou Objetos no JS).

// Declarando um map
estoque := make(map[string]int)

// Adicionando dados
estoque["teclado"] = 50
estoque["mouse"] = 30

// Verificando se uma chave existe
valor, existe := estoque["monitor"]

3. Structs: Criando seus Próprios Tipos 🏗️

As Structs são a forma de Go agrupar diferentes tipos de dados em uma única entidade (como um "objeto" sem classes).

type Usuario struct {
    ID    int
    Nome  string
    Ativo bool
}

// Inicializando
user := Usuario{ID: 1, Nome: "Ricardo", Ativo: true}

Métodos Associados

Você pode "anexar" funções a uma struct, transformando-as em métodos.

func (u Usuario) Saudacao() {
    fmt.Printf("Olá, meu nome é %s\n", u.Nome)
}

4. Visualização de Memória (Mermaid) 📊

graph LR
    subgraph "Slice Header"
        Ptr[Ponteiro]
        Len[Tamanho]
        Cap[Capacidade]
    end
    subgraph "Array Subjacente"
        D1[Dado 1]
        D2[Dado 2]
        D3[Dado 3]
        D4[Em branco]
    end
    Ptr --> D1

5. Exemplo de Manipulação (Termynal) 💻

$ go run main.go
Lista original: [A B C]
Após append: [A B C D]
Mapa de Preços: map[cafe:5.5 pão:1.2]

6. Mini-Projeto: Sistema de Gerenciamento de Alunos 🚀

Crie um programa escola.go que: 1. Defina uma struct Aluno com Nome e Notas (um slice de float64). 2. Crie uma função que receba um Aluno e calcule a média das notas. 3. No main, crie um map onde a chave é o CPF (string) e o valor é a struct Aluno. 4. Imprima a lista de alunos e suas respectivas médias.

7. Exercícios de Fixação 🧠

O que acontece com a capacidade de um Slice quando ele atinge o limite e você faz um append?
Como você remove um elemento de um Map?
Posso ter uma Struct dentro de outra Struct? (Composição)

Próxima Aula: Vamos entender Interfaces e Programação Orientada a Composição, o segredo da flexibilidade do Go! 🧩🐹

Aula 05 - Interfaces e Programação Orientada a Composição 🧩

Objetivo

Objetivo: Compreender o conceito de Interfaces em Go, como elas permitem o polimorfismo e por que a composição é preferível à herança tradicional.

1. O que são Interfaces? 🔌

Em Go, uma Interface define um conjunto de métodos, mas não os implementa. Ela funciona como um "contrato". Se um tipo (geralmente uma struct) possui todos os métodos definidos na interface, dizemos que ele implementa essa interface.

Exemplo: A Interface `Som`

type Animal interface {
    FazerSom() string
}

type Cachorro struct{}
func (c Cachorro) FazerSom() string { return "Au Au!" }

type Gato struct{}
func (g Gato) FazerSom() string { return "Miau!" }

Note que não usamos a palavra implements. Go faz isso de forma implícita (Duck Typing)!

2. Polimorfismo na Prática 🎭

Graças às interfaces, podemos criar funções que aceitam qualquer tipo que se "comporte" de uma certa maneira.

func EmitirSom(a Animal) {
    fmt.Println(a.FazerSom())
}

3. Composição: O "Jeito Go" de Reutilizar Código 🏗️

Go não possui herança de classes. Em vez disso, usamos a Composição (Embedding).

type Motor struct {
    Potencia int
}

type Carro struct {
    Motor // O carro "tem um" motor (embedding)
    Marca string
}

Isso torna o sistema muito mais flexível e evita as armadilhas de hierarquias complexas de classes.

4. Princípios SOLID em Go 🛡️

S (Single Responsibility): Structs focadas.
O (Open/Closed): Aberto para extensão via interfaces.
L (Liskov Substitution): Interfaces garantem que o substituto funcione.
I (Interface Segregation): Interfaces pequenas são melhores (ex: io.Reader).
D (Dependency Inversion): Dependa de abstrações (interfaces), não de implementações.

[!TIP] "Quanto maior a interface, mais fraca a abstração." — Rob Pike.

5. Visualização de Composição (Mermaid) 📊

classDiagram
    class Motor {
        +int Potencia
        +Ligar()
    }
    class Carro {
        +Motor motor
        +string Marca
    }
    class Moto {
        +Motor motor
        +bool TemCarenagem
    }
    Carro *-- Motor
    Moto *-- Motor

6. Mini-Projeto: Sistema de Pagamentos Diversos 🚀

Crie uma interface MetodoPagamento com o método Pagar(valor float64). 1. Implemente a struct Cartao e a struct Boleto. 2. Crie uma função ProcessarCompra que receba a interface e realize o pagamento.

7. Exercícios de Fixação 🧠

Preciso declarar explicitamente que uma Struct implementa uma Interface em Go?
O que é uma "Interface Vazia" (interface{}) e quando ela deve ser evitada?
Qual a vantagem da Composição sobre a Herança?

Próxima Aula: Vamos aprender a lidar com o inevitável: o Tratamento de Erros em Go! ⚠️🐹

Aula 06 - Tratamento de Erros ⚠️

Objetivo

Objetivo: Entender a filosofia de tratamento de erros em Go, a importância do tipo error, além de saber quando usar Panic e Recover.

1. Erros não são Exceções! 🧊

Em Go, erros são valores. Não existe try/catch. Se uma função pode falhar, ela retorna um valor do tipo error como seu último retorno.

O Padrão `if err != nil`

Esta é a frase mais famosa do Go. Quase todo código Go profissional verifica erros dessa forma:

arquivo, err := os.Open("dados.txt")
if err != nil {
    fmt.Println("Erro ao abrir arquivo:", err)
    return
}
// Se chegou aqui, o arquivo foi aberto com sucesso
defer arquivo.Close()

2. Criando Erros Customizados 🛠️

Você pode criar seus próprios erros usando o pacote errors ou formatando strings com fmt.Errorf.

var ErroSaldoInsuficiente = errors.New("saldo insuficiente para a operação")

func Sacar(valor float64) error {
    if valor > saldo {
        return ErroSaldoInsuficiente
    }
    return nil
}

3. Panic e Recover 🚨

O panic deve ser usado apenas para erros irrecuperáveis (fatais). O recover permite capturar um panic e evitar que o programa caia.

Panic: Para o fluxo normal, executa os defer e encerra o programa.
Recover: Retoma o controle dentro de uma função que sofreu um panic.

func protegida() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recuperado de um desastre:", r)
        }
    }()
    panic("ALGO DEU MUITO ERRADO!")
}

4. Diferenciando Erros de Panics (Mermaid) 📊

graph TD
    Op[Operação] --> Res{Sucesso?}
    Res -- Sim --> OK[Retorna Dado, nil]
    Res -- Não --> Type{Severidade?}
    Type -- Comum --> Err[Retorna nil, error]
    Type -- Fatal --> Pnc[Envia Panic]
    Err --> Handle[Tratamento via IF]
    Pnc --> Rec{Tem Recover?}
    Rec -- Sim --> OK
    Rec -- Não --> Crash[Programa Encerra]

5. Boas Práticas de Erro 💡

Não ignore erros: Nunca use _ para descartar o retorno de um erro.
Contexto é tudo: Adicione contexto ao erro antes de retornar: fmt.Errorf("erro no banco: %v", err).
Defer: Use defer para garantir que recursos (arquivos, conexões) sejam fechados, mesmo que ocorra um erro.

6. Mini-Projeto: Sistema de Validação de Senha 🚀

Crie uma função ValidarSenha(senha string) error que retorne: * Um erro se a senha tiver menos de 8 caracteres. * Um erro se a senha não contiver ao menos um número. * nil se estiver tudo certo.

No main, peça a senha ao usuário e trate os possíveis erros.

7. Exercícios de Fixação 🧠

Por que Go não usa try/catch?
Para que serve a palavra-chave defer?
Qual a diferença entre errors.New e fmt.Errorf?

Próxima Aula: Vamos aprender a persistir dados com Manipulação de Arquivos e JSON! 📁🐹

Aula 07 - Manipulação de Arquivos e JSON 📁

Objetivo

Objetivo: Aprender a ler e escrever arquivos no disco e a trabalhar com serialização/desserialização de dados no formato JSON.

1. Lendo e Escrevendo Arquivos ✍️

O pacote os e o io/ioutil (ou os diretamente em versões mais novas) são as ferramentas para lidar com o sistema de arquivos.

Escrita Simples

dados := []byte("Olá, mundo Go!")
err := os.WriteFile("notas.txt", dados, 0644)

Leitura Simples

conteudo, err := os.ReadFile("notas.txt")
fmt.Println(string(conteudo))

2. Trabalhando com JSON 🏗️

O JSON é o padrão de comunicação para APIs modernas. Em Go, usamos Struct Tags para mapear os campos da struct para os nomes das chaves no JSON.

type Produto struct {
    Nome  string  `json:"nome_produto"`
    Preco float64 `json:"preco"`
}

Serialização (Struct -> JSON)

p := Produto{Nome: "Monitor", Preco: 899.90}
jsonDados, _ := json.Marshal(p)

Desserialização (JSON -> Struct)

var p2 Produto
json.Unmarshal(jsonDados, &p2)

3. Fluxo de Dados (Mermaid) 📊

graph LR
    User[Usuário/API] -->|JSON| App[App Go]
    App -->|Struct| Logic[Lógica de Negócio]
    Logic -->|Struct| App
    App -->|JSON| File[(Arquivo .json)]
    File --> App

4. Manipulação via Terminal (Termynal) 💻

$ cat config.json
{
  "versao": "1.0",
  "porta": 8080
}

$ go run main.go
Lendo configurações...
Servidor rodando na porta 8080

5. Encoder e Decoder 🚀

Para lidar com grandes fluxos de dados ou arquivos JSON diretamente, usamos json.NewEncoder e json.NewDecoder. Isso é mais eficiente que carregar tudo na memória com Marshal.

6. Mini-Projeto: CLI To-Do List 🚀

Crie um programa que permita: 1. Adicionar tarefas a uma lista (struct Tarefa). 2. Salvar essa lista em um arquivo chamado tarefas.json sempre que uma tarefa for adicionada. 3. Carregar as tarefas existentes ao iniciar o programa.

7. Exercícios de Fixação 🧠

Para que servem as "Struct Tags" (ex: json:"nome")?
Qual a diferença entre json.Marshal e json.NewEncoder?
O que acontece se um campo da struct não tiver uma tag JSON?

Próxima Aula: Prepare-se para o poder das Goroutines e Channels! ⚡🐹

Aula 08 - Concorrência em Go ⚡

Objetivo

Objetivo: Entender o modelo de concorrência do Go baseado em Goroutines e Channels, aprendendo a criar programas que executam múltiplas tarefas simultaneamente.

1. Concorrência vs Paralelismo 🧩

Concorrência: Lidar com muitas coisas ao mesmo tempo (composição de tarefas independentes).
Paralelismo: Fazer muitas coisas ao mesmo tempo (execução simultânea em múltiplos núcleos).

Go foi desenhada para tornar a concorrência fácil e barata.

2. Goroutines: Threads Levíssimas 🪶

Uma Goroutine é uma função que executa de forma independente. Para iniciar uma, basta usar a palavra-chave go.

func dizer(s string) {
    fmt.Println(s)
}

func main() {
    go dizer("Olá") // Inicia em segundo plano
    fmt.Println("Mundo")
}

Uma Goroutine consome apenas 2KB de memória inicial, permitindo rodar milhões delas em uma máquina comum!

3. Channels: A Comunicação Segura 📡

"Não comunique compartilhando memória; compartilhe memória comunicando."

Channels são os tubos que permitem às Goroutines trocarem dados de forma segura, sem precisar de travas (locks) complexas.

canal := make(chan string)

go func() {
    canal <- "Dados enviados!" // Envia
}()

msg := <-canal // Recebe (bloqueia até chegar algo)

4. O Select: Um Switch para Canais 🚦

O select permite que uma Goroutine espere por múltiplas operações de comunicação.

select {
case msg1 := <-c1:
    fmt.Println("Recebi de c1:", msg1)
case msg2 := <-c2:
    fmt.Println("Recebi de c2:", msg2)
case <-time.After(time.Second):
    fmt.Println("Timeout! ⏰")
}

5. Visualização de Canais (Mermaid) 📊

graph LR
    subgraph "Goroutine 1"
        G1[Processo A]
    end
    subgraph "Canal"
        CH((Channel))
    end
    subgraph "Goroutine 2"
        G2[Processo B]
    end
    G1 -->|Envia dado| CH
    CH -->|Recebe dado| G2

6. Mini-Projeto: Web Crawler Básico 🚀

Crie um programa que receba um slice de 5 URLs e: 1. Dispare uma Goroutine para cada URL. 2. Cada Goroutine deve imprimir o tempo que levou para "acessar" aquela URL (use time.Sleep para simular). 3. Use um canal ou WaitGroup para garantir que o main espere todas terminarem.

7. Exercícios de Fixação 🧠

O que acontece se você enviar um dado para um canal e ninguém estiver lendo? (Deadlock!)
Qual a diferença de memória entre uma Thread comum (OS) e uma Goroutine?
Para que serve um "Buffered Channel"?

Próxima Aula: Iniciaremos o Módulo 3 com Programação Web e net/http! 🌐🐹

Aula 09 - Programação Web com net/http 🌐

Objetivo

Objetivo: Aprender a criar servidores HTTP nativos em Go usando o pacote net/http, entender como funcionam os Handlers e como gerenciar rotas simples.

1. O Pacote net/http 📡

Go possui um servidor web de nível de produção embutido em sua biblioteca padrão. Diferente de outras linguagens que precisam de servidores externos (como Apache ou Nginx) para rodar a lógica, em Go o seu binário é o servidor.

Criando um Servidor "Hello Web"

package main

import (
    "fmt"
    "net/http"
)

func olaHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Olá, você acessou: %s", r.URL.Path)
}

func main() {
    http.HandleFunc("/", olaHandler) // Roteamento
    fmt.Println("Servidor rodando na porta 8080...")
    http.ListenAndServe(":8080", nil) // Inicia o servidor
}

2. Entendendo Handlers e Requests 🏗️

http.ResponseWriter (w): É por onde você envia a resposta para o cliente (Status Code, Headers, Body).
http.Request (r): Contém todas as informações da requisição vinda do cliente (Método, URL, Query Params, Body).

3. Servindo Arquivos Estáticos 📁

Go facilita muito o serviço de arquivos (HTML, CSS, Imagens).

fs := http.FileServer(http.Dir("./static"))
http.Handle("/static/", http.StripPrefix("/static/", fs))

4. Middleware: O Interceptador 🛡️

Middlewares são funções que executam antes (ou depois) do seu handler principal. Úteis para logs, autenticação e métricas.

func LogMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        fmt.Printf("Requisição: %s %s\n", r.Method, r.URL.Path)
        next(w, r)
    }
}

5. Ciclo de Vida da Requisição (Mermaid) 📊

sequenceDiagram
    participant Browser as Cliente (Browser)
    participant Srv as Servidor Go
    participant Mid as Middleware (Log)
    participant Hnd as Handler (Home)

    Browser->>Srv: GET /
    Srv->>Mid: Intercepta
    Mid->>Hnd: Executa lógica
    Hnd-->>Mid: Retorna HTML/JSON
    Mid-->>Browser: Envia Resposta 200 OK

6. Mini-Projeto: Contador de Visitas Web 🚀

Crie um servidor web que: 1. Tenha uma variável global contador. 2. Toda vez que a rota / for acessada, o contador incrementa. 3. A resposta deve ser: "Você é o visitante número X".

7. Exercícios de Fixação 🧠

Qual a função do http.ListenAndServe?
Como você lê um parâmetro de busca (query param) em uma requisição?
O que acontece se você tentar rodar o servidor em uma porta que já está sendo usada?

Próxima Aula: Vamos profissionalizar nossa comunicação com APIs RESTful e Camadas! 🏗️🐹

Aula 10 - Construindo APIs REST 🏗️

Objetivo

Objetivo: Aplicar os conceitos de REST em Go, organizar o projeto em camadas (MVC adaptado) e entender o roteamento de recursos.

1. Organização em Camadas 🏛️

Para projetos reais, colocar tudo no main.go é inviável. Seguimos uma separação de responsabilidades:

Handlers (Controller): Lida com a entrada HTTP e resposta.
Services (Business Logic): Onde as regras de negócio vivem.
Models (Data Objects): Define a estrutura dos dados.
Repository (Data Access): Lida com o banco de dados.

2. Modelando nossa API de Produtos 📦

Vamos criar uma API para um catálogo:

type Produto struct {
    ID    int     `json:"id"`
    Nome  string  `json:"nome"`
    Preco float64 `json:"preco"`
}

var produtos []Produto // Simulação de banco de dados

3. Implementando os Verbos HTTP 🎬

Listar (GET)

func ListarProdutos(w http.ResponseWriter, r *http.Request) {
    json.NewEncoder(w).Encode(produtos)
}

Criar (POST)

func CriarProduto(w http.ResponseWriter, r *http.Request) {
    var p Produto
    json.NewDecoder(r.Body).Decode(&p)
    produtos = append(produtos, p)
    w.WriteHeader(http.StatusCreated)
}

4. Estrutura de Pastas Profissional 📂

$ tree
.
├── main.go
├── handlers/
│   └── product_handler.go
├── services/
│   └── product_service.go
├── models/
│   └── product.go
└── go.mod

5. Hierarquia de Chamadas (Mermaid) 📊

graph TD
    User((Usuário)) -->|JSON| Handler[Handler/Controller]
    Handler -->|Valida| Service[Service/Business]
    Service -->|Salva| Repo[Repository/DB]
    Repo -->|Retorna| Service
    Service -->|Retorna| Handler
    Handler -->|Status 201| User

6. Mini-Projeto: API de Livros 🚀

Crie uma API básica que utilize net/http para: 1. Listar livros. 2. Adicionar um novo livro via POST. 3. Organize o código em ao menos dois pacotes diferentes (ex: main e models).

7. Exercícios de Fixação 🧠

Por que a separação por camadas é importante para testes automatizados?
Como você retornaria um erro 404 se um produto não fosse encontrado?
Qual a diferença entre json.NewDecoder e json.Unmarshal no contexto de uma requisição HTTP?

Próxima Aula: Vamos acelerar o desenvolvimento com o Framework Gin! 🚀🐹

Aula 11 - Framework Web Gin 🚀

Objetivo

Objetivo: Conhecer o framework Gin, suas vantagens sobre a biblioteca padrão, como gerenciar rotas complexas, parâmetros de URL e validação de dados.

1. Por que usar um Framework? 🤔

Embora o net/http seja excelente, ele é muito básico. Frameworks como o Gin fornecem funcionalidades prontas que economizam centenas de linhas de código:

Velocidade: Gin é um dos frameworks mais rápidos do ecossistema Go.
Roteamento Avançado: Suporte a parâmetros na URL (ex: /user/:id) e grupos de rotas.
Middlewares: Sistema de plugin simples e poderoso.
Binding e Validação: Converte JSON automaticamente para structs e valida os dados.

2. Primeiro Servidor com Gin 🍸

package main

import "github.com/gin-gonic/gin"

func main() {
    r := gin.Default() // Cria uma instância com Logger e Recovery

    r.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })

    r.Run() // Inicia na porta 8080 por padrão
}

3. Parâmetros e Query String 📍

Gin torna a captura de dados externa muito simples através do gin.Context.

// Parâmetro de URL: /usuario/ricardo
r.GET("/usuario/:nome", func(c *gin.Context) {
    nome := c.Param("nome")
    c.String(200, "Olá, %s", nome)
})

// Query String: /busca?q=golang
r.GET("/busca", func(c *gin.Context) {
    query := c.Query("q")
    c.JSON(200, gin.H{"resultado": query})
})

4. Binding e Validação de JSON 🏗️

Você pode usar tags binding:"required" para validar se um campo foi enviado.

type Login struct {
    User     string `json:"user" binding:"required"`
    Password string `json:"password" binding:"required"`
}

r.POST("/login", func(c *gin.Context) {
    var json Login
    if err := c.ShouldBindJSON(&json); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }
    c.JSON(200, gin.H{"status": "logado"})
})

5. Comparação de Performance (Mermaid) 📊

graph LR
    NetHttp[net/http] --- Fast((Rápido))
    Gin[Framework Gin] --- UltraFast((Ultra Rápido))
    Echo[Framework Echo] --- Fast((Rápido))

    style Gin fill:#00add8,stroke:#333,stroke-width:2px

6. Mini-Projeto: API de Clientes com Gin 🚀

Utilizando o Gin, crie uma rota POST /clientes que: 1. Receba um JSON com nome, email e idade. 2. Valide se todos os campos estão presentes. 3. Retorne o cliente criado com um ID gerado automaticamente.

7. Exercícios de Fixação 🧠

Qual a principal diferença entre r.GET e r.POST no Gin?
Para que serve o objeto gin.H?
Como você agruparia todas as rotas de uma "v1" da sua API?

Próxima Aula: Vamos conectar tudo isso a um Banco de Dados SQL com GORM! 💾🐹

Aula 12 - Banco de Dados (GORM) 💾

Objetivo

Objetivo: Aprender a conectar sua aplicação Go a um banco de dados relacional (PostgreSQL/SQLite) e realizar operações de CRUD usando o ORM GORM.

1. SQL Nativo vs ORM ⚖️

database/sql: A interface padrão do Go para SQL. Você escreve as queries manualmente. Mais controle, mais código.
GORM: O ORM (Object-Relational Mapping) mais popular para Go. Ele converte suas structs diretamente em tabelas e vice-versa. Menos código, mais produtividade.

2. Configurando o GORM e SQLite 🛠️

Para nossos testes, usaremos o SQLite (um banco de dados em arquivo), mas o código é quase idêntico para PostgreSQL.

type Produto struct {
    gorm.Model // Adiciona ID, CreatedAt, UpdatedAt, DeletedAt
    Nome  string
    Preco float64
}

db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
// Criar a tabela automaticamente (Migration)
db.AutoMigrate(&Produto{})

3. Operações de CRUD 📝

Create (Criar)

db.Create(&Produto{Nome: "Teclado", Preco: 200.0})

Read (Ler)

var produto Produto
db.First(&produto, 1) // Busca pelo ID 1
db.Find(&produtos)    // Busca todos

Update (Atualizar)

db.Model(&produto).Update("Preco", 250.0)

Delete (Remover)

db.Delete(&produto, 1)

4. Integração: API + Banco de Dados (Mermaid) 📊

graph TD
    API[Gin API] -->|Struct| GORM[GORM ORM]
    GORM -->|SQL| DB[(PostgreSQL/SQLite)]
    DB -->|Rows| GORM
    GORM -->|Struct| API

5. Migrations: Evoluindo o Esquema 📈

O GORM cuida da criação e atualização das tabelas para você através do AutoMigrate. Se você adicionar um campo novo na Struct, o GORM cria a coluna no banco na próxima execução!

6. Mini-Projeto: API com Persistência Real 🚀

Modifique sua API de Clientes (da aula anterior) para que: 1. Os dados não sejam mais salvos em um slice, mas sim no banco de dados via GORM. 2. Ao iniciar a aplicação, as tabelas sejam criadas automaticamente.

7. Exercícios de Fixação 🧠

O que a tag gorm.Model adiciona à sua struct?
Como você faria uma busca filtrada (WHERE) usando GORM?
Qual a vantagem de usar AutoMigrate em vez de criar tabelas manualmente no terminal SQL?

Próxima Aula: Vamos garantir que tudo funcione com Testes Automatizados! ✅🐹

Aula 13 - Testes em Go ✅

Objetivo

Objetivo: Compreender a importância dos testes automatizados, aprender a usar a ferramenta nativa go test e aplicar técnicas de TDD e Mocking.

1. Por que testar? 🧪

Testes automatizados garantem que seu código funciona como esperado e permitem que você faça refatorações com segurança. Em Go, o suporte a testes é nativo e integrado à linguagem.

2. Escrevendo seu Primeiro Teste 📝

Arquivos de teste em Go devem terminar obrigatoriamente com _test.go.

Exemplo: `calculadora_test.go`

package calculadora

import "testing"

func TestSoma(t *testing.T) {
    resultado := Soma(2, 3)
    esperado := 5

    if resultado != esperado {
        t.Errorf("Resultado incorreto: obtive %d, queria %d", resultado, esperado)
    }
}

Para rodar os testes, use o comando:

$ go test -v

3. Testes de Tabela (Table-Driven Tests) 📊

Esta é a forma idiomática e profissional de escrever testes em Go, permitindo testar vários cenários em uma única função.

func TestSomaMultipla(t *testing.T) {
    cenarios := []struct {
        a, b, esperado int
    }{
        {1, 1, 2},
        {10, 20, 30},
        {-1, 1, 0},
    }

    for _, c := range cenarios {
        res := Soma(c.a, c.b)
        if res != c.esperado {
            t.Errorf("Erro ao somar %d+%d: obtive %d", c.a, c.b, res)
        }
    }
}

4. Cobertura de Testes 📈

Go pode te dizer exatamente qual porcentagem do seu código está sendo testada.

$ go test -cover
PASS
coverage: 85.0% of statements
ok      meu-projeto/calculadora

5. Mocking em APIs 🎭

Ao testar handlers, não queremos chamar o banco de dados real. Usamos o pacote httptest para simular requisições HTTP.

graph LR
    Test[Test Code] -->|Request Fake| Handler[API Handler]
    Handler -->|Mock| Service[Service Interface]
    Service -->|Retorna Falso| Handler
    Handler -->|Response 200| Test

6. Mini-Projeto: TDD na Prática 🚀

Utilizando TDD (Test Driven Development): 1. Escreva primeiro um teste para uma função InverterString(s string) string. 2. Rode o teste e veja-o falhar. 3. Implemente a função até que o teste passe.

7. Exercícios de Fixação 🧠

Qual o sufixo obrigatório de um arquivo de teste em Go?
O que a flag -v faz no comando go test?
Qual a vantagem dos Testes de Tabela em relação a testes individuais?

Próxima Aula: Vamos organizar o código como profissionais com Clean Architecture! 🏗️🐹

Aula 14 - Arquitetura e Boas Práticas 🏗️

Objetivo

Objetivo: Entender os princípios da Clean Architecture, como aplicar Injeção de Dependência em Go e como organizar projetos de forma que sejam escaláveis e fáceis de manter.

1. Clean Architecture (Arquitetura Limpa) 🧊

A Clean Architecture foca na independência de frameworks, UI e banco de dados. O coração da aplicação é a Lógica de Negócio (Entidades e Casos de Uso).

As Camadas:

Entities/Models: Regras de negócio globais.
Usecases/Services: Lógica específica da aplicação.
Interfaces/Adapters: Conecta o mundo externo (Handlers, Repositories).
Infrastructure: Frameworks, Banco de Dados, Loggers.

2. Injeção de Dependência (DI) 💉

Em Go, aplicamos DI de forma manual e simples, geralmente via construtores que aceitam interfaces.

type Service struct {
    repo RepositoryInterface
}

func NewService(r RepositoryInterface) *Service {
    return &Service{repo: r}
}

Isso permite que você troque o banco de dados real por um mock nos testes com facilidade.

3. Organização de Diretórios (Padrão Go) 📂

Um projeto profissional em Go costuma seguir esta estrutura:

$ tree
.
├── cmd/             # Ponto de entrada (main.go)
├── internal/        # Código privado (Business Logic)
│   ├── entity/      
│   ├── service/     
│   └── repository/  
├── pkg/             # Código que pode ser importado por outros
└── api/             # Definições de API (Swagger/Proto)

4. O Fluxo de Controle (Mermaid) 📊

graph TD
    UI[Handlers/Controllers] --> UC[UseCases/Services]
    UC --> DB[Repositories/Interfaces]
    DB --> SQL[(Database SQL)]

    subgraph "Camadas Externas"
    UI
    SQL
    end

    subgraph "Core da Aplicação"
    UC
    DB
    end

5. Boas Práticas (Cringe Free!) ✨

Nomeie pacotes com substantivos simples: user, auth, order (evite utils, helpers).
Retorne structs, aceite interfaces: Isso dá flexibilidade para quem consome seu código.
Mantenha o main.go magro: Ele só deve "fiar" as dependências e iniciar o servidor.

6. Mini-Projeto: Refatorando para DI 🚀

Pegue sua API da Aula 12 e: 1. Crie uma interface para o seu Repository. 2. Altere o seu Service/Handler para receber essa interface no construtor. 3. Verifique se o seu código continua funcionando após a refatoração.

7. Exercícios de Fixação 🧠

Qual a principal vantagem da Clean Architecture?
Por que usamos a pasta internal em Go?
Como a Injeção de Dependência ajuda no desacoplamento do código?

Próxima Aula: Vamos colocar tudo no container com Docker e preparar o Deploy! 🐳🐹

Aula 15 - Docker e Deploy 🐳

Objetivo

Objetivo: Aprender a "conteinerizar" uma aplicação Go usando Docker, otimizando o tamanho da imagem com Multi-Stage Builds e preparando o ambiente para produção.

1. Por que usar Docker com Go? 🚀

Go gera binários estáticos, o que significa que eles não precisam de um runtime (como Python ou Node) instalado no servidor. O Docker ajuda a empacotar esse binário com suas dependências de sistema e arquivos estáticos, garantindo que o programa rode igual em qualquer lugar.

2. Multi-Stage Builds: O Segredo da Eficiência 🏗️

Como o Go só precisa do binário para rodar, não precisamos levar o compilador para a imagem final. Usamos dois estágios no Dockerfile:

# Estágio 1: Compilação
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY . .
RUN go build -o main cmd/main.go

# Estágio 2: Execução (Imagem Final)
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/main .
CMD ["./main"]

Isso reduz uma imagem de 300MB+ para apenas 15MB!

3. Docker Compose: Orquestrando Dependências 🎼

Se sua API precisa de um banco de dados, o docker-compose.yml facilita subir tudo junto.

services:
  app:
    build: .
    ports: ["8080:8080"]
    depends_on: [db]
  db:
    image: postgres:alpine
    environment:
      POSTGRES_PASSWORD: 123

4. O Fluxo de Deploy (Mermaid) 📊

graph LR
    Dev[Dev Code] -->|Push| Git[GitHub/GitLab]
    Git -->|CI/CD| Build[Build Docker Image]
    Build -->|Push| Registry[Docker Hub/ECR]
    Registry -->|Pull| Server[Production Server]
    Server -->|Run| Container[Running App]

5. Variáveis de Ambiente e Configuração ⚙️

Nunca coloque senhas no código! Use variáveis de ambiente que o Go lê via os.Getenv e o Docker injeta.

6. Mini-Projeto: API no Container 🚀

Crie um Dockerfile para sua API de livros e: 1. Gere a imagem via terminal. 2. Suba um container mapeando a porta 8080. 3. Acesse a API pelo navegador e verifique se ela responde corretamente.

7. Exercícios de Fixação 🧠

Para que serve o "Multi-Stage Build" no Dockerfile?
Qual a vantagem de usar imagens alpine?
Como você passa uma variável de ambiente para um container Docker via linha de comando?

Próxima Aula: É hora de aplicar tudo no nosso Projeto Final! 🏆🐹

Aula 16 - Projeto Final: Sistema de Gerenciamento de Biblioteca 🏆

Objetivo

Objetivo: Consolidar todos os conhecimentos adquiridos (Fundamentos, Web, Banco de Dados, Testes e Docker) através da construção de um projeto completo e profissional.

1. O Desafio 🚩

Você deve construir uma API REST de Gerenciamento de Livros e Empréstimos. O sistema deve permitir que usuários consultem livros, se cadastrem e realizem empréstimos.

Requisitos Funcionais:

[x] Cadastro e Listagem de Livros.
[x] Cadastro de Usuários.
[x] Realização de Empréstimo (Verificando se o livro está disponível).
[x] Devolução de Livros.

2. Requisitos Técnicos (Obrigatórios) 🛠️

Linguagem: Go (Golang).
Framework Web: Gin Gonic.
Banco de Dados: PostgreSQL (via GORM).
Arquitetura: Clean Architecture (divida em camadas: Handler, Service, Repository, Entity).
Qualidade: Ao menos 3 testes unitários significativos.
Infra: Dockerfile e Docker Compose configurados.

3. Estrutura Sugerida do Projeto 📂

/projeto-final
├── cmd/             # Main.go
├── internal/        # Camadas da Clean Arch
│   ├── handler/     # Gin Handlers
│   ├── service/     # Lógica de Empréstimo
│   ├── repository/  # GORM Repos
│   └── entity/      # Structs Models
├── scripts/         # SQL ou outros auxiliares
├── docker-compose.yml
└── Dockerfile

4. Diagrama da Entidade Relacional (Mermaid) 📊

erDiagram
    LIVRO ||--o{ EMPRESTIMO : possui
    USUARIO ||--o{ EMPRESTIMO : faz
    LIVRO {
        int id
        string titulo
        string autor
        bool disponivel
    }
    USUARIO {
        int id
        string nome
        string email
    }
    EMPRESTIMO {
        int id
        int livro_id
        int usuario_id
        date data_emprestimo
    }

5. Dicas para o Sucesso 💡

Pense nos erros: O que acontece se alguém tentar pegar um livro que já está emprestado?
Use Middlewares: Adicione um log simples para cada requisição.
Documentação: Um arquivo README.md bem escrito faz toda a diferença!

6. Conclusão da Jornada 🏁

Parabéns! Você completou o curso de Programação em Go. Você agora possui as ferramentas necessárias para construir sistemas robustos, rápidos e escaláveis no backend.

[!IMPORTANT] O aprendizado não para aqui. Continue explorando a comunidade Go, leia o código fonte da biblioteca padrão e construa seus próprios projetos! 🐹🚀

Próximo Passo: Realize a entrega do seu projeto final e solicite seu feedback! 🎓🐹🏆🚀

Exercícios

Listas de Exercícios 🏋️

Pratique o que aprendeu com desafios graduais para cada aula.

Módulo 1: Fundamentos ---
Módulo 2: Lógica e Persistência ---
Módulo 3: Desenvolvimento Web ---
Módulo 4: Qualidade e Infra ---

Exercícios: Introdução ao Go e Ecossistema 🐹

Instruções

Responda aos exercícios abaixo para consolidar seu aprendizado sobre a história e o ambiente do Go.

🟢 Nível: Básico

A História: Quem são os três criadores originais da linguagem Go no Google?
O Comando: Qual comando do terminal é utilizado para inicializar um novo módulo Go em uma pasta?

🟡 Nível: Intermediário

Filosofia: Explique, com suas palavras, por que o Go é considerado uma linguagem focada em produtividade e simplicidade em comparação ao C++.
Execução: Qual a diferença prática entre os comandos go run main.go e go build main.go? Em qual situação você usaria cada um?

🔴 Nível: Desafio

Multi-Platform: Pesquise sobre a variável de ambiente GOOS e GOARCH. Como você faria para compilar um executável Windows (.exe) estando em uma máquina Linux ou macOS? Escreva o comando necessário.

Exercícios: Fundamentos da Linguagem 🧱

Instruções

Pratique a sintaxe básica de Go com estes exercícios.

🟢 Nível: Básico

Tipagem: Tente somar um int e um float64 em um programa. O que acontece? Como você resolve isso?
Shorthand: Transforme a declaração var count int = 10 para a forma curta (short declaration).

🟡 Nível: Intermediário

Estruturas: Crie um programa que use um switch para imprimir o nome do mês baseado em um número de 1 a 12.
Loops: Escreva um loop for que imprima apenas os números pares de 1 a 20.

🔴 Nível: Desafio

Tabuada Dinâmica: Crie um programa que peça (via fmt.Scan) um número ao usuário e imprima a tabuada desse número de 1 a 10, utilizando um loop for.

Exercícios: Funções e Organização do Código 🧩

Instruções

Teste seus conhecimentos sobre funções, pacotes e ponteiros.

🟢 Nível: Básico

Sintaxe: Crie uma função chamada saudar que recebe um nome (string) e retorna uma saudação formatada.
Múltiplos Retornos: Escreva uma função que receba dois números e retorne a soma e a subtração deles simultaneamente.

🟡 Nível: Intermediário

Ponteiros: Crie uma função zerar que recebe um ponteiro para um inteiro (*int) e define o valor no endereço de memória como 0.
Variádicas: Escreva uma função media que aceite uma quantidade variável de números (float64) e retorne a média aritmética deles.

🔴 Nível: Desafio

Multi-Package: Crie um pequeno sistema onde o pacote matematica contém uma função Fatorial e o arquivo main.go utiliza essa função para calcular o fatorial de um número digitado pelo usuário.

Exercícios: Estruturas de Dados Avançadas 🗄️

Instruções

Exercite o uso de Slices, Maps e Structs em Go.

🟢 Nível: Básico

Slices: Crie um slice de strings com 3 nomes de cidades. Use append para adicionar uma quarta cidade.
Maps: Crie um mapa que armazena nomes de países (chave) e suas capitais (valor). Imprima a capital do Brasil.

🟡 Nível: Intermediário

Structs: Defina uma struct Produto com Nome, Preco e Quantidade. Crie uma instância e imprima o valor total em estoque (Preco * Quantidade).
Slicing: Dado o slice numeros := []int{10, 20, 30, 40, 50}, extraia um novo slice que contenha apenas os valores 20, 30, 40.

🔴 Nível: Desafio

Sistema de Estoque: Crie um programa que use um map[string]Produto. O usuário deve poder digitar o nome de um produto e o programa exibe todos os detalhes daquela struct Produto. Se o produto não existir, exiba uma mensagem de erro.

Exercícios: Interfaces e Composição 🧩

Instruções

Aplique os conceitos de Polimorfismo e Composição em Go.

🟢 Nível: Básico

Interfaces: Crie uma interface chamada Forma com o método Area() float64.
Implementação: Crie uma struct Quadrado (com campo Lado) que implemente a interface Forma.

🟡 Nível: Intermediário

Múltiplas Formas: Crie uma struct Circulo (com campo Raio) que também implemente Forma. Crie uma função que receba um slice de Forma e imprima a área de cada uma.
Composição: Crie uma struct Endereco (Rua, Cidade) e uma struct Pessoa que contenha um Endereco via composição (embedding). Imprima os dados da pessoa e seu endereço.

🔴 Nível: Desafio

Simulador de Notificações: Crie uma interface Notificador com o método Enviar(mensagem string). Implemente dois tipos: Email e SMS. Crie uma função que receba um Notificador e dispare uma mensagem de "Bem-vindo" usando ambos os tipos.

Exercícios: Tratamento de Erros ⚠️

Instruções

Pratique a captura e criação de erros em Go.

🟢 Nível: Básico

Check de Erro: Escreva uma função que leia o nome de um arquivo do terminal e tente abri-lo usando os.Open. Trate o erro caso o arquivo não exista.
Panic: Crie uma função que cause um panic propositalmente (ex: divisão por zero ou acesso a índice inexistente em slice).

🟡 Nível: Intermediário

Recover: Use o recover para capturar o panic do exercício anterior e imprimir uma mensagem amigável sem derrubar o programa.
Custom Error: Defina uma variável de erro ErrIdadeInvalida e use-a em uma função VerificarIdade(idade int).

🔴 Nível: Desafio

Calculadora Segura: Crie uma função Dividir(a, b float64) (float64, error). Se b for 0, retorne um erro detalhado usando fmt.Errorf incluindo os valores de a e b. No main, execute essa função e trate o erro exibindo-o no console.

Exercícios: Manipulação de Arquivos e JSON 📁

Instruções

Trabalhe com persistência de dados e o formato JSON.

🟢 Nível: Básico

Escrita: Crie um programa que salve a frase "Go é incrível para Backend!" em um arquivo chamado aprendizado.txt.
JSON Tags: Crie uma struct Config com campos Porta e Debug. Adicione struct tags para que no JSON apareçam como app_port e debug_mode.

🟡 Nível: Intermediário

Marshal/Unmarshal: Crie uma instância de Config, converta para JSON e imprima a string. Depois, pegue essa string e converta de volta para uma nova struct.
Leitura de Arquivo: Crie um programa que leia o arquivo aprendizado.txt e conte quantas letras existem no arquivo.

🔴 Nível: Desafio

Gerenciador de Contatos: Crie um programa que salve um slice de structs Contato (Nome, Telefone) em um arquivo agenda.json. O programa deve ler o arquivo ao iniciar e permitir que o usuário adicione novos contatos via terminal.

Exercícios: Concorrência em Go ⚡

Instruções

Explore o poder das Goroutines e Channels.

🟢 Nível: Básico

Goroutine: Crie uma função que imprima números de 1 a 10 e execute-a como uma goroutine no main. Verifique se o programa termina antes dela terminar (e como resolver isso com time.Sleep).
Canais: Crie um canal de inteiros, envie o número 42 em uma goroutine e receba no main, imprimindo o valor.

🟡 Nível: Intermediário

Buffer: Crie um canal com buffer de tamanho 2. Envie 2 mensagens sem precisar de uma goroutine consumidora imediata. O que acontece se enviar a 3ª?
Soma Concorrente: Crie duas goroutines, cada uma calcula a soma de uma metade de um slice de números. Elas devem enviar os resultados parciais para um canal e o main deve somar os dois.

🔴 Nível: Desafio

Ping-Pong: Crie duas goroutines chamadas "Ping" e "Pong". Elas devem trocar uma "bola" (um contador que incrementa) através de um canal. O programa deve parar quando o contador chegar a 10. Use o select para monitorar a troca.

Exercícios: Programação Web com net/http 🌐

Instruções

Pratique a criação de servidores e manipulação de requisições HTTP.

🟢 Nível: Básico

Servidor Simples: Crie um servidor que responda "Bem-vindo ao Go Web!" na rota /home.
Portas: Tente rodar dois servidores Go simultâneos em portas diferentes (ex: 8080 e 9090).

🟡 Nível: Intermediário

Status Codes: Crie um handler que verifique se um parâmetro admin na URL é igual a true. Se for, responda 200 OK. Se não, responda 403 Forbidden.
JSON Response: Modifique seu handler para que ele retorne um JSON simples: {"status": "ativo", "mensagem": "API rodando"}. Lembre-se de definir o Content-Type como application/json.

🔴 Nível: Desafio

Calculadora Web: Crie um servidor que receba dois números via Query Params (ex: /?a=10&b=5) e uma operação (op=soma). O servidor deve realizar o cálculo e retornar o resultado em texto puro. Trate o erro caso os valores não sejam números válidos.

Exercícios: Construindo APIs REST 🏗️

Instruções

Organize seu código e implemente padrões RESTful.

🟢 Nível: Básico

Camadas: Crie uma pasta models e mova uma struct de sua escolha para lá. Importe-a no seu main.go.
Verbo POST: Crie um handler que receba um JSON e apenas o imprima no console do servidor.

🟡 Nível: Intermediário

Busca por ID: Implemente uma lógica que, dada uma lista de produtos, retorne apenas o produto que tenha o ID passado na URL (Dica: use strings.Split no Path para pegar o ID).
Status Codes: Garanta que sua API retorne 201 Created ao criar um recurso e 404 Not Found se um recurso solicitado não existir na lista.

🔴 Nível: Desafio

CRUD In-Memory: Crie um CRUD completo (Create, Read, Update, Delete) para uma struct Cliente usando apenas o pacote net/http e um slice global para armazenar os dados. Teste cada rota usando o Postman ou Insomnia.

Exercícios: Framework Web Gin 🚀

Instruções

Explore as facilidades do Gin para criar APIs robustas.

🟢 Nível: Básico

Instalação: Inicialize um módulo Go e instale o Gin usando go get -u github.com/gin-gonic/gin.
Primeira Rota: Crie um servidor Gin que responda com um JSON de boas-vindas na rota raiz /.

🟡 Nível: Intermediário

Parâmetros: Crie uma rota /ola/:nome que responda "Olá, [nome]" tanto em texto puro quanto em um campo JSON.
Grupos: Crie um grupo de rotas /api/v1 e coloque dentro dele uma rota de status que retorne a versão da API.

🔴 Nível: Desafio

Validação de Cadastro: Crie uma struct Usuario com campos Email (obrigatório) e Senha (obrigatório e mínimo de 6 caracteres - pesquise sobre a tag binding). Implemente uma rota POST /cadastro que valide esses dados e retorne um erro amigável caso a validação falhe.

Exercícios: Banco de Dados (GORM) 💾

Instruções

Pratique a integração de banco de dados em aplicações Go.

🟢 Nível: Básico

Conexão: Crie um programa que conecte a um banco SQLite local chamado estudos.db.
Model: Crie uma struct Livro e use o AutoMigrate para criar essa tabela no banco.

🟡 Nível: Intermediário

Seed: Crie uma função que insira 5 livros iniciais no banco caso a tabela esteja vazia.
Busca: Escreva uma consulta GORM que retorne todos os livros com preço maior que 50 reais.

🔴 Nível: Desafio

API Persistente: Crie duas rotas no Gin: GET /livros (lista todos do banco) e POST /livros (salva um novo no banco). Verifique se os dados permanecem salvos mesmo após reiniciar o servidor.

Exercícios: Testes em Go ✅

Instruções

Garanta a qualidade do seu software com testes automatizados.

🟢 Nível: Básico

Unitário: Crie uma função Multiplicar(a, b int) e escreva um teste unitário simples em um arquivo separado.
Execução: Rode seus testes e gere um relatório de cobertura básico.

🟡 Nível: Intermediário

Table-Driven: Transforme o teste da multiplicação em um teste de tabela com ao menos 5 cenários diferentes (incluindo números negativos e zero).
Error Testing: Escreva um teste para uma função que retorna erro (ex: Dividir). Verifique se o erro retornado é o esperado quando tentamos dividir por zero.

🔴 Nível: Desafio

API Test: Utilizando o pacote net/http/httptest, escreva um teste para um handler que retorna um JSON. O teste deve verificar se o Status Code é 200 OK e se o corpo da resposta contém um campo específico.

Exercícios: Arquitetura e Boas Práticas 🏗️

Instruções

Aplique padrões de design para criar códigos mais limpos e testáveis.

🟢 Nível: Básico

Refatoração: Mova sua struct principal para uma pasta chamada entities.
Interface: Crie uma interface que defina as operações básicas de persistência de um objeto seu (ex: Salvar, BuscarPorID).

🟡 Nível: Intermediário

Injeção: Crie uma struct Gestor que possua um campo que é a interface do exercício anterior. Crie uma função NewGestor para injetar a implementação.
Internal: Mova sua lógica de banco de dados para uma pasta internal/repository e verifique como as permissões de acesso funcionam entre pacotes.

🔴 Nível: Desafio

Mock Manual: Escreva um teste para o seu Gestor (do exercício 3). No teste, crie uma struct "fake" que implementa a interface de repositório (sem usar banco real) e injete-a no gestor. Verifique se o gestor chama os métodos corretamente.

Exercícios: Docker e Deploy 🐳

Instruções

Prepare sua aplicação para o mundo real usando containers.

🟢 Nível: Básico

Dockerfile: Crie um arquivo Dockerfile simples para um "Hello World" em Go.
Imagens: Use o comando docker build para criar a imagem e docker images para verificar o tamanho dela.

🟡 Nível: Intermediário

Multi-Stage: Refatore seu Dockerfile para usar Multi-Stage Build e compare a diferença de tamanho entre a imagem de build e a imagem final.
Execução: Suba um container rodando sua aplicação na porta 9000 e verifique se consegue acessá-la de fora do container.

🔴 Nível: Desafio

Compose Completo: Crie um arquivo docker-compose.yml que suba sua API (da aula 12) e um banco de dados PostgreSQL. Garante que a API espere o banco de dados estar pronto antes de tentar conectar.

Projeto Final: Checklist de Entrega 🏆

Instruções

Utilize este checklist para garantir que seu projeto final atenda a todos os requisitos de qualidade e funcionalidade.

✅ Requisitos de Funcionalidade

[ ] A rota POST /livros funciona corretamente?
[ ] A rota POST /emprestimos valida se o livro está disponível antes de concluir?
[ ] É possível listar todos os empréstimos realizados?

✅ Requisitos Técnicos

[ ] O código está organizado em pastas seguindo a Clean Architecture?
[ ] O banco de dados PostgreSQL sobe corretamente via docker-compose up?
[ ] Existe ao menos um arquivo _test.go com testes passando?

🚀 Desafio Extra (Opcional)

[ ] Autenticação: Adicione um middleware de proteção simples (API Key) em rotas de cadastro.
[ ] Swagger: Gere a documentação Swagger da sua API final.
[ ] Deploy: Realize o deploy da imagem Docker em algum serviço gratuito (como Render ou Fly.io).

Projetos

Projetos Práticos 🚀

Transforme teoria em prática com desafios progressivos que compõem seu portfólio.

Módulo 1: Fundamentos ---
Módulo 2: Lógica e Persistência ---
Módulo 3: Desenvolvimento Web ---
Módulo 4: Qualidade e Infra ---

Projeto 01 - Cinto de Utilidades Backend 🛠️

Objetivo: Validar a instalação das ferramentas e testar a comunicação básica com uma API pública.

O Desafio

Instale o Postman ou Insomnia.
Realize uma requisição do tipo GET para a API pública do GitHub: https://api.github.com/users/github.
Analise a resposta (JSON). Identifique os campos login, id e public_repos.
Instale o Docker Desktop e rode o comando docker run hello-world no terminal para garantir que a virtualização está ativa.
Crie uma conta no GitHub (se não tiver) e instale o Git.

O que entregar?

Print (screenshot) da resposta JSON no Postman/Insomnia.
Print do terminal com a mensagem de sucesso do Docker "Hello from Docker!".

Projeto 02 - Modelagem de Fluxo de Gateway 🏗️

Objetivo: Entender o roteamento e a agregação de dados em um Gateway.

O Desafio

Imagine que você tem dois serviços: - Serviço A (User): Retorna { "id": 1, "nome": "Ricardo" } - Serviço B (Orders): Retorna [ { "id": 101, "valor": 50.0 }, { "id": 102, "valor": 30.0 } ]

Desenhe um diagrama (pode ser no Mermaid ou papel) onde um API Gateway recebe uma chamada em /dashboard/1 e busca os dados nos dois serviços.
Escreva o JSON final que o Gateway entregaria para o Frontend, unindo as informações do usuário e seus pedidos.
Pesquisa: Liste 3 ferramentas famosas de API Gateway de mercado (ex: Kong, AWS API Gateway, etc).

O que entregar?

O diagrama de fluxo.
O JSON de resposta agregada.
A lista de ferramentas pesquisadas.

Objetivo: Aplicar os conceitos de recursos, verbos e JSON na modelagem de uma rede social.

O Desafio

Você deve projetar a API para o recurso "Postagens" (Posts).

Liste as 5 rotas principais (CRUD) para gerenciar postagens, indicando o Verbo, a URI e o Status Code de sucesso esperado.
Crie um exemplo de JSON para uma postagem que contenha:
- id
- autor_id
- conteúdo (texto)
- data_publicacao
- tags (lista de strings)
Simulação de Erro: Qual seria a URI e o Verbo para dar um "Like" em uma postagem? Projete isso.

O que entregar?

Tabela com as 5 rotas (Verbo, URI, Status).
Bloco de código com o JSON de exemplo.
Proposta da rota de "Like".

Projeto 04 - Criando o Primeiro Mock 🧱

Objetivo: Dominar o fluxo de documentação de contrato e simulação de servidor.

O Desafio

Você deve criar um servidor de Mock para uma API de Lista de Tarefas (ToDo).

Use o Postman (Mock Server) ou o Mockoon para criar 2 rotas:
- GET /tarefas: Deve retornar uma lista com pelo menos 3 tarefas.
- POST /tarefas: Deve aceitar uma nova tarefa e retornar 201 Created.
Documente os campos de uma tarefa (ex: id, titulo, concluida).
Teste as rotas e garanta que o servidor responda corretamente no formato JSON.

O que entregar?

Print (screenshot) do Swagger UI ou da tela do Mock Server rodando.
O JSON de exemplo retornado pelo GET /tarefas.
Print do teste da rota POST /tarefas com sucesso.

Projeto 05 - Meu Primeiro Controller ⚙️

Objetivo: Praticar a criação de rotas e a captura de diferentes tipos de parâmetros.

O Desafio

Crie a estrutura de um Controller para um sistema de Gestão de Tarefas (To-Do). Você deve definir (em pseudocódigo ou na linguagem que preferir):

Uma rota para listar todas as tarefas, permitindo um filtro opcional por status (ex: concluída ou pendente).
Uma rota para buscar uma única tarefa pelo seu id.
Uma rota para criar uma tarefa, recebendo titulo e descricao.
Sinalize qual seria o Status Code de sucesso para cada uma das rotas acima.

O que avaliar?

Uso correto de Path Params vs Query Params.
Escolha dos verbos HTTP adequados.
Padronização das respostas de sucesso.

Projeto 06 - Implementando a Lógica de Negócio 🧠

Objetivo: Aplicar a separação de camadas criando um Service para validação de dados.

O Desafio

Você deve criar o UsuarioService para um sistema de cadastro.

Função validarSenha(senha): Deve garantir que a senha tenha no mínimo 8 caracteres e contenha pelo menos um número.
Função criarUsuario(dados):
- Chama a validação de senha.
- Verifica se o e-mail já está sendo usado (simule um erro se estiver).
- Retorna o usuário criado (sem a senha!).
Simule o Controller chamando esse Service e tratando o erro de "Senha Insegura" com um Status Code 400.

O que observar?

O Service não deve usar objetos globais como req ou res.
As mensagens de erro devem ser claras e informativas.
Uso de DTOs (retornar objeto filtrado).

Projeto 07 - Modelagem de Banco de Dados 🗄️

Objetivo: Praticar a criação de esquemas relacionais e comandos SQL básicos.

O Desafio

Modele o banco de dados para um sistema de Aluguel de Filmes:

Tabelas: Crie as tabelas Clientes e Filmes.
Campos:
- Clientes deve ter id, nome e email.
- Filmes deve ter id, titulo e genero.
Relacionamento: Crie uma terceira tabela Alugueis que ligue um cliente a um filme (incluindo a data_aluguel).
SQL: Escreva uma query que liste o nome do cliente e o título do filme para todos os aluguéis feitos hoje.

O que avaliar?

Definição correta das Chaves Primárias.
Uso de Chaves Estrangeiras para conectar as tabelas.
Clareza na estrutura das colunas.

Projeto 08 - Schema de Validação Profissional ✅

Objetivo: Praticar a criação de regras de validação para garantir a integridade da API.

O Desafio

Crie o esquema de validação (em pseudocódigo ou usando uma biblioteca como Zod/Joi) para um Cadastro de Eventos:

Campos Obrigatórios: titulo (mín. 10 char), data (deve ser futura), capacidade_maxima (número positivo).
Campos Opcionais: descricao (máx. 500 char), link_inscricao (formato de URL).
Sanitização: O título não deve conter espaços em branco sobrando no início ou no fim (trim).
Simulação: Mostre qual seria a mensagem de erro retornada se o usuário enviasse uma capacidade negativa.

O que avaliar?

Clareza e rigor das regras de validação.
Escolha dos tipos de dados corretos.
Mensagens de erro amigáveis ao desenvolvedor (DX).

Objetivo: Implementar a lógica de geração de tokens JWT para autenticação.

O Desafio

Crie uma API de simulação de login:

Entrada: Receba um JSON com email e senha.
Validação: Verifique se a senha tem mais de 6 caracteres.
JWT: Use uma biblioteca (ou pseudocódigo) para gerar um token que contenha o id do usuário e sua permissão (ex: 'aluno').
Expiração: Configure o token para ser válido por apenas 24 horas.
Resposta: Retorne para o cliente um objeto contendo o token e o nome do usuário.

O que avaliar?

Tratamento correto de erro caso a senha seja curta.
Estrutura limpa do Payload do JWT.
Escolha de uma chave secreta segura (simulada).

Projeto 10 - Gerenciador de Permissões 🛡️

Objetivo: Implementar a lógica de proteção de rotas baseada em perfis de usuário.

O Desafio

Crie a estrutura de autorização para um Sistema de RH:

Roles: Defina três tipos: ADMIN, GESTOR e FUNCIONARIO.
Regras:
- Todos podem ver o próprio perfil (GET /me).
- Apenas GESTOR e ADMIN podem ver a lista de salários (GET /salarios).
- Apenas ADMIN pode deletar um registro (DELETE /colaboradores/:id).
Middleware: Desenhe (em desenho técnico ou código) como seria o "fluxo da cancela" (Authentication Middleware -> Authorization Middleware).

O que avaliar?

Separação clara entre quem é você e o que você pode fazer.
Uso correto dos Status Codes em caso de bloqueio.
Lógica de hierarquia (Admin pode tudo).

Projeto 11 - Blindagem de API 🏗️

Objetivo: Implementar camadas avançadas de segurança e renovação de tokens.

O Desafio

Fortaleça sua API de login:

Helmet: Instale e configure o Helmet para proteger os Headers.
CORS: Restrinja o acesso à API para que apenas o domínio http://localhost:3000 possa consultá-la.
Refresh Token: Implemente uma rota /refresh que receba um refresh token, valide-o no banco (ou lista em memória) e gere um novo accessToken.
Rate Limit: Adicione uma trava para que ninguém possa tentar logar mais de 5 vezes em 1 minuto.

O que avaliar?

Configuração correta das origens no CORS.
Lógica de expiração do Refresh Token (ele deve durar muito mais que o Access Token).
Verificação se o Helmet está realmente escondendo o header X-Powered-By.

Projeto 12 - Primeiro App React ⚛️

Objetivo: Criar e organizar componentes básicos usando React e Vite.

O Desafio

Crie uma página de Perfil de Usuário:

Componente FotoPerfil: Exibe uma imagem circular.
Componente InfoUsuario: Recebe nome e bio via props e exibe na tela.
Componente BotaoSeguir: Um botão simples que, por enquanto, apenas exibe um alerta ao ser clicado.
Layout: Organize esses componentes dentro do App.jsx usando CSS simples para centralizar o conteúdo.

O que avaliar?

Separação correta dos componentes em arquivos diferentes (ou funções separadas).
Uso correto de Props para personalizar o nome do usuário.
Sintaxe JSX correta (tags fechadas, className, etc).

Projeto 13 - Lista Dinâmica de Contatos 📱

Objetivo: Aplicar o uso de useState e gerenciamento de listas.

O Desafio

Crie um mini-gerenciador de contatos:

Inputs: Dois campos de texto (Nome e Telefone).
Botão Adicionar: Quando clicado, deve validar se os campos estão preenchidos e adicionar o contato em um Estado de Array.
Lista: Exiba todos os contatos adicionados abaixo do formulário.
Botão Limpar: Um botão que limpa toda a lista de contatos.

O que avaliar?

Uso correto do useState para os inputs e para a lista.
Uso do .map() para renderizar a lista de contatos.
Limpeza dos campos de input após a adição com sucesso.

Projeto 14 - Buscador de Repositórios 🔍

Objetivo: Consumir uma API real e gerenciar estados de carregamento.

O Desafio

Crie um app que busca repositórios do GitHub de um usuário:

Input: Campo para digitar o nome do usuário do GitHub.
Botão Buscar: Ao clicar, deve disparar a busca.
Loading: Enquanto a API não responde, deve aparecer o texto "Buscando repositórios...".
Lista: Exiba o nome de todos os repositórios públicos encontrados.
Erro: Se o usuário não existir, exiba "Erro: Usuário não encontrado".

O que avaliar?

Uso do useEffect para carregar dados (pode ser ao carregar a página ou via clique).
Tratamento correto dos estados: null, loading, data e error.
Renderização limpa usando .map().

Projeto 15 - Sistema de Multi-Páginas 🚦

Objetivo: Implementar a navegação completa em uma SPA.

O Desafio

Transforme seu app de repositórios ou contatos em um site completo com 3 páginas:

Home (/): Uma página de boas-vindas com links para as outras seções.
Dashboard (/app): Onde fica a funcionalidade principal (ex: a busca de repositórios).
Sobre (/sobre): Uma página contando quem criou o projeto.
404: Uma página personalizada para links quebrados.

Requisito Extra (Parâmetro)

Crie uma página de Perfil de Repositório (/repo/:id) que deve ser aberta ao clicar em um item da lista. Essa página só precisa exibir o ID que foi clicado por enquanto.

O que avaliar?

Configuração correta do BrowserRouter no main.jsx ou App.jsx.
Uso exclusivo de <Link> para navegação em menus.
Funcionamento correto dos parâmetros de URL com useParams.

Projeto 16 - App Final Full-Stack Integrador 🏆

Objetivo: O "TCC (Trabalho de Conclusão de Curso)" do desenvolvedor Full-Stack.

O Tema

Escolha um tema que resolva um problema real integrando o que você construiu no Backend (Módulos 1-3) com o que aprendeu no Frontend (Módulo 4).

Requisitos Mínimos

Backend (Express): Uso obrigatório de rotas protegidas por JWT e validação de dados.
Frontend (React): Componentização clara, uso de Hooks (useState, useEffect) e navegação com React Router.
Integração: O Frontend deve consumir a sua própria API de forma assíncrona.
UX/UI: Interface amigável, com tratamento de estados de carregamento e erro.
Segurança: Configuração correta de CORS e Headers de segurança (Helmet).

Documentação ✨

Seu repositório no GitHub deve ter um README.md impecável, com imagens (prints) da aplicação, explicação das tecnologias usadas e instruções claras de como rodar o servidor e o cliente. Este projeto será o seu maior cartão de visitas!

Boa sorte e bom código! 🚀🚀🚀

Quizzes

Quizzes Interativos 🧠

Teste seus conhecimentos rapidamente ao final de cada módulo.

Módulo 1 ---
Módulo 2 ---
Módulo 3 ---
Módulo 4 ---

Quiz 01 - Introdução

1. Em que ano a linguagem Go foi lançada publicamente como open source?

2005

2007

2009

2012 *Explicação: O Google iniciou o projeto em 2007, mas o lançamento oficial como open source foi em 2009.*

2. Quem são os três criadores originais do Go?

Steve Jobs, Bill Gates e Mark Zuckerberg

Robert Griesemer, Rob Pike e Ken Thompson

Linus Torvalds, Guido van Rossum e Bjarne Stroustrup

James Gosling, Brendan Eich e Anders Hejlsberg *Explicação: Estes três engenheiros do Google uniram forças para criar uma linguagem que resolvesse problemas de escala.*

3. Qual a principal filosofia de design da linguagem Go?

Complexidade máxima para maior controle

Suporte exagerado a herança de classes

Simplicidade, clareza e eficiência

Ser uma linguagem puramente funcional *Explicação: Go preza pelo "menos é mais", removendo recursos complexos que dificultam a leitura do código.*

4. O Go é uma linguagem compilada ou interpretada?

Compilada diretamente para código de máquina

Interpretada como Python ou Ruby

Roda em uma máquina virtual (como Java JVM)

Transpilada para JavaScript *Explicação: Go gera binários estáticos que rodam diretamente no sistema operacional, o que garante alta performance.*

5. O que o comando `go run main.go` faz?

Apenas gera o executável no disco

Formata o código fonte

Compila e executa o programa em um passo temporário

Instala dependências externas *Explicação: É o comando ideal para testes rápidos durante o desenvolvimento.*

6. Qual comando é usado para inicializar um novo projeto (módulo) em Go?

go init

go start

go mod init

go create module *Explicação: O `go mod init ` cria o arquivo go.mod, essencial para gerenciar dependências modernas.*

7. O Go possui Coletor de Lixo (Garbage Collector)?

Não, a memória é manual como em C

Sim, ele gerencia a memória automaticamente

Apenas se você instalar um plugin externo

Sim, mas ele apaga o código fonte também *Explicação: O GC do Go é altamente otimizado para baixa latência, facilitando o trabalho do desenvolvedor.*

8. Qual o nome da mascote oficial do Go?

The Go Cat

Gofer the Rabbit

The Gopher

Rusty the Crab

9. O que significa dizer que o Go gera "Binários Estáticos"?

Que o programa não pode ser alterado depois de pronto

Que ele só roda em computadores parados (estáticos)

Que o executável contém todas as dependências necessárias para rodar

Que a tela do programa nunca se move *Explicação: Isso facilita muito o deploy, pois você só precisa enviar um único arquivo para o servidor.*

10. Qual empresa criou e mantém o Go?

Microsoft

Facebook (Meta)

Google

Amazon *Explicação: O Go nasceu dentro do Google para resolver desafios de infraestrutura da própria empresa.*

Quiz 02 - Introdução

1. Qual a diferença entre declarar uma variável com `var` e usar o operador curto `:=`?

Não há diferença, ambos funcionam igual em qualquer lugar

O `:=` só pode ser usado dentro de funções e detecta o tipo automaticamente

O `var` é para constantes e o `:=` para variáveis

O `:=` é mais lento que o `var` *Explicação: O operador curto é uma conveniência para declarar e inicializar variáveis locais.*

2. O que acontece se você somar um `int` com um `int64` sem conversão explícita?

O Go faz a conversão automática (coerção)

Ocorrerá um erro de compilação (tipos incompatíveis)

O resultado será sempre zero

O Go converte tudo para string *Explicação: Go é extremamente rígido com tipos para evitar bugs silenciosos.*

3. Quantas estruturas de loop existem em Go?

Três: for, while e do-while

Apenas uma: for (que assume várias formas)

Nenhuma, Go usa apenas recursão

Duas: for e foreach *Explicação: A simplicidade do Go remove o `while` e o `do-while`, usando o `for` para tudo.*

4. Como se escreve um teste de condição `if` em Go corretamente?

if (x > 10) { ... }

if x > 10 { ... }

if x > 10 then ...

if [ x -gt 10 ]; then ... *Explicação: Em Go, os parênteses no `if` são desnecessários e não recomendados.*

5. Para que serve a palavra-chave `const`?

Para declarar variáveis que mudam o tempo todo

Para declarar valores fixos que não podem ser alterados durante a execução

Para importar pacotes de outros arquivos

Para definir o nome do autor do código *Explicação: Constantes são usadas para valores como o PI ou mensagens de erro padronizadas.*

6. Qual o valor padrão (zero value) de um tipo `string` em Go?

"null"

"undefined"

"" (string vazia)

"Zero" *Explicação: Em Go, toda variável nasce com um valor padrão seguro.*

7. No comando `switch`, é necessário usar `break` no final de cada `case`?

Sim, senão ele executa o próximo caso

Não, o Go para automaticamente no final do caso (não tem fallthrough por padrão)

Sim, mas apenas se o caso for numérico

O switch do Go não aceita `case` *Explicação: Isso remove uma das maiores fontes de erros do C e Java.*

8. O que é "Inferência de Tipo" em Go?

É quando o programador precisa adivinhar o tipo da variável

É quando o compilador descobre o tipo da variável baseando-se no valor atribuído

É um erro onde o tipo se perde durante a execução

É uma função que converte strings em números *Explicação: `x := 10` faz o compilador entender que `x` é um `int`.*

9. Qual tipo de dado deve ser usado para valores decimais de alta precisão?

int

bool

float64

string *Explicação: O `float64` é o padrão para números de ponto flutuante em Go.*

10. Como se cria um loop infinito em Go?

for true { }

while(true) { }

for { }

loop { } *Explicação: Um `for` sem condições roda para sempre até ser interrompido.*

Quiz 03 - Introdução

1. Como o Go permite que uma função retorne mais de um valor?

Ele não permite, deve-se usar um array

Basta listar os tipos de retorno entre parênteses na assinatura da função

Somente se a função for iniciada com `func*`

Através de variáveis globais *Explicação: `func divisao(a, b int) (int, error)` é um padrão comum em Go.*

2. Para que serve o operador `&` antes de uma variável?

Para realizar uma operação lógica "AND"

Para obter o endereço de memória (ponteiro) daquela variável

Para deletar a variável da memória

Para converter um número em string *Explicação: O `&` diz "onde está" o dado na memória.*

3. O que define se uma função ou variável é "pública" (exportada) para outros pacotes no Go?

A palavra-chave `public`

Se ela estiver dentro do arquivo `main.go`

Se o nome dela começar com uma letra Maiúscula

Se ela tiver um comentário em cima *Explicação: Go usa a capitalização para controle de visibilidade (ex: `Fmt` vs `fmt`).*

4. Qual a finalidade principal de usar um Ponteiro em Go?

Deixar o código mais complexo e difícil de ler

Evitar cópias desnecessárias de dados grandes ou permitir que uma função altere o valor original

O Go obriga o uso de ponteiros em todas as variáveis

Para rodar o código em servidores antigos *Explicação: Ponteiros dão eficiência e controle sobre o estado da aplicação.*

5. O que são "Variadic Functions"?

Funções que mudam de nome sozinhas

Funções que aceitam um número indeterminado de argumentos do mesmo tipo

Funções que não retornam nada

Funções que só funcionam em variáveis do tipo bool *Explicação: O uso de `...tipo` permite passar quantos argumentos você quiser.*

6. Como você ignora um valor de retorno que não deseja usar?

Deixando um espaço em branco

Usando o identificador em branco `_` (underscore)

Usando a palavra-chave `ignore`

O Go não permite ignorar retornos *Explicação: O `_` diz ao compilador para descartar aquele valor específico.*

7. Todo projeto Go deve ter obrigatoriamente um pacote chamado:

start

main

root

server *Explicação: O pacote `main` informa ao compilador onde a execução do programa começa.*

8. O que o arquivo `go.mod` gerencia?

A configuração do roteador wi-fi

O banco de dados do sistema

O nome do módulo e suas dependências externas

O estilo visual do console *Explicação: Ele é a base do gerenciamento de pacotes moderno do Go.*

9. Qual o operador usado para acessar o valor dentro de um ponteiro (desreferenciação)?

&

#

*

-> *Explicação: O `*` busca o "conteúdo" do endereço apontado.*

10. Funções podem ser passadas como argumentos para outras funções em Go?

Não, isso é impossível

Sim, funções são cidadãs de primeira classe

Somente se forem funções matemáticas

Sim, mas apenas dentro do pacote `main` *Explicação: Isso permite padrões poderosos como middlewares e callbacks.*

Quiz 04 - Introdução

1. Qual a principal diferença entre um Array e um Slice em Go?

O Array é mais rápido que o Slice

O Array tem tamanho fixo e o Slice tem tamanho dinâmico

O Slice só aceita strings

Não há diferença, são nomes diferentes para a mesma coisa *Explicação: Slices são abstrações poderosas sobre arrays que permitem crescer conforme a necessidade.*

2. Como você adiciona um elemento a um Slice?

slice.Add(valor)

slice.Push(valor)

slice = append(slice, valor)

slice[last] = valor *Explicação: O `append` é a função nativa para gerenciar o crescimento de slices.*

3. O que é um "Map" em Go?

Um mapa geográfico para navegação

Uma coleção desordenada de pares chave-valor

Um slice que contém apenas números

Uma ferramenta para desenhar diagramas *Explicação: Maps permitem buscas extremamente rápidas baseadas em chaves únicas.*

4. Qual a função usada para inicializar um Map ou um Slice com capacidade prévia?

create()

init()

make()

build() *Explicação: O `make` aloca a memória necessária para estas estruturas.*

5. O que acontece se você tentar acessar uma chave que não existe em um Map?

O programa sofre um crash imediatamente

Ele retorna null

Ele retorna o "zero value" do tipo do valor (ex: 0 para int)

Ele pergunta ao usuário o que fazer *Explicação: Go é seguro e evita crashes, retornando o valor padrão do tipo.*

6. Como você define uma "Struct" em Go?

class Pessoa { ... }

struct Pessoa { ... }

type Pessoa struct { ... }

define Pessoa struct { ... } *Explicação: Structs são agrupamentos de campos que formam um novo tipo de dado.*

7. Go possui herança de classes como em Java ou C#?

Sim, através de extends

Não, Go usa Composição (Embedding) em vez de herança

Sim, mas apenas no pacote main

Sim, mas é considerada má prática *Explicação: A composição é considerada mais flexível e menos propensa a erros que a herança clássica.*

8. O que é um "Método" no contexto de uma Struct?

Uma função global que não pertence a ninguém

Uma função que possui um "receiver" (destinatário), anexando-a a um tipo

O nome técnico para uma variável dentro da struct

Um comentário especial *Explicação: Métodos permitem que tipos tenham comportamentos associados (ex: `p.Saudacao()`).*

9. Ao fatiar um slice como `sub := lista[1:3]`, quais índices são incluídos?

1 e 3

1 e 2 (o limite superior é exclusivo)

1, 2 e 3

Apenas o 1 *Explicação: O padrão do Go (e de muitas linguagens) é `[inclusive:exclusive]`.*

10. Como se remove uma chave de um Map?

map.Remove(chave)

map[chave] = nil

delete(map, chave)

discard(map, chave) *Explicação: A função `delete` remove a entrada do mapa de forma eficiente.*

Quiz 05 - Introdução

1. Por que as interfaces em Go são chamadas de "Duck Typing" implícito?

Porque elas têm um desenho de pato no ícone

Porque você não precisa declarar que "implementa" uma interface; basta ter os métodos necessários

Porque elas só funcionam com nomes de animais

Porque são muito lentas para rodar *Explicação: "Se caminha como pato e faz quack como pato, é um pato". Go detecta a implementação automaticamente.*

2. O que acontece se uma interface definir 3 métodos e uma struct implementar apenas 2?

O Go tenta adivinhar o terceiro

A struct NÃO implementa a interface (erro de tipo)

A struct implementa a interface parcialmente

O programa roda mas dá erro se chamar o método faltante *Explicação: Para implementar uma interface, a satisfação dos métodos deve ser total.*

3. Qual a principal vantagem da Composição sobre a Herança em Go?

Deixa o código mais colorido

Evita hierarquias complexas e rígidas, promovendo o desacoplamento

Permite que o código rode mais rápido no Windows

Nenhuma, herança é sempre melhor *Explicação: A composição permite montar tipos complexos como "peças de Lego".*

4. Para que serve a "Interface Vazia" `interface{}` (ou `any` nas versões mais novas)?

Para indicar que o programa não faz nada

Para representar um valor de qualquer tipo

Para deletar variáveis da memória

Para criar um loop que nunca termina *Explicação: Ela é a base para funções que precisam aceitar qualquer tipo de dado.*

5. O que significa "Aceite Interfaces, Retorne Structs"?

É uma regra de etiqueta do Google

É uma boa prática que dá flexibilidade a quem chama a função e clareza no retorno

Significa que o código deve ser escrito apenas com interfaces

É um padrão para banco de dados *Explicação: Aceitar interfaces torna sua função genérica; retornar structs dá rapidez e precisão no uso.*

6. Como você faz o "Type Assertion" para descobrir o tipo real por trás de uma interface?

var x = interface.(tipo)

interface.as(tipo)

valor, ok := interface.(tipo)

check(interface == tipo) *Explicação: O padrão `v, ok := i.(T)` permite verificar o tipo de forma segura.*

7. Em Go, podemos anexar métodos a tipos básicos (como `int`)?

Não, apenas a structs

Sim, desde que você defina um novo tipo (ex: `type MeuInt int`)

Sim, basta usar a extensão .go

Somente se o computador for de 64 bits *Explicação: Criar novos tipos permite estender funcionalidades até de tipos primitivos.*

8. Qual o limite de métodos que uma interface pode ter?

No máximo 10

Apenas 1

Não há limite técnico, mas interfaces pequenas (1 ou 2 métodos) são preferíveis

Elas devem ter sempre um número par de métodos *Explicação: Interfaces pequenas são mais fáceis de implementar e reutilizar.*

9. O que é "Embedding" (Embutimento) na Composição?

Colocar o computador dentro de uma caixa

Copiar e colar código de um arquivo no outro

Colocar uma struct dentro de outra sem dar um nome ao campo, herdando seus métodos

Salvar o código no banco de dados *Explicação: O embedding faz com que a struct externa "ganhe" os métodos da interna automaticamente.*

10. Go suporta Polimorfismo?

Não, Go é funcional

Sim, através do uso de Interfaces

Somente se usar o pacote `poly`

Não, Go é procedural e não tem objetos *Explicação: O polimorfismo em Go é limpo e focado no comportamento, não na identidade.*

Quiz 06 - Introdução

1. Qual o padrão idiomático para tratar erros em Go?

Usar blocos try/catch/finally

Verificar se o retorno do tipo `error` é diferente de `nil`

Ignorar todos os erros e torcer para o melhor

Usar somente o comando panic *Explicação: Go trata erros como valores comuns, forçando o desenvolvedor a lidar com eles no momento em que ocorrem.*

2. O que é o tipo `error` em Go?

Uma palavra-chave do sistema operacional

Uma interface nativa com o método `Error() string`

Um número inteiro que indica o código do erro

Um booleano (true ou false) *Explicação: Por ser uma interface, qualquer tipo que implemente o método `Error()` pode ser usado como erro.*

3. Quando se deve usar a função `panic`?

Em qualquer erro de validação de formulário

Apenas para erros críticos e irrecuperáveis que impedem o programa de continuar

Para retornar mensagens de sucesso

Para fechar o programa voluntariamente *Explicação: O panic é agressivo e deve ser reservado para falhas catastróficas (ex: falta de memória).*

4. Qual a função do comando `defer`?

Deletar uma variável

Adiar a execução de uma função até o final da função atual (mesmo em caso de erro)

Aumentar a velocidade do loop for

Esconder o erro do usuário *Explicação: Essencial para garantir o fechamento de arquivos e conexões de rede.*

5. Para que serve o comando `recover`?

Para recuperar arquivos deletados

Para capturar um panic em execução e evitar o encerramento do programa

Para restaurar o banco de dados

Para atualizar a versão do Go *Explicação: O recover só funciona dentro de uma função chamada via `defer`.*

6. Qual a diferença entre `errors.New` e `fmt.Errorf`?

Nenhuma, são sinônimos

`errors.New` é mais rápido no Linux

`fmt.Errorf` permite formatar a mensagem com variáveis (estilo Printf)

`errors.New` apaga o log automaticamente *Explicação: `fmt.Errorf` é ideal para adicionar contexto dinâmico ao erro.*

7. Por que Go não utiliza exceções (try/catch)?

Porque os criadores esqueceram de implementar

Para manter o fluxo de controle visível, simples e evitar "saltos" mágicos no código

Porque exceções consomem muita bateria

Porque Go é uma linguagem para crianças *Explicação: O tratamento explícito torna o código mais previsível e fácil de debugar.*

8. O que acontece se você declarar um erro e não verificá-lo (usar `_`)?

O Go avisa o usuário na tela

O programa fica mais rápido

Você corre o risco de ignorar falhas graves, gerando bugs difíceis de encontrar

O compilador deleta o arquivo fonte *Explicação: Ignorar erros é considerado um dos maiores "pecados" de um desenvolvedor Go.*

9. Onde o comando `defer` costuma ser colocado?

Sempre no final da função

Logo após a declaração bem-sucedida do recurso (ex: após abrir um arquivo)

Apenas dentro do pacote main

Em um arquivo separado de configuração *Explicação: Colocá-lo logo após o recurso evita o esquecimento de fechá-lo.*

10. Pode-se retornar um valor e um erro ao mesmo tempo?

Não, é proibido

Sim, é o padrão recomendado em Go

Somente se o valor for uma string

Apenas em funções que usam ponteiros *Explicação: `return resultado, nil` ou `return nil, erro` é a base da robustez do Go.*

Quiz 07 - Introdução

1. Qual pacote da biblioteca padrão é o mais utilizado para operações de entrada e saída (I/O) e arquivos em Go?

io/json

os (e io/ioutil em versões legadas)

net/http

database/sql *Explicação: O pacote `os` fornece uma plataforma agnóstica para acessar recursos do sistema operacional.*

2. O que são as "Struct Tags" no contexto do JSON?

Comentários que o Go ignora

Metadados entre crases (backticks) que dizem ao codificador JSON como mapear os campos

Etiquetas usadas para imprimir o código em impressoras térmicas

Comandos para apagar o banco de dados *Explicação: Tags como `json:"nome_completo"` permitem que o JSON tenha nomes diferentes da nossa struct interna.*

3. Qual a diferença entre `json.Marshal` e `json.Unmarshal`?

Marshal cria arquivos, Unmarshal deleta

Marshal converte Struct para JSON; Unmarshal converte JSON para Struct

Marshal é para números, Unmarshal é para textos

Nenhuma, fazem a mesma coisa *Explicação: São os dois pilares da serialização em Go.*

4. Como você garante que um arquivo seja fechado corretamente após a leitura, mesmo que ocorra um erro no meio do processo?

Usando um loop infinito

Chamando Close() três vezes

Usando o comando `defer arquivo.Close()` logo após a abertura

Reiniciando o computador *Explicação: O `defer` é a técnica padrão para gestão segura de recursos em Go.*

5. Qual formato o `json.Marshal` retorna?

Uma string formatada

Um slice de bytes (`[]byte`) e um erro

Um número inteiro

Um mapa (map) *Explicação: Retornar bytes dá mais flexibilidade para enviar o dado pela rede ou salvar no disco.*

6. Para que serve o terceiro parâmetro numérico (ex: `0644`) na função `os.WriteFile`?

É o código de barras do arquivo

São as permissões de acesso do arquivo no sistema (Unix permissions)

É a velocidade de escrita em KB/s

É a cor do ícone do arquivo *Explicação: Controla quem pode ler, escrever ou executar aquele arquivo.*

7. Quando você deve usar `json.NewEncoder` em vez de `json.Marshal`?

Quando o JSON for muito pequeno

Quando estiver escrevendo diretamente em um fluxo (como o corpo de uma resposta HTTP ou um arquivo)

Somente em datas especiais

Quando o código for rodar em um Mac *Explicação: O Encoder é mais eficiente para fluxos contínuos (streams) de dados.*

8. O que acontece se uma tag JSON for definida como `json:"-"`?

O campo é salvo como um traço

O campo é ignorado e não aparecerá no JSON resultante

O programa dá erro

O campo vira obrigatório *Explicação: Útil para esconder senhas ou dados sensíveis que não devem sair da aplicação.*

9. Go consegue ler arquivos ZIP nativamente?

Não, precisa de bibliotecas em C++

Sim, através do pacote `archive/zip` da biblioteca padrão

Somente se o Windows permitir

Sim, mas apenas se o arquivo tiver menos de 1MB *Explicação: A biblioteca padrão do Go é riquíssima e cobre compressão, criptografia e muito mais.*

10. Como se verifica se um arquivo existe em Go sem abri-lo?

if exist("arquivo.txt")

Usando `os.Stat(nome)` e verificando se o erro é `os.IsNotExist(err)`

Olhando pela janela

Usando o comando grep *Explicação: `os.Stat` retorna informações sobre o arquivo (metadados) sem carregar seu conteúdo.*

Quiz 08 - Introdução

1. O que é uma "Goroutine"?

Uma rotina de exercícios físicos para programadores

Uma thread extremamente leve gerenciada pelo runtime do Go

Uma função que só roda no navegador

Uma ferramenta para comprimir imagens *Explicação: Goroutines permitem rodar milhares de tarefas simultâneas com pouquíssima memória (aprox. 2KB cada).*

2. Qual palavra-chave é usada para disparar uma função em segundo plano de forma concorrente?

thread

async

go

parallel *Explicação: Basta um `go minhaFuncao()` para que ela execute de forma assíncrona.*

3. Segundo a filosofia do Go, como devemos gerenciar o estado entre tarefas concorrentes?

Usando variáveis globais e locks pesados

Não comunique compartilhando memória; compartilhe memória comunicando (através de Canais)

Usando arquivos de texto temporários

O Go não permite compartilhar dados *Explicação: Canais (Channels) são a forma segura e elegante de trocar dados entre goroutines.*

4. O que acontece se você tentar ler de um canal vazio em que ninguém está enviando nada?

Ele retorna um erro imediatamente

Ele retorna zero

A goroutine fica bloqueada (em espera) até que algo seja enviado

O computador reinicia *Explicação: O bloqueio de canais é o que permite o sincronismo natural do Go.*

5. Para que serve o comando `select`?

Para escolher qual banco de dados usar

Para aguardar por múltiplas operações em canais simultâneos

Para selecionar texto no terminal

Para deletar goroutines travadas *Explicação: O `select` é como um `switch`, mas para operações de entrada e saída em canais.*

6. Qual a diferença entre um Canal comum e um "Buffered Channel" (Canal com Buffer)?

O Buffered Channel é azul

O Buffered Channel permite enviar uma quantidade limitada de dados sem precisar de um recebedor imediato

O Buffered Channel é mais lento

Não há diferença *Explicação: Canais com buffer evitam bloqueios imediatos se houver espaço no "balde".*

7. O que é um "Deadlock"?

Um filme de ação famoso

Uma situação onde todas as goroutines estão bloqueadas esperando umas pelas outras

Quando o código é apagado acidentalmente

Quando a internet cai durante a compilação *Explicação: É um erro comum de lógica em sistemas concorrentes que o Go consegue detectar em tempo de execução.*

8. Qual o tamanho médio inicial de memória que uma Goroutine consome?

2 MB (como uma thread comum de SO)

1 GB

Cerca de 2 KB

0 bytes *Explicação: Por serem tão leves, você pode rodar milhões delas em um único servidor.*

9. Para que serve o pacote `sync.WaitGroup`?

Para fazer o programa esperar o usuário apertar uma tecla

Para sincronizar a conclusão de um grupo de goroutines antes de encerrar o programa

Para limpar o cache do computador

Para organizar arquivos por data *Explicação: O `Wait()` trava o programa principal até que todas as goroutines avisem que terminaram (`Done()`).*

10. Go utiliza paralelismo real?

Não, apenas simulação

Sim, o runtime distribui as goroutines entre os diversos núcleos (cores) da CPU

Somente se o programador escrever código em Assembly

Somente em servidores Linux *Explicação: O escalonador do Go (scheduler) aproveita todo o poder do seu hardware multicore.*

Quiz 09 - Introdução

1. Como o Go permite rodar um servidor HTTP sem depender de softwares como Apache ou Nginx?

Ele se conecta via Bluetooth

Ele possui um servidor HTTP de nível de produção embutido na biblioteca padrão (`net/http`)

Ele usa o Internet Explorer escondido

Ele não roda sem o Nginx *Explicação: O pacote `net/http` é robusto o suficiente para ser o próprio servidor da aplicação.*

2. No handler `func(w http.ResponseWriter, r *http.Request)`, qual o papel do `w`?

Representar o Windows do servidor

Enviar a resposta (Headers, Body, Status) de volta para o cliente

Receber os dados enviados pelo navegador

Inverter o sentido da internet *Explicação: O `ResponseWriter` é o canal de saída do servidor para o cliente.*

3. O que o objeto `r *http.Request` contém?

Apenas o endereço IP do usuário

Toda a informação da requisição: Método, URL, Cabeçalhos e Corpo (Body)

O código fonte do navegador do cliente

A senha do administrador *Explicação: O `Request` é o pacote completo de informações que o cliente envia para o servidor.*

4. Qual comando inicia o servidor e o faz escutar em uma porta específica?

http.Start(":8080")

http.Listen()

http.ListenAndServe(":8080", nil)

server.Run() *Explicação: Esta função bloqueia a execução do main e mantém o servidor ativo respondendo requisições.*

5. O que são "Middlewares" em uma aplicação Web?

Softwares que ficam entre o teclado e a tela

Funções que interceptam uma requisição antes que ela chegue ao handler final (ex: para logs ou login)

Cabos de rede especiais

Vírus que lentificam o servidor *Explicação: Middlewares permitem adicionar camadas de lógica comuns a várias rotas.*

6. Como você serve arquivos estáticos (HTML, CSS, Imagens) em Go?

Copiando e colando o arquivo na tela

Usando o `http.FileServer` apontando para um diretório

Go não serve arquivos estáticos

Usando o comando `print(arquivo)` *Explicação: O FileServer é uma ferramenta nativa eficiente para entregar conteúdo estático.*

7. O que acontece se uma rota não for encontrada e você não definiu um handler padrão?

O computador explode

O servidor retorna automaticamente o erro `404 page not found`

O servidor trava

Ele escolhe uma página aleatória *Explicação: O roteador padrão do Go já possui tratamento básico para rotas inexistentes.*

8. No Go nativo (`net/http`), como se pega um parâmetro da Query String (ex: `?id=10`)?

r.ID()

r.URL.Query().Get("id")

r.Body["id"]

Através de um loop for *Explicação: Os parâmetros de busca ficam organizados dentro do objeto URL da requisição.*

9. Qual o valor de retorno padrão de uma requisição bem-sucedida?

0

404

200 OK

500 *Explicação: O código 200 é o sinal universal de que a requisição foi atendida com sucesso.*

10. É possível rodar múltiplos servidores Go em portas diferentes no mesmo binário?

Não, apenas um por vez

Sim, usando Goroutines para iniciar cada `ListenAndServe`

Somente se houver duas placas de rede

Sim, mas eles compartilham o mesmo log *Explicação: A concorrência do Go facilita subir múltiplos micro-serviços ou painéis administrativos no mesmo processo.*

Quiz 10 - Introdução

1. No design de APIs REST, o que representa um "Recurso"?

O código fonte do servidor

Qualquer entidade ou dado nomeável (ex: /usuarios, /produtos)

A velocidade da CPU

O manual de instruções *Explicação: REST foca na manipulação de recursos através de identificadores únicos (URIs).*

2. Qual a principal vantagem de organizar o projeto em Camadas (MVC/Serviços)?

O código fica mais bonito no editor

Facilita a manutenção, testes e a troca de tecnologias (ex: mudar o banco de dados)

O programa compila mais rápido

Impede que hackers vejam o código *Explicação: Separar lógica de negócio, acesso a dados e handlers HTTP garante um sistema escalável.*

3. Qual verbo HTTP deve ser usado para CRIAR um novo recurso?

GET

POST

PUT

DELETE *Explicação: O POST é o método padrão para submissão de novos dados para o servidor.*

4. O que a camada "Repository" deve fazer?

Validar o e-mail do usuário

Lidar puramente com a persistência e busca de dados (Banco de Dados/Arquivos)

Desenhar o JSON de resposta

Controlar as rotas da API *Explicação: O Repository abstrai como e onde os dados são salvos.*

5. Qual o código de status HTTP recomendado ao se criar um recurso com sucesso?

200 OK

201 Created

400 Bad Request

500 *Explicação: O 201 informa explicitamente que algo novo nasceu no sistema.*

6. No REST profissional, devemos usar verbos nas URLs (ex: `/deletar_item/123`)?

Sim, deixa mais claro

Não, devemos usar substantivos e deixar a ação para o Verbo HTTP (ex: `DELETE /items/123`)

Depende do humor do desenvolvedor

Somente se o projeto for pequeno *Explicação: APIs RESTful usam os métodos HTTP para definir a ação sem poluir a URL.*

7. Para que serve o método `PATCH`?

Para deletar tudo

Para atualizar apenas parte de um recurso (ex: mudar só o preço de um produto)

Para enviar mensagens secretas

Para instalar atualizações no servidor *Explicação: Diferente do PUT (substituição total), o PATCH é cirúrgico.*

8. O que é "Idempotência"?

Um tipo de bateria de longa duração

A propriedade de uma requisição que, se repetida, produz o mesmo resultado no servidor sem efeitos colaterais extras

Uma função que gera números aleatórios

A velocidade de resposta da internet *Explicação: GET, PUT e DELETE são idempotentes; POST geralmente não é.*

9. Onde costuma ficar a "Regra de Negócio" na organização por camadas?

No arquivo main.go

Na camada de Service (Serviços)

Dentro do banco de dados

No frontend *Explicação: A camada de serviço é o "cérebro" que toma decisões baseadas nos dados.*

10. Qual ferramenta é o padrão para documentar e testar contratos de APIs REST?

Microsoft Word

Swagger (OpenAPI)

Paint

Notepad++ *Explicação: O Swagger gera uma documentação viva e interativa da sua API.*

Quiz 11 - Introdução

1. O Gin é considerado um framework "leve" e "rápido". Qual o principal motivo dessa fama?

Ele usa inteligência artificial para codar

Ele utiliza um roteador baseado em Radix Tree e tem baixíssima alocação de memória

Ele apaga os arquivos desnecessários do Windows

Ele só funciona com strings curtas *Explicação: O roteador do Gin é um dos mais performáticos do ecossistema Go.*

2. No Gin, qual objeto central é passado para todos os handlers para gerenciar a requisição e a resposta?

gin.Server

*gin.Context

http.Request

context.Background() *Explicação: O `*gin.Context` encapsula tudo o que você precisa (parâmetros, JSON, resposta).*

3. Como se define uma rota com parâmetro dinâmico no Gin (ex: pegar o ID do usuário)?

r.GET("/user/ID")

r.GET("/user/:id")

r.GET("/user/$id")

r.GET("/user/?id") *Explicação: O uso dos dois pontos `:` define um parâmetro que pode ser recuperado via `c.Param("id")`.*

4. Qual a função do método `c.ShouldBindJSON(&struct)`?

Deletar o JSON enviado

Mapear automaticamente o corpo da requisição (JSON) para uma struct em Go

Validar a conexão com a internet

Transformar a struct em uma imagem *Explicação: O Binding economiza dezenas de linhas de tratamento manual de bytes.*

5. O que o `gin.H{}` permite que façamos?

Criar um loop infinito

Escrever um JSON de forma rápida e curta no estilo chave-valor

Hostear o site na nuvem

Esconder o cabeçalho da página *Explicação: `gin.H` é um atalho para `map[string]interface{}`.*

6. Como você agrupa rotas que compartilham um prefixo comum (ex: `/api/v1`)?

Copiando e colando o prefixo em cada linha

Usando o método `r.Group("/api/v1")`

Criando vários servidores diferentes

O Gin não permite agrupamento *Explicação: Grupos de rotas permitem aplicar middlewares a conjuntos específicos de endpoints.*

7. Para que serve a tag `binding:"required"` nas structs?

Para deixar o texto em negrito

Para que o Gin valide automaticamente se aquele campo foi enviado no JSON

Para travar o banco de dados

Para aumentar a segurança contra hackers *Explicação: O Gin retorna erro automaticamente se um campo obrigatório estiver faltando.*

8. Qual o comando para iniciar o servidor Gin na porta padrão?

r.Start()

r.Run()

r.Listen()

r.Serve() *Explicação: O `Run()` inicia o motor do framework e aguarda conexões na porta 8080.*

9. O Gin já vem com sistema de logs e recuperação de pânicos (Recovery) por padrão?

Não, deve ser instalado por fora

Sim, ao usar `gin.Default()`, esses dois middlewares são ativados

Somente se o computador for potente

Somente na versão paga *Explicação: O Log ajuda no debug e o Recovery evita que o servidor caia por um erro inesperado.*

10. Podemos usar Middlewares personalizados no Gin?

Não, o Gin é fechado

Sim, usando o método `r.Use()`

Sim, mas apenas para contar o tempo

Somente no pacote main *Explicação: O sistema de middlewares do Gin é extremamente modular e fácil de usar.*

Quiz 12 - Introdução

1. O que significa a sigla ORM (como o GORM)?

Organized Recovery Manager

Object-Relational Mapping (Mapeamento Objeto-Relacional)

Online Router Monitor

Only Ready Models *Explicação: ORMs transformam tabelas de banco de dados em objetos (structs) no código.*

2. Qual a principal vantagem do GORM sobre o pacote nativo `database/sql`?

Ele obriga o uso de cartões de crédito

Ele automatiza tarefas repetitivas como gerar queries SQL e gerenciar tabelas

Ele apaga o banco caso o código esteja feio

Ele só funciona no Google Cloud *Explicação: O GORM traz alta produtividade ao abstrair o SQL complexo em funções Go.*

3. Para que serve o método `db.AutoMigrate(&MinhaStruct{})`?

Para migrar o código para outra linguagem

Para criar ou atualizar automaticamente a tabela no banco conforme a estrutura da struct

Para deletar todos os dados do banco

Para salvar o banco de dados em um pendrive *Explicação: Migrations automáticas garantem que o banco acompanhe as mudanças do seu código.*

4. O que a struct embarcada `gorm.Model` adiciona ao seu modelo?

Somente o campo de nome

ID, CreatedAt, UpdatedAt e DeletedAt (soft delete)

Um link para o GitHub do autor

A cor de fundo da tabela *Explicação: Facilita a criação de metadados padrão para qualquer registro no banco.*

5. Como o GORM trata a deleção de registros por padrão se o modelo tiver `gorm.Model`?

Exclui permanentemente do disco

Realiza um "Soft Delete" (apenas marca como deletado, mas mantém o dado)

Pergunta ao administrador se ele tem certeza

Copia o dado para um arquivo TXT *Explicação: Soft delete permite recuperar dados apagados acidentalmente.*

6. Qual método é usado para inserir um novo registro no banco de dados?

db.Save()

db.Insert()

db.Create()

db.Add() *Explicação: O `Create` recebe um ponteiro para a struct e realiza a inserção SQL.*

7. Como se faz uma busca por todos os registros de uma tabela?

db.ListAll(&slice)

db.Get(&slice)

db.Find(&slice)

db.Select("*") *Explicação: O `Find` preenche o slice passado com todos os registros encontrados.*

8. O GORM suporta vários bancos de dados (PostgreSQL, MySQL, SQLite, SQL Server)?

Não, apenas SQLite

Sim, através de "Drivers" específicos para cada banco

Sim, mas apenas um por projeto

Somente bancos de dados do Google *Explicação: Você pode desenvolver em SQLite localmente e subir para PostgreSQL em produção sem mudar quase nada no código.*

9. Para que servem as Tags do GORM (ex: `gorm:"primaryKey;unique"`)?

Para traduzir o banco de dados

Para dar instruções específicas ao banco sobre aquela coluna (chave primária, valor único, etc.)

Para colorir a tabela no editor SQL

Para bloquear o acesso de hackers *Explicação: Permite configurar o banco de dados detalhadamente diretamente pela struct.*

10. O que é o "Eager Loading" (Pré-carregamento) no GORM?

Carregar o banco antes de ligar o computador

Carregar dados de tabelas relacionadas (relacionamentos) em uma única consulta (usando `Preload`)

Aumentar a velocidade do mouse

Baixar o banco de dados da internet *Explicação: Vital para buscar um Usuário já com todos os seus Pedidos associados.*

Quiz 13 - Introdução

1. Qual o sufixo obrigatório de um arquivo que contém testes em Go?

.test

_go_test.go

_test.go

.spec.go *Explicação: O compilador Go ignora arquivos com este sufixo durante a compilação normal e só os usa no comando `go test`.*

2. Qual o parâmetro obrigatório de uma função de teste unitário?

s *sync.WaitGroup

t *testing.T

err error

ctx context.Context *Explicação: O objeto `*testing.T` fornece métodos para reportar falhas e logs nos testes.*

3. De onde vem o pacote de testes do Go?

É preciso baixar do GitHub

Faz parte da biblioteca padrão (`testing`)

É um plugin do VS Code

Vem junto com o Docker *Explicação: Go preza por ter ferramentas de qualidade embutidas na linguagem.*

4. O que é um "Table-Driven Test" (Teste de Tabela)?

Um teste feito no Excel

Uma técnica de organizar vários cenários de entrada e saída em um slice para testar uma única função

Um teste que verifica se o banco de dados tem tabelas

Um teste que roda apenas em tabelas HTML *Explicação: É a forma mais organizada e escalável de escrever testes em Go.*

5. Qual comando gera um relatório de cobertura de testes no terminal?

go test -v

go test -cover

go coverage

go check *Explicação: A cobertura indica quais partes do seu código foram realmente executadas pelos testes.*

6. Para que serve o pacote `httptest`?

Para hackear sites

Para simular requisições e respostas HTTP sem precisar subir um servidor real

Para medir a velocidade da internet

Para criar sites bonitos *Explicação: Essencial para testar Handlers e Middlewares de forma isolada.*

7. Em Go, o que significa TDD (Test Driven Development)?

Total Data Design

Desenvolvimento Orientado por Testes (escrever o teste antes do código)

Técnica De Depuração

Trabalho De Desenvolvedor *Explicação: O TDD ajuda a desenhar funções melhores e mais simples.*

8. O que acontece se uma função de teste começar com letra minúscula (ex: `func testSoma`)?

O Go avisa que está errado

O programa trava

O `go test` irá ignorar a função (ela deve começar obrigatoriamente com `Test...`)

Ela vira um teste privado *Explicação: A ferramenta de testes só executa funções exportadas que seguem o padrão `TestXxx`.*

9. Qual o papel do método `t.Errorf`?

Encerrar o programa imediatamente

Reportar que um teste falhou mas continuar a execução dos próximos testes

Enviar um e-mail para o desenvolvedor

Formatar o código *Explicação: Ele permite capturar múltiplos erros em uma única rodada de testes.*

10. Pode-se testar performance (benchmarks) no Go nativamente?

Não, precisa de ferramentas externas

Sim, usando funções que começam com `Benchmark...` e o objeto `*testing.B`

Sim, mas apenas em servidores potentes

Somente se o código estiver em nuvem *Explicação: Go possui um sistema robusto para medir a velocidade e alocação de memória das suas funções.*

Quiz 14 - Introdução

1. Qual o maior objetivo da "Clean Architecture"?

Fazer com que o código rode em computadores antigos

Isolar a lógica de negócio de detalhes externos como banco de dados, UI e frameworks

Exigir que o programador tome banho antes de codar

Diminuir o espaço em disco do projeto *Explicação: A arquitetura limpa permite que o "coração" do sistema seja testável e imune a trocas de tecnologia externa.*

2. Em Go, o que define a camada de "Entidade"?

A conexão com o banco de dados

As structs que representam o domínio do negócio e suas regras fundamentais

Os scripts de deploy

A interface visual do site *Explicação: Entidades são o nível mais alto e estável da arquitetura.*

3. O que é "Injeção de Dependência" (DI)?

Colocar vírus no código de terceiros

Passar as dependências de um objeto (como um repositório) via construtor ou interface, em vez de criá-las internamente

Uma vacina para erros de sintaxe

Formatar o computador via terminal *Explicação: A DI permite desacoplar componentes, facilitando o uso de Mocks nos testes.*

4. Por que a pasta `internal/` é especial em Go?

Porque ela é escondida por padrão

Porque o compilador impede que pacotes fora do projeto importem o código que está dentro dela

Porque ela acelera o processamento de imagens

Porque só o administrador pode editá-la *Explicação: É a forma do Go garantir o encapsulamento e privacidade de módulos internos.*

5. Qual a recomendação para nomenclatura de pacotes em Go?

Usar nomes complexos e técnicos (ex: `BusinessLogicImplementation`)

Usar substantivos curtos, simples e em minúsculo (ex: `user`, `auth`, `order`)

Usar apenas números

Usar o nome do desenvolvedor *Explicação: Nomes simples facilitam a leitura e o import do código.*

6. O que significa a frase "Retorne structs, aceite interfaces"?

É uma tradução errada de um livro

Que suas funções devem aceitar abstrações (interfaces) para serem flexíveis, mas retornar dados concretos para serem rápidas

Que o programa deve ter apenas 10 arquivos

Que não devemos usar variáveis *Explicação: Essa prática maximiza o polimorfismo mantendo a facilidade de uso do retorno.*

7. Na Clean Architecture, quem pode conhecer quem?

Todos podem conhecer todos

As camadas externas podem conhecer as internas, mas as internas nunca conhecem as externas

Somente o banco de dados conhece o resto

As camadas são secretas *Explicação: A regra de dependência aponta sempre para dentro (para o Core).*

8. Qual o papel do arquivo `main.go` em um projeto bem arquitetado?

Conter toda a lógica do sistema

Atuar como o "fio de ligação", instanciando as dependências e iniciando o servidor

Ser o manual de instruções

O projeto não precisa de um main.go *Explicação: O main deve ser magro, servindo apenas para o bootstrapping da aplicação.*

9. Go prefere Composição ou Herança?

Herança pesada com várias camadas

Composição (Embedding)

Go não permite nenhum dos dois

Depende do sistema operacional *Explicação: A composição é considerada mais robusta e simples de manter em Go.*

10. Onde deve ficar a lógica de "Como salvar no banco de dados"?

Na camada de Service

No arquivo main

Na camada de Repository

Directamente no Handler *Explicação: O Repository é o especialista em persistência, protegendo o resto do sistema dos detalhes do SQL.*

Quiz 15 - Introdução

1. Qual a principal vantagem de usar Docker para uma aplicação Go?

Ele deixa o código Go mais rápido que o normal

Ele empacota o binário e suas dependências de sistema em um ambiente isolado e idêntico em qualquer lugar

Ele converte o código Go para HTML automaticamente

Ele substitui a necessidade de programar *Explicação: Docker resolve o problema do "na minha máquina funciona".*

2. O que é o "Multi-Stage Build" em um Dockerfile?

Um build que roda em vários computadores ao mesmo tempo

Uma técnica de usar um estágio para compilar o código e outro estágio (menor) apenas para rodar o binário final

Um comando que instala várias versões do Docker

Um build que troca de cor no terminal *Explicação: Isso permite imagens extremamente leves, na casa dos 15MB.*

3. Por que podemos usar a imagem `alpine` ou até `scratch` como base final para o Go?

Porque elas são grátis

Porque binários Go são estáticos e não precisam de um sistema operacional completo para rodar

Porque elas têm o logo de um gopher

Porque elas são mais coloridas *Explicação: Menos arquivos na imagem significa mais segurança e menor tempo de download.*

4. Qual comando do Dockerfile define qual comando será executado quando o container subir?

RUN

COPY

CMD

WORKDIR *Explicação: O CMD é a instrução final de execução do container.*

5. Para que serve o arquivo `docker-compose.yml`?

Para salvar senhas do banco de dados

Para orquestrar e subir múltiplos containers juntos (ex: API + PostgreSQL)

Para traduzir o Docker para português

Para editar o código fonte *Explicação: Ele facilita muito o ambiente de desenvolvimento e testes locais.*

6. Como você passa uma variável de ambiente sensível para um container no Docker Compose?

Escrevendo diretamente no código Go

Usando a seção `environment` ou um arquivo `.env`

Gritando para o monitor

Usando um comentário no Dockerfile *Explicação: Variáveis de ambiente mantêm segredos fora do controle de versão (Git).*

7. O que a instrução `COPY --from=builder` faz?

Copia o código do GitHub

Copia arquivos de um estágio anterior do build para o estágio atual

Faz o download de dependências

Move o arquivo para a lixeira *Explicação: É a base do Multi-Stage Build para economizar espaço.*

8. No Go, como lemos uma variável de ambiente injetada pelo Docker?

env.Read("NOME")

os.Getenv("NOME")

get.Environment("NOME")

system.Variable("NOME") *Explicação: O pacote `os` é o responsável por falar com o ambiente do sistema operacional.*

9. Qual comando Docker é usado para remover containers parados e liberar espaço?

docker remove all

docker clean

docker system prune

docker format c: *Explicação: O `prune` faz uma limpeza geral de recursos não utilizados.*

10. O que significa "Orquestração de Containers"?

Tocar música com o computador

Gerenciar o ciclo de vida, escalonamento e rede de vários containers (ex: Kubernetes)

Organizar o código por pastas

Baixar vários containers ao mesmo tempo *Explicação: Em sistemas grandes, ferramentas de orquestração automatizam o trabalho pesado de manter tudo rodando.*

Quiz 16 - Introdução

1. Qual o principal diferencial do Go em relação à concorrência?

Ela tem as cores mais bonitas

O modelo de concorrência nativo (CSP) com Goroutines e Channels

Ela permite programar apenas com o mouse

Ela não usa internet para compilar *Explicação: Concorrência de baixo custo é o "superpoder" do Go.*

2. Na organização por camadas, onde ficam as validações de campos obrigatórios?

No banco de dados

Na camada de Handler (via Binding) ou no Service (Regras de Negócio)

No manual do usuário

Em um arquivo de imagem *Explicação: Validar na entrada evita que dados sujos poluam o sistema.*

3. O que garante que o binário de produção seja pequeno e seguro?

Usar um computador novo

Multi-Stage Builds no Docker e compilação estática do Go

Deletar o código fonte antes de rodar

Comprimir o arquivo com WinRAR *Explicação: Imagens Alpine com apenas o binário são o padrão da indústria.*

4. Qual o comando usado para atualizar todas as dependências do projeto?

go clean

go get -u ./...

go mod tidy

go update *Explicação: O `go mod tidy` limpa o arquivo, mas o `get -u` busca novas versões.*

5. O que define que uma struct em Go "implementa" uma interface?

Ela deve ter um comentário dizendo isso

Ela deve possuir as assinaturas exatas de todos os métodos da interface

Ela deve herdar de uma classe base

Ela deve estar no mesmo arquivo da interface *Explicação: O mapeamento é implícito e automático.*

6. Qual a função do arquivo `.env` em um projeto profissional?

Enviar e-mails automaticamente

Armazenar configurações e segredos específicos do ambiente que não devem ir para o Git

Decorar o terminal

Aumentar o brilho da tela *Explicação: Segurança em primeiro lugar.*

7. Em um sistema de biblioteca, "Empréstimo" seria melhor modelado como:

Um campo dentro da struct Usuário

Uma entidade/struct separada que relaciona Usuário e Livro

Um comentário no código

Um arquivo de texto separado *Explicação: Relacionamentos n-pra-n ou com metadados exigem estruturas próprias.*

8. O que acontece se chamarmos `db.AutoMigrate` e a tabela já existir?

O banco de dados é apagado

O GORM altera a tabela para incluir novas colunas (se houver), mas mantém os dados existentes

O programa trava com erro

Ele cria uma cópia da tabela *Explicação: É uma migração incremental e segura na maioria dos casos.*

9. Qual ferramenta é usada para simular múltiplos usuários acessando a API ao mesmo tempo em testes?

Um browser aberto 100 vezes

Goroutines em um loop de teste

O cronômetro do celular

O comando ping *Explicação: Go é a melhor ferramenta para testar o próprio Go sob carga.*

10. Qual a melhor maneira de continuar aprendendo Go após este curso?

Parar de programar e só ler livros

Construir projetos reais, ler a biblioteca padrão e participar da comunidade

Esperar o Google lançar uma nova versão

Decorar o dicionário de funções *Explicação: Programação é uma prática constante. Mão na massa!*

Slides

Slides 📺

Material visual para acompanhamento das vídeo-aulas.

Módulo 1: Fundamentos ---
Módulo 2: Lógica e Persistência ---
Módulo 3: Desenvolvimento Web ---
Módulo 4: Qualidade e Infra ---

Aula 01 - Introdução ao Go e Ecossistema 🐹

A Linguagem do Google para a Nuvem

Agenda de Hoje 📅

Origens e Filosofia do Go
Diferenciais com outras linguagens
Instalação e Setup
O Arquivo go.mod
"Hello World" na prática
O Ecossistema e a Comunidade

1. Por que o Go nasceu? 🐣

Criado no Google (2007) por:
- Robert Griesemer, Rob Pike e Ken Thompson.
Problemas reais:
- Compilação lenta (C++).
- Dependências complexas.
- Dificuldade com multicore (concorrência).

2. Filosofia: "Menos é Mais" 🧊

Simplicidade acima de tudo.
Uma única forma de fazer as coisas.
Foco em legibilidade e manutenibilidade.
Binários estáticos e rápidos.

3. Go vs Outras Linguagens 🥊

Recurso	Go	Python	Java
Velocidade	⚡ Alta	🐢 Baixa	🐎 Média
Tipagem	Estática	Dinâmica	Estática
Concorrência	Nativa	Complexa	Pesada
Binário	Único	Precisa Interpreter	Precisa JVM

4. O Ecossistema Go 🐹

graph TD
    Tools[Go Toolchain] --> Comp[Compiler]
    Tools --> Test[Test Runner]
    Tools --> Mod[Go Modules]
    Tools --> Doc[Go Doc]
    Tools --> Fmt[Go Fmt]
    style Tools fill:#00add8,stroke:#333

5. Setup do Ambiente 🚀

Passo a Passo:

Baixar em go.dev/dl.
Extensão Go no VS Code.
Verificar versão: go version.

6. O Primeiro Programa 📝

package main

import "fmt"

func main() {
    fmt.Println("Olá, Gopher! 🐹")
}

7. Módulos e Dependências 📂

O arquivo go.mod é o coração do projeto.
Comando: go mod init meu-projeto.
Gerencia versões de bibliotecas externas de forma segura.

8. Termynal na Prática 💻

$ go mod init aula01
$ go run main.go
Olá, Gopher! 🐹
$ go build main.go
$ ./main

Resumo da Aula ✅

Go une a eficiência do C com a simplicidade do Python.
É a linguagem oficial da infraestrutura moderna (Docker, K8s).
Simplicidade gera produtividade em times grandes.

Próxima Aula: Fundamentos 🧱

Variáveis e Tipos.
Controle de Fluxo.
Loops (o único for!).

Dúvidas? 🤔

"O código deve ser escrito para que humanos o leiam, e apenas incidentalmente para que máquinas o executem."

Aula 02 - Fundamentos da Linguagem 🧱

Variáveis, Tipos e Controle de Fluxo

Agenda de Hoje 📅

Variáveis e Declaração Curta
Tipos de Dados Primitivos
Constantes e Iota
Estruturas Condicionais (If/Switch)
Repetição: O Poder do For
Mini-Projeto: Calculadora IMC

1. Declarando Variáveis 📦

Forma Explícita: var nome string = "Gopher"
Forma Curta: idade := 25
Zero Values: Int (0), String (""), Bool (false).

2. Tipos Primitivos 💎

Inteiros: int, int64, uint.
Decimais: float32, float64.
Booleano: bool.
Texto: string (Imutável).

[!WARNING] Go não converte tipos automaticamente! int + float64 causa erro.

3. Controle de Fluxo: If/Else 🚦

Não usa parênteses.
Chaves {} são obrigatórias.

if idade >= 18 {
    fmt.Println("Adulto")
} else {
    fmt.Println("Menor")
}

4. O Switch "Inteligente" 💡

Não precisa de break.
Pode avaliar condições complexas.

switch {
case nota >= 7:
    fmt.Println("Aprovado")
case nota >= 5:
    fmt.Println("Recuperação")
default:
    fmt.Println("Reprovado")
}

5. Estruturas de Repetição 🔁

O Único Loop: for.

// Estilo C
for i := 0; i < 5; i++ { ... }

// Estilo While
for x < 10 { ... }

// Infinito
for { ... }

6. Diagrama de Fluxo 📊

graph TD
    A[Start] --> B{x > 0?}
    B -- Sim --> C[Positivo]
    B -- Não --> D[Negativo/Zero]
    C --> E[End]
    D --> E

7. Mini-Projeto: Calculadora IMC 🚀

func main() {
    peso := 70.0
    altura := 1.75
    imc := peso / (altura * altura)
    fmt.Printf("Seu IMC é: %.2f\n", imc)
}

Resumo da Aula ✅

Go é estaticamente tipado e seguro.
Controle de fluxo simples e direto.
O for é a ferramenta universal de repetição.

Próxima Aula: Funções e Organização 🧩

Múltiplos retornos.
Ponteiros (sem medo!).
Pacotes e Módulos.

Aula 03 - Funções e Organização do Código 🧩

Estruturando Projetos de Forma Profissional

Agenda de Hoje 📅

Anatomia de uma Função
Retornos Múltiplos e Variádicos
Ponteiros: Endereços vs Valores
Visibilidade (Exportação)
Módulos e Gestão de Pacotes
Mini-Projeto: Conversos Modular

1. Funções em Go ⚙️

Funções são blocos independentes.
Cidadãs de 1ª Classe: Podem ser variáveis e argumentos.

func somar(a int, b int) int {
    return a + b
}

2. O Diferencial: Retornos Múltiplos 🔄

Útil para retornar o dado e o erro simultaneamente.

func dividir(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("não pode dividir por 0")
    }
    return a / b, nil
}

3. Ponteiros: O Guia Definitivo 📍

Endereço (&): Onde o dado mora.
Valor (*): O que tem dentro da casa.

func dobrar(n *int) {
    *n = *n * 2
}

"Ponteiros economizam memória ao evitar cópias de objetos grandes."

4. Organizando a Casa: Pacotes 📂

Pastas = Pacotes.
Exportação Camuflada:
- Calcular (Maiúsculo) -> Público.
- calcular (Minúsculo) -> Privado do pacote.

5. Estrutura de Projeto 🏗️

$ tree
.
├── go.mod
├── main.go
└── conversor/
    └── temperatura.go

6. Diagrama de Módulo 📊

graph LR
    Main[main.go] -->|import| P1[Package 1]
    Main -->|import| P2[Package 2]
    P1 -->|internal| F1[Func Privada]
    P1 -->|exported| F2[Func Pública]

Resumo da Aula ✅

Go força uma organização clara por pastas.
Múltiplos retornos eliminam a necessidade de exceções globais.
Ponteiros dão controle total sobre a performance.

Próxima Aula: Estruturas de Dados 🗄️

Slices: Arrays dinâmicos.
Maps: O dicionário do Go.
Structs: Criando seus tipos.

Dúvidas? 🤔

"Um código bom é um código organizado."

Aula 04 - Estruturas de Dados Avançadas 🗄️

Gerenciando Coleções e Tipos Customizados

Agenda de Hoje 📅

Arrays vs Slices
Manipulação de Slices (Append/Slice)
Maps: Chave e Valor
Structs: O Coração dos Dados
Métodos e Comportamento
Mini-Projeto: Escola de Gophers

1. Arrays vs Slices 🍕

Arrays: Rígidos, tamanho faz parte do tipo.
Slices: Flexíveis, dinâmicos. O "padrão" do Go.

// Array
var a [2]string

// Slice
s := []string{"A", "B"}
s = append(s, "C")

2. Anatomia de um Slice 🔍

graph LR
    subgraph "Capacidade (Reservado)"
        D3[Elemento 3]
        D4[Vazio]
    end
    subgraph "Slice (Existente)"
        D1[Elemento 1]
        D2[Elemento 2]
    end
    Ptr[Ponteiro] --> D1

3. Maps: O Dicionário Veloz 🗝️

Coleção de pares chave-valor.
Chaves devem ser comparáveis.

estoque := make(map[string]int)
estoque["teclado"] = 50

valor, existe := estoque["mouse"]

4. Structs: Seus Próprios Tipos 🏗️

Go não tem classes, tem Structs.
Agrupam dados de tipos diferentes.

type Aluno struct {
    Nome  string
    Idade int
    Notas []float64
}

5. Adicionando Comportamento (Métodos) ⚡

Funções "anexadas" a um tipo.

func (a Aluno) Media() float64 {
    total := 0.0
    for _, n := range a.Notas {
        total += n
    }
    return total / float64(len(a.Notas))
}

6. Mini-Projeto: Escola de Gophers 🚀

Criar um sistema que armazena alunos em um map.
Cada aluno é uma struct.
Calcular e exibir médias.

Resumo da Aula ✅

Slices são extensões dinâmicas de memória.
Maps oferecem performance em buscas por chaves.
Structs modelam o domínio do seu negócio.

Próxima Aula: Interfaces e Flexibilidade 🧩

O segredo do Polimorfismo em Go.
Programação baseada em Composição.

Dúvidas? 🤔

"A estrutura de dados correta resolve metade do problema."

Aula 05 - Interfaces e Composição 🧩

O Segredo da Flexibilidade em Go

Agenda de Hoje 📅

O Conceito de Interfaces
Implementação Implícita (Duck Typing)
Polimorfismo na Prática
Composição vs Herança
Embedding de Structs
Mini-Projeto: Sistema de Pagamentos

1. O que são Interfaces? 🔌

Define O Que um objeto faz, não Como.
É um conjunto de assinaturas de métodos.

type Documento interface {
    Imprimir() string
}

2. Duck Typing em Go 🦆

"Se caminha como pato e faz quack como pato..."

Não existe a palavra implements.
Se você tem os métodos, você é o tipo.

3. Polimorfismo 🎭

func ExecutarImpressao(d Documento) {
    fmt.Println(d.Imprimir())
}

// Aceita PDF, Docx, TXT... qualquer um que "Imprima".

4. Composição (O Diferencial) 🏗️

Go não tem herança (class A extends B).
Usamos Embedding para reutilizar comportamento.

5. Exemplo de Composição 🚲

type Motor struct { ... }

type Carro struct {
    Motor // Carro "tem um" motor
    Marca string
}

6. Diagrama de Composição 📊

classDiagram
    class Motor { +Ligar() }
    class Carro { +Motor motor }
    class Caminhao { +Motor motor }
    Carro *-- Motor
    Caminhao *-- Motor

7. A Interface Vazia: `any` ☁️

interface{} aceita qualquer valor.
Útil para funções genéricas (ex: fmt.Println).
Cuidado: Perde a segurança de tipos!

Resumo da Aula ✅

Interfaces focam em comportamento.
Composição é mais simples e flexível que herança.
"Aceite interfaces, retorne structs".

Próxima Aula: Tratamento de Erros ⚠️

Por que não temos try/catch?
O valor error.
Panic e Recover.

Dúvidas? 🤔

"Dê-me uma interface e eu moverei o mundo."

Aula 06 - Tratamento de Erros ⚠️

Lidando com Falhas de Forma Idiomática

Agenda de Hoje 📅

Filosofia: Erros como Valores
O Padrão if err != nil
Erros Customizados
O Poder do defer
Panic e Recover
Mini-Projeto: Validador de Senha

1. Por que não Try/Catch? 🚫

Exceções criam fluxos de controle ocultos ("saltos mágicos").
Go prefere o tratamento explícito: "Lide com o erro onde ele ocorre".
Erros são retornos, não interrupções catastróficas.

2. O Padrão Ouro do Go 🏆

f, err := os.Open("arquivo.txt")
if err != nil {
    return fmt.Errorf("falha ao abrir: %w", err)
}
defer f.Close()

Simples, legível e previsível.

3. Defer: Adiar para Garantir ⏱️

Executa no final da função, não importa o que aconteça.
Ideal para limpeza de recursos (Clean-up).

mu.Lock()
defer mu.Unlock() // Destrava no final, aconteça o que acontecer

4. Diferença Crucial ⚖️

Erro (Common)	Panic (Fatal)
Validação de dados	Falta de memória
Arquivo não encontrado	Erro lógico impossível
Timeout de rede	Corrupção de estado

5. Fluxo de Tratamento 📊

graph TD
    A[Inicia Operação] --> B{Erro?}
    B -- Sim --> C[Log e Retorno]
    B -- Não --> D[Continua Fluxo]
    C --> E[Final da Função]
    D --> E

6. Mini-Projeto: Validador de Senha 🚀

Função Validar(senha string) error.
Retorna erros específicos para:
- Senha curta.
- Sem números.

Resumo da Aula ✅

Erros são valores e devem ser verificados.
O defer é seu melhor amigo para evitar vazamento de recursos.
Reserve o panic para o que é realmente fatal.

Próxima Aula: Arquivos e JSON 📁

Lendo e escrevendo no disco.
Serialização com Struct Tags.

Dúvidas? 🤔

"Não apenas trate o erro, dê contexto a ele."

Aula 07 - Manipulação de Arquivos e JSON 📁

Persistindo Dados e Comunicando-se com o Mundo

Agenda de Hoje 📅

O Pacote os e o Sistema de Arquivos
Leitura e Escrita de Arquivos
Permissões de Acesso (Chmod)
Serialização com JSON
Struct Tags e Mapeamento
Mini-Projeto: CLI To-Do com JSON

1. Falando com o SO 🖥️

Go é excelente para ferramentas de linha de comando.
Pacote os abstrai a diferença entre Windows/Linux.

2. Escrita Simplificada ✍️

texto := "Dados do sistema"
err := os.WriteFile("log.txt", []byte(texto), 0644)

0644: Permissão de leitura/escrita padrão.

3. JSON: A Língua do Backend 🏗️

Go possui suporte nativo via encoding/json.
Marshal: Struct -> JSON.
Unmarshal: JSON -> Struct.

4. O Poder das Struct Tags 🏷️

Permite renomear chaves no JSON.

type User struct {
    Nome  string `json:"full_name"`
    Senha string `json:"-"` // Oculta no JSON
}

5. Fluxo de Dados JSON 📊

graph LR
    A[Struct em Memória] -->|json.Marshal| B[Slice de Bytes]
    B -->|os.WriteFile| C[(Arquivo config.json)]
    C -->|os.ReadFile| B
    B -->|json.Unmarshal| A

6. Mini-Projeto: To-Do List CLI 🚀

Uma struct Tarefa (ID, Texto, Status).
Salvar um slice de tarefas em tarefas.json.
Ler e exibir ao abrir o programa.

Resumo da Aula ✅

Go trata arquivos de forma binária ([]byte).
JSON é mapeado diretamente para structs via Tags.
Defer é vital para liberar o arquivo após o uso.

Próxima Aula: Concorrência ⚡

Goroutines: Rodando em paralelo.
Channels: A comunicação segura.

Dúvidas? 🤔

"Dados são o novo petróleo, mas o JSON é o oleoduto."

Aula 08 - Concorrência em Go ⚡

Desbloqueando a Alta Performance

Agenda de Hoje 📅

Concorrência vs Paralelismo
Goroutines: Threads Levíssimas
Canais (Channels): Comunicação Segura
O Poder do select
Sincronização com WaitGroups
Mini-Projeto: Web Crawler Básico

1. Concorrência vs Paralelismo 🧩

Concorrência: Gerenciar múltiplas tarefas (composição).
Paralelismo: Executar tarefas ao mesmo tempo (hardware).
"Go é mestre em lidar com milhares de conexões ao mesmo tempo."

2. Goroutines 🪶

Inicie uma tarefa em background com apenas a palavra go.
Muito Leves: 2KB de RAM inicial.

go processoLongo() // Executa sem travar o main

3. Canais (Channels) 📡

Como as goroutines conversam? Através de "tubos".

canal := make(chan string)

go func() {
    canal <- "Feito!" // Envia
}()

msg := <-canal // Bloqueia até receber

4. CSP: A Filosofia do Go 🧐

"Não comunique compartilhando memória; compartilhe memória comunicando."

Evita Race Conditions (condições de corrida).
Código mais limpo e seguro.

5. Visualização de Canais 📊

graph LR
    G1[Goroutine A] -- envia --> CH((Canal))
    CH -- recebe --> G2[Goroutine B]
    style CH fill:#f9f,stroke:#333

6. Sincronização: WaitGroups 🛑

Como o main sabe que as goroutines terminaram?

var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    // Trabalho...
}()
wg.Wait() // Espera o trabalho acabar

Resumo da Aula ✅

Goroutines permitem escala massiva com pouco recurso.
Canais garantem que os dados troquem de mãos com segurança.
Go foi pensada para o mundo multicore moderno.

Próxima Aula: Programação Web 🌐

Iniciando o Backend Real.
O pacote net/http.

Dúvidas? 🤔

"O paralelismo é sobre execução, a concorrência é sobre estrutura."

Aula 09 - Programação Web com net/http 🌐

Construindo a Base do seu Próprio Servidor

Agenda de Hoje 📅

O Pacote net/http
Handlers: Response vs Request
Roteamento Simples
Middlewares e Interceptação
Servindo Arquivos Estáticos
Mini-Projeto: Contador de Visitas

1. O Servidor Nativo 📡

Go não precisa de Nginx ou Apache para lógica.
Binário independente e de alta performance.

http.ListenAndServe(":8080", nil)

2. Handlers: A Alma da Web 🏗️

func Handler(w http.ResponseWriter, r *http.Request) {
    // w: Onde eu escrevo (Response)
    // r: O que eu recebo (Request)
}

3. Fluxo de uma Requisição 📊

sequenceDiagram
    Cliente->>Servidor: Request (URL, Headers, Body)
    Servidor->>Handler: Processa Lógica
    Handler-->>Servidor: Gera bytes
    Servidor-->>Cliente: Response (Status, JSON/HTML)

4. Middlewares 🛡️

"Camadas de cebola" ao redor do seu código.
Aplicações:
- Logs de acesso.
- Verificação de Autenticação.
- Rate Limiting.

5. Arquivos Estáticos 📁

fs := http.FileServer(http.Dir("./public"))
http.Handle("/", fs)

Simples, direto e seguro.

6. Mini-Projeto: Contador de Visitas 🚀

var count int
func Counter(w http.ResponseWriter, r *http.Request) {
    count++
    fmt.Fprintf(w, "Visitas: %d", count)
}

Resumo da Aula ✅

net/http é tudo que você precisa para começar.
ResponseWriter envia, Request recebe.
Servidores em Go são leves e portáveis.

Próxima Aula: APIs REST Profissionais 🏗️

Modelagem e Camadas.
JSON e Verbos HTTP.

Dúvidas? 🤔

"A Web é feita de requisições e respostas. Go é o mestre de ambas."

Aula 10 - Construindo APIs REST 🏗️

Arquitetura Profissional e Design de Recursos

Agenda de Hoje 📅

O que é REST na Prática?
Verbos HTTP e Semântica
Organização por Camadas (Pattern)
Status Codes: A Linguagem da Resposta
JSON como Contrato
Mini-Projeto: API de Livros

1. REST: Representational State Transfer 🧊

É um estilo de arquitetura para sistemas distribuídos.
Recurso: Tudo o que é Nomeável (Substantivo).
URI: O Identificador único (ex: /usuarios/1).

2. Verbos HTTP: As Ações 🎬

Verbo	Ação	Ideal para...
GET	Ler	Listar ou buscar um item.
POST	Criar	Inserir novo dado.
PUT/PATCH	Atualizar	Alterar dados existentes.
DELETE	Remover	Apagar um recurso.

3. Organização Profissional 📂

"Separe quem recebe o dado de quem decide o que fazer com ele."

Handlers: Tratam o HTTP.
Services: Regras de Negócio.
Models/Entity: A cara do dado.
Repository: Acesso ao Banco de Dados.

4. Diagrama de Camadas 📊

graph TD
    Client[Browser/Postman] --> Handler[Handler/Controller]
    Handler --> Service[Service/Business]
    Service --> Repo[Repository/DB]
    Repo --> Data[(Banco de Dados)]

5. Status Codes: O Feedback 🚦

2xx: Sucesso (200 OK, 201 Created).
4xx: Erro do Cliente (400 Bad Request, 404 Not Found).
5xx: Erro do Servidor (500 Internal Error).

6. Mini-Projeto: API de Livros 🚀

Criar estrutura de pastas.
Implementar Listagem e Cadastro.
Separar Structs em um pacote models.

Resumo da Aula ✅

REST usa o protocolo HTTP de forma inteligente.
Camadas facilitam a manutenção e testes.
URIs devem ser substantivos, não verbos.

Próxima Aula: Framework Gin 🚀

Desenvolvimento ultra-rápido.
Validação automática de JSON.

Dúvidas? 🤔

"Uma boa API é aquela que se explica sozinha."

Aula 11 - Framework Web Gin 🚀

Acelerando o Desenvolvimento Backend

Agenda de Hoje 📅

Por que usar Frameworks?
Introdução ao Gin Gonic
Roteamento e Parâmetros
JSON Binding e Validação
Grupos de Rotas e Organização
Mini-Projeto: API de Clientes

1. Gin: O Motor de Performance 🏍️

Um dos frameworks mais rápidos do mundo Go.
Sintaxe amigável (estilo Martini/Sinatra).
Gopher Friendly: Foca na produtividade.

r := gin.Default()
r.Run()

2. O Contexto do Gin 📦

c *gin.Context é o seu canivete suíço.
Captura Params, Query, Body e Response.

id := c.Param("id")
status := c.Query("status")

3. Roteamento Limpo 📍

v1 := r.Group("/v1")
{
    v1.POST("/login", loginHandler)
    v1.GET("/perfil", perfilHandler)
}

Aplique Middlewares apenas em grupos específicos.

4. Validação Inteligente 🛡️

Use as Struct Tags a seu favor.

type User struct {
    Email string `json:"email" binding:"required,email"`
    Idade int    `json:"idade" binding:"gte=18"`
}

Gin valida e retorna erro 400 automaticamente.

5. Hierarquia Gin 📊

graph TD
    Engine[Gin Engine] --> Router[Router Group]
    Router --> Middleware[Log/Auth]
    Middleware --> Handler[Business Func]
    Handler --> Context[Gin Context]

6. Mini-Projeto: API de Clientes 🚀

Criar rota POST /clientes.
Validar entrada de e-mail.
Retornar JSON com sucesso ou erro detalhado.

Resumo da Aula ✅

Gin automatiza as tarefas chatas (binding, roteamento).
Grupos de rotas mantêm o projeto organizado.
Validação via Tags evita código boilerplate de if.

Próxima Aula: Banco de Dados com GORM 💾

Persistência real.
Migrations Automáticas.

Dúvidas? 🤔

"Não reinvente a roda, use um motor potente. Use Gin."

Aula 12 - Banco de Dados (GORM) 💾

Persistência de Dados Profissional em Go

Agenda de Hoje 📅

SQL Puro vs ORM
Introdução ao GORM
Models e Auto-Migrations
Operações de CRUD
Relacionamentos (Has One, Has Many)
Mini-Projeto: API com Banco Real

1. O que é um ORM? 🗺️

Object-Relational Mapping.
Traduz Tabelas ↔ Structs.
Abstrai o SQL para funções Go.

2. Definindo Modelos 🏗️

type Produto struct {
    gorm.Model // ID, Created, Updated, Deleted
    Nome  string `gorm:"size:100;not null"`
    Preco float64
}

Tags controlam o comportamento do SQL.

3. Auto-Migrations 📈

Não escreva CREATE TABLE manual!

db.AutoMigrate(&Produto{})

O GORM sincroniza seu código com o banco.

4. O Ciclo do CRUD 📝

Create: db.Create(&p).
Read: db.First(&p, 1) ou db.Find(&lista).
Update: db.Model(&p).Update("Preco", 100).
Delete: db.Delete(&p).

5. Arquitetura DB 📊

graph LR
    App[Código Go] -->|Struct| ORM[GORM]
    ORM -->|SQL| Driver[SQLite Driver]
    Driver -->|Disk| File[(test.db)]

6. Mini-Projeto: API Persistente 🚀

Integrar Gin + GORM.
Salvar dados enviados pelo Postman no SQLite.
Garantir que dados existam após reiniciar.

Resumo da Aula ✅

GORM traz velocidade e segurança ao lidar com SQL.
gorm.Model padroniza seus registros.
Migrations automáticas eliminam erros de script manuais.

Próxima Aula: Testes em Go ✅

Garantindo que a API não quebre.
Testes Unitários e Table-Driven.

Dúvidas? 🤔

"Quem não persiste, não existe. No banco de dados e na vida."

Aula 13 - Testes em Go ✅

Garantindo a Qualidade e Estabilidade do seu Código

Agenda de Hoje 📅

Por que testar é vital?
O comando go test
Testes Unitários Básicos
Table-Driven Tests (Idiomático)
Cobertura e Performance
Mini-Projeto: TDD na Prática

1. O Suporte Nativo 🧪

Go não precisa de frameworks externos (como Jest ou JUnit).
Pacote testing e comando go test fazem tudo.
Sufixo obrigatório: _test.go.

2. Testes de Tabela (Professional) 📊

Teste múltiplos cenários com um único loop.

tests := []struct {
    a, b, want int
}{
    {1, 1, 2},
    {2, 2, 4},
    {-1, 1, 0},
}

3. Cobertura de Testes 📈

Quanto do seu código está realmente protegido?

$ go test -cover
coverage: 87.5%

Gere relatórios HTML visuais para análise.

4. Mocking de API 🎭

Teste Handlers sem subir o servidor.
Pacote net/http/httptest.

graph LR
    Test[Test Code] -->|Fake Req| Handler[Handler]
    Handler -->|Record| res[ResponseRecorder]
    res -->|Verify| Test

5. Benchmarks: Medindo Velocidade ⚡

Teste o tempo de execução e alocação de memória.

func BenchmarkProcesso(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Processo()
    }
}

6. Mini-Projeto: TDD na Prática 🚀

Inverter uma string.
Passo 1: Criar o teste (FAIL).
Passo 2: Codar a função.
Passo 3: Testar novamente (PASS).

Resumo da Aula ✅

Testes em Go são simples e rápidos.
Table-driven tests evitam duplicação de lógica.
Cobertura alta = Dormir tranquilo.

Próxima Aula: Arquitetura Limpa 🏗️

Injeção de Dependência.
Organizando grandes projetos.

Dúvidas? 🤔

"Testes não evitam bugs, eles evitam que os mesmos bugs voltem."

Aula 14 - Arquitetura e Boas Práticas 🏗️

Criando Sistemas Escaláveis e Fáceis de Manter

Agenda de Hoje 📅

O Caos vs Organização
Clean Architecture em Go
Injeção de Dependência
Estrutura de Pastas (Padrão)
Visibilidade e o pacote internal
Mini-Projeto: Refatorando para DI

1. Clean Architecture 🧊

Mantra: Independência de Framework e Banco.
O código de negócio deve ser puro Go.

graph TD
    UI[Handlers] --> UC[UseCases]
    UC --> EN[Entities]
    UC --> DB[Repositories]

2. Injeção de Dependência (DI) 💉

Não deixe a struct criar seu próprio Repository.
Dê o repositório para ela (via construtor).

func NewService(r Repository) *Service {
    return &Service{repo: r}
}

3. O Pacote `internal` ⚔️

Protege o seu código de "vazar".
Apenas pacotes dentro do módulo podem importá-lo.
Ideal para: Lógica de banco e regras internas.

4. Estrutura de Pastas Profissional 📂

$ tree
.
├── cmd/        # Entrypoints
├── internal/   # Core (Business)
├── pkg/        # Shared Libs
└── api/        # Docs/OpenAPI

5. Boas Práticas (Cringe Free) ✨

Pacotes com nomes curtos: user, auth.
Sem utils ou helpers genéricos.
Retornos concretos, entradas abstratas.

6. Mini-Projeto: Refatorando 🚀

Isolar a struct Livro em entitites.
Criar interface LivroRepository.
Fazer o Handler receber a interface.

Resumo da Aula ✅

Clean Arch foca no que Realmente Importa (Negócio).
Injeção de Dependência facilita Testes Unitários.
Estrutura de pastas reflete a maturidade do time.

Próxima Aula: Docker e Deploy 🐳

Indo para o mundo real.
Containers e Infra.

Dúvidas? 🤔

"A arquitetura é o que permite que você mude de ideia depois."

Aula 15 - Docker e Deploy 🐳

Do Código Local para a Infraestrutura Moderna

Agenda de Hoje 📅

O que é Containerização?
Dockerfile para Go
Multi-Stage Builds (Otimização)
Docker Compose: Multi-Serviços
CI/CD e Fluxo de Deploy
Mini-Projeto: API no Container

1. Por que Docker + Go? 🦦

Go gera binários estáticos.
Docker garante bibliotecas de sistema e rede.
Resultado: "Build once, run anywhere".

2. Dockerfile Inteligente 🏗️

# Estágio de Build
FROM golang:alpine AS builder
WORKDIR /app
COPY . .
RUN go build -o app

# Estágio Final (Lightweight)
FROM alpine:latest
COPY --from=builder /app/app .
CMD ["./app"]

3. Comparativo de Tamanho 📏

Imagem com Go SDK: ~300MB.
Imagem Final (Alpine): ~12MB.
Benefício: Deploy mais rápido e seguro.

4. Orquestração com Compose 🎼

services:
  api:
    build: .
    ports: ["8080:8080"]
    depends_on: [db]
  db:
    image: postgres:alpine

5. Fluxo de Vida 📊

graph LR
    Code[Go Code] -->|Build| Bin[Binary]
    Bin -->|Containerize| Img[Docker Image]
    Img -->|Push| Reg[Registry]
    Reg -->|Pull| Prod[Production]

6. Mini-Projeto: API no Container 🚀

Criar Dockerfile.
Rodar docker build -t minha-api ..
Rodar docker run -p 8080:8080 minha-api.
Testar via Postman.

Resumo da Aula ✅

Multi-stage build é obrigatório para eficiência.
Docker Compose facilita o setup do desenvolvedor.
Variáveis de ambiente são a forma correta de configurar.

Próxima Aula: Projeto Final 🏆

Juntando tudo.
Desafio Completo.

Dúvidas? 🤔

"Um container é uma promessa de que o código vai rodar."

Aula 16 - Projeto Final: Sistema de Biblioteca 🏆

Consolidando o Conhecimento do Gopher

O Desafio Final 🚩

Construir uma API de Gerenciamento de Biblioteca.
Funcionalidades:
- CRUD de Livros e Usuários.
- Lógica de Empréstimo (Disponibilidade).
- Relatórios Simples.

Requisitos Técnicos 🛠️

Framework Gin.
Banco PostgreSQL (GORM).
Clean Architecture (Camadas).
Docker & Docker Compose.
Testes Unitários.

Estrutura de Domínio 📊

erDiagram
    LIVRO ||--o{ EMPRESTIMO : possui
    USUARIO ||--o{ EMPRESTIMO : faz

Dicas para o Sucesso 💡

Comece pelas Entities.
Implemente o Repository e teste o banco.
Crie o Service com a regra de empréstimo.
Finalize com os Handlers e as rotas.

Avaliação de Qualidade ✅

Código limpo (Go Fmt).
Sem variáveis globais.
Tratamento correto de erros (err != nil).

Conclusão da Jornada 🏁

Você dominou o básico e o intermediário do Go.
Está apto a criar microserviços escaláveis.
Bem-vindo à comunidade Gopher! 🐹🚀

Próximos Passos 🚀

Explore Generics (Go 1.18+).
Estude Microsserviços com gRPC.
Contribua com projetos Open Source.

Parabéns! 🎓🏆

"O fim de um curso é apenas o começo de uma carreira."

Configuração

Ambientes de Desenvolvimento 🛠️

Guias para configurar seu computador para o desenvolvimento mobile.

Android --- Instalação do Android Studio, SDK e emuladores.
- Setup 01 - Android Studio
iOS (Opcional/Referência) --- Configuração básica de Xcode e ferramentas Mac.
- Setup 02 - Xcode Foundation
Ferramentas de Apoio --- Git, Terminais e Postman/Insomnia para testes de API.
- Setup 03 - Tools

Setup 01: Android Studio 🤖

O Android Studio é a IDE oficial para o desenvolvimento Android.

1. Requisitos de Sistema

RAM: Mínimo 8GB (Sugerido 16GB+).
Espaço: Mínimo 10GB para IDE + SDKs.
Processador: Intel Core i5 ou equivalente.

2. Instalação

Acesse o site oficial: developer.android.com/studio.
Baixe a versão mais recente para o seu Sistema Operacional.
Execute o instalador e escolha a opção "Standard" na configuração inicial.

3. Configurando o SDK

Após a instalação, vá em Settings > Languages & Frameworks > Android SDK.
Certifique-se de que a versão mais recente do Android (estável) esteja instalada.
Na aba SDK Tools, instale o "Android Emulator" e o "Intel x86 Emulator Accelerator (HAXM)" se estiver no Windows com Intel.

4. Criando um Emulador (AVD)

Abra o Device Manager.
Clique em Create Device.
Escolha um dispositivo (ex: Pixel 7).
Selecione uma imagem de sistema (ex: Level 34 - Android 14).
Finalize e clique no "Play" para iniciar o celular virtual.

5. Solução de Problemas ⚠️

VT-x is disabled: Você precisa habilitar a virtualização na BIOS do seu computador.
Studio muito lento: Adicione a pasta do projeto e as pastas do Android SDK nas exclusões do seu Antivírus.

Setup 02: Xcode (iOS Foundation) 🍎

O Xcode é a ferramenta necessária para compilar e testar apps iOS.

[!IMPORTANT] O Xcode requer um computador Mac (macOS).

1. Instalação

Abra a App Store no seu Mac.
Pesquise por Xcode.
Clique em Obter/Instalar.
Após o download, abra o Xcode para carregar os componentes adicionais do macOS.

2. Configurando Simuladores

Vá em Settings > Platforms.
Verifique se o componente "iOS" está baixado.
Se não estiver, clique em "GET" para baixar a versão mais estável.

3. Comandos de Linha (CLI)

Para que ferramentas de automação funcionem, você precisa instalar os Command Line Tools:

xcode-select --install

4. Opcional: CocoaPods

Muitos projetos iOS antigos ainda usam CocoaPods para dependências:

sudo gem install cocoapods

5. Solução de Problemas ⚠️

Espaço em Disco: O Xcode é muito grande. Garanta pelo menos 40GB de espaço livre para ele e os simuladores.
Build Lento: Use simuladores de modelos mais simples (ex: iPhone SE) para poupar memória RAM se necessário.

Sobre

Sobre o Curso

🎓 APIs e Microsserviços Profissionais

Este curso foi projetado para capacitar desenvolvedores na criação de arquiteturas distribuídas modernas, focando na integração entre backends escaláveis e frontends dinâmicos do tipo SPA.

🎯 Objetivos do Curso

Arquitetura Distribuída --- Compreender a transição de monólitos para microsserviços e a importância da comunicação eficiente entre serviços.
Domínio de APIs REST --- Dominar a modelagem, implementação e documentação de APIs seguindo as melhores práticas do mercado.
Segurança Avançada --- Implementar sistemas de autenticação e autorização robustos utilizando JWT e controle de acesso baseado em perfis.
Frontend Moderno (SPA) --- Desenvolver interfaces ricas e reativas, conectando-as perfeitamente ao ecossistema de APIs backend.

📚 O Que Você Vai Aprender

Módulo 1 – Serviços e Microsserviços

Conceitos de Microsserviços vs Monólitos
Arquitetura e API Gateways
Modelagem de APIs RESTful
Documentação com Swagger e Mocks

Módulo 2 – Manipulação de Dados

Implementação de Endpoints (Backend)
Persistência com ORM e SQL
Testes Unitários com Mocks
Testes Integrados e Deploy

Módulo 3 – Autenticação e Segurança

Estratégias Web (Cookies vs Tokens)
Implementação de JWT
Criptografia e Proteção de Rotas
Autorização RBAC (Perfis)

Módulo 4 – Aplicações Web SPA

Conceitos de SPA e Renderização
Componentização e Templates
Gerenciamento de Estados e Eventos
Roteamento e Projeto Integrador

🛠️ Metodologia

Foco 100% prático e orientado a projetos. Cada módulo culmina em uma etapa funcional de um sistema completo, garantindo que ao final do curso você tenha um portfólio robusto de arquitetura fullstack.

Pronto para dominar o Backend? Começar Agora

Roadmap do Projeto: APIs e Microsserviços 🚀

Este documento rastreia a evolução do curso.

✅ Fase 1: Planejamento (Concluído)

[x] Definição Syllabus (16 Aulas)
[x] Estrutura Backend-first com integração SPA
[x] Configuração MkDocs Material

✅ Fase 2: Conteúdo Base (Concluído)

[x] Criação das 16 Aulas (Markdown)
[x] Criação dos 16 Quizzes (HTML)
[x] Criação dos 16 Conjuntos de Exercícios
[x] Criação dos 16 Slides (RevealJS)

✅ Fase 3: Projetos e UX (Concluído)

[x] Definição dos 16 Projetos práticos
[x] Documentação Swagger/OpenAPI integrada
[x] Diagramação Mermaid de arquitetura de serviços

🚀 Fase 4: Lançamento e Manutenção

[x] Deploy GitHub Pages (GitHub Actions)
[ ] Atualização para novas versões de frameworks (Spring/Node/React)
[ ] Inclusão de exemplos de mensageria (RabbitMQ/Kafka)

Status Atual: Finalizado / Manutenção Última Atualização: 19/02/2026

Materiais Complementares 📚

Bem-vindo à seção de materiais complementares do curso de APIs e Microsserviços. Aqui você encontra recursos adicionais para apoiar seus estudos e aprofundar seu conhecimento técnico.

Slides
- Acompanhe o conteúdo teórico com slides dinâmicos.
Exercícios
- Pratique a implementação de microsserviços e rotas REST.
Quizzes
- Valide seu aprendizado com testes rápidos por módulo.
Projetos
- Construa um ecossistema completo para seu portfólio.
Ambiente
- Guias de instalação (Docker, IDEs, Postman).

Versão para Impressão

Esta página foi gerada automaticamente para impressão.

🤖 Spec Sistemas com Golang

🧭 Atalhos Rápidos

🗺️ Mapa da Jornada

Aulas

Aula 01 - Introdução ao Go e Ecossistema 🐹

1. O que é Go? 🚀

🏛️ Os Pilares da Linguagem

2. Por que escolher Go? ⚖️

Onde o Go brilha? (Mermaid)

3. Instalação e Setup 🛠️

4. Estrutura de um Programa Go 📂

5. Seu Primeiro Programa: "Hello, World" 🚀

6. Mini-Projeto: Dashboard do Sistema 📊

7. Exercícios de Fixação 🧠

Aula 02 - Fundamentos da Linguagem 🧱

1. Variáveis e Constantes 📦

Declaração Explícita vs Curta

2. Tipos Primitivos 💎

3. Estruturas Condicionais 🚦

If / Else

Switch

4. Estruturas de Repetição 🔁

For Tradicional

For como "While"

5. Visualização de Fluxo (Mermaid) 📊

6. Mini-Projeto: Calculadora de IMC 🚀

7. Exercícios de Fixação 🧠

Aula 03 - Funções e Organização do Código 🧩

1. Funções em Go ⚙️

Sintaxe Básica e Múltiplos Retornos

Funções Variádicas

2. Ponteiros: Onde mora o dado? 📍

3. Organização Profissional: Pacotes e Módulos 📂

4. Visualização de Estrutura de Projeto (Termynal) 📂

5. Fluxo de Execução (Mermaid) 📊

6. Mini-Projeto: Conversor de Medidas Modular 🚀

7. Exercícios de Fixação 🧠

Aula 04 - Estruturas de Dados Avançadas 🗄️

1. Arrays vs Slices 🍕

Arrays (Tamanho Fixo)

Slices (Tamanho Dinâmico)

2. Maps: Chave e Valor 🗝️

3. Structs: Criando seus Próprios Tipos 🏗️

Métodos Associados

4. Visualização de Memória (Mermaid) 📊

5. Exemplo de Manipulação (Termynal) 💻

6. Mini-Projeto: Sistema de Gerenciamento de Alunos 🚀

7. Exercícios de Fixação 🧠

Aula 05 - Interfaces e Programação Orientada a Composição 🧩

1. O que são Interfaces? 🔌

Exemplo: A Interface Som

2. Polimorfismo na Prática 🎭

3. Composição: O "Jeito Go" de Reutilizar Código 🏗️

4. Princípios SOLID em Go 🛡️

5. Visualização de Composição (Mermaid) 📊

6. Mini-Projeto: Sistema de Pagamentos Diversos 🚀

7. Exercícios de Fixação 🧠

Aula 06 - Tratamento de Erros ⚠️

1. Erros não são Exceções! 🧊

O Padrão if err != nil

2. Criando Erros Customizados 🛠️

3. Panic e Recover 🚨

4. Diferenciando Erros de Panics (Mermaid) 📊

5. Boas Práticas de Erro 💡

6. Mini-Projeto: Sistema de Validação de Senha 🚀

7. Exercícios de Fixação 🧠

Aula 07 - Manipulação de Arquivos e JSON 📁

1. Lendo e Escrevendo Arquivos ✍️

Escrita Simples

Leitura Simples

2. Trabalhando com JSON 🏗️

Serialização (Struct -> JSON)

Desserialização (JSON -> Struct)

3. Fluxo de Dados (Mermaid) 📊

4. Manipulação via Terminal (Termynal) 💻

5. Encoder e Decoder 🚀

6. Mini-Projeto: CLI To-Do List 🚀

7. Exercícios de Fixação 🧠

Aula 08 - Concorrência em Go ⚡

1. Concorrência vs Paralelismo 🧩

Exemplo: A Interface `Som`

O Padrão `if err != nil`

Exemplo: `calculadora_test.go`