Rust mudou-me como desenvolvedor

A ênfase do Rust em tipagem forte, ownership e tipos soma é retratada como um catalisador para repensar o design de programas, o tratamento de erros e a programação defensiva em comparação com C, C++ e linguagens com garbage collection. Os comentaristas ampliam isso para um ponto mais geral: enfrentar projetos substanciais em múltiplos paradigmas de linguagem (família ML, Lisp, Erlang/BEAM, HDLs, linguagens de arrays, etc.) muda fundamentalmente a forma como desenvolvedores modelam problemas, mesmo que muitas ideias “modernas” já existissem muito antes do Rust. Outros questionam o quanto esse aprendizado profundo de linguagens ainda importa numa era de codificação assistida por LLMs, mas muitos argumentam que entender os conceitos e trade-offs subjacentes — segurança versus poder, nulabilidade explícita, design de macros e de sistema de tipos — continua crucial para software robusto.

Aprender entre famílias de linguagens

  • Muitos argumentam que fazer um projeto substancial em cada grande paradigma de linguagem (Lisp, ML/FP, OO, lógica, array, HDL, Forth, etc.) remodela a forma como você pensa, independentemente de Rust especificamente.
  • “Projeto grande” é definido de várias formas: ~10k LOC, algo que você não consegue manter na cabeça, que dura mais de um mês, ou que está sob pressão e mudança reais. Outros dizem que até projetos menores, mas não triviais (por exemplo, resolvedor de Sudoku, servidor HTTP de brinquedo, sistema de chat), são valiosos.
  • Alguns contestam que você não precisa de “toda” família; outros relatam que tentar muitas linguagens (Erlang/BEAM, Haskell, Elixir, HolyC, linguagens de arrays, HDLs) foi singularmente ampliador de horizontes.

O sistema de tipos do Rust, enums e comparações

  • Vários observam que muitas “inovações” do Rust (tipos soma, pattern matching, tipagem estática forte) já existiam há muito tempo em linguagens da família ML e em Haskell.
  • Tipos soma são amplamente elogiados: qualquer linguagem sem eles “parece empobrecida” para alguns.
  • Debate detalhado sobre enums do Rust vs. o estilo Zig/Ada de “tag separada + union/variant record”:
    • Críticos: Rust mistura tag e payload; você não pode reutilizar tipos de discriminante nem referir-se ao “tipo” sem dados, levando a soluções improvisadas (macros, enums separados para manter em sincronia).
    • Defensores: você pode modelar isso com traits, generics, tipos unit/never, std::mem::discriminant e macros; a separação é de nicho e, em grande parte, solucionável com ferramentas, embora mais verbosa.

Tratamento de erros, nulls e cultura de segurança

  • Rust é elogiado por forçar o tratamento explícito de falhas (Option, Result, newtypes), tratando erro humano como algo esperado em vez de uma “falha de habilidade”.
  • Alguns comparam isso ao que testes unitários e recursos antigos de linguagem sempre tentaram fazer: conter erros mais cedo.
  • Debate sobre null vs. opcionais:
    • Alguns afirmam que null não deveria existir e que opcionais são um “hack irritante”; outros argumentam que opcionais são a forma principiada de representar “valor ou nada”, enquanto null/padrões sentinela escondem estados do sistema de tipos e são propensos a bugs.
    • Valores sentinela como string vazia ou 0 como “não definido” são amplamente criticados por serem inseguros e ambíguos.
  • Há desacordo sobre ergonomia de sintaxe: cadeias explícitas de Option / mônadas versus operadores de coalescência de null; alguns preferem brevidade, outros clareza e análise/validação antecipadas.

História, hype e mudança de contexto (LLMs, era C, etc.)

  • Vários enfatizam conhecer a história: muitas ideias do Rust o precedem; o hype às vezes apaga trabalhos anteriores (ML, Scala, PL/I, compiladores antigos, etc.).
  • Alguns veem Rust como parte de uma longa tendência de “poder sem verificações” (C nos anos 80) em direção a maior segurança e abstrações; limitações de hardware que motivaram o design de C são menos relevantes hoje.
  • Alguns questionam se epifanias de linguagem ainda importam em um mundo dominado por LLMs, enquanto outros insistem que compreensão profunda e múltiplos paradigmas continuam valiosos, de forma análoga a aprender matemática avançada apesar das calculadoras.

Linguagens, pensamento e ferramentas

  • Vários comentários conectam linguagem e pensamento (Sapir–Whorf / relatividade linguística), argumentando que isso é ainda mais verdadeiro para linguagens de programação do que para as naturais, devido às diferenças muito maiores de expressividade.
  • Outros enquadram linguagens como ferramentas: a “certa” inclui o que os colegas sabem e o que leva a modelos mais claros, não apenas o que é teoricamente poderoso.