Legacy code: il modo migliore per gestirlo

Il codice sorgente è l’elemento centrale di un software. Che il programma venga eseguito nel modo desiderato e permetta di svolgere determinate funzioni, dipende dalle istruzioni e dai comandi registrati in questo codice. I programmatori lo modificano, lo mantengono e lo aggiornano regolarmente per fornire agli utenti la migliore fruibilità possibile. Qualsiasi modifica del codice può talvolta comportare errori del software o compromettere la capacità di esecuzione del programma.

Per gli sviluppatori e i programmatori, la manutenzione e l’aggiornamento del software si rivelano particolarmente problematici quando devono lavorare con un codice che non hanno scritto loro stessi o che è stato scritto per sistemi operativi più vecchi e non più supportati, in versioni altrettanto vecchie del linguaggio di programmazione che ne sta alla base. Nel nostro articolo vi mostriamo che cos’è esattamente il legacy code e il modo migliore per gestirlo.

Definizione di legacy code

Il termine “legacy code” è usato nella tecnologia software e sta a indicare un codice antico. Si tratta di un codice più vecchio, che di solito non viene più sviluppato attivamente. Il legacy code è in un certo senso la controparte del “Clean Code”, che è intuitivamente comprensibile, particolarmente facile da mantenere e facilmente adattabile. Il legacy code è voluminoso, obsoleto e disordinato, motivi per i quali possono insorgere numerosi problemi. Esso dipende fortemente dalla visione dello sviluppatore e dal contesto particolare per il quale viene creato. In linea di principio, è caratterizzato dai seguenti aspetti:

  • Il codice non viene più mantenuto dallo sviluppatore originale.
  • Il codice è stato scritto originariamente per sistemi operativi non più supportati.
  • Il codice non può essere testato per i bug in modo automatizzato.

Quali sono gli svantaggi del legacy code?

Alla luce di questa serie di svantaggi, perché si continua a utilizzare il legacy code? Semplicemente perché non si può sempre evitare: spesso accade che nel corso di un progetto subentri un nuovo programmatore a occuparsi della manutenzione e dell’ulteriore sviluppo del codice. Mentre lo sviluppatore originale ha scritto il codice in maniera intuitiva, i nuovi membri del team devono prima di tutto comprenderlo per poterne continuare lo sviluppo. Può accadere che parti del codice vengano trascurate o che non vengano completamente comprese.

Se un codice viene mantenuto, migliorato e modificato diversamente da più programmatori nel corso degli anni, il codice può diventare col tempo un’accozzaglia sempre più difficile da comprendere e modificare. Il problema è che, a un certo punto, gli aggiornamenti o le modifiche necessarie non possono essere effettuati se nessuno riesce più a comprendere il codice e i suoi effetti.

Il codice legacy ha un ulteriore svantaggio: i test di regressione, cioè i test automatizzati, non possono essere eseguiti a causa della programmazione troppo voluminosa, ingombrante e disomogenea. Agli sviluppatori che devono occuparsi del legacy code è richiesto quindi un impegno manuale per la verifica decisamente più elevato. I bug sono più difficili da risolvere, gli aggiornamenti più complicati da implementare.

Refactoring: la risposta giusta al legacy code

Gli sviluppatori non amano occuparsi del legacy code per vari motivi. Uno dei problemi maggiori è il fatto che il codice non può essere testato automaticamente per bug o errori. Che cosa possono fare, quindi, gli sviluppatori se improvvisamente devono confrontarsi con il legacy code nel corso di un nuovo progetto?

La risposta migliore è: refactoring. Con questa tecnica di sviluppo, il codice viene ristrutturato senza modificare la sua funzione originale. Prima di eseguire il refactoring vero e proprio, i programmatori devono aver compreso la finalità di ogni parte del codice. Inoltre, tutte le funzioni devono essere convalidate tramite test.

Solo quando è chiaro come funziona il codice, si può procedere al refactoring vero e proprio. Il codice viene così ottimizzato pezzo per pezzo. Le parti superflue vengono rimosse o riscritte, le classi di codice e le variabili vengono semplificate e raggruppate, i metodi di comando vengono modificati e riscritti. In definitiva, il refactoring è una revisione generale del legacy code. Ne risulta un codice più facile da capire, più facile da mantenere e più veloce da modificare.