CLARC: C/C++ Benchmark for Robust Code Search

Este trabajo presenta CLARC, un nuevo benchmark automatizado en C/C++ derivado de repositorios reales de GitHub que, al evaluar modelos de búsqueda de código bajo condiciones desafiantes como la anonimización de identificadores y la compilación a lenguajes de bajo nivel, revela la dependencia persistente de los modelos actuales en características léxicas en lugar de una comprensión semántica profunda.

Lo esencial

¡Claro! Imagina que el código de computadora es como una biblioteca gigante llena de libros (programas) escritos en un lenguaje muy técnico. Los desarrolladores son los bibliotecarios que necesitan encontrar un libro específico muy rápido para resolver un problema.

Para ayudarles, existen "motores de búsqueda" (como Google, pero para código). La pregunta es: ¿Son estos motores de búsqueda realmente inteligentes o solo están "adivinando" basándose en palabras clave?

Aquí es donde entra este paper, que presenta CLARC.

1. El Problema: Los Motores de Búsqueda son "Superficiales"

Imagina que tienes un motor de búsqueda que busca un libro titulado "Cómo hacer un pastel de chocolate".

• El problema actual: La mayoría de los motores de búsqueda actuales son como un niño que solo lee la portada. Si el libro se llama "Receta de pastel", lo encuentra. Pero si cambias el título a "Instrucciones para un postre dulce" (mismo contenido, diferente título), el motor se pierde.
• La realidad: Los investigadores se dieron cuenta de que los motores actuales funcionan muy bien con Python (un lenguaje popular), pero fallan estrepitosamente con C/C++ (el lenguaje que usa para construir sistemas complejos, como el sistema operativo de tu teléfono o videojuegos). Además, si cambias los nombres de las variables (por ejemplo, cambiar precio por costo), el motor deja de entender que es lo mismo.

2. La Solución: CLARC (El "Examen de Estrés" para Motores)

Los autores crearon un nuevo banco de pruebas llamado CLARC. Piensa en CLARC como un entrenador de gimnasio muy estricto que quiere ver si los motores de búsqueda son realmente fuertes o solo tienen músculos de mentira.

CLARC tiene tres trucos principales para poner a prueba a los motores:

• Truco 1: El "Anonimato" (Censura).
  Imagina que le pones a un motor de búsqueda un libro donde tacharon todas las palabras importantes y las cambiaron por "palabra A", "palabra B", "palabra C".

  • ¿Qué pasa? Si el motor es inteligente, debería entender que el libro trata sobre "hacer un pastel" basándose en la estructura de las oraciones.
  • El resultado: ¡Los motores se confundieron! Se dieron cuenta de que dependían demasiado de las palabras específicas (como "precio" o "costo") y no entendían el significado real.

• Truco 2: El "Idioma Alienígena" (Ensamblaje y WebAssembly).
  El código C/C++ normal es como hablar en español. Pero CLARC también traduce ese código a Ensamblaje o WebAssembly.

  • La analogía: Es como si le pidieras a un traductor que busque un libro, pero en lugar de darte el libro en español, te lo dan escrito en jeroglíficos egipcios o en código binario (unos y ceros).
  • El resultado: Los motores se quedaron totalmente paralizados. No podían entender la lógica porque el lenguaje era demasiado bajo nivel y complejo.

• Truco 3: La "Complejidad de Dependencias".
  A veces, un trozo de código no funciona solo; necesita ayuda de otros trozos (como una receta que necesita otra receta para hacer la salsa). CLARC prueba si el motor entiende si necesita leer todo el contexto o solo una parte.

3. ¿Cómo lo hicieron? (La Máquina Automática)

Crear este banco de pruebas manualmente hubiera sido imposible (como intentar escribir un diccionario de memoria). Así que usaron Inteligencia Artificial (LLMs) para:

1. Buscar código real en GitHub (como buscar en una biblioteca pública).
2. Escribir preguntas naturales sobre ese código (ej: "¿Cómo ordeno una lista de nombres?").
3. Verificar que el código realmente funcionara (que se pudiera "compilar", es decir, que no tuviera errores).
4. Hacer que humanos expertos revisaran una muestra para asegurar que la IA no estaba mintiendo.

4. Los Resultados: Una Mala Noticia (y una Oportunidad)

Cuando probaron a los mejores motores de búsqueda del mundo con CLARC, pasó lo siguiente:

• En condiciones normales: ¡Funcionaban genial! (Como un estudiante que saca un 10 en un examen fácil).
• Con el "Anonimato" o en "Idioma Alienígena": ¡Sus notas cayeron al suelo! (Como si el mismo estudiante sacara un 2 en un examen difícil).

La conclusión: Los motores actuales son como detectives que solo miran las huellas dactilares (los nombres de las variables) en lugar de entender la historia del crimen (la lógica del código). Si cambias las huellas, pierden el caso.

¿Por qué importa esto?

Este trabajo es como un aviso de seguridad. Nos dice: "Oye, si quieres que la IA sea realmente útil en el mundo real (donde el código está ofuscado, protegido o escrito en lenguajes difíciles), necesitamos entrenarla mejor para que entienda la esencia del código, no solo las palabras que lo rodean".

CLARC es ahora una herramienta pública para que los investigadores construyan motores de búsqueda que sean verdaderamente inteligentes y no solo "adivinos" de palabras.

Resumen técnico

Aquí tienes un resumen técnico detallado del artículo CLARC: C/C++ Benchmark for Robust Code Search, presentado en la conferencia ICLR 2026.

1. El Problema

Aunque la recuperación de código es vital para la productividad de los desarrolladores, los benchmarks existentes presentan limitaciones críticas que impiden evaluar la verdadera robustez de los modelos de búsqueda:

• Sesgo de lenguaje: La mayoría de los conjuntos de datos se centran en Python, ignorando lenguajes de programación de sistemas como C/C++.
• Falta de compilabilidad: Muchos fragmentos de código en benchmarks actuales no son compilables debido a la falta de dependencias, funciones auxiliares o declaraciones de inclusión, lo que no refleja la práctica profesional.
• Fragilidad ante perturbaciones: Los modelos actuales rara vez se prueban contra ofuscación o cambios léxicos (como el renombrado de variables). Esto oculta si los modelos entienden la semántica del código o simplemente dependen de características léxicas superficiales (nombres de variables, funciones, etc.).
• Brecha de robustez: No existe una evaluación sistemática sobre cómo funcionan los modelos cuando el código se transforma a lenguajes de bajo nivel (Ensamblador, WebAssembly) donde las pistas léxicas desaparecen.

2. Metodología: CLARC y su Pipeline Automatizado

Los autores presentan CLARC (C/C++ LAnguage Retrieval with Anonymized Code), un benchmark completo construido a partir de repositorios reales de GitHub. El proceso de construcción sigue un pipeline automatizado de cuatro etapas:

1. Recopilación de Datos: Se extrajeron funciones de 144 repositorios populares de C/C++. Se filtró estrictamente para incluir solo funciones compilables, asegurando que todo el contexto de dependencias (gráficos de llamadas, definiciones) estuviera presente.
2. Categorización por Complejidad de Dependencias: El conjunto de datos se divide en tres grupos según la complejidad contextual:
   • Grupo 1: Depende únicamente de funciones y tipos de bibliotecas estándar.
   • Grupo 2: Usa funciones estándar pero con tipos de variables definidos por el usuario.
   • Grupo 3: Invoca funciones auxiliares definidas por el usuario (dividido en "Short" y "Long" según si las funciones auxiliares se incluyen en el mismo fragmento o no).
3. Generación y Validación de Consultas (Queries):
   • Se utilizaron LLMs (o3-mini y grok-4) para generar descripciones en lenguaje natural que sirvan como consultas de búsqueda.
   • Validación Rigurosa: Se realizó una prueba de hipótesis con anotadores humanos expertos (ingenieros de software con +5 años de experiencia) y estudiantes de doctorado. Los resultados mostraron que las consultas generadas por LLMs son estadísticamente comparables o superiores a las humanas en calidad y precisión.
4. Configuraciones de Robustez (Stress-Tests): Para evaluar la dependencia de características superficiales, el pipeline introduce cuatro configuraciones de evaluación:
   • Neutralizado: Los identificadores se reemplazan por marcadores neutrales (ej. func_a, var_b).
   • Aleatorizado: Los identificadores se reemplazan por cadenas aleatorias, eliminando cualquier pista léxica.
   • Ensamblador (Assembly): El código se compila a x86 Assembly, eliminando la mayoría de los identificadores.
   • WebAssembly (Wasm): El código se compila a WebAssembly, donde los nombres de funciones se pierden por defecto.

El dataset final contiene 6,717 pares consulta-código (1,245 para evaluación y 5,472 para entrenamiento).

3. Contribuciones Clave

• CLARC: El primer benchmark de C/C++ completamente compilable y escalable, diseñado específicamente para evaluar la robustez de la recuperación de código bajo diversas complejidades de dependencias y transformaciones de código.
• Pipeline Automatizado Validado: Un método escalable para generar benchmarks de alta calidad utilizando LLMs, validado mediante pruebas de hipótesis estadísticas y evaluación humana, que reduce la carga manual y asegura la reutilizabilidad.
• Evidencia de Dependencia Léxica: Demostración empírica de que los modelos de búsqueda de código más avanzados (SOTA) dependen excesivamente de características léxicas superficiales en lugar de comprender la semántica profunda del código.

4. Resultados Experimentales

Se evaluaron seis modelos de vanguardia (incluyendo BM25, CodeT5+, OASIS, Nomic-emb-code, OpenAI-text-embedding-large y Voyage-code-3) bajo diferentes configuraciones:

• Rendimiento en Configuración Estándar: Los modelos modernos (especialmente Nomic, OASIS y Voyage) lograron un alto rendimiento en la búsqueda estándar, superando significativamente a modelos más antiguos y a BM25.
• Caída Drástica en Configuraciones Neutralizadas/Aleatorizadas:
  • Al anonimizar los identificadores, el rendimiento de todos los modelos cayó drásticamente.
  • Por ejemplo, en el Grupo 3 (código complejo con dependencias), el rendimiento de modelos como CodeT5+ y Nomic se desplomó, indicando que sin los nombres de las funciones y variables, no pueden inferir la lógica subyacente.
  • Esto confirma que los modelos actuales no generalizan bien la semántica cuando se eliminan las pistas léxicas.
• Rendimiento en Lenguajes de Bajo Nivel (Assembly/Wasm):
  • La caída de rendimiento fue aún más severa al compilar a Assembly o WebAssembly.
  • Los modelos mostraron una capacidad limitada para interpretar la lógica del programa cuando se presenta como instrucciones de bajo nivel, donde la densidad semántica es diferente y las variables de alto nivel desaparecen.
• Limitaciones del Fine-tuning: Se intentó mejorar la robustez mediante fine-tuning supervisado. Aunque hubo mejoras marginales en las métricas generales, la brecha de rendimiento entre la configuración estándar y la neutralizada persistió. Esto sugiere que el entrenamiento supervisado estándar no es suficiente para enseñar a los modelos a ignorar el ruido léxico y centrarse en la semántica pura.

5. Significado e Impacto

El trabajo de CLARC es fundamental para el campo de la ingeniería de software asistida por IA porque:

1. Expone una vulnerabilidad crítica: Revela que el alto rendimiento en benchmarks tradicionales puede ser engañoso, basado en "trucos" léxicos en lugar de verdadera comprensión del código.
2. Establece un nuevo estándar: Proporciona una metodología rigurosa para probar la robustez de los modelos contra ofuscación y ataques adversarios, algo crucial para la seguridad del software y la recuperación de código en entornos reales.
3. Impulsa la investigación futura: Al ofrecer un dataset compilable y diverso, invita a la comunidad a desarrollar modelos que realmente comprendan la semántica del código, independientemente de la sintaxis superficial o el nivel de abstracción (desde C++ hasta Assembly).

En resumen, CLARC demuestra que, a pesar de los avances en modelos de lenguaje, la recuperación de código robusta sigue siendo un desafío abierto, ya que los modelos actuales aún no han logrado abstraer completamente la semántica de las características léxicas superficiales.