Quando o criador de uma linguagem e seus “donos” discordam fortemente [pdf]

Uma tentativa fracassada de adicionar “contracts” ao próximo padrão C++26 expôs profundas divisões entre o criador original da linguagem, o comitê de padrões ISO e a comunidade C++ mais ampla. Comentadores debatem quem realmente “possui” uma linguagem de programação — o órgão de padrões, os implementadores ou os usuários — e se a evolução conduzida por comitê está produzindo uma linguagem excessivamente complexa e insegura, em comparação com opções mais novas como Rust ou Zig. O episódio é visto como um teste para a viabilidade de longo prazo do C++, os limites da compatibilidade retroativa e como linguagens de programação devem ser governadas em uma era de hardware multicore e desenvolvimento assistido por IA.

Propriedade da linguagem e governança

  • Debate sobre se alguém “possui” uma linguagem:
    • Um lado: o comitê de padrões “possui” o padrão e, portanto, o futuro da linguagem; um órgão governante evita divergência ou estagnação.
    • Outro lado: eles só possuem o documento; a propriedade real está com os implementadores de compiladores e os usuários, que podem ignorar o padrão quando ele é impraticável.
  • Discussão sobre modelos de comitê versus “ditador benevolente vitalício” (BDFL):
    • Pró-BDFL: produz um design mais coerente e unificado; o design por comitê gera esquisitices e complexidade.
    • Anti-BDFL: não escala nem sobrevive à aposentadoria/morte; linguagens bem-sucedidas migraram para conselhos ou governança mais distribuída.

Complexidade do C++, curva de aprendizado e design

  • Vários participantes descrevem tentar aprender C++ moderno e desistir, citando:
    • Múltiplas formas sobrepostas de fazer as coisas (ponteiros, iteração, contêineres, algoritmos).
    • Evolução constante e bagagem histórica; sensação de “escavação arqueológica”.
  • Outros argumentam:
    • Você só precisa de um subconjunto; trate C++ como uma caixa de ferramentas e adicione recursos conforme necessário.
    • Muitas linguagens têm cicatrizes de legado; o C++ apenas as torna mais visíveis e amplamente usadas.
  • Há desacordo sobre quantos tipos de ponteiro/referência um novato precisa manter na cabeça e se “nenhum ponteiro a menos que necessário” é realista.

Recurso de contratos e impasse do C++26

  • A thread se concentra fortemente na proposta de contracts e na votação fracassada do C++26:
    • As objeções do criador ao design atual (por exemplo, semântica, falta de implementação, falta de uso no mundo real) são amplamente vistas como substantivas.
    • Alguns veem contracts como desnecessários em comparação com verificações do tipo assert já existentes.
  • Caminhos propostos: pular o C++26, abandonar contracts, ajustar contracts (por exemplo, execução garantida), votar novamente ou afastar a padronização da ISO.
  • Desacordo sobre “execução garantida”:
    • Pró: necessária para confiabilidade em bases de código mistas e bibliotecas endurecidas.
    • Contra: pode ser caro demais ou disruptivo; compiladores e ferramentas não estão prontos.

Segurança, Rust e outras linguagens

  • Crítica forte de que C++ é inerentemente inseguro e inadequado para um mundo de exploração disseminada e caça automatizada de bugs.
  • Contra-argumentos:
    • Idiomas e ferramentas modernos (incluindo LLMs) podem encontrar e corrigir muitos bugs.
    • Linguagens de sistemas alternativas (por exemplo, Rust) também são complexas e dependem de unsafe em domínios difíceis.
  • Alguns argumentam que, se redesenhado do zero, grande parte da complexidade do C++ não seria necessária.

Concorrência e hardware

  • Menção ao argumento clássico de que “a festa grátis acabou” e ao papel do C++ na definição de um modelo de memória usado por outras linguagens.
  • Desacordo sobre quão impactantes essas ideias foram e se as linguagens realmente “alcançaram” o multicore:
    • Alguns querem concorrência como construção de linguagem de primeira classe (concorrência estruturada, afinidade com núcleos).
    • Outros argumentam que a concorrência é melhor escondida em runtimes/bibliotecas padrão; a maioria dos desenvolvedores não quer lidar com escalonamento de baixo nível ou modelos de memória fracos.

LLMs e prática em C++

  • Vários participantes relatam boas experiências usando LLMs como mentores ou pares de programação para C++.
  • Outros observam que as intricacias do C++ ainda fazem código gerado por LLM esbarrar em linters e ferramentas.
  • Há uma leve discussão meta sobre LLMs sendo usados para escrever documentos adjacentes ao padrão e se seus tiques de estilo são reconhecíveis.

Perspectivas para o C++

  • Alguns afirmam que o C++ está “gasto” ou “à beira do fim”:
    • Inseguro por design, cada vez mais complexo e sob pressão de alternativas mais seguras.
    • O roteiro é visto como inchado; novos recursos grandes (módulos, contracts) são percebidos como pela metade.
  • Outros esperam que o C++ continue por décadas:
    • Base de código e ecossistema de bibliotecas imensos.
    • Amplo suporte de compiladores e perfil de desempenho que continua atraente.
  • Tom geral: fadiga crescente com adições grandes e complexas; ceticismo de que o processo atual consiga equilibrar evolução com coerência.