Cosa Git modelli di ramificazione lavoro per voi?

La nostra società sta attualmente utilizzando un semplice tronco/stampa/aggiornamenti rapidi di ramificazione modello e vorrei consigli su quali modelli di ramificazione funzionano meglio per la vostra azienda o il processo di sviluppo.

  1. Flussi di lavoro /modelli di ramificazione

    Qui di seguito sono i tre principali descrizioni di ciò che ho visto, ma sono parzialmente contraddire gli altri o non andare abbastanza lontano per ordinare i numeri successivi abbiamo eseguito in (come descritto di seguito). Così la nostra squadra di default non è così grande soluzioni. Stai facendo qualcosa di meglio?

  2. Fusione vs riassegnazione (tangled vs sequenziale storia)

    Dovrebbe pull --rebase o di attendere con il merge principale fino a quando il vostro compito è finito? Personalmente mi chino verso la fusione, poiché in questo modo si conserva un audiovisivo su base che un compito è stato iniziato e finito, e anche io preferisco merge --no-ff per questo scopo. Ha altri inconvenienti, però. Anche molti non hanno capito l’utile proprietà di fusione – che non è commutativa (unione di un ramo in master non significa fusione master in argomento ramo).

  3. Sto cercando un flusso di lavoro naturale

    Gli errori a volte succede, perché le nostre procedure non acquisire una specifica situazione con regole semplici. Per esempio una correzione necessaria per le versioni precedenti, ovviamente, dovrebbe essere basata sufficientemente a valle per essere possibile fondere a monte in tutti i rami necessario (è l’uso di questi termini è abbastanza chiaro?). Tuttavia accade che un fix rende il master prima di sviluppatore realizza dovrebbe essere posizionato più a valle, e se è già spinto, peggio, di una fusione o qualcosa basato su di esso), allora l’opzione rimanente è cherry-picking, con i relativi pericoli. Cosa semplici regole come si usa? Anche in questo è incluso l’imbarazzo di un ramo necessariamente escludere altro argomento rami (supponendo che essi sono ramificati partire da una base comune). Gli sviluppatori non vogliono finire una funzione che consente di avviare un’altra sensazione, come il codice appena scritto non c’è più

  4. Come evitare di creare conflitti di fusione (a causa di cherry-pick)?

    Quello che sembra un modo sicuro per creare un conflitto di unione è quello di cherry-pick tra i rami, non possono mai essere unite di nuovo? Vorresti applicare la stessa impegnarsi a ripristinare (come fare?) in entrambi ramo eventualmente risolvere questa situazione? Questo è un motivo per cui non ho il coraggio di spingere per una gran parte di unione-base del flusso di lavoro.

  5. Come si decompongono in attualità rami?

    Ci rendiamo conto che sarebbe fantastico per assemblare un insieme finito di integrazione dell’argomento rami, ma spesso lavoro da parte dei nostri sviluppatori non è chiaramente definito (a volte semplice come “rovistando”) e se il codice è già andato in “misc” argomento, non può essere presa fuori di lì di nuovo, in base alla domanda di sopra? Come si fa a lavorare con la definizione/approvazione/laurea/rilasciando il vostro argomento rami?

  6. Procedure adeguate, come la revisione del codice e la laurea sarebbe, naturalmente, di essere bella.

    Ma noi semplicemente non in grado di mantenere le cose districò abbastanza per gestire questo – eventuali suggerimenti?
    integrazione rami, illustrazioni?

Di seguito è riportato un elenco di domande relative a:

Anche verificare che cosa di Plastica SCM scrive su attività driven development, e se la Plastica non è la vostra scelta, studio nvie del modello di ramificazione e la sua gli script di supporto.

  • Ah, grazie, davvero… mi hanno fatto leggere la maggior parte di che… roba 🙂 . E ‘ qualcosa che mi sono noto per non accontentarsi della mediocrità soluzione, ma continua, alla ricerca della perfezione. Spesso questo è un errore, ma in questo caso molto è in gioco e le soluzioni a portata di mano sono troppo disordinato o poveri che ho bisogno di continuare la ricerca. Così ho deciso di elencare tutti i problemi che ho con esso.
  • Plastica SCM blog gettò il loro parere in discussione, almeno perspicace: codicesoftware.blogspot.com/2010/08/…
  • Si deve prestare attenzione quando si utilizza una “unione –no-ff”, selezionare questa opzione per alcune avvertenze sandofsky.com/blog/git-workflow.html
  • Io sarei interessato a quanto specificamente –no-ff è presumibilmente contribuisce al problema descritto nel link che pubblichi. Per me il problema descritto c’è il fallimento di bisecare con checkpoint, si impegna, e il fallimento di git colpa per aiutare in questo caso – ma non vedo come “–no-ff” cambi qualcosa, rispetto al non uso. L’autore lamenta che un merge con l’opzione –no-ff non fare un file modificato ma senza di esso, il file non essere modificati, devi solo vedere anche i vecchi impegnarsi nella vostra storia, giusto?
  • Altre ramificazione modello: cactus modello barro.github.io/2016/02/…, mainline modello bitsnbites.eu/a-stabile-mainline-diramazione-modello-per-git. Questa ramificazione modello offre un approccio di gitflow.
InformationsquelleAutor HiQ CJ | 2010-04-12

 

4 Replies
  1. 89

    Più preoccupante di nuovi sviluppatori per DVCS necessario rendersi conto è di circa il processo di pubblicazione:

    • è possibile importare (fetch/pull) qualunque sia il repo remoto è necessario
    • è possibile pubblicare (push) per ogni (nudo) repo si desidera

    Da questo, si può rispettare alcune regole per rendere le vostre domande più semplice:

    Ora:

    Flussi di lavoro /modelli di ramificazione:

    ogni flusso di lavoro è lì per il supporto di un processo di gestione del rilascio, e che è su misura per ogni progetto.

    Quello che posso aggiungere al flusso di lavoro si parla è: ogni sviluppatore non dovrebbe creare una funzione ramo, solo una “corrente di dev ramo, perché la verità è che lo sviluppatore spesso non sa che cosa esattamente la sua/il suo ramo si producono: una caratteristica che, più (perché è finito per essere troppo complesso una funzione), nessuno (perché non pronto in tempo per il rilascio), un’altra caratteristica (perché quello originale era “trasformato”),…

    Solo un “integratore” dovrebbe funzionario di funzionalità di rami su un “centrale” repo, che possono poi essere recuperati dagli sviluppatori per il rebase/unire la parte del loro lavoro che si adatta di quella funzione.

    Fusione vs riassegnazione (tangled vs sequenziale storia):

    Mi piace la mia risposta si parla (“Descrizione del flusso di lavoro per il git di utilizzo per lo sviluppo in-house“)

    Sto cercando un flusso di lavoro naturale:

    per le correzioni, è possibile aiutare l’associazione di ciascuna correzione con un biglietto da un bug tracking, che consente agli sviluppatori di ricordare dove (cioè il ramo, cioè un ramo dedicato “per le correzioni”) lui/lei dovrebbe commettere tali modifiche.

    Quindi ganci possono aiutare a proteggere un repository centrale contro la spinge da non convalidato, correzioni di bug o dai rami da cui non si deve spingere. (non specifico la soluzione qui, tutto deve essere adattato al proprio ambiente)

    Come evitare di creare conflitti di fusione (a causa di cherry-pick)?

    Come affermato da Jakub Narębski in la sua risposta, cherry-picking dovrebbero essere riservati per le rare situazioni in cui è richiesto.

    Se la tua impostazione comporta un sacco di cherry-picking (cioè “non è raro”), poi qualcosa si è spento.

    Vorresti applicare la stessa impegnarsi a ripristinare (come fare?)

    git ripristinare dovrebbe prendersi cura di questo, ma che non è l’ideale.

    Come si decompongono in attualità rami?

    Come lungo come un ramo in cui non è ancora stato spinto ovunque, uno sviluppatore deve riorganizzare la sua storia di impegna, una volta che lui/lei finalmente vedere lo sviluppo richiede una più definitiva e stabile forma) in:

    • diversi rami, se necessario (uno con chiaro identificato funzione)
    • un insieme coerente, si impegna all’interno di un ramo (vedi Ritaglio Git Checkins)

    Procedure adeguate, come la revisione del codice e la laurea ?

    Integrazione rami (in un’apposita integrazione) repo può aiutare lo sviluppatore a:

    • rebase la sua/il suo sviluppo sulla cima di quel remoto integrazione del ramo (pull –rebase)
    • risolvere localmente
    • spingere lo sviluppo di quel repo
    • verificare con l’integratore, che non si tradurrà in un disastro 😉
    • Grazie VonC, prenderò in considerazione la tua risposta al più presto!
    • come si può vedere, questo non è esattamente un risposta finale per la tua “domanda finale” 😉
    • Ho capito, e ho un bel senso dell’ironia così, è ok 😉
    • Ok, ho imparato una cosa fondamentale da Linus ” post, “non si deve mai tirare in un ramo che non è già in buona forma”, ma trovo ancora difficile da tagliare le archiviazioni per raggiungere strettamente sequenziale storia (è necessario o no?!). È così facile per due sviluppatori di mistakingly creare un innocente unione e lasciarlo lì… Anche per me è impossibile inchiodare esattamente quello che “a monte” e “a valle” significa.
    • a monte, dove è regolarmente tirare dal mio post, ovunque tutti i commit finire (la versione di rilascio o del tronco in SVN gergo). A valle di tutti noi è che sotto di loro. L’invio di roba a monte è il processo di ottenere confluì nella versione repo (come linux-2.6) e, a valle, sia le modifiche da lì andando fuori, o dal vostro repository come dicono i manager di sviluppare tale funzione per i serventi… voglio dire squadra.
    • Ho letto questo post più chiaramente ora e sono perfettamente d’accordo.
    • ancora è difficile da tagliare le archiviazioni per raggiungere strettamente sequenziale storia”: è più facile con Git1.7 e la sua rebase --interactive --autosquash che si muovono automaticamente tutti i commit con l’inizio di un altro messaggio di commit. Se chi commette l’uso di un numero di ticket (per esempio), anche se le correzioni relative alla biglietteria non sono stati fatti in sequenza, al momento, la autosquash consente un rapido riordino di chi si impegna.
    • sequenziale storia (è necessario o no?!)”: non è sempre necessario, ma aiutare a mantenere traccia di dipendenze funzionali (stackoverflow.com/questions/881092/…) e conflitti semantici (stackoverflow.com/questions/2514502/…)
    • Ulteriore domanda stupida materia di ritaglio si impegna e se, per raggiungere sequenziale storia o non stiamo parlando di singoli sviluppatori prima di pubblicare i cambiamenti finora, e a proposito di Linus “generali” a quanto ho capito si chiamano, fanno a raddrizzare le cose o, al contrario, mantenere la unisce a mostrare chiaramente che le linee base e fonde i “minion” hanno usato? È anche possibile comunicare questo tipo di groviglio di rami tramite patch?
    • è anche possibile comunicare questo tipo di groviglio di rami tramite patch? “: sì, questo è in realtà il tutto principio di GitHub, Forcella Coda (github.com/blog/270-the-fork-queue).
    • In “generale” di configurazione, se si impegna non si applica correttamente, si sono rifiutati, e l’utente finale è chiesto di base il suo/la sua opera prima (sulla parte superiore della filiale di destinazione recuperare in repo dello sviluppatore), prima di spingere di nuovo la sua/il suo lavoro al generale. Una volta che è fatto, non di raddrizzamento (cioè senza la riscrittura della storia) dovrebbe essere fatto se quelle “generali” rami sono tirato di nuovo. Gli utenti finali non sarebbe in grado di facilmente tirato quelle pubbliche rami di qualsiasi raddrizzamento aveva preso il posto.

  2. 21

    Penso, e posso sbagliarmi, che una delle cose che più frainteso git è la sua natura distribuita. Questo lo rende molto diverso da dire subversion, i modi in cui si può lavorare anche se è possibile mimick SVN comportamento, dovrebbe si desidera. Il problema è che praticamente qualsiasi flusso di lavoro, che è grande, ma anche fuorviante.

    Se ho la mia comprensione di sviluppo del kernel (mi concentrerò su questo), il diritto, ognuno ha il proprio repository git per lo sviluppo del kernel. C’è un repository di linux-2.6.git, curato da Torvalds, che agisce come il rilascio del repository. Persone clone da qui, se vogliono iniziare a sviluppare una funzione contro il “rilascio” del ramo.

    Altri repository fare un po ‘ di sviluppo. L’idea è di farlo da linux-2.6, filiale di quante volte vuoi fino a tal punto, da come hai avuto un lavoro “nuovo” funzione. Poi, quando questo è pronto, si può renderlo disponibile a chi viene considerato attendibile, che si tira questo ramo dal repository in loro e unire nel mainstream. Nel kernel linux, questo avviene su più livelli (fidati luogotenenti) fino al raggiungimento di linux-2.6.git che a questo punto diventa il “kernel”.

    Ora qui è dove diventa confuso. Filiale di nomi non hanno bisogno di essere coerente tra i repertori a tutti. Così posso git pull origin master:vanilla-code e ottenere un ramo dal origin‘s master in un ramo nel mio repository chiamato vanilla-code. Fornendo so cosa sta succedendo, davvero non importa – è distribuito nel senso che tutti i depositi sono pari a vicenda e non appena condiviso su più computer come SVN.

    Così, con tutto questo in mente:

    1. Credo che per ogni programmatore come fanno il loro ramificazione. Tutto ciò che serve è un repository centrale per la gestione di versioni etc. Tronco potrebbe essere head. Versioni potrebbero essere i tag o le filiali e gli aggiornamenti rapidi sono probabilmente i rami in se stessi. Infatti, io probabilmente fare una release come rami, in modo che si può tenere curarli.
    2. Vorrei unire e non rebase. Se per esempio si prende un repository, clone, ramo e fare qualche dev, poi estrarre dal tuo origin si dovrebbe, in archivio, probabilmente un altro ramo e fondere le ultime master in yourbranch in modo che qualcun altro può tirare le modifiche con il minor sforzo possibile. C’è molto raramente è necessario veramente rebase, nella mia esperienza.
    3. Penso sia un caso di capire come Git funziona e cosa si può fare. Ci vuole un po ‘ e un sacco di buona comunicazione – ho solo cominciato veramente a capire che cosa sta succedendo quando ho iniziato a usare git con altri sviluppatori e anche ora, alcune cose non sono sicuro.
    4. Conflitti di unione sono utili. Lo so, lo so, vi voglio tutti al lavoro, ma il fatto è che il codice cambia e si ha bisogno di unire i risultati in qualcosa che funziona. I conflitti di unione sono, infatti, più che di programmazione. Non ho mai trovato una semplice spiegazione di cosa fare su di loro, così qui è: nota i file che hanno conflitti di unione, andare e cambiare quello che dovrebbe essere, git add . e poi git commit.
    5. Tuttavia si adatta. Come ho detto, ogni utente repository git è proprio a giocare con i nomi dei rami non c’è bisogno di essere lo stesso. Se tu avessi una messa in scena repository, ad esempio, è possibile applicare uno schema di denominazione, ma non è necessario per ogni sviluppatore, solo nella versione repo.
    6. Questo è l’unione di stage. È solo unire la versione rami ecc se si considera codice rivedendo/pass test di qualità.

    Spero che aiuta. Mi rendo conto VonC come ha appena inviato una molto simile spiegazione… io non riesco a tipo abbastanza veloce!

    Modifica alcune ulteriori riflessioni su come utilizzare git in un contesto commerciale, in quanto questo sembra rilevante per l’OP dai commenti:

    • Il rilascio repository chiameremo product.git, è accessibile da un numero di senior programmatori /tecnici responsabili in realtà cercando dopo che il prodotto stesso. Essi sono analoghi per il ruolo di manutentori OSS.
    • Questi programmatori, probabilmente, anche in parte al piombo allo sviluppo di nuove versioni, in modo che possano anche il codice se stessi e mantenere varios repository. Si potrebbe gestire la stadiazione repository per davvero nuove funzionalità e potrebbero anche avere i propri repository.
    • Sotto di loro sono programmatori responsabile per lo sviluppo dei singoli bit. Per esempio, qualcuno potrebbe essere responsabile per la UI di lavoro. Essi, pertanto, di gestire l’interfaccia utente.repository git.
    • Sotto di loro sono i veri programmatori che sviluppano le caratteristiche come il loro pieno giorno per giorno di lavoro.

    Quindi cosa succede? Beh, ognuno tira all’inizio di ogni giorno di più “a monte” source cioè la versione del repository (che sarà anche probabilmente contenere il materiale più recente dai precedenti giorni di sviluppo). Tutti fanno così, direttamente. Questo andrà su un ramo nel loro repository, probabilmente chiamato “master” o forse, se mi stai chiamato “ultima”. Il programmatore che deve poi fare un certo lavoro. Questo lavoro potrebbe essere qualcosa che non sei sicuro di voler, fare in modo che un ramo per fare il lavoro. Se non funziona, può eliminare il ramo e tornare indietro. Se lo fa, che dovrà unire il ramo principale a cui stanno lavorando. Diciamo che questo è un UI programmatore a lavorare su latest-ui così si fa git checkout latest-ui seguita da git merge abc-ui-mywhizzynewfeature. Poi dice a suo vantaggio tecnico (interfaccia utente di piombo) ehi, ho portato a termine tale compito, tirare da me. Così l’interfaccia utente di piombo non git pull user-repo lastest-ui:lastest-ui-suchafeature-abc. L’interfaccia utente di piombo poi guarda su quel ramo e dice che, in realtà, molto bene, cercherò di unire nel ui-latest. Si potrebbe quindi dire a tutti sotto di lui per tirare da lui su di loro ui-latest rami o qualunque sia il nome che hai dato loro, e quindi la funzione viene esplorato dai devs. Se il team è felice, l’interfaccia utente di piombo potrebbe chiedere il test di portare a tirare da lui e unire le modifiche. Questo si propaga a tutti (a valle del cambiamento) che le prove e invia segnalazioni di bug etc. Infine, se la funzione passa il test, ecc, uno dei migliori tecnici conduce potrebbe unire in corso la copia di lavoro del programma, al punto che tutte le modifiche sono poi propagate verso il basso. E così via.

    Non è un “tradizionale” modo di lavorare ed è progettato per essere “peer driven”, piuttosto che “gerarchico” come SVN/CVS. In sostanza, ognuno di noi ha il commit, ma solo a livello locale. Si tratta di accesso al repository e il repository di cui si designa come il rilascio repo che consente di utilizzare gerarchia.

    • +1 per il “distribuita”, aspetto chiarimenti.
    • Grazie mille per la sua ampia risposta (e voti), ho letto un paio di più tempo per estorcere informazioni utili al di fuori di esso. Tuttavia, siamo una società, non un OSS comitato per lo sviluppo ;-), e devo aiutare la mia sviluppatori più chiare linee guida di “smanettare come si desidera nel vostro repository”. Andiamo a vedere dove questo post porta, mi sento in un buon momento, tenerlo a venire!
    • Grazie. @UncleCJ vero, ma si, sono sicuro, hanno comunicato-manager e così via. Chiunque con accesso al repository è in grado di fare queste cose. Come per lo sviluppo, perché non dare agli sviluppatori la libertà, all’interno di motivo, per ramo di distanza? Se si dispone di alcune di protocollo per l’accordo unisce e il repository centrale(ies) sono denominati come ti piace, non c’è un problema. Detto questo, un comune schema di denominazione non è una cattiva idea. Io tendo ad usare le iniziali-versione-funzione-sezioni per personale rami e versione per rami.
    • Ho aggiunto un esempio di come potrebbe funzionare in una società. È essenzialmente l’OSS ruoli sostituito con i gestori, ma si ottiene l’idea. Esso ha il vantaggio su SVN che il tuo sviluppatori possono lavorare anche offline (hanno solo bisogno la rete di pull/push) e penso che lo rende più facile di testare le funzionalità, se si implementa bene.
    • Wow, che in realtà è un grande esempio, si potrebbe iniziare a utilizzare qualcosa di simile per la laurea. Non mi riferisco tanto che dal momento che non stiamo facendo OSS che ognuno debba essere regolamentato, in realtà siamo una piccola e piatta squadra, ma dobbiamo cercare di collaborare in modo efficiente su un calendario fitto di appuntamenti e di apprendimento anche come squadra. È per questo che sono qui a chiedere queste domande stupide, così posso aiutare il resto della squadra dopo 🙂 . Ho anche realizzato da #git che mal definiti baseline combinato con la pressione a ridurre i tempi ci sta facendo il viaggio in piedi… sarà di nuovo più tardi.
    • Questo è abbastanza giusto – io ci sono stato di recente, che è esattamente come ho preso quell’esempio, da provare e fallire un sacco… e anche l’adattamento di alcuni OSS progetto, modi di lavorare. Credo che il vero problema è che non importa come si branch e dove i repository sono… si possono definire tali in qualsiasi modo si desidera, che è stato un vero shock per me comunque! Ma permette di fare alcune cose interessanti. Comunque, buona fortuna e buon divertimento!

  3. 9

    Un modello che ho usato con buoni risultati è la seguente:

    Un “beato” repo tutti spinge e tira da/per, fondamentalmente di tipo client-server topologia.

    Non c’è ramo master in modo che nessun sviluppatore può inserire il codice in linea “principale”.

    Tutti gli sviluppi che avvengono sul tema rami. Siamo nel namespace nomi di rilevare facilmente di chi è la responsabilità: gv/newFeature o gv/problema-1234

    C’è anche un vicino di 1 a 1 la mappatura tra i rami e kanban/scrum carte sulla lavagna.

    Per il rilascio di un ramo si è spinto alla beata repo e il kanban-carta viene spostata pronto per la revisione.

    Quindi, se il ramo è accettato dalla recensione, è un candidato per un rilascio.

    Un rilascio succede quando una serie di accettato i rami sono fusi insieme e contrassegnati con un numero di versione.

    Spingendo il nuovo tag per il beato repo c’è una nuova base per le nuove funzioni.

    Per evitare conflitti di unione sviluppatori sono pregati di aggiornamento (merge) il loro inedito rami all’ultima versione di tag.

  4. 2

    Personalmente, cerco di tenere solo rilascio-codice pronto nel branch master.

    Quando lavoro su una nuova funzionalità o correzioni di bug lo faccio in un ramo. Anche io unit test del ramo. Se tutto funziona OK, solo allora ti unisci/rebase indietro nel master.

    E cerco di uso comune, filiale di convenzioni di denominazione, come:

    • bugfix/recursive_loop
    • bugfix/sql_timeout
    • funzione/new_layout
    • funzione/enhanced_search

Lascia un commento