A che punto dovresti passare a rilasciare build?

Una delle pratiche stabilite nella consegna continua di Jez Humble è che è necessario creare un pacchetto e quindi rilasciarlo in ogni ambiente in cui si esegue la distribuzione, in modo che la distribuzione e gli artefatti siano stati testati più volte prima di passare alla produzione.

Sostengo pienamente questa idea.

D'altra parte, le build in modalità debug che offrono tracce di stack con numeri di riga sono incredibilmente utili negli ambienti di test, così come la possibilità di eseguire il debug remoto. Tuttavia, si desidera inviare una build di rilascio alla produzione.

Quindi, per le persone che seguono il primo principio, a che punto passi dal debug alle versioni build?

È prima della prima distribuzione in un ambiente di test, capire che vale la pena pagare il costo della perdita della modalità di debug per assicurarsi di testare in anticipo il candidato alla versione effettiva? O ricostruisci ad un certo punto del processo di promozione, immaginando che ti fidi del processo di compilazione sul software? O hai semplicemente rovinato tutto e distribuito le versioni di debug alla produzione?

Nota: so che questo non si applica davvero alle lingue interpretate perché di solito è possibile scorrere l'interruttore nella configurazione piuttosto che farlo al momento della compilazione.

Quindi, per le persone che seguono il primo principio, a che punto passi dal debug alle versioni build?

Passiamo presto, quando il codice sorgente ottiene un numero di versione e viene inserito nella coda di compilazione di Debian. Siamo nella fortunata situazione di realizzare software scientifici con input e output ben specificati e poca interazione del sistema, quindi il costo di riproduzione di una situazione di errore è abbastanza basso.

Questa è anche la mia risposta generale: il punto di cambiare le build dipende principalmente dai costi di riproduzione degli errori. Se questi sono molto alti, spedirei anche build di debug per testare i clienti. Sebbene ciò comporti il ​​rischio di errori di compilazione per la build di produzione, questo potrebbe essere ancora più economico rispetto al trascorrere settimane nella riproduzione dei casi di test.

Quindi, per le persone che seguono il primo principio, a che punto passi dal debug alle versioni build?

Non appena passiamo al QA, passiamo al rilascio delle build. Ma ogni volta che costruiamo una release build il nostro processo di build crea anche una versione di debug delle dll. Questo ci consente di rilasciare rapidamente le dll di debug nell'ambiente QA e ottenere ulteriori informazioni, se necessario.

Sia la versione di rilascio che quella di debug delle dll sono sottoposte a backup e conservate per diversi anni.

Nel nostro ambiente, il codice viene distribuito in molti siti. E quindi dovrebbe essere applicato un contesto diverso a ciascuna istanza di distribuzione. Di solito, lo distribuiamo in luoghi chiave "meno rischiosi" e vediamo l'esperienza.

Questa distribuzione è ancora in produzione quindi, questa non è la modalità di "debug". Ma presuppone anche che i test vengano eseguiti correttamente.

Ovviamente, con la modalità di debug disattivata, il debug rapido del codice (sul sito) potrebbe essere difficile. Ma se il rilascio non è riuscito, la produzione ritorna al rilascio fallback.

Tuttavia, proviamo a mantenere o creare un ambiente identico, che può riprodurre un ambiente simile per testarlo nuovamente. (So ​​che questo non è sempre banale da fare) ma a volte tutto ciò che serve è riprodurre le transazioni / input.

Il punto è, quanto mai la tentazione, il rilascio della modalità debug non dovrebbe essere in produzione. Tuttavia, non dirò che questa è una regola.

Un'altra cosa è che il rilascio è ancora chiamato processo fino a quando non ha stabilito (eseguendo per un tempo significativo) che altri locali non lo accettano ancora.

Esistono altre poche pratiche per garantire che il processo di compilazione non sia del tutto difettoso. Vedi questo: un modo semplice per migliorare la qualità di rilascio in ambiente RAD

Abbiamo le nostre macchine sviluppatore configurate per costruire build di debug. Ma una volta che gli sviluppatori hanno commesso il codice, viene creato un pacchetto di distribuzione nel nostro ambiente di integrazione continua (TeamCity) e creato per il rilascio. Pertanto, ogni volta che decidiamo di eseguire la distribuzione nel QA, prendiamo l'ultimo pacchetto di distribuzione dal server CI e lo distribuiamo, quindi viene sempre rilasciato a meno che non si trovi su una macchina di sviluppo.

A proposito, per alcune lingue, anche quando si crea per il rilascio, è ancora possibile creare simboli di debug. In .NET, ad esempio, esiste un'impostazione "solo pdb" che consente ottimizzazioni ma crea comunque file di debug. Ovviamente il debug contro una versione di rilascio è più complicato poiché non è equivalente riga per riga, ma può comunque essere utile in un pizzico.