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

Dit paper introduceert CLARC, een robuust C/C++ benchmark voor codezoekopdrachten dat is opgebouwd uit een geautomatiseerde pipeline en real-world GitHub-repositories, en waaruit blijkt dat bestaande modellen sterk afhankelijk zijn van lexicale kenmerken in plaats van semantisch begrip.

De kern

Stel je voor dat je een enorme bibliotheek binnenstapt, maar dan niet met boeken, maar met miljoenen regels computercode. Als programmeur ben je vaak op zoek naar een specifieke oplossing, een stukje code dat al eens is geschreven, zodat je het niet zelf hoeft uit te vinden. Dit noemen we "code zoeken".

Vandaag de dag gebruiken we slimme computers (AI) om ons te helpen zoeken. Maar er is een groot probleem: de tests die we gebruiken om te zien hoe goed deze AI's zijn, zijn te makkelijk. Het is alsof we de AI's testen met een zoekopdracht waarbij we alleen naar de titel van het boek kijken, in plaats van naar de inhoud. Als de titel "Hoe maak je een taart" heet, denkt de AI: "Ah, ik weet het!" Maar als de titel verandert in "Recept voor gebak", raakt de AI in paniek, zelfs als de inhoud exact hetzelfde is.

Hier komt CLARC in beeld. Dit is een nieuw, veel strengere test voor code-zoekmachines, speciaal gemaakt voor C en C++ (de talen die worden gebruikt voor besturingssystemen, auto's en complexe software).

Hier is hoe het werkt, uitgelegd met een paar creatieve vergelijkingen:

1. De Bibliotheek van de Realiteit

De makers van CLARC hebben niet zomaar een paar voorbeelden bedacht. Ze hebben de hele GitHub (een enorme online bibliotheek voor programmeurs) doorzocht en echte, werkende stukken code geselecteerd.

• De Analogie: Stel je voor dat je eerder alleen oefende met recepten uit een kinderboekje. CLARC gooit je nu in een professionele keuken met echte, complexe recepten die daadwerkelijk kunnen worden gekookt (gecompileerd).

2. De Drie Levels van Moeilijkheid

De test verdeelt de code in drie groepen, net als een videogame met steeds zwaardere levels:

• Level 1 (De Solo-avonturier): Een stukje code dat alleen standaard hulpmiddelen gebruikt.
• Level 2 (De Teamspeler): Code die werkt met speciale, zelfgemaakte bouwstenen (zoals een eigen soort bakplaat).
• Level 3 (De Orkestleider): Complexe code die afhankelijk is van andere stukken code die eronder zitten. Hier moet de AI echt begrijpen hoe alles samenwerkt.

3. De "Vermommingstest" (De Kern van het Experiment)

Dit is het meest spannende deel. De onderzoekers wilden weten: Begrijpt de AI echt wat de code doet, of kijkt hij alleen naar de namen van de variabelen?

Ze hebben de code drie keer "vermomd":

• De Neutralisatie: Alle namen worden vervangen door saaie namen als functie_a, variabele_b. Het is alsof je een boek leest waar alle namen van personages zijn vervangen door "Hij" en "Zij".
• De Randomisatie: De namen worden willekeurig veranderd in onbegrijpelijke klinkerreeksen.
• De Vertaling naar Machine-taal: De code wordt vertaald naar Assembly of WebAssembly. Dit is als het vertalen van een prachtig geschreven roman naar een lijst met binaire cijfers (0 en 1) of een lijst met machine-instructies. De "smaak" van de taal is weg, alleen de logica blijft over.

4. Wat bleek er? (De Schokkende Resultaten)

Toen ze de beste AI-modellen (zoals die van OpenAI en andere tech-giganten) op deze test lieten werken, gebeurde er iets vreemds:

• Op de normale test: De AI's scoorden fantastisch. Ze vonden de juiste code bijna altijd.
• Op de "vermomde" test: De scores instortten.

De Metaphor:
Het is alsof je een superheld hebt die elke sleutel herkent aan de vorm van de tandjes. Maar zodra je de tandjes afslijpt en de sleutel een andere kleur geeft, kan hij hem niet meer openen, zelfs niet als het exact dezelfde sleutel is die hij gisteren nog gebruikte.

De AI's blijken niet te begrijpen wat de code doet (de logica). Ze kijken alleen naar de woorden die erin staan (de namen van variabelen en functies). Als die namen weg zijn of veranderd zijn, raken ze volledig verdwaald.

5. Waarom is dit belangrijk?

In de echte wereld wordt code vaak "vermomd" (obfuscatie) om hackers te misleiden, of wordt code vertaald naar een andere taal voor verschillende apparaten. Als onze zoekmachines niet robuust genoeg zijn om door deze vermommingen heen te kijken, kunnen we geen veilige software bouwen of fouten vinden in gecompliceerde systemen.

Conclusie

CLARC is een waarschuwing en een hulpmiddel. Het zegt: "Stop met het testen van AI's met te makkelijke vragen. Ze zijn slim in het herkennen van patronen, maar ze zijn nog niet slim genoeg om de diepere betekenis van code te begrijpen als de oppervlakte verandert."

De onderzoekers hopen dat deze nieuwe test ervoor zorgt dat de volgende generatie AI's echt gaat leren denken als een programmeur, in plaats van alleen maar te kijken als een woordenboek.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "CLARC: C/C++ Benchmark for Robust Code Search", gepresenteerd op ICLR 2026, in het Nederlands.

Probleemstelling

Bestaande benchmarks voor code-zoekopdrachten (code search) vertonen drie fundamentele tekortkomingen die hun praktische bruikbaarheid beperken:

1. Taalkenmerk-imbalance: De meeste datasets focussen op Python en negeren systemprogrammeringstalen zoals C/C++, ondanks hun cruciale rol in de software-industrie.
2. Gebrek aan compilatie-eigenschap: Veel code-snippets in huidige benchmarks zijn niet compileerbaar (ontbrekende include-statements, helper-functies of definities), wat in strijd is met professionele ontwikkelpraktijken waar context en afhankelijkheden essentieel zijn voor code-analyse.
3. Gebrek aan robuustheidstests: Benchmarks testen zelden de weerbaarheid van modellen tegen tekstuele verstoringen (zoals het anonimiseren van variabelennamen) of vertaling naar laag-niveau talen. Dit verbergt het feit dat state-of-the-art modellen vaak vertrouwen op oppervlakkige lexische kenmerken (zoals variabele- en functienamen) in plaats van diepgaand semantisch begrip van de code.

Methodologie: Het CLARC Framework

Om deze gaten te dichten, stellen de auteurs CLARC (C/C++ LAnguage Retrieval with Anonymized Code) voor. Dit is een geautomatiseerde pipeline voor het genereren van een dataset, opgebouwd uit real-world GitHub-repositories.

1. Dataverzameling en Categorisatie:

• De dataset bevat 6.717 query-code paren (1.245 voor evaluatie, 5.472 voor training) afkomstig van 144 populaire C/C++ repositories.
• Alle code is geverifieerd op compilatie binnen een gestandaardiseerde omgeving.
• De code is gecategoriseerd op basis van afhankelijkheidscomplexiteit:
  • Groep 1: Alleen afhankelijk van standaardbibliotheekfuncties.
  • Groep 2: Afhankelijk van standaardfuncties maar met aangepaste (custom) datatypes.
  • Groep 3: Bevat door de gebruiker gedefinieerde helper-functies. Deze groep is verder opgesplitst in Short (separate snippets) en Long (gecombineerde snippets met dependencies).

2. Robuustheidsscenario's (Settings):
Om te testen of modellen echt code begrijpen of alleen namen "lezen", introduceert CLARC vier specifieke settings:

• Standaard: Originele code.
• Neutraal (Neutralized): Identifiers (variabelen, functies) worden vervangen door generieke placeholders (bijv. func_a, var_b) om niet-functionele informatie te verwijderen terwijl de structuur behouden blijft.
• Geraandomiseerd (Randomized): Identifiers worden vervangen door willekeurige strings om alle lexische hints te elimineren.
• Laag-niveau: Code is gecompileerd naar x86 Assembly en WebAssembly (Wasm). Hierbij zijn alle hoog-niveau identifiers verdwenen, waardoor alleen de instructiestructuur overblijft.

3. Query-Generatie en Validatie:

• Natural Language Queries worden gegenereerd door Large Language Models (LLMs) zoals o3-mini en grok-4.
• De kwaliteit wordt streng gevalideerd via hypothese-toetsing met menselijke experts (software-engineers met 5+ jaar ervaring). Statistische tests tonen aan dat de LLM-generatie kwalitatief gelijkwaardig of superieur is aan menselijke annotaties.

Belangrijkste Bijdragen

1. CLARC Dataset: Een volledig compileerbare C/C++ dataset die specifiek is ontworpen om de robuustheid van zoekmodellen te testen onder variërende afhankelijkheidscomplexiteit en geobfuscureerde settings.
2. Geautomatiseerde Pipeline: Een schaalbare methode voor het genereren van benchmarks, gevalideerd door statistische tests, die kan worden hergebruikt voor andere datasets.
3. Empirisch Bewijs van Lexische Afhankelijkheid: Het blootleggen van de beperkingen van huidige state-of-the-art modellen, die sterk afhankelijk zijn van oppervlakkige lexische kenmerken in plaats van semantisch begrip.

Resultaten

De auteurs evalueerden zes modellen, waaronder BM25, CodeT5+, OASIS, Nomic-emb-code, OpenAI-text-embedding-large en Voyage-code-3.

• Prestatiedaling bij Anonimisering: Wanneer identifiers worden geanonimiseerd (Neutralized/Randomized settings), zien alle modellen een drastische daling in prestaties (bijv. NDCG en MRR). Dit bewijst dat modellen voornamelijk vertrouwen op variabele- en functienamen in plaats van de onderliggende logica.
  • Voorbeeld: Voyage-code-3, een topmodel, zakt van een NDCG van ~89 (Standaard) naar ~83 (Neutraal) en ~84 (Geraandomiseerd), maar de daling is nog scherper bij complexere code (Groep 3).
• Problemen met Laag-niveau Talen: De prestaties van modellen op Assembly en WebAssembly zijn extreem laag. Dit wijst op een gebrek aan vermogen om laag-niveau instructies te interpreteren zonder de context van de hoog-niveau taal.
• Invloed van Context: Modellen presteren beter bij "Groep 3 Long" (waar helper-functies in de context zitten) dan bij "Groep 3 Short" in de standaard setting, maar dit voordeel verdwijnt grotendeels bij anonimiserende settings, wat aantoont dat modellen moeite hebben om de logica van helper-functies te integreren zonder de namen te gebruiken.
• Fine-tuning Beperkingen: Het fine-tunen van modellen op de trainingsset verbetert de algemene prestaties, maar lost het robuustheidsprobleem niet op. De kloof tussen prestaties op standaard code versus geanonimiseerde code blijft bestaan, wat aangeeft dat standaard supervised learning onvoldoende is om echte semantisch robuuste zoekopdrachten te leren.

Significantie en Conclusie

CLARC legt een kritieke zwakte bloot in de huidige generatie code-zoekmodellen: ze zijn "lexische krakers" en geen "semantische begrijpers". Zolang modellen afhankelijk blijven van namen en tekstuele oppervlakken, zullen ze falen in scenario's zoals:

• Het doorzoeken van geobfuscureerde code (veiligheid/analyses).
• Het zoeken in gecompileerde binaries (Assembly/Wasm).
• Het werken met code waar namen zijn gewijzigd (refactoring).

De dataset en pipeline bieden een noodzakelijk fundament voor de gemeenschap om modellen te trainen en evalueren die werkelijk de intentie en structuur van code begrijpen, ongeacht de oppervlakkige representatie. De dataset is publiek beschikbaar via Hugging Face.