Che cos'è il codice legacy?

Nel suo libro del 2004 Working Effectively with Legacy Code, Michael Feathers ha offerto un'altra descrizione: "codice senza test".¹ Questa definizione di codice legacy implica che i programmatori non hanno modo di verificare che il codice funzioni come previsto. Molti sistemi legacy mancano inoltre di una documentazione adeguata, fondamentale per comprenderne il comportamento, il che rende la loro estensione o il loro miglioramento un compito difficile per gli sviluppatori.

Il codice legacy contribuisce al debito tecnico, che deve essere "ripagato" nel tempo attraverso una manutenzione del codice. Ecco alcune sfide comuni che le organizzazioni potrebbero incontrare nella manutenzione del codice legacy:

    ● Adattabilità

    ● Costi

    ● Prestazioni

    ● Scalabilità

    ● Sicurezza e conformità

A causa della sua natura obsoleta, il codice legacy può essere incompatibile o difficile da integrare con i sistemi più moderni. Questa mancanza di adattabilità può ostacolare l'innovazione e rallentare la crescita aziendale, con il rischio che le imprese perdano il loro vantaggio competitivo.

I sistemi legacy possono essere costosi da mantenere. I costi operativi e di manutenzione possono aumentare, così come i costi di assistenza di terze parti per le versioni più vecchie di software e hardware. Inoltre, trovare sviluppatori esperti in pratiche informatiche o linguaggi di programmazione obsoleti può essere impegnativo e costoso.

Le architetture ingombranti e monolitiche portano a una elevata latenza, tempi di risposta lenti e frequenti tempi di inattività. Prestazioni inadeguate possono influire negativamente sull'esperienza dell'utente, riducendo la soddisfazione dei clienti. Possono anche ostacolare la produttività e l'efficienza dei membri del team che gestiscono e mantengono questi sistemi.

I sistemi obsoleti possono risentire dell'aumento del carico di utenti. Hanno difficoltà a soddisfare un aumento della domanda e a scalare in base alle esigenze. I loro componenti strettamente accoppiati rendono anche difficile l'aggiornamento delle funzionalità esistenti o l'aggiunta di nuove.

Il vecchio codice potrebbe non essere aggiornato attivamente con patch di sicurezza e non seguire gli standard di sicurezza più recenti, e quindi diventare vulnerabile agli attacchi informatici e alle violazioni. I sistemi legacy potrebbero anche non essere conformi alle normative vigenti.

La modernizzazione delle applicazioni legacy richiede un'attenta pianificazione. Ecco una metodologia in 5 fasi per semplificare il processo:

    ● Conoscere la codebase

    ● Suddividere il problema per risolverlo

    ● Creare test di caratterizzazione

    ● Effettuare refactoring, migrazione o riscrittura

    ● Eseguire test e documentare

Il primo passo è conoscere la codebase, e di solito è la parte più difficile. Inizia esaminando tutta la documentazione disponibile, che si tratti di documenti sui requisiti, commenti nel codice o cronologia del controllo delle versioni, come registri di commit o registri delle modifiche.

Se la documentazione non è sufficiente, prova a utilizzare strumenti di analisi statica del codice che esaminano automaticamente il codice senza eseguirlo. Inoltre, gli strumenti di visualizzazione del codice possono creare una rappresentazione grafica della struttura del codice sorgente, aiutando a mappare le dipendenze e le interazioni tra gli elementi.

Una volta che i team di sviluppo software hanno acquisito una conoscenza approfondita del sistema legacy, possono iniziare ad affrontarlo. Gestire queste vaste codebase può essere complicato, quindi è consigliabile dividerle in moduli più piccoli e gestibili e lavorare su un modulo alla volta.

I test vengono in genere scritti per convalidare la correttezza del codice e il comportamento previsto. I test di caratterizzazione, invece, vengono creati per comprendere cosa fa il codice e come funziona. Di conseguenza, possono essere utili per conoscere il codice legacy.²  

Le aziende hanno generalmente 3 opzioni per modernizzare il codice legacy: refactoring, migrazione o riscrittura. Possono anche combinare questi approcci. Decidere quale percorso intraprendere richiede il coinvolgimento sia del team di ingegneria del software che del team di leadership aziendale.

Il refactoring del codice altera la struttura interna del codice sorgente senza modificarne il comportamento esterno o influire sulla sua funzionalità. Queste piccole modifiche hanno meno probabilità di introdurre bug e possono contribuire a creare un codice più chiaro, pulito e gestibile.

Per il codice legacy, i team possono iniziare con piccole modifiche per ciascun modulo, ad esempio rinominando le variabili, rimuovendo i metodi duplicati o inutilizzati e standardizzando la formattazione. Possono quindi procedere con una ristrutturazione più basata sulla logica, ad esempio suddividendo metodi troppo grandi in altri più piccoli, semplificando condizioni complesse e spostando parti di logica tra funzioni per ridurre le dipendenze e migliorare la coesione.

La migrazione è un altro percorso verso la modernizzazione del codice legacy. Comporta la migrazione totale o parziale del codice verso piattaforme o stack più recenti, come la transizione da un'architettura monolitica ai microservizi o il passaggio da un ambiente on-premise al cloud. È importante verificare la compatibilità con la piattaforma o lo stack tecnologico e confermare se i provider offrono supporto durante la migrazione.

La riscrittura del codice legacy è spesso l'ultima risorsa, perché comporta la creazione di codice completamente nuovo per sostituire quello vecchio. Questo è di per sé un nuovo progetto, un'impresa enorme che potrebbe richiedere un team di sviluppo separato per essere gestita.

Sia la migrazione che la riscrittura possono essere un compito arduo per enormi codebase legacy, quindi i team possono prendere in considerazione la "strangler fig strategy".³ Il fico strangolatore (strangler fig) cresce sulla sommità di un albero, facendo scendere le sue radici fino al suolo e avvolgendo lentamente l’albero ospite in una rete soffocante, che con il tempo lo porta ad appassire.

In termini di sistemi legacy, i team possono migrare o riscrivere in modo incrementale piccoli frammenti di codice fino a quando l'intera codebase non viene convertita in un framework moderno o sviluppata in un linguaggio di programmazione attuale. Tuttavia, i team devono creare un'architettura di transizione per far coesistere il codice esistente e il nuovo codice. Questa architettura di transizione verrà quindi dismessa una volta completata la migrazione o la riscrittura.³

È fondamentale testare attentamente il codice sottoposto a refactoring, migrazione o riscrittura per assicurarsi che non emergano bug. Gli sviluppatori possono scrivere i propri test unitari e di integrazione, ma è anche essenziale coinvolgere i team del controllo qualità che possono eseguire test end-to-end, funzionali e di regressione per verificare che le funzionalità e i comportamenti siano intatti.

La documentazione è un'altra parte fondamentale del workflow di modernizzazione. È importante documentare le modifiche al codice sorgente, sia annotando direttamente il codice con commenti inline, sia creando log delle modifiche dettagliati o redigendo una documentazione tecnica approfondita, come documenti di architettura e progettazione.

Esistono diversi strumenti che possono aiutare a velocizzare e automatizzare il processo di modernizzazione del codice legacy. Ecco alcuni dei più diffusi:

    ● Analizzatori statici di codice

    ● Applicazioni di visualizzazione del codice

    ● Framework di automazione dei test

    ● Piattaforme e toolkit di migrazione

    ● Generatori di documenti

Gli analizzatori statici possono aiutare nel debug del codice legacy per individuare difetti di programmazione, problemi di qualità e persino vulnerabilità di sicurezza. Molti strumenti di analisi statica del codice supportano linguaggi di programmazione legacy come C, COBOL, PL/I e RPG. Esempi di analizzatori statici di codice includono CodeSonar, Klocwork, il PMD open source e SonarQube.

I visualizzatori di codice rappresentano graficamente il codice sorgente per fornire un quadro migliore di come funziona, soprattutto per codebase grandi o complesse. Queste rappresentazioni grafiche sono disponibili in diversi formati come mappe di codici, diagrammi di flusso e diagrammi UML (Unified Modeling Language). Esempi di app di visualizzazione del codice sono CodeScene, CodeSee e Understand, tra le altre.

Questi framework creano ed eseguono test automatizzati e producono report su tali test. I più diffusi framework di automazione dei test includono Cypress e Selenium per applicazioni web e Appium per app per dispositivi mobili.

Queste piattaforme e toolkit aiutano a semplificare e automatizzare i workflow di migrazione per i sistemi legacy. Alcune delle principali piattaforme di migrazione sono AWS Application Migration Service, Azure Migrate, Google Cloud migration toolkit, IBM Cloud Transformation Advisor e Red Hat Migration Toolkit for Applications.

Questi strumenti generano automaticamente la documentazione dal codice sorgente e da altri file di input. Esempi di strumenti per la document generation sono Doxygen, Sphinx e Swimm, tra gli altri.

L'intelligenza artificiale (AI) può aiutare nella modernizzazione del codice legacy. Le applicazioni di AI generativa sono supportate da modelli linguistici di grandi dimensioni (LLM) in grado di analizzare codebase legacy molto grandi o complesse.

L'AI generativa può essere utilizzata come supporto per le seguenti attività di modernizzazione del codice legacy:

    ● Spiegazione del codice

    ● Refactoring del codice

    ● Trasformazione del codice

    ● Generazione di test e documentazione

L'AI generativa è in grado di comprendere il contesto e la semantica alla base delle codebase legacy. Questo le consente di delineare la logica e la funzionalità sottostanti, spiegando il codice in un modo comprensibile per i programmatori.

Gli strumenti basati su AI possono offrire suggerimenti sul refactoring in tempo reale. Ad esempio, IBM® watsonx Code Assistant impiega i modelli IBM® Granite per identificare bug e ottimizzazioni. Suggerisce quindi correzioni mirate che si allineano alle convenzioni di programmazione stabilite da un team, contribuendo a semplificare e accelerare il refactoring del codice.

I sistemi di AI possono suggerire modi per implementare il codice sorgente da un linguaggio di programmazione legacy a uno più moderno. Ad esempio, IBM watsonx Code Assistant for Z unisce automazione e AI generativa per aiutare gli sviluppatori a modernizzare le applicazioni mainframe. Queste funzionalità di AI generativa includono la spiegazione del codice per COBOL, JCL e PL/I e la conversione da COBOL al codice Java.

Come i framework di automazione dei test, anche gli assistenti alla programmazione AI possono generare test automaticamente. Inoltre, possono creare commenti inline per documentare cosa fanno determinati frammenti o snippet di codice.

Come per qualsiasi applicazione basata su AI, i programmatori devono comunque fare attenzione quando utilizzano l'AI per modernizzare il codice legacy. Devono esaminare gli output per verificarne la precisione e testare eventuali modifiche o correzioni suggerite.