Che cos'è il refactoring del codice?

Martin Fowler ha reso popolare questa pratica attraverso il suo libro Refactoring, pubblicato nel 1999. Il refactoring del codice può aiutare a eliminare i "code smell", che Fowler definisce come "un'indicazione superficiale che di solito nasconde un problema più profondo nel sistema". Aggiunge che i code smell sono facili da individuare e cita, come esempi, metodi troppo lunghi e classi che contengono solo dati senza alcun comportamento.

Esempi di refactoring del codice includono la correzione della formattazione, la modifica dei nomi di variabili poco chiare, l'eliminazione di funzioni duplicate o inutilizzate e la suddivisione di metodi troppo lunghi in blocchi più semplici e gestibili. Queste semplici modifiche, che preservano il comportamento del codice, hanno meno probabilità di causare errori o malfunzionamenti, ma il loro effetto cumulativo può contribuire a ottimizzare le prestazioni del software.

Il refactoring può sembrare un'impresa semplice, ma esistono alcune tattiche che possono aiutare gli sviluppatori di software ad adottare un approccio più strategico:

    ● Astrazione

    ● Composizione

    ● Spostamento di funzionalità

    ● Red-green refactor

    ● Semplificazione

L'astrazione è un concetto fondamentale nella programmazione orientata agli oggetti. Comporta la generalizzazione degli oggetti in modo che i dettagli complessi siano nascosti e rimangano solo le informazioni essenziali.

Nel refactoring del codice, l'astrazione viene in genere implementata per codebase di grandi dimensioni. Si compone di 2 meccanismi:

● Il metodo pull-up estrae il codice da una sottoclasse e lo sposta verso l'alto nella gerarchia in una classe astratta o superclasse. Ciò consente una minore duplicazione del codice e una migliore riutilizzabilità di eventuali attributi o funzioni condivise.

 ● Il metodo push-down sposta il codice da una classe astratta o superclasse verso una sottoclasse, nel caso di logiche che non sono riutilizzabili o che si applicano solo a una specifica sottoclasse.

Questo approccio modulare scompone o divide grandi quantità di codice in parti più piccole per renderle più semplici e gestibili. Il metodo di estrazione e il metodo inline rappresentano 2 approcci alla composizione:

● L'approccio di estrazione consiste nel prendere parti di un metodo esistente e spostarle in un nuovo metodo. Questo può essere fatto, ad esempio, con metodi molto lunghi che contengono funzioni diverse, in modo che ciascuna funzione possa avere un proprio metodo autonomo.

● L'approccio inline consiste nel sostituire una chiamata a un metodo con il contenuto del metodo stesso, che viene poi eliminato. Questo si applica solitamente a metodi composti da poche righe di codice e utilizzati, ad esempio, da una sola classe.

In questa tecnica, attributi, metodi e altre funzionalità vengono spostati tra classi diverse per ridurre le dipendenze e migliorare la coesione all'interno delle funzioni di una classe e tra le classi stesse. Questa ridistribuzione consente di ottenere una progettazione più logica ed equilibrata del codice esistente, semplificandone l'estensione e la manutenzione.

Il metodo red-green-refactor deriva dal test-driven development, un approccio in cui i test vengono scritti prima del codice sorgente vero e proprio. Si tratta di una strategia iterativa che consente refactoring e test continui.

Questo processo in 3 fasi prevede i seguenti passaggi:

● Durante la fase red, gli sviluppatori scrivono dei test per convalidare un comportamento o una funzione specifica del software. Questi test sono inizialmente destinati a fallire perché il codice non è stato ancora creato.

● Nella fase green, i programmatori scrivono il codice per il comportamento o la funzione specificati. Può trattarsi del codice minimo necessario per superare i test, perché in questa fase l’obiettivo è la velocità più che la qualità.

● Infine, la fase refactor è quella in cui avviene il perfezionamento, apportando tutti i miglioramenti necessari per ottenere un codice più pulito, chiaro ed efficiente, preservandone comunque il comportamento e superando tutti i test correlati.

L'obiettivo è semplificare il codice e la logica associata. Questo può avvenire riducendo il numero di parametri di un metodo, rinominando variabili o metodi troppo lunghi, combinando espressioni condizionali che portano allo stesso risultato, disaccoppiando frammenti condizionali complessi o anche utilizzando il polimorfismo al posto delle condizioni.

Possiamo paragonare il refactoring del codice all'abitudine di riordinare una stanza ogni giorno per rendere le pulizie nel fine settimana molto più facili e veloci. L'obiettivo del refactoring del codice è ridurre il debito tecnico, che si accumula con l'utilizzo di scorciatoie da parte dei programmatori, come la duplicazione della logica, il mancato rispetto delle regole di programmazione o l'uso di nomi di variabili poco chiari.

Questi sono alcuni dei vantaggi che i team di sviluppo software possono ottenere dal refactoring del codice:

    ● Minore complessità

    ● Maggiore manutenibilità

    ● Migliore leggibilità del codice

    ● Maggiore velocità

Il refactoring semplifica il codice, aiutando gli sviluppatori a comprendere meglio anche codebase molto ampie. Questo è particolarmente utile per i programmatori appena assunti, che possono familiarizzare più rapidamente con il funzionamento di un codice a loro nuovo.

Il refactoring del codice crea le basi per una manutenzione più efficace. Un codice chiaro richiede meno sforzi durante il debug, l'implementazione di nuove funzionalità, l’aggiornamento di quelle esistenti o il passaggio alle tecnologie più recenti. Come la manutenzione preventiva nel settore manifatturiero, il refactoring del codice consente di effettuare piccole correzioni nel presente per evitare problemi maggiori in futuro.

Il refactoring rende il codice più pulito, più facile da capire e da gestire. Il codice sottoposto a refactoring è anche più semplice da esplorare , contribuendo a rendere più fluido il processo di sviluppo software.

Il refactoring potrebbe non avere un impatto significativo come le ottimizzazioni del codice mirate a migliorare le prestazioni. Tuttavia, un codice più semplice e snello può comunque rendere un software più efficiente e i tempi di esecuzione più veloci.

Il refactoring può migliorare il codice rendendolo più chiaro e pulito, ma il processo può presentare degli inconvenienti. Ecco alcune sfide che i team di sviluppo potrebbero incontrare durante il refactoring del codice:

    ● Assegnazione degli sviluppatori

    ● Introduzione di bug

    ● Codice legacy

    ● Scope creep

    ● Vincoli di tempo

I team devono decidere chi farà parte del processo di refactoring del codice e quali saranno i loro ruoli e responsabilità. Ciò può distogliere i programmatori dalle attività più importanti di sviluppo software e i team più piccoli potrebbero non essere in grado di permettersi tale compromesso.

Anche la più piccola modifica del codice comporta la possibilità di creare un nuovo bug o di farne riemergere uno esistente. Un refactoring più complesso del codice potrebbe anche causare malfunzionamenti o alterare caratteristiche e funzioni.

Il codice legacy si riferisce a vecchie codebase che svolgono ancora il loro ruolo, ma sono state sviluppate utilizzando tecnologie ormai obsolete e non sono più attivamente supportate o mantenute. Durante il refactoring potrebbero anche sorgere problemi di dipendenza e di compatibilità. Per gestire eventuali modifiche che possano influire sul codice legacy, è necessaria un’analisi più approfondita del codice e un piano dettagliato.

Si potrebbe essere tentati di correggere più cose del necessario, soprattutto se non è stato predisposto alcun piano o non sono stati fissati obiettivi chiari. Quando si effettua una riorganizzazione logica del codice, l'intervento può ampliarsi se i programmatori non si sono presi il tempo di esaminare il codice e individuare quali parti possono essere ottimizzate.

Il refactoring del codice può richiedere molto tempo, cosa che manca alla maggior parte dei team di sviluppo. Devono trovare un equilibrio tra la necessità di effettuare il refactoring e il rispetto delle scadenze di progetto, valutando quando intervenire e fino a che punto.

Prima di intraprendere un percorso di refactoring del codice, tieni in considerazione questi suggerimenti per superare le sfide del processo:

    ● Le tempistiche sono importanti

    ● La pianificazione è fondamentale

    ● Analizzare e standardizzare

    ● Eseguire test e documentare

Il momento in cui effettuare il refactoring del codice è importante tanto quanto il perché o il come. Può rientrare tra le attività periodiche di manutenzione di un team di sviluppo software oppure essere integrato nelle revisioni del codice.

Il refactoring è fondamentale anche prima di aggiungere nuove funzionalità, introdurre aggiornamenti importanti, passare a tecnologie più recenti o aggiornare le application programming interface (API) o le librerie. Questo crea una struttura più scalabile e adattabile su cui costruire in futuro.

Il refactoring del codice può richiedere molto tempo, rendendo essenziale la pianificazione. I team di sviluppo devono tenere in considerazione i propri obiettivi e l'ambito di intervento. Possono procedere per piccoli passi, dedicando alcuni giorni a piccole modifiche come l'eliminazione di codice inutilizzato, la correzione della formattazione o la rimozione di duplicati. Nei casi in cui è richiesta una pulizia più complessa, il refactoring diventa un progetto con tempistiche e intervalli di tempo più lunghi.

Le attività di refactoring più semplici non richiedono analisi approfondite. Tuttavia, per le tecniche che riguardano la logica, è fondamentale una comprensione completa di tutto il codice correlato. Comprendere le ragioni alla base della struttura del codice può aiutare i programmatori a prendere decisioni più consapevoli e apportare modifiche mirate.

Inoltre, seguire le regole di programmazione e i principi di progettazione di un team può preservare l'integrità e l'architettura della codebase.

Eseguire il refactoring non significa solo migliorare il codice: richiede anche di assicurarsi che tali miglioramenti funzionino. Per questo motivo i test sono importanti, per confermare che il software e il suo funzionamento rimangano intatti.

Sebbene gli sviluppatori possano eseguire i propri test unitari e di integrazione, coinvolgere il team del controllo qualità è fondamentale. Il team può eseguire test funzionali per verificare le funzionalità e i test di regressione per verificare che il codice sottoposto a refactoring non introduca bug o interrompa alcuna funzione.

Anche documentare le modifiche è importante all'interno del processo. In questo modo è più facile tenere traccia delle modifiche ed effettuare il refactoring del codice in futuro.

Ci sono diversi strumenti che possono aiutare a velocizzare e automatizzare il refactoring del codice. Ecco alcuni dei più diffusi:

    ● Ambienti di sviluppo integrati (IDE)

    ● Analizzatori statici di codice

    ● Altre risorse

Molti degli IDE odierni offrono già funzionalità integrate per il refactoring automatico, senza rischiare di compromettere il codice o introdurre bug. Alcuni forniscono persino suggerimenti per il refactoring basati su AI.

Gli IDE che possono essere utilizzati per il refactoring del codice includono IntelliJ IDEA per i linguaggi di programmazione basati su Java Virtual Machine (JVM), PyCharm per Python e l'estensione ReSharper Visual Studio per C#, C++ e .NET.

Gli analizzatori statici valutano il codice senza eseguirlo. Questi analizzatori rilevano i difetti di programmazione più comuni e i problemi di qualità del codice, aiutando gli sviluppatori a risolverli nelle prime fasi del processo di sviluppo software.

Esempi di analizzatori statici di codice includono Codacy e il PMD open source che supportano entrambi più linguaggi di programmazione, JArchitect per Java, NDepend per .NET e il linter e formattatore RuboCop per Ruby.

Refactoring.com è il sito web di Martin Fowler che contiene un catalogo online dei metodi di refactoring tratti dal suo libro. Refactoring.Guru è un altro sito web che illustra tecniche di refactoring e modelli di progettazione.

L'intelligenza artificiale (AI) può aiutare nel processo di refactoring del codice. Le applicazioni di AI generativa si basano su modelli linguistici di grandi dimensioni (LLM) in grado di analizzare codebase complesse o di grandi dimensioni e di comprenderne la semantica e il contesto. Sulla base di ciò, forniscono prontamente suggerimenti per il refactoring in tempo reale.

IBM® watsonx Code Assistant, ad esempio, impiega i modelli IBM® Granite per identificare bug e aree di miglioramento. Suggerisce quindi correzioni mirate che si allineano alle convenzioni di programmazione stabilite da un team, contribuendo a semplificare e accelerare il refactoring del codice. Altri strumenti di refactoring AI simili includono Amazon CodeGuru Reviewer, GitHub Copilot e ChatGPT di OpenAI.

Per chi lavora con codice legacy, IBM watsonx Code Assistant for Z unisce AI generativa e automazione per aiutare gli sviluppatori a modernizzare le proprie applicazioni. watsonx Code Assistant for Z Refactoring Assistant consente agli sviluppatori di ristrutturare le proprie applicazioni in servizi più modulari e riutilizzabili. Utilizza algoritmi di analisi del codice per modernizzare le applicazioni COBOL.

Come con qualsiasi sistema di AI, gli sviluppatori devono comunque esaminare gli output degli strumenti di refactoring del codice basati su AI per verificarne l'accuratezza. È inoltre necessario eseguire dei test per assicurarsi che le modifiche suggerite funzionino come previsto.