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
assertjá 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
unsafeem 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.