Python é Fácil. Go é Simples. Simples != Fácil
Defensores de Go e Python entram em choque sobre se linguagens “simples” ou “fáceis” levam a software melhor no longo prazo. O Go é elogiado por estilo uniforme, compilação rápida, binários estáticos e adequação a projetos grandes e multi-equipes, mas criticado por verbosidade, tratamento manual de erros, abstrações fracas e armadilhas relacionadas a nulos. O Python é valorizado por seu ecossistema rico, curva de aprendizado rápida e sintaxe expressiva, mas muitos apontam o gerenciamento frágil de dependências, limites de desempenho e a crescente complexidade à medida que sua popularidade e conjunto de recursos aumentaram.
Boilerplate do Go, tratamento de erros e verbosidade
- Muitos consideram o boilerplate do Go (especialmente
if err != nil) tedioso e visualmente poluído; outros o veem como explícito, previsível e fácil de escanear. - O tratamento de erros é debatido: os defensores preferem retornos explícitos em vez de exceções; os críticos observam que o Go não obriga a checagem de erros e pode continuar silenciosamente com dados errados.
- Ferramentas como
go vet, linters e ErrCheck são recomendadas para detectar erros não verificados, mas céticos argumentam que depender de ferramentas junto com boilerplate é frágil. deferé apreciado, mas o comportamento com escopo de função torna padrões como “defer em um loop” estranhos; alguns gostariam que fosse com escopo de bloco.
Simplicidade vs expressividade do Go
- Defensores argumentam que o Go é “simples, não fácil”: recursos limitados, compilação rápida, compatibilidade binária estável e estilo uniforme entre bases de código.
- Críticos dizem que a simplicidade é excessiva: a ausência de tipos soma, enums robustos, tipos não anuláveis, propagação de erros mais ergonômica e uma stdlib mais rica leva a padrões verbosos e propensos a erros (múltiplos
min,filter, etc. feitos sob medida). - Generics e adições recentes à stdlib (por exemplo,
slices,maps,min/max) melhoram as coisas, mas chegaram tarde.
Go em projetos e equipes grandes
- Defensores afirmam que o Go escala bem para bases de código grandes, duradouras e multi-equipes: o código “parece o mesmo”, o desempenho é “bom o suficiente” e tipagem estática com concorrência simples é uma vantagem.
- Contraexemplos: bases de código grandes em Go podem ser profundamente abstratas com interfaces e métodos pequenos, tornando-se “camadas de cebola” ao estilo Java. O uso excessivo de
interface{}e truques inseguros pode causar quebras não locais. - Alguns relatam sistemas em Go com milhões de linhas de código como pesadelos; outros dizem que qualquer projeto com milhões de linhas de código é doloroso, independentemente da linguagem.
A facilidade do Python e seu ecossistema vs fundamentos
- Python é elogiado pela baixa barreira de entrada, sintaxe concisa, bibliotecas ricas (especialmente para ML/dados) e produtividade para scripts e aplicações pequenas/médias.
- As críticas incluem: fricção em empacotamento e implantação, incompatibilidades em tempo de execução entre versões, desempenho, problemas com tipagem dinâmica/duck typing, monkey patching e tipagem “colada depois”.
- Alguns argumentam que ferramentas como mypy e virtualenv mitigam muitos problemas; outros dizem que os problemas centrais (anulabilidade, falta de tipos soma, velocidade) permanecem.
Simples vs fácil, e alternativas
- A dicotomia “Simple vs Easy” (via Rich Hickey) é invocada repetidamente: o Go mira simplicidade; o Python, facilidade; Clojure e linguagens FP são sugeridas como “simples” num sentido mais profundo, mas com curvas de aprendizado mais íngremes e ecossistemas mais fracos.
- Vários concluem que a escolha da linguagem deve priorizar runtime, ferramentas e ecossistema em vez da pureza do design da linguagem.