Quali sono le buone strategie di check-in di controllo del codice sorgente per attività di grandi dimensioni?

La regola generale è di mantenere piccoli i check-in e il check-in spesso. Ma a volte l'attività richiede grandi modifiche al framework sottostante. Quindi il check-in prima della compilazione dell'attività interromperà il progetto fino a quando non si verifica il lavoro finito.

Quindi quali strategie usano le persone per ridurre il rischio di perdere il lavoro o decidere che qualcosa che stai facendo è un approccio sbagliato, quindi cambiare idea dopo aver rimosso il codice e aver provato un altro approccio?

Quando posso, farò il check-in a metà del lavoro commentato, o se si compila e nulla sta usando nuovi file, li controllerò. Più grande è la modifica, più è probabile che diramerò il progetto e poi lo ricollegherò quando tutto funziona di nuovo. Un'altra opzione se il sistema di controllo della sorgente lo consente sono i set di scaffali, che sono sostanzialmente piccoli rami. Quindi, quando finirò la giornata o giungerò a un punto di decisione, accantonerò i miei cambiamenti, e quindi se succede qualcosa di catastrofico, o voglio tornare a quel punto, posso.

Uso git, quindi la mia risposta è "branch". Ramifica e impegna il pezzo-pasto mentre completi i vari bit.

Spingi i tuoi commit a monte quando sei felice, in modo che i tuoi colleghi possano rivedere le modifiche senza interrompere il trunk.

Quando tutti sono soddisfatti del codice, unisci e il gioco è fatto!

(Quello che tendo a fare per rami relativamente lunghi è unire periodicamente il tronco (master, nella terminologia git) nel mio ramo, quindi i due rami non divergono troppo radicalmente.)

Penso che la risposta varierà in base al tipo di sistema di controllo della versione che stai usando: centralizzato (ad es. Sovversione) o distribuito (ad es. Git). Non ho alcuna esperienza nel mondo reale con l'uso di un sistema di controllo del codice sorgente distribuito, quindi la mia risposta si basa su ciò che facciamo con la sovversione.

Se c'è un grande cambiamento in corso che interromperà la costruzione del nostro bagagliaio per un periodo di tempo o che in qualche modo interromperà il resto della squadra, allora creeremo un ramo. Direi però che dovresti fare tutto il possibile per evitare di doverlo fare - la maggior parte delle modifiche possono stare fianco a fianco con il resto del codice con poco sforzo. Ad esempio, è possibile attivare percorsi di codice nel nuovo codice (con semplici istruzioni if ​​oppure è possibile iniettare le nuove versioni in base alle impostazioni di configurazione se si utilizza un framework DI). Quindi, quando hai finito, modifica semplicemente la configurazione nella nuova versione, testa tutto, elimina il codice inutilizzato, prova di nuovo e infine elimina l'impostazione di configurazione. Non puoi sempre farlo, ma a causa del sovraccarico di mantenere un ramo penso che dovresti sempre verificare se ciò è possibile.

Se fai ramo penso che l'errore che vedo spesso la gente non stia mantenendo il proprio ramo aggiornato con il tronco. Dovresti unire costantemente le modifiche dal tronco al tuo ramo mentre esiste in modo che quando hai finito l'unione inversa di tutto ciò che è di nuovo indietro sia abbastanza banale.

Nella nostra squadra usiamo la sovversione e normalmente commettiamo piccole modifiche direttamente al tronco. Per le attività più grandi, lo sviluppatore che ci lavora crea in genere un ramo privato, che viene unito nel trunk una volta terminato. Quindi il ramo privato viene eliminato. Naturalmente, mentre esiste una filiale privata, il suo proprietario dovrebbe controllarla spesso.

Cerchiamo di evitare di avere rami di lunga durata e fusioni tronco-ramo, perché ciò richiede un'attenta contabilità. Invece abbiamo rami relativamente di breve durata che vengono uniti al tronco una volta sola e vengono eliminati subito dopo.

E abbiamo una regola secondo cui nulla può essere impegnato o unito al trunk fino a quando almeno un'altra persona non esamina le modifiche e le approva.

Proprio come il solito commento delle persone del server SQL "dipende"

Se puoi, ti suggerirei di creare una filiale sul codice in modo da poter continuare ad applicare piccoli check-in del tuo lavoro. Una volta completato, eseguire un'unione indietro nel trunk principale.

Sì, c'è qualche possibilità di reowrk duplicazione degli sforzi nel fare questo. ma almeno manterrai una scia di lavoro che puoi ripristinare e che si rivela un vicolo cieco.