Scrivere per due giorni un'unica grande modifica e provarla alla fine è il modo più rapido per scoprire, all'ultimo momento, che il problema stava nella prima ora. L'implementazione incrementale rovescia l'ordine: si costruisce un pezzo piccolo, lo si prova, lo si salva, e solo allora si passa al successivo.
Il ciclo dell'incremento
Si sceglie la prossima porzione piccola, la si realizza, la si prova (test, compilazione, controllo a vista), la si salva con un commit descrittivo e solo poi si passa oltre. Se a metà strada qualcosa si rompe, il danno è di venti minuti, non di due giorni.
Come tagliare il lavoro
- Fette verticali (preferite). Una fetta attraversa tutti gli strati e produce qualcosa che funziona: dal dato allo schermo, per un caso semplice. Si può mostrare e provare.
- Prima il contratto. Quando più parti devono parlare tra loro, si concorda e si scrive per primo il confine (l'interfaccia, il formato dei dati), poi ciascuno lavora dalla sua parte.
- Prima il rischio. Si affronta per prima la parte più incerta: se non si può fare, meglio saperlo il primo giorno.
Le regole
Prima la semplicità. La soluzione più semplice che funziona è quella giusta finché la realtà non dimostra altro.
Disciplina del perimetro. Si fa ciò che è nel compito. L'idea "già che ci sono aggiungo anche questo" è il modo in cui una modifica di un'ora diventa una di tre giorni.
Una cosa per volta. Un incremento, un'intenzione. Modifiche non correlate in uno stesso incremento rendono impossibile capire che cosa ha rotto che cosa.
Sempre compilabile. Tra un incremento e l'altro il sistema parte e i test passano. Se si rompe, si ripara prima di proseguire.
Interruttori per le funzioni incomplete. Una funzione a metà si nasconde dietro un'opzione di configurazione (feature flag), così il codice può essere integrato senza che gli utenti lo vedano.
Valori predefiniti sicuri. Una nuova opzione parte spenta e prudente.
Facile da annullare. Ogni incremento deve poter essere ritirato da solo, senza trascinare altro.
Quando si lavora con un agente
Vale lo stesso, e di più: un agente lasciato libero tende a produrre molto codice in una volta. Si chiede un passo per volta, si verifica e si decide il successivo. Più di un centinaio di righe scritte senza eseguire nulla è un campanello.
Segnali d'allarme
- Più di un centinaio di righe scritte senza eseguire i test.
- Più modifiche non correlate in un solo incremento.
- Espansioni di perimetro del tipo "aggiungo anche questo al volo".
- Saltare la verifica per andare più in fretta.
- Compilazione o test rotti tra un incremento e l'altro.
- Grandi modifiche non salvate che si accumulano.
- Astrazioni costruite prima che un terzo caso d'uso le richieda.
Un esempio
Si deve aggiungere l'invio di una notifica quando un ordine cambia stato. Primo incremento: inviare un messaggio fisso al cambio da "nuovo" a "confermato", provato con un test. Secondo: personalizzare il testo. Terzo: gestire gli altri stati. Quarto: permettere al cliente di disattivarla. A ogni passo il sistema funziona e chi rivede il codice legge poche righe, non un muro.
Quando usarla
Quando si realizza una funzionalità o una modifica che tocca più di un file, quando si sta per scrivere molto codice in una volta o quando un lavoro sembra troppo grande per essere concluso in un solo passo.
Questo metodo deriva dalla famiglia di skill open source agent-skills di Addy Osmani (licenza MIT), riscritta e adattata.
Questo articolo è una skill di OIAR
Quello che hai letto è il contenuto di una skill del catalogo OIAR, scritto per le persone. Una conoscenza come questa ma più ricca e profonda, scritta per gli agenti, guida le interviste, l'analisi e il report dentro la piattaforma. Le skill si usano in OIAR: per provarla su un tuo progetto serve un account.
incremental-implementationMetodo per realizzare una modifica a piccoli incrementi verificabili: ciclo scegli-realizza-prova-salva, fette verticali, regole di perimetro, codice sempre compilabile, interruttori per funzioni incomplete, ritorno indietro facile. Usarla quando una modifica tocca più file o quando si sta per scrivere molto codice in una volta.