Go mental model: simplicity first
Go é uma linguagem pequena de propósito
| O que Go NÃO tem | O que se usa no lugar | O que se ganha |
|---|---|---|
| Herança de classe | Composição por embutimento e interfaces pequenas | Hierarquia não engessa: o tipo satisfaz o contrato sem declarar nada |
| Exceções | Erro como valor de retorno | A falha aparece na assinatura — quem chama não consegue ignorá-la por descuido |
| Sobrecarga de função | Nomes distintos, ou variádicos | Ler a chamada basta para saber qual função executa |
| Anotação de nulidade | Valor zero útil por tipo | Struct recém-criada já é utilizável, sem construtor obrigatório |
| Macros e metaprogramação | Geração de código explícita | O que roda é o que está escrito no arquivo — nada é sintetizado em compilação |
A spec de Go cabe em uma tarde. Não há herança, não há method overloading, não há generics complexos (os que existem são restritos), não há exceptions. Cada ausência foi decidida — a aposta é que código uniforme é mais produtivo em times grandes do que código expressivo em times pequenos.
Hello Go idiomático
package main
import (
"fmt"
"os"
)
func main() {
if len(os.Args) < 2 {
fmt.Fprintln(os.Stderr, "uso: hello <nome>")
os.Exit(1)
}
fmt.Printf("olá, %s\n", os.Args[1])
}Sem classe. Função main é entry. Import explícito. Erro tratado com early return. Esse estilo se estende para programas de 100 mil linhas.
Módulos e layout
go mod init github.com/ffv/orders
# cria go.mod
# layout convencional
orders/
├── go.mod
├── go.sum
├── cmd/
│ └── orders/
│ └── main.go # entry point
├── internal/ # privado ao módulo
│ ├── order/
│ │ ├── order.go
│ │ └── order_test.go
│ └── http/
│ └── handler.go
└── pkg/ # exportável (opcional)
└── pricing/
└── pricing.gointernal/ é regra do compilador: pacotes dentro só podem ser importados pelo próprio módulo. Excelente para esconder detalhe e não poluir a API pública.
Convenções que valem como regra
// gofmt/goimports é obrigatório — roda no save
// Nomes curtos em escopo pequeno: i, ctx, err
// ExportedNames em CamelCase, unexported em camelCase
// Interfaces com sufixo -er: Reader, Writer, Closer
// Errors minúsculo: "file not found", não "File Not Found."
// Comment em todo Exported começa com o nome
// New cria um servidor configurado com timeouts padrão.
func NewServer(addr string) *Server { ... }Qual princípio de projeto explica a maior parte das decisões dessa linguagem?
O que Go não tem (e por quê)
// Sem classes → struct + funções/methods
// Sem herança → composition via embedding
// Sem exceptions → erros como valores
// Sem overloading → nome explícito (Dial vs DialContext)
// Sem ternário → if/else explícito
// Sem macros → gerar código com 'go generate' se precisarQuem chega de Java/C# sente falta das features. Resista à vontade de reintroduzir padrões de outras linguagens — o idiomático Go costuma ser mais direto quando você aceita a restrição.
O que você leva desse módulo
Go aposta em simplicidade como feature. Módulos, gofmt, structure internal/ e convenção de nomes são a base. Os próximos módulos mostram como essa simplicidade escala em concorrência, erro e generics.
Perguntas frequentes
❓ Qual é a filosofia do Go, na prática?
❓ Por que o Go não tem exceções?
❓ Composição em vez de herança funciona?
Fixando
Como o tratamento de erro difere do modelo de exceções?
O que a interface implícita muda na organização do código?
Terminou de ler?
Marcar como concluído registra o XP, mantém sua sequência e coloca 3 cartas deste módulo na fila de revisão espaçada.
Próximos passos sugeridos
Temas deste módulo
Discussão
Carregando comentários…