Por qué C++ todavía supera a Rust en la era de la IA

Introducción

Las discusiones sobre los lenguajes de programación a menudo se convierten en teatro moral mucho antes de convertirse en ingeniería. Una lengua se describe como limpia y la otra como cargada. Uno es imaginado como el futuro, el otro como un equipaje del pasado. Estas historias son emocionalmente satisfactorias porque hacen que la historia parezca ordenada. También engañan a los equipos que tienen que enviar sistemas dentro de plazos, presupuestos, limitaciones de integración y ahora una fuerza adicional que no existía de la misma manera hace diez años: los asistentes y agentes de codificación de IA.

Una vez que la generación de código se convierte en parte de la entrega diaria, la pregunta cambia. Ya no se trata sólo de "¿Qué idioma es elegante?" o "¿Qué idioma es seguro de forma predeterminada?" La pregunta más difícil y práctica es la siguiente: si un equipo espera que los sistemas de IA le ayuden a escribir, refactorizar, comparar, integrar y depurar el código de producción, ¿qué lenguaje ofrece actualmente a esos sistemas el entorno más rico para ser útiles? Mi respuesta sigue siendo C++, y el meollo del argumento no es ni la nostalgia ni el machismo. Es densidad.

C++ todavía se encuentra dentro de un mundo más denso de código público, infraestructura implementada, herramientas de proveedores, ejemplos de plataformas, folklore de optimización y cicatrices de producción reales que Rust. Los modelos de IA aprenden de esa densidad. No sólo aprenden sintaxis. Aprenden cómo las personas unieron sistemas grandes, cómo evolucionaron los archivos de compilación, cómo se hicieron integraciones feas para funcionar, cómo se diagnosticaron errores de bajo nivel y cómo el código sensible al rendimiento se escribió en realidad con ira y no en teoría. Cuando más tarde se pide a esos modelos que ayuden con la ingeniería real, la forma de esa memoria histórica importa.

Esto no significa que Rust sea débil, poco serio o irrelevante. Por el contrario, Rust ha ejercido una presión saludable sobre la programación de sistemas. Hizo que la seguridad de la memoria fuera imposible de ignorar, mejoró el tono de muchas conversaciones de ingeniería y produjo herramientas y bibliotecas realmente sólidas. Pero la existencia de las fortalezas de Rust no borra automáticamente las ventajas actuales de C++ en la entrega asistida por IA. La ingeniería madura a menudo requiere sostener ambas verdades a la vez.

Primero la evidencia, después los eslóganes

Un argumento cuidadoso comienza separando lo que puede observarse públicamente de lo que debe inferirse. Los conjuntos de datos públicos utilizados en la investigación de modelos de código, como The Stack, muestran sustancialmente más C++ que Rust. Las encuestas públicas a desarrolladores y las tendencias del lenguaje GitHub continúan mostrando un uso absoluto más amplio de C++ en toda la industria. La infraestructura pública de IA, desde los SDK de los proveedores hasta los tiempos de ejecución de inferencia optimizados y las bibliotecas matemáticas de bajo nivel, todavía expone un mundo profundamente moldeado por C y C++. Los esfuerzos públicos de evaluación comparativa como CRUST-Bench también sugieren que los modelos actuales todavía tienen dificultades para generar Rust idiomático y seguro en el sentido fuerte que valoran las comunidades de Rust.

De esos hechos hacemos una inferencia, no un dogma. La inferencia es que actualmente es más probable que los sistemas de IA generen C++ útil para la producción, integrable y optimizable en muchos dominios de sistemas porque el entorno circundante para C++ es más rico. Esto no es magia. Es exposición combinada con retroalimentación. Un lenguaje con más repositorios, más scripts de compilación, más ejemplos de hardware, más integraciones de proveedores, más correcciones de errores públicos, más investigaciones de rendimiento y más historias de guerra de producción ofrece un modelo con más formas de ser aproximadamente correcto incluso antes de que un ingeniero humano comience a corregirlo.

A menudo se resiste a este punto porque suena poco generoso con el lenguaje más nuevo. Pero no es un insulto para Rust decir que ha tenido menos tiempo para acumular sedimentos de ingeniería pública. C++ ha estado integrado durante décadas en sistemas operativos, navegadores, bases de datos, pilas de medios, herramientas de seguridad, motores de juegos, telecomunicaciones, informática científica, productos integrados y sistemas financieros. El óxido ha crecido rápida y admirablemente, pero crecimiento no es lo mismo que profundidad geológica. Los modelos de IA absorben la profundidad.

Por qué el tamaño del corpus es más importante de lo que la gente admite

A veces, los ingenieros tratan el volumen de datos de entrenamiento como si fuera un tema de conversación burdo. En la práctica, importa de una manera mucho más humana. Un agente de IA que trabaja en una base de código de producción generalmente no inventa un algoritmo perfecto desde los primeros principios. Está haciendo algo más complicado. Puede ser actualizar un archivo CMake, adaptarse a una queja del compilador en una plataforma, reemplazar un contenedor de ruta activa, empaquetar una API de proveedor, convertir diseños de imágenes o tensores, corregir una discrepancia de ABI o hacer que un antiguo subsistema nativo sea un poco menos doloroso sin romper todo lo que lo rodea.

Esas tareas recompensan la familiaridad con el código vivido, ordinario e imperfecto. El agente se beneficia de haber visto no sólo ejemplos claros de libros de texto, sino también miles de intentos reales de resolver problemas adyacentes. C++ proporciona a los modelos mucha más cantidad de ese material. Hay C++ más moderno, más C++ heredado que se está reparando lentamente, más C++ basado en pruebas comparativas, más C++ vergonzoso que de alguna manera todavía dirige negocios importantes y más ejemplos de personas que navegan exactamente por el tipo de compromisos que exigen los sistemas reales.

Es por eso que la "producción desordenada de C++" sigue siendo información de entrenamiento valiosa. Algunos ingenieros escuchan esa frase e imaginan que debilita el caso. En realidad lo fortalece. Los sistemas de producción no se componen enteramente de elegantes módulos totalmente nuevos. Incluyen interfaces heredadas, suposiciones extrañas de ABI, condicionales de plataforma, peculiaridades del hardware, migraciones parciales y código que sobrevivió porque era útil antes de ser hermoso. Si un sistema de IA ha visto muchos más ejemplos de ese panorama en C++, simplemente está mejor preparado para ayudar dentro de ese panorama.

Vale la pena exponer abiertamente un contraejemplo. Si un equipo está creando un pequeño servicio totalmente nuevo con una sólida experiencia en Rust, requisitos de seguridad claros, necesidades de integración modestas y ningún ecosistema nativo pesado a su alrededor, Rust puede ser una mejor opción local. En esa situación, el argumento del tamaño del corpus es menos decisivo porque el contexto de ingeniería circundante es más simple y el equipo humano puede mantener el sistema dentro de una banda más estrecha de complejidad. La cuestión no es que C++ gane todos los argumentos. El punto es que a medida que el problema se vuelve más antiguo, más extraño, más sensible al rendimiento y más enredado con la infraestructura nativa existente, C++ se convierte cada vez más en el lenguaje más fácil de ayudar de manera efectiva para los sistemas de IA.

El mundo de la infraestructura de IA todavía tiene forma de C++

Incluso si ignoráramos por completo el volumen de datos de entrenamiento, todavía habría una segunda fuerza que empujaría el estándar hacia C++: la infraestructura detrás de los productos modernos de IA sigue siendo fuertemente nativa. CUDA, bibliotecas matemáticas optimizadas, componentes internos de ONNX Runtime, oneDNN, OpenVINO, implementaciones de tokenizadores, canalizaciones de preprocesamiento multimedia, aceleradores de servicio de modelos, SDK de proveedores de hardware y muchos tiempos de ejecución de implementación están escritos en C o C++ o exponen sus interfaces más serias allí. Esto no significa que Rust no pueda llamarlos. Significa que el camino más corto a través del paisaje suele ser un camino C o C++.

Esto es importante porque los agentes codificadores de IA no son útiles de forma aislada. Son útiles dentro de los gráficos de dependencia. Un modelo al que se le pide que ayude a integrar un tiempo de ejecución, depurar una compilación, ajustar una ruta activa o razonar sobre la propiedad a través de los límites del SDK de un proveedor tiene ventajas cuando ha visto muchos ejemplos adyacentes en la misma familia de lenguajes. C++ todavía se beneficia de esa familiaridad con el entorno más que Rust en la mayoría de los trabajos de infraestructura de IA críticos para el rendimiento.

Aquí también se vuelve importante la conversación sobre los ciclos de retroalimentación. El código generado por IA sólo se vuelve verdaderamente valioso cuando los humanos pueden verificarlo rápidamente. C++ a menudo brinda a los equipos una verificación local más completa en estos dominios porque el ecosistema en torno a la evaluación comparativa, la creación de perfiles, la reproducción, los desinfectantes, los contadores de hardware y los diagnósticos de bajo nivel es muy maduro. Cuando un agente propone un cambio en una ruta de inferencia de C++, un equipo a menudo puede compilarlo, perfilarlo, inspeccionar el comportamiento de asignación, comparar distribuciones de latencia e iterar rápidamente. Rust también tiene herramientas sólidas, pero en muchos sistemas nativos adyacentes a la IA, la densidad combinada de bibliotecas, ejemplos, perfiladores y prácticas existentes aún hace que C++ sea el lugar más fácil para ejecutar ciclos de corrección humanos en el ciclo.

Por qué los equipos suelen moverse más rápido con C++ incluso cuando Rust parece más limpio

Este es el punto que tiende a ofender a la ideología, porque suena descortés con la limpieza. El óxido suele verse más limpio en la pizarra. La propiedad es explícita. El compilador guarda errores importantes. La cultura en torno a la corrección es admirable. Pero la velocidad de producción no es idéntica a la elegancia del lenguaje. La velocidad de entrega real surge de todo el ciclo: base de código existente, bibliotecas disponibles, grupo de talentos, herramientas de depuración, limitaciones de implementación, calidad de la asistencia de IA y el costo de realizar un cambio más el próximo mes.

Actualmente, C++ gana ese circuito más amplio en muchos sistemas de la era de la IA porque los equipos pueden preguntar más al mundo circundante sin abandonar el lenguaje. Pueden integrar bibliotecas nativas antiguas, adjuntar generadores de perfiles que se crearon teniendo en cuenta el trabajo de rendimiento nativo, ajustar asignadores, explotar instalaciones específicas de la plataforma y aprovechar un conjunto mucho mayor de ejemplos públicos cuando algo sale mal. Los asistentes de IA se benefician exactamente de la misma realidad. Cuando el mundo que rodea al modelo es denso y muy transitado, los borradores del modelo mejoran más rápidamente.

Imagine dos equipos creando un servicio de inferencia sensible a la latencia con algún preprocesamiento personalizado, una matriz de implementación complicada y la necesidad de realizar ajustes repetidos del rendimiento. El equipo de Rust puede producir un conjunto más pequeño de errores de seguridad de la memoria, y eso no es trivial. Pero si el equipo de C++ puede integrar el ecosistema de manera más directa, obtener sugerencias de IA más sólidas en el código base real que tienen y verificar los cambios de rendimiento más rápido con herramientas nativas maduras, el resultado general de la entrega aún puede favorecer a C++. En términos comerciales, eso importa más que si un idioma ganó una discusión filosófica en línea.

Un contraejemplo útil nos mantiene honestos. Si el riesgo dominante en un proyecto no es la integración o la evolución del rendimiento sino la seguridad de la memoria en un nuevo servicio con dependencias relativamente simples, Rust puede crear absolutamente mejores resultados organizacionales. El error es tomar esa verdad y exportarla indiscriminadamente a todos los problemas de sistemas adyacentes a la IA. Los idiomas ganan en contextos, no en sermones.

Lo que Rust todavía hace bien

Rust merece respeto, y el argumento a favor de C++ es más débil cuando caricaturiza a Rust. Rust es excelente para hacer visibles suposiciones inseguras. Crea una fuerte disciplina en torno a la propiedad y la vida útil. A menudo es una opción convincente para infraestructura nueva donde la corrección y la mantenibilidad dominan sobre la compatibilidad con un mundo nativo existente. En algunos equipos, Rust también mejora la claridad de la contratación porque el código base en sí impone cierto tipo de seriedad en la ingeniería.

También es importante decir claramente que C++ no gana por defecto sólo porque sea más antiguo. El C++ indisciplinado sigue siendo peligroso. Si un equipo tiene una cultura de revisión débil, ningún hábito de elaboración de perfiles, pruebas deficientes y ningún respeto por la observabilidad, entonces los corpus más grandes y las herramientas más ricas no lo salvarán. Los sistemas de inteligencia artificial pueden amplificar ese caos con la misma facilidad con la que aceleran la buena ingeniería. La verdadera afirmación es más estrecha y práctica: dados los equipos disciplinados que resuelven problemas de sistemas de la era de la IA sensibles al rendimiento y con mucha integración, C++ sigue siendo la apuesta predeterminada más fuerte hoy en día porque los agentes, las herramientas y la gravedad del ecosistema lo refuerzan.

Por eso prefiero la frase apuesta predeterminada en lugar de ganador universal. Una apuesta predeterminada es lo que usted elige cuando la carga de la prueba aún no se ha trasladado a otra parte. Rust puede lograr ese cambio en proyectos específicos. Pero C++ todavía comienza con más evidencia a su favor siempre que el trabajo esté profundamente enredado con la infraestructura nativa de IA, el rendimiento de bajo nivel, los sistemas de producción de larga duración o el tipo de código base que los agentes de IA han visto en gran cantidad pública.

Una forma práctica de decidir

Si la ruta activa es nativa, el gráfico de dependencia es nativo, la historia de creación de perfiles es importante y espera que los asistentes de IA le ayuden dentro del código de producción real desordenado, C++ merece ser su primera discusión seria sobre el lenguaje. Si el sistema es totalmente nuevo, domina el caso de seguridad, el ecosistema circundante ya tiene la forma de Rust y el problema no depende en gran medida de los antiguos estratos nativos, Rust se vuelve más atractivo. Si el sistema contiene ambos mundos, lo que muchos hacen, la respuesta madura suele ser una arquitectura híbrida en lugar de una pureza tribal.

Este marco calma la conversación porque devuelve la decisión al trabajo en lugar de a la identidad. Un tiempo de ejecución de inferencia nativo dentro de una plataforma C++ existente no es el mismo problema que un nuevo servicio de plano de control. Una canalización de medios de baja latencia no es el mismo problema que una API de backend. Un componente de borde que sirve modelos no es el mismo problema que un motor de transición de estado nativo de la cadena. Una vez que nombramos la obra real, la elección del lenguaje suele parecer menos ideológica y más obvia.

También hay un beneficio humano al tomar la decisión de esta manera. Los equipos se vuelven más cooperativos cuando dejan de preguntarse qué idioma merece admiración y comienzan a preguntarse qué idioma le da al sistema actual la mejor oportunidad de volverse confiable, inteligible y mejorable. La asistencia de la IA hace que esto sea aún más importante. Los agentes son poderosos cuando están inmersos en una cultura de verificación, no cuando se utilizan para decorar el lenguaje fandom con una confianza sintética.

La verdadera oportunidad

La mayor oportunidad en la era de la IA no es simplemente que los agentes puedan escribir código. Es que ahora pueden participar en todo el ciclo de retroalimentación en torno a los sistemas maduros: leer código antiguo, proponer ediciones, mejorar los puntos de referencia, sacar a la luz pistas del perfilador, traducir ideas aproximadas en experimentos compilables y ayudar a los ingenieros a pasar de la sospecha a la medición más rápido que antes. En ese mundo, el lenguaje que más se beneficia no es necesariamente el que tiene la mejor historia teórica. Es el que tiene la red más espesa de realidad pública, práctica y probada en batalla.

Hoy en día, para una gran clase de problemas graves de sistemas, ese lenguaje sigue siendo C++. Y esa es una buena noticia, no porque la industria deba dejar de aprender de Rust, sino porque los equipos pueden utilizar el enorme conjunto de conocimiento nativo existente en lugar de pretender que desapareció en el momento en que llegó la IA. La postura más productiva no es el triunfalismo. Es gratitud. C++ acumuló décadas de memoria de ingeniería real y los sistemas de inteligencia artificial ahora hacen que esa memoria sea más fácil de usar. Los equipos inteligentes lo aprovecharán.

Laboratorio práctico: cree y mejore un proceso de puntuación nativo

Si un artículo sobre la elección del idioma en la era de la IA no contiene código, corre el riesgo de convertirse en un sermón.

Así que construyamos una pequeña utilidad nativa de C++ del tipo que a los agentes de IA se les pide constantemente que mejoren en las empresas reales: un canal de puntuación de texto que carga datos, calcula características simples, ordena los resultados e imprime las filas superiores.

Es modesto a propósito. La mayor parte de la ingeniería de producción es modesta.

__CÓDIGO_0__

#include <algorithm>
#include <chrono>
#include <cctype>
#include <fstream>
#include <iostream>
#include <string>
#include <string_view>
#include <vector>

struct Sample {
    std::string text;
    double score = 0.0;
};

static int count_digits(std::string_view s) {
    int n = 0;
    for (unsigned char c : s) {
        n += std::isdigit(c) ? 1 : 0;
    }
    return n;
}

static int count_upper(std::string_view s) {
    int n = 0;
    for (unsigned char c : s) {
        n += std::isupper(c) ? 1 : 0;
    }
    return n;
}

static int count_punct(std::string_view s) {
    int n = 0;
    for (unsigned char c : s) {
        n += std::ispunct(c) ? 1 : 0;
    }
    return n;
}

static double score_line(std::string_view s) {
    const auto len = static_cast<double>(s.size());
    const auto digits = static_cast<double>(count_digits(s));
    const auto upper = static_cast<double>(count_upper(s));
    const auto punct = static_cast<double>(count_punct(s));
    return len * 0.03 + digits * 0.7 + upper * 0.15 - punct * 0.05;
}

int main(int argc, char** argv) {
    if (argc < 2) {
        std::cerr << "usage: scorer <input-file>\n";
        return 1;
    }

    std::ifstream in(argv[1]);
    if (!in) {
        std::cerr << "cannot open input file\n";
        return 1;
    }

    std::vector<Sample> rows;
    rows.reserve(200000);

    std::string line;
    while (std::getline(in, line)) {
        rows.push_back({line, 0.0});
    }

    const auto t0 = std::chrono::steady_clock::now();
    for (auto& row : rows) {
        row.score = score_line(row.text);
    }
    std::sort(rows.begin(), rows.end(), [](const Sample& a, const Sample& b) {
        return a.score > b.score;
    });
    const auto t1 = std::chrono::steady_clock::now();

    const auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(t1 - t0).count();
    std::cout << "processed " << rows.size() << " rows in " << ms << " ms\n";

    const size_t limit = std::min<size_t>(5, rows.size());
    for (size_t i = 0; i < limit; ++i) {
        std::cout << rows[i].score << " | " << rows[i].text << "\n";
    }
}

Construir

En Linux o macOS:

g++ -O2 -std=c++20 -o scorer main.cpp
./scorer sample.txt

En Windows con MSVC:

cl /O2 /std:c++20 main.cpp
.\main.exe sample.txt

Por qué este pequeño programa es útil

Porque es exactamente el tipo de código donde la ingeniería asistida por IA se vuelve tangible:

• es nativo
• toca cuerdas y memoria
• tiene un tiempo de ejecución medible
• se puede perfilar
• se puede mejorar progresivamente

Ése es el hábitat real de muchos agentes C++ hoy en día: no grandes demostraciones, sino programas nativos ordinarios que necesitan mejorar sin ser reinventados.

Tareas de prueba para entusiastas

Si quieres convertir el artículo en un ejercicio práctico, prueba estos:

1. Pídale a su agente de codificación favorito que optimice el programa sin cambiar la salida. Inspeccione si reduce los pases duplicados o los temporales innecesarios.
2. Agregue tiempos separados para la carga, puntuación y clasificación de archivos. Verifica adónde va realmente el tiempo.
3. Reemplace la entrada con un millón de líneas y compare la calidad de las optimizaciones sugeridas por diferentes agentes.
4. Transfiera la utilidad a Rust y compare la experiencia honestamente: qué se sintió más claro, qué se sintió más pesado y qué herramientas circundantes se sintieron más maduras para esta tarea exacta.
5. Ejecute la versión C++ con un generador de perfiles y anote si su primera suposición sobre el punto de acceso fue realmente correcta.

Este es un pequeño ejercicio, pero precisamente por eso es útil. La mayoría de los debates sobre ingeniería se vuelven más veraces cuando se ven obligados a sobrevivir al contacto con un pequeño programa real.

Resumen

Rust merece el respeto que recibe. Elevó el estándar para las conversaciones sobre seguridad y brindó a la programación de sistemas un conjunto de valores predeterminados más saludables. Pero la era de la IA no recompensa únicamente los incumplimientos. Recompensa el lenguaje que se encuentra en el centro del mayor corpus vivo de código real, el ecosistema más profundo de integraciones de bajo nivel, la cultura de optimización más rica y el ciclo práctico más rápido desde el borrador generado hasta el resultado de producción medible. Hoy en día, eso todavía describe a C++ con más fuerza que Rust.

Eso no hace que C++ sea moralmente superior y no hace que Rust sea irrelevante. Simplemente significa que, para muchos problemas graves de los sistemas nativos, los agentes de IA todavía tienen más terreno útil bajo sus pies cuando el mundo objetivo es C++. Los equipos que entienden esto pueden tomar mejores decisiones sin dramatismo. Pueden aprender de Rust dónde Rust es más fuerte y seguir utilizando la inmensa memoria acumulada de C++ donde esa memoria es más valiosa económicamente.

Referencias

1. Octubre de GitHub 2024: https://github.blog/news-insights/octoverse/octoverse-2024/
2. Octubre de GitHub 2025: https://github.blog/news-insights/octoverse/octoverse-a-new-developer-joins-github-every-second-as-ai-leads-typescript-to-1/
3. Encuesta para desarrolladores de Stack Overflow 2023: https://survey.stackoverflow.co/2023
4. Sección de tecnología de la encuesta para desarrolladores de Stack Overflow 2025: https://survey.stackoverflow.co/2025/technology/
5. La tarjeta del conjunto de datos de Stack: https://huggingface.co/datasets/bigcode/the-stack
6. El papel de la pila: https://arxiv.org/abs/2211.15533
7. Documento ICLR 2025 sobre el impacto de los datos de código en la capacitación previa: https://openreview.net/pdf?id=zSfeN1uAcx
8. CRUST-Bench: un punto de referencia integral para la transpilación de C a óxido seguro: https://arxiv.org/abs/2504.15254
9. Guía de programación CUDA C++: https://docs.nvidia.com/cuda/cuda-c-programming-guide/
10. API de tiempo de ejecución de ONNX C/C++: https://onnxruntime.ai/docs/api/c/index.html
11. Documentación de la interfaz de PyTorch C++: https://docs.pytorch.org/cppdocs/frontend.html
12. Directrices básicas de C++: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines