Il ciclo che descrivi è normale. Il modo per migliorare le cose non è evitare questo ciclo, ma semplificarlo. Il primo passo è accettare che:
- È quasi impossibile sapere tutto il primo giorno di un progetto.
- Anche se in qualche modo sai tutto, quando avrai finito il progetto, allora qualcosa (i requisiti del cliente, il mercato in cui si trovano, la tecnologia con cui stai lavorando, i desideri dei loro clienti) sarà cambiato e fatto almeno parte di ciò che sapevi non valido o errato.
Pertanto, è impossibile pianificare tutto in anticipo, e anche se tu potessi, seguire quel piano ti porterebbe a costruire qualcosa di imperfetto o obsoleto. Sapendo questo, integriamo il cambiamento nella nostra pianificazione. Diamo un'occhiata ai tuoi passaggi:
- Inizia con alcuni casi d'uso
- Inizia a scrivere codice
- Realizza alcune cose che non ho gestito bene e che non si adattano bene alla base di codice corrente.
- Riscrivi gran parte del codice
Questo è in realtà un ottimo punto di partenza. Ecco come mi avvicinerei:
1. Inizia con alcuni casi d'uso
Buono. Dicendo "casi d'uso", si sta concentrando su ciò che il software è per . Dicendo "pochi", non stai cercando di scoprire tutto; stai rispettando una quantità gestibile di lavoro. Tutto ciò che aggiungerei qui è di dare la priorità. Con il tuo cliente o l'utente finale, elabora la risposta a questa domanda:
Qual è il software più piccolo e semplice che potrei darti per migliorare la tua situazione?
Questo è il tuo prodotto minimo realizzabile - qualsiasi cosa più piccola di questa non è utile per il tuo utente, ma qualsiasi cosa più grande rischia di pianificare troppo presto. Ottieni informazioni sufficienti per costruirlo, quindi vai avanti. Ricorda che non saprai tutto a questo punto.
2. Inizia la codifica.
Grande. Ti metti al lavoro il prima possibile. Fino a quando non hai scritto il codice, i tuoi clienti non hanno ricevuto alcun vantaggio. Più tempo dedichi alla pianificazione, più tempo il cliente ha trascorso in attesa senza rimborso.
Qui, aggiungerei un promemoria per scrivere un buon codice. Ricorda e segui i Principi SOLIDI , scrivi test unitari decenti su qualsiasi cosa fragile o complessa, prendi appunti su tutto ciò che potresti dimenticare o che potrebbe causare problemi in seguito. Vuoi strutturare il tuo codice in modo che il cambiamento non causi problemi. Per fare ciò, ogni volta che prendi la decisione di costruire qualcosa in questo modo invece che in quel modo, strutturi il tuo codice in modo tale che il meno possibile il codice sia influenzato da quella decisione. In generale, un buon modo per farlo è separare il codice:
- usa componenti semplici e discreti (a seconda della lingua e della situazione, questo componente potrebbe essere una funzione, una classe, un assembly, un modulo, un servizio, ecc. Potresti anche avere un componente di grandi dimensioni costruito da quelli più piccoli, come una classe con molte funzioni o un assembly con molte classi.)
- ogni componente fa un lavoro o lavori relativi a una cosa
- le modifiche al modo in cui un componente esegue il suo funzionamento interno non dovrebbero comportare la modifica di altri componenti
- componenti devono essere fornite cose essi utilizzano o dipendono, piuttosto che il recupero o la creazione li
- i componenti dovrebbero fornire informazioni ad altri componenti e chiedere loro di fare il lavoro, piuttosto che recuperare informazioni e fare il lavoro da soli
- i componenti non devono accedere, utilizzare o dipendere dal funzionamento interno di altri componenti: utilizzare solo le loro funzioni accessibili al pubblico
In questo modo, stai isolando gli effetti di una modifica in modo che nella maggior parte dei casi, puoi risolvere un problema in un punto e il resto del codice non se ne accorge.
3. Incontrare problemi o carenze nella progettazione.
Questo accadrà. È inevitabile Accetta questo Quando si verifica uno di questi problemi, decidere che tipo di problema è.
Alcuni problemi sono problemi nel codice o nella progettazione che rendono difficile fare ciò che il software dovrebbe fare. Per questi problemi, è necessario tornare indietro e modificare il progetto per risolvere il problema.
Alcuni problemi sono causati dalla mancanza di informazioni sufficienti o da qualcosa a cui non hai mai pensato prima. Per questi problemi, devi tornare al tuo utente o client e chiedere loro come vorrebbero affrontare il problema. Quando hai la risposta, vai e aggiorna il tuo design per gestirlo.
In entrambi i casi, dovresti prestare attenzione a quali parti del codice devono cambiare e, mentre scrivi più codice, dovresti pensare a quali parti potrebbero dover cambiare in futuro. Ciò rende più semplice capire quali parti potrebbero essere troppo interconnesse e quali parti potrebbero necessitare di essere più isolate.
4. Riscrivi parte del codice
Una volta identificato il modo in cui è necessario modificare il codice, è possibile procedere e apportare la modifica. Se hai strutturato bene il tuo codice, di solito ciò comporta la modifica di un solo componente, ma in alcuni casi potrebbe comportare anche l'aggiunta di alcuni componenti. Se scopri che devi cambiare molte cose in molti posti, allora pensa al perché. Potresti aggiungere un componente che mantiene tutto questo codice dentro di sé, e quindi avere tutti questi posti solo per usare quel componente? Se puoi, fallo e la prossima volta devi cambiare questa funzione, sarai in grado di farlo in un unico posto.
5. Test
Una causa comune di problemi nel software non è conoscere abbastanza bene i requisiti. Questo non è spesso colpa degli sviluppatori - spesso, l'utente non è sicuro nemmeno di ciò di cui ha bisogno. Il modo più semplice per risolverlo è invertire la domanda. Invece di chiedere "che cosa devi fare per fare il software?", Ogni volta che esegui questi passaggi, dai all'utente ciò che hai costruito finora e chiedi loro "L'ho costruito - fa quello che ti serve?". Se dicono di sì, allora hai costruito qualcosa che risolve il loro problema e puoi smettere di funzionare! Se dicono di no, saranno in grado di dirti in termini più specifici cosa c'è di sbagliato nel tuo software e puoi andare a migliorare quella cosa specifica e tornare per ulteriori feedback.
6. Impara
Durante questo ciclo, presta attenzione ai problemi che stai riscontrando e alle modifiche che stai apportando. Ci sono schemi? Puoi migliorare?
Qualche esempio:
- Se continui a scoprire di aver trascurato il punto di vista di un determinato utente, potresti coinvolgere maggiormente l'utente nella fase di progettazione?
- Se continui a dover cambiare le cose per renderle compatibili con una tecnologia, potresti costruire qualcosa per l'interfacciare tra il tuo codice e quella tecnologia in modo da dover cambiare solo l'interfaccia?
- Se l'utente continua a cambiare idea su parole, colori, immagini o altre cose nell'interfaccia utente, potresti creare un componente che fornisce al resto dell'applicazione quelli in modo che siano tutti in un unico posto?
- Se scopri che molte delle tue modifiche sono nello stesso componente, sei sicuro che quel componente si attenga a un solo lavoro? Potresti dividerlo in alcuni pezzi più piccoli? Puoi cambiare questo componente senza dover toccare altri?
Sii agile
Quello a cui ti stai muovendo qui è uno stile di lavoro noto come Agile. Agile non è una metodologia, è una famiglia di metodologie che incorporano un intero carico di cose (Scrum, XP, Kanban, solo per citarne alcuni) ma la cosa che tutti hanno in comune è l'idea che le cose cambino, e come sviluppatori software noi dovrebbe pianificare di adattarsi ai cambiamenti anziché evitarli o ignorarli. Alcuni dei suoi principi fondamentali - in particolare quelli rilevanti per la tua situazione - sono i seguenti:
- Non pianificare in anticipo di quanto tu possa prevedere con fiducia
- Tieni conto che le cose cambiano mentre vai
- Invece di costruire qualcosa di grande in una volta, costruisci qualcosa di piccolo e poi miglioralo in modo incrementale
- Mantieni l'utente finale coinvolto nel processo e ricevi un feedback tempestivo e regolare
- Esamina il tuo lavoro e i tuoi progressi e impara dai tuoi errori