Revisione del codice sorgente: quando serve e cosa permette di scoprire

Quando serve una revisione del codice sorgente? Cosa verificare in un software: sicurezza, dipendenze, debito tecnico e codice generato con l'AI.

Header articolo
Ieri
7 Minuti

Revisione del codice sorgente: quando serve e cosa permette di scoprire

Un software può funzionare per mesi e nascondere problemi che emergono soltanto quando qualcuno prova a modificarlo. Magari hai ereditato un progetto da un altro sviluppatore, hai acquistato un'applicazione e vuoi affidarne la manutenzione a qualcuno, oppure hai realizzato un prodotto con strumenti AI e non sai quanto sia affidabile il codice che è stato generato.

In tutti questi casi può essere utile una revisione del codice sorgente. È un modo per capire su quali basi è costruito un progetto, quali problemi ci sono davvero e quanto lavoro potrebbe servire per continuare a svilupparlo.

Quando il codice di un software merita un controllo

Uno dei casi più frequenti è il passaggio di consegne. Il precedente sviluppatore non segue più il progetto, la documentazione è incompleta e chi subentra deve prima capire come funziona tutto. Senza conoscere il codice, anche una modifica apparentemente semplice può richiedere molto tempo o provocare errori in altre parti del software.

Può succedere anche con un prodotto già in uso. Un gestionale che si blocca dopo un aggiornamento, un'applicazione che perde dati in determinate condizioni, un servizio che restituisce errori senza una spiegazione chiara: sono situazioni in cui continuare ad aggiungere correzioni senza capire l'origine del problema rischia di peggiorare le cose.

La revisione può riguardare praticamente qualsiasi progetto software: un sito web, un'app mobile, un programma desktop, un gestionale, una piattaforma SaaS, un'API, un backend o uno strumento sviluppato per uso interno. Cambiano le tecnologie e i controlli da effettuare, ma la domanda di partenza è la stessa: il codice attuale è una base affidabile su cui continuare a lavorare?

Cosa guardo quando analizzo il codice sorgente

Per iniziare ho bisogno di accedere al codice, normalmente attraverso un repository Git o un archivio del progetto. Se ci sono documentazione, istruzioni per l'avvio e credenziali per un ambiente di test, posso ricostruire più facilmente il contesto.

La prima lettura serve a orientarsi. Cerco di capire quali tecnologie sono state utilizzate, come sono organizzati i file e dove si trovano le parti principali del software. In un'applicazione web, ad esempio, guardo come dialogano frontend e backend; in un programma desktop o in un servizio interno il percorso sarà diverso.

Poi entro nelle funzionalità. Prendo in esame le operazioni più importanti, seguo il modo in cui vengono trattati i dati e cerco di capire cosa succede quando qualcosa va storto. Se un'applicazione permette di registrare utenti, per esempio, non basta che il modulo di registrazione mostri un messaggio di conferma: bisogna capire come vengono salvate le informazioni, quali controlli vengono eseguiti e cosa succede in caso di richieste ripetute o dati non validi.

Anche le librerie esterne meritano attenzione. Un progetto può continuare a funzionare pur utilizzando pacchetti non più mantenuti o versioni che presentano vulnerabilità conosciute. I file di configurazione e quelli che registrano le versioni delle dipendenze aiutano a ricostruire la situazione.

Quando è possibile, avvio il software e provo le funzionalità principali. Se esistono test automatici, li eseguo; posso inoltre utilizzare strumenti di analisi statica per trovare errori ricorrenti o punti che richiedono un esame più attento. Questi strumenti sono un aiuto, non un verdetto: una segnalazione va verificata e l'assenza di avvisi non dimostra che il codice sia corretto.

I problemi che possono emergere

A volte il problema è evidente: una funzione non restituisce il risultato atteso oppure un'operazione fallisce in determinate condizioni. Altre volte il software sembra funzionare, ma basta leggere il codice per capire perché ogni modifica è diventata complicata.

Mi capita di prestare particolare attenzione a situazioni come queste:

  • Controlli di sicurezza incompleti. Per esempio, un'applicazione può nascondere una funzione agli utenti non autorizzati, ma non verificare i permessi quando viene chiamata direttamente l'API. L'interfaccia, da sola, non protegge i dati.
  • Gestione dei dati poco affidabile. Salvataggi, modifiche e cancellazioni possono non tenere conto di tutti i casi possibili. In un gestionale o in una piattaforma che conserva informazioni importanti, queste mancanze possono avere conseguenze concrete.
  • Dipendenze problematiche. Librerie obsolete o vulnerabili possono esporre il progetto a rischi e rendere più complicati gli aggiornamenti.
  • Logica duplicata e codice difficile da seguire. Quando la stessa operazione viene gestita in punti diversi, una modifica può risolvere un problema e crearne un altro. Non è una questione estetica: incide sul tempo e sul rischio necessari per intervenire.
  • Monolite e codice non pulito. Tutto agganciato in un unico pezzo, nomi confusi, file lunghissimi, pezzi morti lasciati lì: ogni intervento diventa lento e rischioso, anche se “in superficie” il software sembra funzionare.
  • Errori e configurazioni gestiti male. Credenziali inserite direttamente nel codice, informazioni riservate nei log o messaggi di errore che rivelano dettagli interni sono aspetti da non trascurare.

Non tutti questi problemi hanno la stessa gravità. Una dipendenza da aggiornare non equivale a un controllo degli accessi mancante. Per questo è importante capire quali difetti sono effettivamente presenti e quali conseguenze possono avere.

Software creato con l'intelligenza artificiale: funziona davvero?

Oggi si possono realizzare applicazioni, gestionali, piattaforme e strumenti interni descrivendo a un assistente AI quello che si vuole ottenere. Gli strumenti di generazione del codice hanno reso possibile costruire prototipi in tempi molto brevi, anche senza conoscere a fondo un linguaggio di programmazione.

Il punto è che riuscire a ottenere un risultato visibile non significa necessariamente aver sviluppato un software pronto per essere utilizzato. Una schermata può funzionare, una registrazione può andare a buon fine e una funzione può sembrare completa, mentre dietro ci sono controlli mancanti, dati gestiti male o parti del codice che non sono mai state verificate.

Il rischio aumenta quando si procede per tentativi: si chiede all'AI di aggiungere una funzione, poi di correggere un errore, poi di modificare un'altra parte. Dopo molte modifiche il progetto può diventare un insieme di soluzioni aggiunte una sopra l'altra, senza una struttura coerente.

Imprecare contro l'LLM quando qualcosa non torna non fa di te un professionista. Un professionista legge il codice, verifica i controlli e decide se il progetto regge, se è recuperabile o se conviene ripartire. Lo strumento non è il colpevole di default: lo è il modo in cui è stato usato e non rivisto.

In alcuni casi è possibile recuperare buona parte del lavoro. In altri, i problemi sono così estesi che correggere ogni singola parte richiederebbe più tempo che ricostruire il software su basi diverse. Non escludo questa possibilità quando analizzo un progetto: preferisco capire prima quanto sia recuperabile, invece di promettere interventi che potrebbero rivelarsi poco convenienti.

Ha senso fare una revisione del codice?

Ha senso se:

  • Hai ricevuto un progetto da un altro sviluppatore e vuoi sapere in che condizioni si trova prima di affidargli nuove modifiche.
  • Il software presenta errori ricorrenti, problemi dopo gli aggiornamenti o comportamenti che non riesci a spiegare.
  • Hai creato un'applicazione con strumenti AI e vuoi capire se il codice è adatto a un utilizzo reale e a sviluppi futuri.

Può non essere necessaria se:

  • Devi correggere un singolo errore già individuato e circoscritto.
  • Il progetto è piccolo, funziona correttamente e non hai in programma modifiche o nuove funzionalità.
  • Hai già una documentazione tecnica aggiornata e verifiche recenti che rispondono alle domande che ti interessano.

Non è detto che ogni progetto abbia bisogno di un audit completo. A volte basta esaminare una parte specifica del codice; altre volte è proprio la struttura generale a richiedere attenzione.

Cosa ottieni da una revisione tecnica

Una revisione utile dovrebbe lasciarti indicazioni concrete, non un elenco di termini tecnici senza spiegazioni. Dovresti sapere quali problemi sono stati riscontrati, dove si trovano, quali meritano di essere affrontati prima e quali possono essere rimandati.

Dopo l'analisi ti dico chiaramente se si può continuare a lavorare su quello che hai oppure se conviene rifare da zero (o ricostruire solo alcune parti). Non ha senso promettere correzioni a oltranza se la base non regge; allo stesso modo non ha senso rifare tutto se il progetto è recuperabile.

Se hai un progetto da far controllare, scrivimi: raccontami cosa hai realizzato, quali problemi stai incontrando e cosa vorresti fare in seguito. Base a Frosinone e Roma; lavoro da remoto in Italia e all'estero.

Hai un progetto?

Scrivimi cosa hai in mente. Entro un giorno lavorativo ti rispondo.

Preferisci scrivere subito? WhatsApp