From Restructuring to Stabilization: A Large-Scale Experiment on Iterative Code Readability Refactoring with Large Language Models

1. Il Problema e il Contesto

I Large Language Models (LLM) sono sempre più utilizzati per l'automazione del refactoring del codice. Sebbene questi modelli possano modificare rapidamente il codice, la qualità dei risultati è spesso incoerente e il comportamento può essere imprevedibile.
Il problema centrale affrontato dallo studio è la mancanza di comprensione su come gli LLM si comportano quando sottoposti a iterazioni ripetute di refactoring. Nello specifico, gli autori si chiedono:

• Gli LLM convergono verso una rappresentazione stabile e "ottimale" del codice dopo diverse iterazioni?
• Oppure continuano a introdurre cambiamenti superficiali, oscillanti o regressivi?
• Come influenzano diverse strategie di prompt (generici vs. mirati) e le condizioni iniziali del codice (es. nomi di variabili privi di senso, assenza di commenti) questo processo di evoluzione?

2. Metodologia

Gli autori hanno condotto un esperimento su larga scala utilizzando il modello GPT-5.1 di OpenAI.

• Dataset: Sono stati selezionati 230 snippet di codice Java dal repository open source "The Algorithms – Java".
• Varianti dei Dati: Per ogni snippet originale, sono state create tre varianti per testare diverse condizioni di partenza:
  1. Originale: Codice conforme alle best practice.
  2. Meaningless: Nomi di classi, metodi e variabili resi privi di senso, e contenuti dei commenti alterati (mantenendo la struttura).
  3. NoComment: Rimozione totale di tutti i commenti (JavaDoc, blocchi e inline).
• Iterazioni e Prompt: Ogni variante è stata sottoposta a 5 iterazioni di refactoring utilizzando tre diverse strategie di prompt:
  1. Prompt Generale: "Refactor this code for improved readability." (Non guidato).
  2. Prompt Mirato (Naming): Focus specifico sul miglioramento della nomenclatura degli identificatori.
  3. Prompt Mirato (Comments): Focus specifico sul miglioramento dei commenti.
• Strumenti di Analisi: È stato sviluppato un tool personalizzato (DiffParser) in Python che utilizza misure di similarità basate su sequenze, token e AST (Abstract Syntax Tree) per categorizzare le modifiche a livello di riga in:
  • Cambiamenti di implementazione (semantici).
  • Cambiamenti sintattici.
  • Cambiamenti nei commenti.
  • Rinominazioni.
• Metriche: Sono state analizzate metriche assolute (linee di codice, commenti, metodi) e relative (percentuale di codice invariato, similarità media tra versioni, distribuzione dei tipi di cambiamento).

3. Contributi Chiave

Il paper offre quattro contributi principali:

1. Evidenza Empirica di Convergenza: Dimostra che il refactoring iterativo basato su LLM tende a convergere verso uno stato stabile, anche partendo da codice degradato, suggerendo che i modelli possiedono una comprensione internalizzata di cosa costituisca un codice "leggibile".
2. Analisi dell'Impatto dei Prompt: Evidenzia come la progettazione del prompt influenzi drasticamente la traiettoria del refactoring (es. prompt focalizzati sui nomi causano oscillazioni, mentre quelli sui commenti favoriscono la stabilizzazione).
3. Framework Riutilizzabile: Fornisce un framework agnostico rispetto al modello LLM per analizzare l'evoluzione del codice sotto refactoring iterativo, permettendo repliche esatte e studi comparativi.
4. Pacchetto di Replicazione: Rilascio pubblico di tutti i dati, snippet, script e figure per la riproducibilità completa dello studio.

4. Risultati Principali

A. Dinamica di Evoluzione: Ristrutturazione seguita da Stabilizzazione (RQ1)

• Fase Iniziale: Le prime iterazioni (v0 → v1) introducono cambiamenti sostanziali (rinominazioni, decomposizione in metodi, rimozione di commenti).
• Fase di Stabilizzazione: Dalle iterazioni successive (v2 in poi), il numero di cambiamenti diminuisce drasticamente. La similarità tra le versioni aumenta costantemente, indicando che il modello converge verso una rappresentazione stabile.
• Osservazione Critica: Anche quando il codice di partenza è già di alta qualità, l'LLM continua a introdurre piccole modifiche non necessarie (over-refactoring), suggerendo che la sua definizione interna di "ottimo" potrebbe differire leggermente dalle best practice umane o che tende a perfezionare eccessivamente.

B. Convergenza tra Varianti (RQ2)

• Indipendentemente dal punto di partenza (codice originale, nomi privi di senso o assenza di commenti), tutte le varianti convergono verso rappresentazioni strutturalmente molto simili dopo 5 iterazioni.
• Le metriche strutturali (numero di righe, commenti, metodi) si stabilizzano rapidamente.
• Questo suggerisce un effetto di normalizzazione: l'LLM tende a ridurre le differenze strutturali e stilistiche, allineando il codice a un insieme di convenzioni interne coerenti.

C. Impatto dei Prompt Espliciti (RQ3)

• Prompt per i Nomi (Naming): Ha un effetto destabilizzante. Le operazioni di rinominazione persistono per tutte le iterazioni, causando un comportamento oscillatorio (il modello cambia nome, poi lo cambia di nuovo in iterazioni successive) senza raggiungere una vera stabilità.
• Prompt per i Commenti: Porta a una rapida stabilizzazione. L'LLM aggiunge commenti nella prima iterazione e poi smette di modificarli, riconoscendo che ulteriori aggiunte non migliorano la leggibilità.
• Significatività Statistica: I test statistici (Kruskal-Wallis e Mann-Whitney U) confermano che la scelta del prompt ha un impatto statisticamente significativo sulla frequenza dei cambiamenti di tipo "Rename" e "CommentChange".

D. Robustezza e Correttezza Funzionale

• Correttezza Funzionale: Un'analisi di follow-up su 154 snippet con test unitari ha mostrato che il refactoring ha causato un calo minimo (<1%) nella correttezza funzionale, confermando che le modifiche strutturali non compromettono significativamente il comportamento del codice.
• Codice Nuovo: Un esperimento su snippet generati dopo la data di cutoff del training del modello (codice "nuovo") ha replicato gli stessi risultati, indicando che il comportamento osservato non è dovuto alla memorizzazione dei dati di training ma a una comprensione fondamentale del codice.

5. Significato e Implicazioni

Questo studio fornisce una base empirica fondamentale per valutare l'affidabilità del refactoring assistito da LLM:

• Sicurezza d'uso: Gli sviluppatori possono utilizzare il refactoring iterativo con maggiore fiducia, sapendo che il processo tende a stabilizzarsi e a non degradare la funzionalità.
• Gestione del Processo: È necessario implementare criteri di arresto espliciti per evitare l'over-refactoring, specialmente quando si usano prompt generici su codice già buono.
• Ingegneria del Prompt: La scelta del prompt è critica. Prompt troppo specifici su aspetti dinamici (come i nomi delle variabili) possono portare a cicli infiniti di modifiche, mentre prompt su aspetti statici (commenti) favoriscono la stabilità.
• Futuro della Ricerca: Il lavoro apre la strada a studi comparativi tra diversi modelli LLM e alla valutazione sistematica di altre dimensioni della qualità del software (es. complessità, code smells) in contesti di refactoring automatizzato.

In sintesi, il paper dimostra che gli LLM possiedono una capacità robusta di normalizzare il codice verso standard di leggibilità coerenti, ma richiedono una gestione attenta delle iterazioni e dei prompt per evitare comportamenti oscillanti o modifiche eccessive.