Technische Samenvatting: Neuronale Codevertaling van Legacy Code van APL naar C#

Probleemstelling

De migratie van legacy-systemen van gespecialiseerde, array-georiënteerde talen naar moderne, statisch getypeerde objectgeoriënteerde talen vormt aanzienlijke uitdagingen voor onderhoudbaarheid en integratie. Dit artikel behandelt het specifieke probleem van het vertalen van APL (A Programming Language) naar C#. De taak is inherent moeilijk door drie primaire factoren:

1. Syntactische Dispariteit: APL maakt gebruik van een schaarse syntaxis met unieke glyphen en werkt op multidimensionale arrays zonder expliciete loops, terwijl C# vertrouwen stelt op uitvoerige, expliciete procedurele logica en distincte typehandtekeningen.
2. Data Schaarste: Er is een gebrek aan grootschalige, parallelle corpora die functioneel equivalente APL- en C#-codeparen bevatten, wat de training van standaard neuronale vertaalmodellen beperkt.
3. Semantische Ambiguïteit: De dynamische typering van APL en rank-polymorfe functies (waarbij een enkele functie werkt op scalairen, vectoren en matrices) creëren ambiguïteit bij het mappen naar het strikte typesysteem van C#, wat vaak complexe methodenoverlading of runtime-typecontrole vereist om functionaliteit te behouden.

Methodologie

De studie behandelt codevertaling als een sequentie-naar-sequentie generatieprobleem met behulp van Large Language Models (LLM's). Om data-beperkingen en structurele ambiguïteiten te overwinnen, stellen de auteurs een framework voor en evalueren ze vier verschillende vertaalstrategieën tegen een baseline:

1. Directe Vertaling (Baseline): Finetunen van een LLM om APL-code direct naar C# te vertalen zonder tussentijdse begeleiding.
2. Natuurlijke Taal (NL) Mediatie: Een tweestapsbenadering waarbij een LLM eerst een hoog-niveau beschrijving in natuurlijke taal genereert van de APL-code, die vervolgens wordt gecombineerd met de broncode om de C#-vertaling te genereren.
3. Retrieval-Augmented Generation (RAG): Het systeem haalt relevante APL-documentatie en idiomatische uitdrukkingen op uit externe bibliotheken (bijv. APL2 Idiom Library) om context te bieden aan het model tijdens de generatie.
4. Iteratieve Verfijning: Een geautomatiseerde lus waarbij gegenereerde C#-code wordt gecompileerd en uitgevoerd tegen testcases. Compilatiefouten, runtime-uitzonderingen en functionele mismatches worden teruggekoppeld aan het model als context voor daaropvolgende verfijningsiteraties.

Dataset Constructie:
Vanwege de schaarste aan bestaande data hebben de auteurs meerdere datasets geconstrueerd:

• Dataset A: 800 handmatig samengestelde fundamentele APL-C#-paren.
• Dataset B: 143 complexe hulpprogramma-functies afgeleid van productieomgevingen.
• Dataset C: 320 cross-taal implementaties van Rosetta Code.
• Dataset I: 45 APL-idiomen met beschrijvingen.
  Een totaal van 1.066 samples werd gebruikt voor finetunen, waarbij Dataset B diende als primaire testomgeving voor productie-gerichte generalisatie.

Technische Implementatie:

• Tokenisatie: De studie analyseerde tokenisatie-efficiëntie voor APL-glyphen en identificeerde Qwen3-32B en Gemma-4-31b-it als de meest efficiënte modellen voor het verwerken van APL-tekens zonder round-trip-fouten.
• Finetunen: Parameter-efficiënt finetunen (LoRA) met 8-bit kwantisatie werd ingezet om modellen binnen de beschikbare H100 GPU-geheugenbeperkingen te laten passen.
• Evaluatiepipeline: Een geautomatiseerde pipeline verifieerde vertaalkwaliteit door te controleren op succesvolle compilatie en functionele equivalentie tegen input-output testcases.

Belangrijkste Bijdragen

• Eerste Systematisch Onderzoek: Dit werk presenteert het eerste systematische onderzoek en gespecialiseerde dataset voor neuronale codevertaling van APL naar een moderne taal (C#).
• Geleide Vertaalframework: Het artikel introduceert en valideert empirisch een framework dat methodesignaturen (geëxtraheerd via een F#-parser), beschrijvingen in natuurlijke taal en iteratieve feedbacklussen combineert om de paradigma-kloof tussen APL en C# te overbruggen.
• Geautomatiseerde Evaluatie: De ontwikkeling van een rigoureuze evaluatiepipeline die zowel syntactische correctheid (compilatie) als functionele correctheid (uitvoering) meet voor gegenereerde code.

Experimentele Resultaten

De experimenten werden uitgevoerd op een testset van 49 productie-grade APL-functies (uit Dataset B). Belangrijkste bevindingen zijn:

• Impact van Begeleiding: De opname van C#-methodesignaturen verbeterde de compilatiepercentages aanzienlijk voor alle modellen. Bijvoorbeeld, het toevoegen van signaturen aan het Gemma-4-31b-it-model verhoogde het volledige slagingspercentage van 22,45% naar 46,94%.
• Effectiviteit van Iteratie: De Iteratieve Vertaling-strategie leverde de hoogste prestaties op. De combinatie van NL-beschrijvingen en iteratieve feedback bereikte een piek Volledig Slagingspercentage van 79,59% met Claude Opus 4, gevolgd door 77,55% met Gemma-4-31b-it.
• Modelprestaties: Gefinetuned open-weight modellen (Gemma-4-31b-it, Qwen3-32B) met begeleidingsstrategieën behaalden prestaties die concurrerend waren met closed-weight modellen (GPT-5, Claude Opus 4).
• Foutanalyse: De primaire oorzaak van falen verschuift van compilatie/runtime-fouten in vroege iteraties naar functionele fouten in latere iteraties. Dit geeft aan dat hoewel modellen kunnen leren om syntactisch geldige C# te genereren, het behoud van de specifieke mathematische intentie van APL-idiomen het meest uitdagende aspect blijft.
• Data Schaling: Prestatiemetrics toonden een consistente opwaartse trend met een toename van de trainingsdatagrootte, wat suggereert dat de huidige resultaten worden beperkt door de dataset-schaal in plaats van de modelarchitectuur.

Betekenis en Claims

Het artikel claimt dat neuronale codevertaling de kloof tussen legacy APL-systemen en moderne C#-architecturen succesvol kan overbruggen, mits passende begeleidingsstrategieën worden toegepast. De auteurs stellen het volgende:

1. Haalbaarheid: Geautomatiseerde vertaling is levensvatbaar voor een breed scala aan programma's, verdergaand dan eenvoudige syntaxisconversie naar functionele equivalentie.
2. Kosteneffectiviteit: Door gefinetuned open-weight modellen te combineren met iteratieve verfijning kunnen organisaties resultaten behalen die vergelijkbaar zijn met dure closed-source modellen, wat een schaalbare oplossing biedt voor legacy-modernisering.
3. Praktische Toepasbaarheid: De methodologie vermindert de handmatige inspanning die nodig is om gemigreerde code te debuggen en te verfijnen, en adresseert het afnemende aantal APL-experts.

De auteurs behouden een bescheiden standpunt, waarbij zij opmerken dat hoewel de aanpak effectief is, het merendeel van de resterende mislukkingen voortkomt uit een misverstand van de originele APL-intentie in plaats van fouten in de generatie van low-level code. Zij concluderen dat toekomstig werk zich moet richten op het uitbreiden van trainingscorpora en de overgang van vertaling van een enkel programma naar multi-agent systemen die projectniveau-afhankelijkheden kunnen verwerken.