Addio al debito tecnico: soluzioni Agile per uno sviluppo ordinato

Il debito tecnico è un concetto usato nello sviluppo software che descrive il costo futuro di scegliere una soluzione facile o veloce nel presente, anziché adottare un approccio migliore ma più dispendioso in termini di tempo. 

Quando gli sviluppatori danno priorità alla velocità rispetto alla qualità del codice, si creano soluzioni non ottimali che richiedono un refactoring o miglioramenti in futuro. Questo comporta il doppio del lavoro per i team, con un conseguente consumo di budget, risorse e tempo dedicato al progetto. 

Pensa, ad esempio, a cosa succede quando si usa una raccolta obsoleta perché la si conosce già o quando i valori che dovrebbero essere configurabili sono invece hardcoded. Al momento può sembrare una soluzione efficace, ma in realtà comporterà costose ripetizioni del lavoro in seguito, ad esempio:

• Riscrittura di un codice poco affidabile che viene decodificato ogni volta che cambia una funzionalità correlata.

• Refactoring di un modulo che non è stato progettato per adattarsi all'aumento di utenti o dati.

• Sostituzione di dipendenze obsolete che non ricevono più gli aggiornamenti di sicurezza.

• Separazione dei componenti strettamente accoppiati in modo che le funzionalità possano essere create e implementate in modo indipendente.

I programmi software tradizionali seguono un approccio allo sviluppo basato su fasi: sviluppo di funzionalità, alfa, beta e Golden Master (GM).

Ogni rilascio del software inizia con una fase in cui vengono create nuove funzionalità e, idealmente, vengono risolti i problemi ancora presenti nell'ultimo rilascio.

• La fase alfa si raggiunge quando ogni funzionalità è implementata e pronta per i test. 

• La fase beta inizia quando il numero di bug corretti è tale da consentire il feedback dei clienti. Purtroppo, mentre il team è impegnato a correggere un numero di bug sufficiente per raggiungere la fase beta, compaiono nuovi bug che contribuiscono all'aumento del debito tecnico. È un classico: correggi un bug e ne compaiono altri due. 

• Di solito si raggiunge l'azzeramento dei bug aperti quando si correggono alcuni problemi noti e si rimanda il resto al rilascio successivo. 

Se si rimandano all'infinito le correzioni dei bug, il debito tecnico si accumula e aumenta a dismisura. Man mano che il backlog cresce, diventa sempre più scoraggiante da affrontare. Lo sviluppo rallenta, le tempistiche slittano e i difetti persistono. L'adozione di pratiche Agile può fornire un approccio più sostenibile, evitando che il debito tecnico vada fuori controllo.

Capire il debito tecnico significa riconoscere che non tutti i debiti sono uguali. Il debito tecnico rientra principalmente nelle categorie descritte di seguito. 

• Debito deliberato: quando i team prendono consapevolmente scorciatoie per rispettare le scadenze o rilasciare più rapidamente le funzionalità. È una decisione cosciente in cui gli sviluppatori comprendono che stanno creando il lavoro futuro ma preferiscono la velocità alla perfezione. 

• Debito accidentale: la scarsa qualità del codice può essere involontaria. Uno sviluppatore può interpretare erroneamente i requisiti oppure il team può non avere esperienza con una particolare tecnologia. Questo tipo di debito tecnico deriva da errori in buona fede, non da scelte strategiche. 

• Bit rot: anche un buon codice può diventare problematico nel tempo. Man mano che i sistemi si evolvono, le dipendenze cambiano e vengono aggiunte nuove funzionalità, il codice che un tempo era solido può diventare obsoleto o incompatibile con i componenti più recenti.

I team accumulano debito tecnico per diversi motivi, spesso senza rendersene conto. Di seguito sono descritte le cause più comuni. 

• Scadenze strette: quando la gestione del prodotto impone una consegna più rapida, si tende a prendere delle scorciatoie. Si privilegiano soluzioni rapide piuttosto che soluzioni adeguate, creando un debito che si aggrava nel tempo. 

• Test non svolti: per risparmiare tempo, spesso si saltano i test, ma i bug che non vengono rilevati causano oneri di manutenzione che rallentano lo sviluppo futuro. 

• Scarsa comunicazione: quando le pratiche di gestione dei progetti Agile vengono suddivise, gli sviluppatori rischiano di fraintendere i requisiti o fare supposizioni che causano poi la necessità di ripetere il lavoro. 

• Lacune nelle competenze: spesso i team che lavorano con tecnologie che non conoscono creano soluzioni non ottimali che devono essere perfezionate una volta che le competenze aumentano. 

• Requisiti che cambiano costantemente: man mano che la strategia di prodotto si evolve, il codice che una volta andava bene potrebbe non essere più in linea con la vision corrente, trasformandosi di fatto in debito tecnico.

L'aspetto più difficile del debito tecnico è che spesso non è visibile finché non inizia a causare problemi reali. E a quel punto è già tardi. Fortunatamente, però, esistono alcuni modi semplici per identificarlo prima che diventi un problema serio.

I seguenti sono i metodi più efficaci per identificare precocemente il debito tecnico. 

• Revisioni del codice: attraverso peer review regolari, spesso emergono aree in cui sono state prese scorciatoie o la complessità è cresciuta raggiungendo livelli in cui non può più essere gestita. 

• Metriche di complessità: gli strumenti che misurano la complessità del codice possono permettere di identificare le sezioni problematiche che richiedono attenzione. L'elevata complessità ciclomatica o la nidificazione profonda spesso indicano aree mature per il refactoring. 

• Feedback degli sviluppatori: i membri del team che lavorano quotidianamente sul codice possono individuare schemi e punti deboli che le metriche potrebbero non rilevare. Le loro intuizioni sono preziose per identificare i punti di attrito che rallentano il processo di sviluppo. 

• Monitoraggio delle prestazioni: tempi di risposta lenti o picchi nell'utilizzo delle risorse possono essere sintomi di problemi tecnici sottostanti da risolvere. 

Anche bug ricorrenti o ritardi imprevisti indicano un debito nascosto che sta rallentando l'avanzamento. Quando continuano a comparire problemi dello stesso tipo oppure delle semplici modifiche richiedono più tempo del previsto, di solito significa che il debito tecnico sta influendo sulla velocità del team.

Il debito tecnico può accumularsi, che si tratti di soluzioni rapide effettuate in tempi stretti, requisiti in evoluzione o sistemi obsoleti. Ed è probabile che parte di questo debito ti sia capitata in eredità se hai lavorato con codice legacy. 

I seguenti suggerimenti ti aiuteranno, tuttavia, a controllare il debito esistente e consentiranno al tuo team di concentrarsi su aspetti divertenti come lo sviluppo di nuove funzionalità. 

1. Fornisci una definizione chiara di "debito tecnico"

A volte gli sviluppatori e i responsabili di prodotto non hanno la stessa opinione su cosa sia il debito tecnico. Chiudiamo qui la diatriba:

Dal lato dello sviluppo c'è la tentazione di caratterizzare il lavoro relativo all'architettura come debito tecnico. Potrebbe anche essere così, a seconda della natura del cambiamento (ad esempio, la sostituzione di una scorciatoia con la soluzione "reale" rispetto alla suddivisione di una base del codice monolitica in microservizi).

D'altra parte, dal punto di vista della gestione dei prodotti spesso la creazione di nuove funzionalità è avvertita come più urgente rispetto alla correzione di bug o al rallentamento delle prestazioni. 

Per evitare che una delle due parti si stanchi, tutti devono comprendere la distinzione tra debito tecnico, modifiche dell'architettura desiderate nel codebase e nuove funzionalità. È altrettanto importante una comunicazione chiara tra team di sviluppo e gestione del prodotto per dare priorità ai backlog e far evolvere il codebase. 

2. Integra test nel flusso di lavoro

Assicurati che il ciclo di sviluppo iniziale includa test per identificare e risolvere i problemi iniziali. Inizia con una chiara definizione del concetto di completamento ed evitando di posticipare i test. 

Definisci come "completate" non solo le funzionalità complete, ma anche quelle testate e pronte per il rilascio. Ciò significa aggiungere un task di test separato alla user story originale. Se i test non vengono eseguiti come parte della story originale o della correzione di bug, la story originale o la correzione dei bug non vengono completati. 

Rinviare i test è sin troppo facile e apre le porte al debito tecnico.

3. Risolvi i bug in modo automatizzato

Quando qualcuno identifica un bug nel software, prenditi il tempo necessario per aggiungere un test automatizzato che lo dimostri. Una volta corretto il bug, ripeti il test per assicurarti che sia superato. 

Questo è il fulcro dello sviluppo basato sui test, una metodologia consolidata per mantenere la qualità nello sviluppo Agile.

Non è facile cambiare la filosofia del team (e degli stakeholder del team) sulla gestione del debito tecnico. A volte è più importante ridurre i tempi di sviluppo per arrivare prima sul mercato. Tenendo presente questo aspetto, facciamo un riepilogo di alcuni elementi di azione che permettono di controllare il debito tecnico.

• Informa l'owner di prodotto riguardo al costo reale del debito tecnico: assicurati che i valori degli story point siano precisi, in modo da poterli usare per le story future che richiedono la risoluzione del debito tecnico esistente.

• Rendi modulare la tua architettura: prendi una posizione ferma sul debito tecnico in nuovi componenti o nuove raccolte nell'applicazione. Una volta che l'agilità sarà visibile in questi nuovi componenti, i team vorranno naturalmente estendere queste pratiche ad altre parti del codice.

• Scrivi test automatizzati: per prevenire i bug, non c'è niente di meglio dei test automatizzati e della continuous integration. Quando viene trovato un nuovo bug, scrivi un nuovo test per riprodurlo e poi correggi il problema. Se il bug dovesse riemergere, il test automatizzato lo rileverà prima che lo facciano i clienti.

Il concetto di debito tecnico può essere illustrato con alcuni semplici esempi.

Prendi in considerazione un team che utilizza l'hardcoding per le connessioni al database invece di un sistema di configurazione. Questo approccio permette di risparmiare tempo inizialmente, però crea problemi durante l'implementazione in ambienti diversi. 

Un altro esempio è saltare la corretta gestione degli errori per rispettare una scadenza, lasciando il sistema vulnerabile ad arresti anomali che richiederanno correzioni di emergenza in un secondo momento. 

Una buona gestione del debito potrebbe comportare la scelta deliberata di un algoritmo più semplice e più facile da capire e mantenere, anche se leggermente meno efficiente. Quando la gestione è mediocre, si accumulano varie soluzioni rapide ma non si affronta la causa principale. 

I team possono utilizzare Jira per monitorare, definire le priorità e risolvere il debito tecnico, oltre che per il normale lavoro sulle funzionalità. Crea tipi di ticket specifici per i diversi elementi del debito tecnico e includili nel normale processo di pianificazione dello sprint. 

Usa le funzionalità di pianificazione delle risorse per assegnare il tempo per la riduzione del debito e sfrutta gli strumenti di gestione delle risorse per monitorare i processi. Definisci flussi di lavoro con cui tutti gli stakeholder, e non solo gli sviluppatori, possano notare il debito tecnico. 

Con Rovo Dev, i team possono andare ancora oltre, utilizzando l'IA per automatizzare i task di codifica di routine e accelerare il refactoring. Rovo Dev può creare flussi di lavoro in più fasi, mettere in evidenza le conoscenze e pianificare, generare e rivedere codice su larga scala. Riducendo l'impegno manuale richiesto per identificare, pianificare e risolvere il debito tecnico, Rovo Dev aiuta i team a fornire software di qualità superiore più velocemente.

Questa trasparenza aiuta i product manager a comprendere il costo reale del debito accumulato e rende più facile giustificare il tempo dedicato agli interventi di manutenzione. 

Prova Jira

Cos'è il debito tecnico in Scrum?

In Scrum, il debito tecnico rappresenta il lavoro che deve essere svolto per continuare a garantire la qualità del codice e l'integrità del sistema. I team Scrum risolvono il problema includendo gli elementi del debito nei backlog dello sprint e trattandoli con la stessa priorità del resto del lavoro. 

Come è possibile prevenire il debito tecnico?

Per prevenire il debito tecnico, occorre iniziare con una pianificazione adeguata, revisioni paritarie periodiche e test automatizzati. La creazione di una cultura che valorizzi la qualità del codice a lungo termine rispetto alla velocità a breve termine aiuta i team a prendere decisioni architetturali migliori sin dall'inizio. 

Il debito tecnico è sempre una cosa negativa?

Non necessariamente. Il debito tecnico strategico è accettabile quando i team privilegiano consapevolmente la velocità rispetto alla perfezione per validi motivi aziendali. Il segreto è gestirlo intenzionalmente anziché lasciare che si accumuli accidentalmente.

Chi subisce le conseguenze del debito tecnico?

Tutti. I team di progettazione sono costretti a dedicare più tempo alla manutenzione, mentre i team di prodotto subiscono una distribuzione delle funzionalità più lenta e i clienti riscontrano più bug. La responsabilità di gestire il debito in modo efficace è condivisa da stakeholder in ambito di progettazione e prodotto. 

Come si misura il debito tecnico?

Usa strumenti come Jira per tenere traccia degli elementi del debito, misurare i tempi di risoluzione e monitorare le tendenze. Controlli regolari del codice, metriche di complessità e sondaggi tra gli sviluppatori possono aiutare a quantificare la portata e l'impatto del debito accumulato.