DePro: Understanding the Role of LLMs in Debugging Competitive Programming Code

Probleemstelling

Foutopsporing (debugging) verbruikt naar schatting bijna 50% van de levenscyclus van softwareontwikkeling. Hoewel Large Language Models (LLMs) succesvol zijn ingezet voor het genereren van code en het oplossen van algoritmen, is de effectiviteit van deze modellen bij het debuggen van bestaande, defecte code nog niet goed onderzocht. Bestaande tools (zoals Copilot) focussen vaak op het genereren van nieuwe oplossingen in plaats van het corrigeren van bestaande code.

Competitieve programmering biedt een ideale testomgeving voor deze evaluatie vanwege de strenge efficiëntie-eisen, diverse probleemgebieden en de aanwezigheid van specifieke testgevallen. De auteurs stellen dat LLMs vaak vastlopen bij complexe scenario's waar menselijke programmeurs flexibel redeneren, en dat er een gebrek is aan systematische evaluaties van LLMs in deze context.

Methodologie

De auteurs hanteren een tweeledige aanpak: eerst een empirische en handmatige studie om het gedrag van LLMs te begrijpen, gevolgd door de ontwikkeling en evaluatie van een geautomatiseerd systeem genaamd DePro.

1. Empirische en Handmatige Studie

• Dataverzameling: Er werd een dataset samengesteld van 100 defecte gebruikerscodes (10 gebruikers per 10 verschillende problemen) afkomstig van het platform Codeforces.
• Proces: ChatGPT-5 werd gevraagd om de bestaande code te debuggen zonder nieuwe code te genereren, maar door fouten in de huidige implementatie te corrigeren.
• Observaties:
  • LLMs waren over het algemeen efficiënter dan mensen (gemiddeld 1,8 pogingen versus 3,68 voor mensen).
  • Beperkingen: LLMs vertonen een gebrek aan strategisch redeneren. Ze neigen naar lokale aanpassingen rondom falende testgevallen in plaats van fundamentele herstructurering. Ze hebben moeite met problemen die meerdere geldige oplossingen toelaten of onconventionele heuristieken vereisen.
  • Kerninzicht: De prestaties van de LLM verbeterden aanzienlijk wanneer specifieke informatie over falende testgevallen (input en verwachte output) werd meegegeven.

2. DePro Architectuur (DePro: Debugging with Proactive Test Cases)

Gebaseerd op de bevindingen hierboven, ontwikkelden de auteurs DePro, een testcase-gedreven aanpak die bestaat uit drie fasen:

1. Brute-force Referentiegeneratie: De LLM genereert eerst een brute-force oplossing die alle sample testcases moet doorstaan. Dit dient als een "ground truth" of referentie.
2. Stress Testing en Faldetectie: De originele (defecte) gebruikerscode en de brute-force referentie worden uitgevoerd op een breed scala aan gegenereerde testgevallen, inclusief randgevallen (edge cases). Het proces stopt zodra een testcase wordt gevonden waarbij de output van de gebruikerscode afwijkt van de referentie.
3. Iteratief Debuggen met LLM:
   • De LLM wordt geprompt met de specifieke falende input, de verwachte output (van de brute-force oplossing) en de defecte code.
   • De LLM suggereert een correctie.
   • De aangepaste code wordt opnieuw onderworpen aan stress testing.
   • Deze feedbacklus (aanpassing -> testen -> feedback) loopt maximaal 8 iteraties per probleem.

Belangrijkste Bijdragen

• Empirisch Bewijs: Een gedetailleerde analyse van hoe LLMs zich gedragen bij het debuggen van competitieve programmeeropgaven, met een focus op de verschillen in strategie tussen mens en machine.
• DePro Framework: Introductie van een nieuw, geautomatiseerd debuggingsysteem dat brute-force referenties combineert met stress testing en iteratieve LLM-gestuurde correcties.
• Testcase-Gedreven Benadering: Het bewijs dat het leveren van specifieke falende testgevallen de debuggingsuccesratio van LLMs drastisch verhoogt ten opzichte van "zero-shot" prompting (zonder extra context).

Resultaten

DePro werd geëvalueerd op 13 defecte gebruikersinschrijvingen van 6 verschillende Codeforces-problemen.

• Aantal Pogingen: DePro reduceerde het aantal pogingen om een oplossing te vinden met 64% vergeleken met een zero-shot LLM-aanpak. In vergelijking met menselijke programmeurs was DePro ook consistenter en efficiënter.
• Tijdsbesparing: De gemiddelde debugtijd per probleem daalde met 7,6 minuten ten opzichte van menselijke methoden. DePro had gemiddeld slechts 6,5 minuten nodig per probleem om tot een correcte oplossing te komen.
• Succesratio: DePro slaagde erin om alle 13 geteste defecte codes te corrigeren tot een werkende oplossing.

Betekenis en Toekomstperspectief

• Efficiëntie: DePro toont aan dat het combineren van dynamische testfeedback met LLMs een krachtige methode is om de debugtijd aanzienlijk te verkorten.
• Toepassingsgebied: Hoewel de studie zich richt op competitieve programmering, heeft DePro potentie voor bredere software-engineering toepassingen, zoals het onderhoud van productiecode en geautomatiseerde reparatiepijplijnen.
• Beperkingen: De huidige methode is afhankelijk van de mogelijkheid om een correcte brute-force oplossing te genereren en effectieve testgevallen te produceren, wat uitdagingen kan vormen bij zeer complexe problemen of enorme invoerruimtes.
• Toekomst: De auteurs suggereren integratie met runtime-debuggers (zoals GDB) en symbolische executie-tools (zoals KLEE) om nog rijker uitvoeringsfeedback te krijgen, evenals toepassing in educatieve platforms en IDE's.

Kortom, het paper onderstreept dat LLMs waardevolle debug-assistenten kunnen zijn, maar dat hun effectiviteit sterk afhankelijk is van de kwaliteit van de feedback (specifiek falende testgevallen) die hen wordt geboden.