Cuando el creador de un lenguaje y sus responsables discrepan profundamente [pdf]

Un intento fallido de añadir “contracts” al próximo estándar C++26 ha puesto de manifiesto profundas divisiones entre el diseñador original del lenguaje, su comité de estándares ISO y la comunidad C++ en general. Los comentaristas debaten quién “posee” realmente un lenguaje de programación —el organismo de estándares, los implementadores o los usuarios— y si la evolución guiada por comité está produciendo un lenguaje cada vez más complejo e inseguro en comparación con opciones más nuevas como Rust o Zig. El episodio se ve como un caso de prueba para la viabilidad a largo plazo de C++, los límites de la compatibilidad hacia atrás y cómo deberían gobernarse los lenguajes de programación en una era de hardware multinúcleo y desarrollo asistido por IA.

Propiedad y gobernanza del lenguaje

  • Debate sobre si alguien “posee” un lenguaje:
    • Un bando: el comité de estándares “posee” el estándar y, por tanto, el futuro del lenguaje; un órgano de gobierno evita la divergencia o el estancamiento.
    • El otro bando: solo poseen el documento; la verdadera propiedad reside en quienes implementan compiladores y en los usuarios, que pueden ignorar el estándar cuando no es práctico.
  • Discusión sobre los modelos de comité frente a “dictador benevolente de por vida” (BDFL):
    • A favor de BDFL: da un diseño más coherente y unificado; el diseño por comité produce rarezas y complejidad.
    • En contra de BDFL: no escala ni sobrevive a la jubilación/muerte; los lenguajes exitosos han pasado a consejos o a una gobernanza más distribuida.

Complejidad de C++, curva de aprendizaje y diseño

  • Varios comentaristas describen intentar aprender C++ moderno y rendirse, citando:
    • Múltiples formas superpuestas de hacer las cosas (punteros, iteración, contenedores, algoritmos).
    • Evolución constante y lastre histórico; sensación de “excavación arqueológica”.
  • Otros argumentan:
    • Solo necesitas un subconjunto; trata C++ como una caja de herramientas y añade funciones según las necesites.
    • Muchos lenguajes tienen defectos heredados; en C++ simplemente son más visibles y está más extendido.
  • Hay desacuerdo sobre cuántos tipos de punteros/referencias debe manejar mentalmente un principiante y si “ningún puntero salvo que sea necesario” es realista.

La característica de contratos y el estancamiento de C++26

  • El hilo se centra mucho en la propuesta de contratos y la votación fallida de C++26:
    • Las objeciones del creador al diseño actual (p. ej., semántica, falta de implementación, falta de uso en el mundo real) se consideran ampliamente sustantivas.
    • Algunos ven los contratos como innecesarios frente a las comprobaciones tipo assert ya existentes.
  • Caminos propuestos: saltarse C++26, eliminar contratos, ajustar los contratos (p. ej., cumplimiento garantizado), volver a votar o sacar la estandarización del ISO.
  • Desacuerdo sobre el “cumplimiento garantizado”:
    • A favor: necesario para la fiabilidad en bases de código mixtas y bibliotecas endurecidas.
    • En contra: podría ser demasiado costoso o disruptivo; compiladores y herramientas no están listos.

Seguridad, Rust y otros lenguajes

  • Crítica fuerte de que C++ es intrínsecamente inseguro y poco adecuado para un mundo de explotación omnipresente y caza automática de errores.
  • Contraargumentos:
    • Los idioms modernos y las herramientas (incluidos los LLM) pueden encontrar y corregir muchos errores.
    • Otros lenguajes de sistemas alternativos (p. ej., Rust) también son complejos y dependen de unsafe en dominios difíciles.
  • Algunos sostienen que, si se rediseñara desde cero, gran parte de la complejidad de C++ no sería necesaria.

Concurrencia y hardware

  • Mención del clásico argumento de que “se acabó el almuerzo gratis” y del papel de C++ al definir un modelo de memoria usado por otros lenguajes.
  • Desacuerdo sobre cuán influyentes fueron esas ideas y si los lenguajes realmente se han “puesto al día” con la multicore:
    • Algunos quieren la concurrencia como constructo de lenguaje de primera clase (concurrencia estructurada, afinidad al núcleo).
    • Otros sostienen que la concurrencia se oculta mejor en runtimes/bibliotecas estándar; la mayoría de los desarrolladores no quiere lidiar con planificación de bajo nivel ni con modelos de memoria débiles.

LLMs y la práctica de C++

  • Varios comentaristas informan de buenas experiencias usando LLMs como mentores o compañeros de programación para C++.
  • Otros señalan que las complejidades de C++ siguen haciendo que el código generado por LLM tropiece con linters y herramientas.
  • Hay una ligera metadiscusión sobre el uso de LLMs para escribir documentos cercanos a los estándares y si sus tics estilísticos son reconocibles.

Perspectivas para C++

  • Algunos afirman que C++ está “agotado” o “en las últimas”:
    • Inseguro por diseño, cada vez más complejo y bajo presión de alternativas más seguras.
    • La hoja de ruta se percibe como hinchada; las nuevas grandes funciones (módulos, contratos) se ven como a medio cocer.
  • Otros esperan que C++ continúe durante décadas:
    • Inmensas bases de código y ecosistemas de bibliotecas existentes.
    • Amplio soporte de compiladores y un perfil de rendimiento que sigue siendo atractivo.
  • Tono general: creciente cansancio con añadidos grandes y complejos; escepticismo de que el proceso actual pueda equilibrar evolución y coherencia.