Integrating Structural and Semantic Analysis for Code Smell Refactoring Prediction

Software is nooit echt af. Net als een stad die organisch over decennia heen groeit, stapelen computerprogramma's lagen van toevoegingen, patches en snelle oplossingen op. Na verloop van tijd kan deze organische groei leiden tot structurele zwakheden, vergelijkbaar met een gebouw waarbij een gang breder is gemaakt zonder de muren te verstevigen. In de wereld van software engineering worden deze lokale gebreken "code smells" genoemd. Het zijn geen fouten die ervoor zorgen dat een programma crasht, maar eerder tekenen van slecht ontwerp die de code moeilijk begrijpelijk, aanpasbaar of onderhoudbaar maken. Wanneer ontwikkelaars deze "smells" opmerken, voeren ze vaak "refactoring" uit, een zorgvuldig proces van het herorganiseren van de code om de structuur te verbeteren zonder te veranderen wat de software daadwerkelijk doet. De uitdaging is dat ontwikkelaars niet altijd elke geur die ze vinden oplossen, en het voorspellen welke ervan worden opgelost is moeilijk omdat de beslissing vaak afhangt van menselijke intentie en context, en niet alleen van de code zelf.

Een team onderzoekers aan de Universiteit van Milano-Bicocca zette zich in om te zien of machines konden leren om deze menselijke beslissingen te voorspellen. Ze wilden weten of een computer naar een stuk code kon kijken, een gebrek kon identificeren, en accuraat kon raden of een ontwikkelaar het uiteindelijk zou opruimen. Om dit te doen, bouwden ze een systeem dat twee verschillende manieren combineert om naar code te kijken. De eerste manier is traditioneel: het tellen van eigenschappen zoals hoe lang een methode is of hoeveel variabelen deze gebruikt. De tweede manier is moderner en complexer: het omzetten van de code in een kaart van de logica en het gedrag, om die kaart vervolgens te vertalen naar een wiskundige representatie die een computer kan analyseren op verborgen patronen. Door deze gecombineerde informatie in machine learning-modellen te voeden, testten de onderzoekers of computers de subtiele regels konden leren die sturen wanneer een ontwikkelaar besluit tot refactoring.

De onderzoekers verzamelden gegevens van 79 open-source Java-projecten, een collectie software die door vele verschillende mensen is ontwikkeld en onderhouden over een bepaalde tijd. Ze gebruikten geautomatiseerde tools om de geschiedenis van deze projecten te scannen, waarbij ze duizenden instanties identificeerden waar code smells aanwezig waren en bijhielden welke later werden opgelost door specifieke refactoring-acties, zoals het hernoemen van een variabele, het extraheren van een methode naar een kleiner stuk, of het veranderen van een parameter. Vervolgens creëerden ze een hybride dataset voor elk stuk code. Deze dataset bevatte standaardmetingen, zoals het aantal regels in een methode, naast twee verschillende soorten "embeddings". Het ene type embedding bracht de controleflow in kaart, die laat zien in welke volgorde instructies worden uitgevoerd. Het andere, geavanceerdere type, bracht de diepere semantische relaties in kaart, waarbij werd vastgelegd hoe data door het programma beweegt en hoe verschillende delen van de code van elkaar afhankelijk zijn, wat effectief een rijk, multidimensionaal portret vormt van het gedrag van de code.

De resultaten toonden aan dat machine learning-modellen inderdaad in staat zijn om refactoring met een hoge mate van betrouwbaarheid te voorspellen. Wanneer de modellen werden getest op tien verschillende soorten refactoring-operaties, behaalden ze regelmatig AUC-scores ruim boven de 0,70, en voor sommige taken zelfs boven de 0,80. Dit suggereert dat er inderdaad detecteerbare patronen in de code zitten die de intentie van een ontwikkelaar om op te ruimen signaleren. De studie onthulde echter een cruciale nuance: niet alle code smells zijn gelijk. De modellen waren uitzonderlijk goed in het voorspellen van structurele wijzigingen, zoals het toevoegen van een parameter aan een methode of het veranderen van het type van een variabele. Deze acties worden vaak gedreven door duidelijke, meetbare factoren zoals de lengte van een instructie of de complexiteit van een berekening. In contrast hiermee hadden de modellen moeite met het voorspellen van meer conceptuele wijzigingen, zoals het hernoemen van een methode. Hernoemen is vaak een subjectieve beslissing gebaseerd op hoe een ontwikkelaar over het doel van de code denkt, een factor die moeilijk enkel met getallen of structurele kaarten te vatten is.

Misschien wel de meest significante bevinding betrof het type gegevensrepresentatie dat werd gebruikt. De onderzoekers verwachtten aanvankelijk dat het simpelweg toevoegen van complexere kaarten van de executieflow van de code de voorspellingen zou verbeteren. In plaats daarvan ontdekten ze dat een specifere soort flow-kaart, die de volgorde van instructies bijhield, juist ruis introduceerde die de modellen in verwarring bracht. Wanneer deze flow-kaart werd gecombineerd met de traditionele metingen, maakte het de voorspellingen vaak slechter, omdat de computer moeite had om de irrelevante details te negeren. Echter, toen de onderzoekers overstapten naar de meer geavanceerde representatie die structurele afhankelijkheden combineerde met de werkelijke tekst en logica van de code, veranderden de resultaten drastisch. Deze rijkere representatie bood een complementair signaal dat de modellen effectief konden gebruiken. Sterker nog, voor sommige taken presteerden de modellen die uitsluitend getraind waren op deze geavanceerde representatie bijna net zo goed als die getraind waren op de volledige dataset, wat bewees dat het diepe structurele en semantische begrip van de code op zichzelf een krachtige voorspeller is.

De studie benadrukte ook de grenzen van wat voorspeld kan worden vanuit code alleen. Hoewel de modellen betrouwbaar technische fixes kunnen voorspellen die gedreven worden door complexiteit, konden ze niet gemakkelijk de menselijke beslissingen voorzien achter het hernoemen of reorganiseren van code voor de duidelijkheid. Dit suggereert dat hoewel machines uitstekend kunnen zijn in het identificeren wanneer software technisch gezien toe is aan onderhoud, de uiteindelijke beslissing tot refactoring vaak rust op een visie en context van de ontwikkelaar die buiten de code zelf bestaat. Het onderzoek concludeert dat de toekomst van geautomatiseerd softwareonderhoud niet ligt in het vervangen van menselijk oordeel, maar in het gebruiken van deze voorspellende tools om de structurele schulden te highlighten die het meest urgent zijn, zodat ontwikkelaars hun beperkte tijd kunnen richten op de wijzigingen die er echt toe doen. Door te begrijpen welke signalen sterk zijn en welke ruis zijn, kunnen we betere tools bouwen om onze digitale infrastructuur gezond en duurzaam te houden.