Impegnati solo in un punto di controllo logico o anche quando sei a un punto di arresto? [duplicare]

Il codice di commit è economico in git . Hai diverse opzioni:

Confida e modifica più tardi

    $ git commit --all -m "WIP: half-implemented hack"

... il tempo passa ...

    $ # back to work
    $ git commit --all --amend -m "Nice logical atomic commit"

Utilizza git stash

Come sopra, ma usando una scorta:

1. I comandi sono un po 'più brevi per scrivere

2. Una scorta per natura sembra in corso di lavorazione (gli stash sono denominati "WIP on master" per impostazione predefinita).

   $ git stash # must go home now
   

   ... later ...

   $ git stash pop # back to work
   

Nota che il tuo lavoro verrà temporaneamente ripristinato, il che potrebbe creare confusione se ti dimentichi di aver lavorato su qualcosa. Aiuta a lavorare con gitk o magit (emacs) per nascondere vedere .

Conferma e rebase

Puoi dividere il tuo lavoro in diverse unità e / o esperimenti. Quando hai finito, fai un git rebase --interactive ( -i ) per modificare singoli commit (il comando si aspetta un commit di base come argomento). Quindi, puoi spingere le tue modifiche a monte (o no, aiuta a pulire regolarmente).

Perché eseguire il commit?

Devi impegnarti, perché anche se i fallimenti sono minimi, il costo di commit è così basso che non devi correre rischi. Come notato nel commento, in qualsiasi momento puoi scegliere di avere una filiale locale per mantenere le cose organizzate, se aiuta.

Fondamentalmente, tutto ciò che fai localmente è buono, purché non imposti commit temporanei.

Detto questo, puoi push le tue modifiche semicoperte su un altro server, a patto che tu lo faccia solo in un privato, ramo privato.

Impegnati. Impegnati il più spesso possibile. Impegnati quando è incompleto, commetti quando è finito. Non importa davvero. Persino commetterò e spingerò in remoto quando mi alzo per una riunione di un'ora o pranzo anche ...

Il problema è che devi essere nel tuo ramo (uno da cui nessun altro tirerà fuori). Questo dovrebbe comunque essere parte del normale ciclo di sviluppo ed è il modo più semplice per mantenere pulita la cronologia git. Prima di fonderti nell'albero di sviluppo genitore, ripulisci la cronologia schiacciando i commit. Non ci vuole quasi più tempo extra e ti permette davvero di scegliere e decidere cosa commette farlo in ciò che si impegna / spinge.

Lavorerò spesso su diversi bug prima di schiacciare i commit, ridistribuire sul ramo remoto genitore e fondermi con il ramo remoto genitore. I miei messaggi di commit mi dicono quando ho finito con un bug e mi sono spostato su un altro. Spaccherò i commit in commit 'single' che contengono ogni 'fix' in un commit e li uniamo a monte. Commettere spesso e con buoni messaggi quando necessario ti permetterà di non preoccuparti della semantica e di proseguire con la programmazione.

Il concetto di commettere il codice quando ha raggiunto un "traguardo" è principalmente dovuto a, altri sviluppatori / tester dovrebbero essere in grado di eseguire il checkout dell'ultima versione senza temere che non possano compilare / debuggare il codice perché è rotto.

Quando si tratta di sistemi di controllo della versione distribuita come Git, non c'è alcun problema quando si effettua il check-in del codice mentre è impegnato sul repository locale, ma questo è importante.

Quando hai un codice un po 'cotto e quando devi smettere di lavorare, credo che sarebbe meglio fermarsi dove si trova e riprendere il giorno dopo anziché impegnarsi, perché il rischio di guasti hardware / software è minimo. Inoltre, è importante che le modifiche siano cambiamenti ragionevolmente piccoli che, anche se perdi la modifica a causa di un errore hardware / software, dovresti essere in grado di rifarlo senza un grande sforzo.

Dico che non solo potrebbe impegnare modifiche non completate quando è necessario smettere di lavorarci sopra: probabilmente dovrebbe farlo. Quando devi lasciare un compito per un lungo periodo, supponi sempre che stai per "cambiare contesto" al momento del tuo ritorno. Ora, se hai intenzione di fare un caffè - o anche di fare una pausa di lancio - dovresti stare bene, ma se esci dall'ufficio o passi a un'altra attività prima che torni all'attività originale dovrai fai uno sforzo per ricordare dove esattamente ti sei fermato.

È qui che il commit può aiutarti - commettere tutto, scrivere nella testa "Temp" o "WIP" o qualsiasi altra cosa per indicare che non è un commit completamente sfornato, e scrivere nelle note del corpo a te stesso riguardo a cosa stavi facendo , cosa avevi intenzione di fare in seguito, quali sono i problemi irrisolti che stai incontrando, qualsiasi cosa tu pensi che sia necessario per tornare rapidamente a quell'attività.

Il controllo del codice sorgente non è solo per non perdere il codice, ma anche per non perdere la traccia del tuo codice.

Ovviamente - non spingere mai questi commit a uno dei principali rami condivisi ( master , develop , release-### - qualsiasi ramo usato da tutti gli sviluppatori). Ma se è un ramo privato, impazzisci. Puoi sempre forzare a spingerlo - sei l'unico a lavorarci sopra.

E non dimenticare di modificare questi commit una volta che hai finito - non vuoi che tutti questi commit temporanei WIP stiano nel tuo grafico ...

Un commit locale può sempre essere modificato in modo sicuro se non è stato ancora spinto a monte, in modo che tu possa impegnarti alla fine della giornata e riprenderlo il giorno dopo. Tuttavia, questo è di utilità limitata per quanto riguarda la condivisione del codice e la ridondanza, a meno che non si lavori su un ramo che è solo tuo. In quel caso, hai il diritto di spingere un giorno e forzare un aggiornamento il prossimo, il che lascia a chiunque altro abbia tirato la tua filiale responsabile per affrontare le conseguenze. In particolare, questo sacrifica una certa quantità di gestione automatica delle revisioni e lascia alle persone coinvolte.

Dato che git è abbastanza flessibile da supportare vari flussi di lavoro, quali commit & condividere la pianificazione da utilizzare in ultima analisi dipende dalle esigenze della tua squadra, in modo che possano fornire le risposte esatte che cerchi. Sembra che, come minimo, un commit EOD locale soddisferà le tue esigenze individuali di mantenere le modifiche organizzate in commit.

La tua domanda dipende molto da alcune cose: complessità del codice base , modifica della complessità , persone che lavorano sul codice base , persone interessate dal tuo cambiamento , ecc.

Personalmente evito di commettere affari incompiuti, anche se ciò significa non impegnarsi per alcuni giorni (Molte persone non saranno d'accordo qui). Ed è certamente buono rimanere "connessi".

Quindi, alla luce di tutto ciò, direi: Se il compito è troppo grande per essere realizzato prima della fine della giornata lavorativa, allora forse il problema potrebbe essere suddiviso in problemi più piccoli, quindi compiti, e ciascuno di questi possono essere commessi separatamente in modo non distruttivo.

Ecco alcuni altri punti che mi piace ricordare a me stesso quando mi impegno (sono solo linee guida e non si applicano ogni volta):

• Impegna codice funzionante - anche se devi fare diversi commit separati (grande base di codice, più copie di lavoro, ecc.) assicurati di impegnarti in un tale ordine, che non infranga il codice base, se qualcuno dovesse aggiornamento a metà del tuo commit.

• Il commit NON deve essere l'ultima cosa che fai - Evita di impegnarti alla fine della giornata, senza controllare / testare / correre / altro. Questo, più spesso poi non è una decisione sbagliata. Sei stanco, la tua mente è focalizzata su ciò su cui stai lavorando e non sempre vede il quadro generale ... particolarmente male quando lavori con altre persone, che saranno influenzate dal cambiamento ... Meglio impegnarsi al mattino, lavoro di ieri.

• Se hai più modifiche logiche in un singolo file, impegnale separatamente (quando possibile). Non vuoi confondere le persone quando guardano indietro attraverso i tuoi commit, specialmente quando è complesso, coinvolgono molti file, ecc.

• Rompa il grande problema in problemi più piccoli - È molto meglio e più chiaro avere alcuni commit più piccoli con una logica incapsulata e un messaggio di commit conciso (forse anche il collegamento ad altri commit relativi), piuttosto che un enorme commit con un messaggio simile a un articolo.

• Evita di scrivere codice commentato, evita di commentare il codice e di impegnarti - è per questo che usi il controllo della versione in primo luogo ... Se qualcosa è così lontano dall'essere finito, devi commentare , in modo che il progetto possa essere compilato - NON impegnarlo ... Se qualcosa deve essere rimosso dal codice base, NON commentarlo, ma rimuovilo.

Da quello che ho osservato, diverse persone variano notevolmente nella frequenza di commit. Alcune persone commettono piccoli commit frequenti e altri commettono rari grandi commit. Ho visto persone non impegnate fino a quando non hanno terminato diverse settimane di lavoro, risultando in un gigantesco commit che tocca centinaia di file.

IMHO, enormi commit sono una cattiva idea. Mi piace pensare ai commit come tipo di unità di lavoro atomiche. Tendo a fare frequenti piccoli commit.

Ad esempio, se rinominare un file, questo probabilmente significa che il nome del file deve cambiare, il file di progetto deve essere aggiornato per puntare al nuovo percorso, il nome del codice all'interno del file probabilmente cambia, e quindi qualsiasi codice quello che si riferisce a questo deve anche cambiare. Questo è un bel po 'di cambiamenti, ma concettualmente ho fatto solo una cosa: rinominare questo file. Quindi farei tutto questo in one commit . In modo che chiunque osservi la storia può vedere che tutto ciò che è successo in stuff è accaduto, ma semanticamente è solo una operazione banale.

Spesso vado al punto di cambiare un sacco di cose e, una volta compilato, passo alla GUI di commit e seleziono le modifiche in insiemi concettualmente separati. Quindi se il codice non funziona, e provo un sacco di cose, e si scopre che c'erano tre problemi non collegati che lo stavano fermando, lo renderò in tre commit separati.

È meglio se puoi commettere cose nei punti in cui il codice funziona ancora. Ma non sempre mi occupo rigidamente di questo. Forse cambiando questa interfaccia e il codice che lo usa si rompono anche 3.000 test unitari. In tal caso, probabilmente importerò le relative modifiche al codice e correggerò i test delle unità in un commit successivo.

Un'altra cosa che vale la pena di tenere a mente: non si tratta solo di "salvare il proprio lavoro". È anche un "punto di sicurezza" su cui tornare se si finisce per incasinare così male il codice che sembra non funzionare più, e si vuole solo ripristinare tutto all'ultimo punto di lavoro. Se hai 6 settimane di modifiche senza commit (!!) allora questo è molto, molto imbarazzante da fare. Per questo motivo, se non altro, commetti spesso. (Ma cerca di tenerlo come unità che può avere un messaggio di commit significativo.)

Tutto dipende dal significato di "check in".

Con git, puoi avere un repository privato, quindi il check-in non è altro che un backup personale. Faccio un piccolo cambiamento, funziona fino ad ora, lo controllo. Faccio qualche esperimento, non funziona, o l'esperimento mi dice cosa voglio sapere, cancello la cassa. Ciò significa che devo registrarmi quando ci sono cose che non voglio perdere.

Quindi arriva il punto in cui si registrano le modifiche a un repository condiviso. Se il tuo codice non viene compilato, sarà molto, molto infastidito. Va bene se hai delle modifiche che sono compilate ma sono incomplete, a patto che non influenzino nessuno (ad esempio, puoi avere una funzione semilavorata che necessita di un interruttore per accenderla, e tu la spegni). Ma questo dipende molto dalle regole della compagnia. E le regole aziendali dipendono dal modo in cui le persone lavorano.

Qualcosa da considerare, stai usando il controllo della versione distribuita o centralizzato? ( Modifica: mi rendo conto che questo è stato etichettato come git, ma sento ancora che ci sono informazioni rilevanti su come decidere quando impegnarsi nel mio post.) Se è sul tuo computer locale o sul tuo proprio ramo personale poi fare ciò che sento giusto, ma mi piacerebbe ancora incline a seguire il seguito.

Al mio lavoro usiamo SVN, perché i miei commit potrebbero finire in una build. Non mi piace controllare le cose a meno che non siano per lo più fatte. L'intera storia / funzionalità non ha bisogno di essere implementata, ma mi piacerebbe almeno avere sottotasche logiche complete, cose come

• Cambia lo schema per il nuovo prodotto
• Aggiunge l'elemento ui per il nuovo prodotto
• Aggiunge l'elaborazione per il prodotto

al contrario di

• Iniziare le modifiche ui per il prodotto
• Implementazione parziale della nuova elaborazione per prodotto

Per me, se non riesco a esprimere il mio commit in un modo come "Aggiunge x", "Rimuove x", "corregge x", allora lo prendo come una bandiera rossa. Ogni commit dovrebbe essere chiaro su quanto fa.

Sono nuovo nello sviluppo professionale, quindi tutto questo potrebbe essere formulato male, mi dispiace. In realtà si tratta di due domande,

1. In che modo "pubblico" è il commit?
   • locale o condiviso?
   • si tratta di un ramo principale o di un ramo personale?
   • è probabile che finisca in una compilazione?
   • è probabile che finisca in una build consegnata al QA?
2. Quanto è fuori forma la caratteristica?
   • completamente fatto e testato?
   • completamente fatto ma non testato?
   • principalmente fatto?
   • probabilità di interrompere altri componenti?

Quanto più strong è la tua risposta alla domanda 1, tanto più strong deve essere la tua risposta alla domanda 2.