Ci sono pochissime persone che possono scrivere il codice senza errori da zero. Personalmente mi sento sempre a disagio se compila un pezzo piuttosto lungo del mio codice e viene eseguito immediatamente e la mia intuizione si interrompe solo raramente.
Finché accetti questi che non puoi scrivere direttamente il codice senza errori è più facile trovare un compromesso tra gli sforzi che investi nel tuo codice e la (potenziale) frequenza di bug in esso.
Un ottimo approccio per ridurre al minimo i bug nel tuo codice è il già citato Sviluppo basato sui test . Lo uso spesso quando parlo in pubblico adattandolo nel modo seguente.
Ogni pezzo di codice indipendente viene scritto e riscritto in diverse iterazioni costituite da quanto segue:
- Progetta l'idea principale di ciò che il tuo codice dovrebbe fare.
- Annota la rappresentazione schematica del tuo algoritmo.
- Riscrivi la rappresentazione schematica in modo che sia sintatticamente corretta.
- Scrivi alcuni test unitari più importanti per il tuo codice (ad esempio, smoke test ).
- Implementa l'algoritmo per soddisfare i tuoi test esistenti.
- Rifatta il tuo codice per migliorarlo.
- Ripeti da 1 a 4 (in base alla maturità del codice) per ogni iterazione e ogni nuova funzione.
Ecco alcuni esempi.
(1) Comincio con qualcosa di simile
I want to calculate pi, so I will simulate a target being a circle
with diameter d and use random numbers to cast arrows to it. I will
then use the proportion of circle area to the total target size to
calculate pi.
(2) Poi passo a
Request size of the target.
Request number of arrows.
Cast arrows randomly to the target.
Calculate the arrows that met the target.
Calculate the pi value.
(3) Lo riscrivo in C # (solo un esempio):
var Radius = RequestFromUser<double>("Radius of Target");
var NumberOfShots = RequestFromUser<long>("Number of shots");
long GoodShots = 0; long TotalShots = NumberOfShots;
while (--NumberofShots > 0)
{
if (ShootTarget(Radius)) GoodShots++;
}
Output(CalculatePi(GoodShots, TotalShots));
(4) Creo tutti gli stub del metodo in IDE (automaticamente). Questo mi consente di scrivere i miei test unitari in modo semi-automatico (ottieni alcuni modelli creati automaticamente per loro)
(5) Disegno il test del fumo:
var computed = ComputerPi(Radius: 10.0, NumberOfShots: 10000);
Assert.IsTrue(computed > 3.0 && computed < 3.5);
(6) I rapidamente (che significa senza lucidare il codice) implementa tutti gli stub per iniziare il test.
(7) Fintanto che i miei test mostreranno il verde, rifletto sulla mia implementazione cercando di renderla più "carina".
(8) Ripeto da (5) se la mia implementazione non è completa, o da un passaggio precedente se voglio estenderlo.
Questo mi aiuta a mantenere il mio codice piuttosto pulito e i test delle unità lentamente emergenti servono come test di regressione se lo faccio modifiche troppo drastiche al mio codice.