Master Versjonskontroll for eksterne lag

Arbeidet eksternt har blitt mye mer vanlig i webutvikling de siste årene. Før versjonskontrollen, fungerte du eksternt på samme utviklingsprosjekt, hadde vært et absolutt mareritt. Utviklere ville ha hatt Send store filer til hverandre (sannsynligvis via e-post), lim inn i sin egen kode før du sender den tilbake. Det var ingen reell måte å spore hva som hadde blitt lagt til og når.

• 6 må-ha ferdigheter for unge webutviklere

Heldigvis, versjonskontrollen er kommet og gjort utvikling på alle fronter mye mer håndterlig. Webprosjekter har blitt mye lettere å implementere og administrere, spesielt når det gjelder å jobbe i et eksternt utviklingslag. Du trenger ikke lenger å bekymre deg for den nåværende versjonen av et nettsted som blir overskrevet - hvert lagmedlem er gratis å jobbe på en hvilken som helst fil når som helst, det er ingen forvirring om hvor den nyeste versjonen av en fil blir lagret - og topp skylagring Hjelper med prosessen også.

I denne opplæringen skal vi bruke GitHub. å administrere koden vår. Det finnes mange forskjellige typer versjonskontrollverktøy der ute, for eksempel bitbucket og tfvc, men selv om de er forskjellige, forblir prinsippene de samme når det gjelder administrering av kode.

For flere måter å gjøre nettstedet ditt bygge prosessen enklere, se våre guider til toppen Nettstedbygger og Web Hosting. service.

Forgreningsmodell

For det første er det svært viktig å ha en vellykket forgreningsmodell når du arbeider i et hvilket som helst lag for å gjøre utviklings- og distribusjonsprosessen jevnt. Du vil mest sannsynlig ha flere utviklere som jobber med det samme prosjektet. Når jeg jobber med en ekstern arbeidsstyrke, tror jeg at den beste arbeidsflyten består av tre hovedgrener, samt et sett med midlertidige:

• Utvikle grenen: Hver linje med koden er testet og validert av klienten.
• Staging Branch: Dette vil svare til valideringsmiljøet.
• Slett grenen: Dette inneholder den siste versjonen av nettstedet ditt i produksjonen.

Det vil også være et sett med funksjonsgrener. Disse vil imidlertid bare være midlertidige å opprinnelig bygge ut de nye funksjonene.

Flere utviklere på ett prosjekt

La oss anta at du kjører et lag med to utviklere som jobber eksternt. Vi ringer dem Sarah og James: De jobber begge på samme e-handelsnettsted for en klient. Sarah må utvikle en funksjon som registrerer kundens detaljer.

Vi ville bryte dette ned i tre separate brukerhistorier - legge til, redigere og fjerne - og deretter legge til disse tre billettene i sprintbackloggen.

Har grener

Så, la oss si at Sarah begynner på delen Legge til kundetaljer. Hun ville trenge å opprette funksjonen-avdelingens kunde-detaljer 'og en brukerhistorie en for de første oppgavene' tilleggsdetaljer '.

 Git Checkout Develop & Amp; git trekke opprinnelse / utvikle
Git Checkout -B Funksjon / Kunde-Detaljer
Git Checkout -B Add-Details 

Sarah ville fortsette å jobbe med den midlertidige grenens address 'lokalt og forplikte henne som hun utvikler seg. Nå, la oss si at James ønsker å hjelpe Sarah med kundens detaljer, så han begynner å jobbe med detaljene sletting.

James ville trekke den siste versjonen av den delte grenen og opprette en ny gren for brukerhistorien 'Slett-detaljer'. Så kan han begynne å lage sine egne tillegg uten å bekymre seg for å overskrive Sarahs kode.

 git kassen funksjon / kunde-detaljer
GIT Pull Origin / Funksjon / Kunde-Detaljer
Git Checkout -B Delete-Details 

Han vil også bruke sin midlertidige gren til kode lokalt og begå eventuelle endringer. Når Sarah har fullført sin funksjon lokalt, setter hun billetten i kodeanmeldelse. Hun ville presse koden hennes til Staging Branch og åpne en trekkforespørsel med oppføringsmiljøet.

// hun skyver koden til staging grenen
git push opprinnelse add-detaljer
// Hun åpner en trekkforespørsel med staging miljøet
GIT Request-Pull Staging Add-Details 

Vi vil nå ha kundens-detaljer-funksjonen og de to brukerhistoriefunksjonene i utviklings-tilleggsdetaljer 'og' Slett-detaljer '.

Fusjonere

Når hennes kode har blitt gjennomgått, kan hun fusjonere sin gren til å stages. Billetten er nå i valideringskolonnen, og venter på validering fra ledendeutvikleren.

 // Hun får den siste versjonen av Staging Branch
git checkout staging & amp; & amp; git trekke opprinnelse / staging
Git Merge Add-Details & Amp; git push opprinnelse staging
// hun bygger valideringsmiljøet
// og spør produktets eier å validere 

Når Sarahs arbeid har blitt validert, kan billetten flyttes inn i den ferdige kolonnen. Hun kan fusjonere sitt arbeid i Feature Branch og starte en annen brukerhistorie, som sletting av kundeinformasjon.

 // Hun trekker den siste versjonen av funksjonen
git kassen funksjon / kunde-detaljer
GIT Pull Origin Feature / Kunde-detaljer
Git Merge Add-adresse & Amp; git push opprinnelse funksjon / kunde-detaljer 

Når hele funksjonen er blitt validert av både lederutvikleren og klienten, kan Sarah fusjonere funksjonen for å utvikle seg, da den er klar til å gå.

 // Hun får den siste versjonen av den utviklende grenen
git kassen utvikle og amp; git trekke opprinnelse / utvikle
Git Merge Feature / Customer-detaljer & Amp; git push opprinnelse utvikle 

Distribuere til produksjon

Når alt er fullført, og det er klart å distribuere til produksjon, utvikler James Mames til frigjøring og lanserer distribusjonen. På dette tidspunktet ville han vite at all kode er riktig og klienten er glad. Han koker forpliktelsen på utgivelsen for å få historien til hver versjon.

 Git Checkout Develop & Amp; git trekke opprinnelse / utvikle
git kasse utgivelse & amp; git trekke opprinnelse / utgivelse
git fusjonere utvikle og amp; git tag 2.1.
git push opprinnelse frigjøring - toags 

Regler å følge for denne arbeidsflyten

Denne fjerntliggende utviklings arbeidsflyten kan være ganske vanskelig å forstå først, men hvis du får teamet ditt til å jobbe med denne metoden, så har du en gratis arbeidsflyt uten at du trenger å få panikk om at filer blir overskrevet eller dine utviklere som jobber på samme område.

Det er noen viktige ting å huske:

• Det første du må lære fjernkontrollen din, er din versjonskontroll arbeidsflyt og sørg for at de alle leser fra samme bok.
• Hvis du utvikler en funksjon, kan du prøve å bryte dette ned i mindre brukerhistorier. På denne måten er det lettere å holde styr på hver forpliktelse.
• Ikke gå glipp av noen trinn: samme arbeidsflyt må følges hver gang.
• Du må alltid fusjonere avdelingen din til å utvikle for å forberede neste utgivelse.
• Du bør rengjøre staging-depotet hver uke hvis mulig. Du bør slette staging grenen, lokalt og eksternt, og gjenskape det fra utvikle gren - se eksempel nedenfor:

 git co utvikle og amp; git trekke opprinnelse / utvikle
git Branch -D Staging & amp; git push opprinnelse --delete staging
git co -b staging & amp; git trekke opprinnelse staging 

Ekstra arbeidsflyter

Med mindre prosjekter, vil du kanskje bruke en mindre kompleks arbeidsflyt. Du kan bruke Master, som inneholder den mest oppdaterte versjonen, en utvikle gren og deretter et sett med grener for hver ekstra funksjon - om det er forum, kontaktskjema, kassenesystem. Alt avhenger av din personlige preferanse.

Administrere sammenføyningskonflikter

Å håndtere flette konflikter er vanskelig nok hvis du alle jobber i samme rom, men de kan bli enda mer av et mareritt hvis du alle jobber på et annet kontor. Det viktigste er å huske at du alltid kan løsne en sammenføyning og gå tilbake til staten før konflikten oppstod.

Enten du gjør alle fusjonene som lederutvikler eller laget ditt, er de som gjør dem selvstendig, det første skrittet er å forstå hva som har skjedd.

• Har en av dine medutviklere redigere samme linje i samme fil?
• Har de slettet en fil som du endret?
• Har du begge lagt til en fil med samme navn?

Git vil fortelle deg at du har unmeged stier Via. git status :

 $ git status
# På grenskassen-systemet
# Du har uberegnede stier.
# (fikse konflikter og kjøre "git commit")
#
# UNMERGED PATHS:
# (bruk "git add & lt; fil & gt; ..." å markere oppløsning)
#
# Både endret: checkout.html
#
ingen endringer lagt til for å begå (bruk "git add" og / eller "git commit -a") 

Nå er den vanligste årsaken til en konflikt når endringer påvirker de samme filene på samme linje. Så, la oss se på innholdet i den konfliktede linjen. Du vil legge merke til at git er veldig bra i det faktum at det vil markere det konfliktede området ved å omslutte det i lt; & lt; & lt; head og & gt; & gt; & gt; & gt; & gt; & gt; & gt; [Other / gren / navn] . I dette tilfellet er det kassen-systemet .

 & lt; & lt; & lt; HODE
Denne linjen ble begått mens du jobbet i "brukerform" grenen.
=======.
Denne linjen, i kontrast, ble begått mens de jobbet i "kassen-systemet" grenen.
& gt; & gt; & gt; & gt; & gt; & gt; & gt; & gt; Refs / Heads / Checkout-System 

Innholdet etter den første markøren kommer fra din nåværende arbeidsgren. Etter vinkelbeslaget forteller git oss hvilken gren endringene kom fra. En linje med. =======. skiller de to motstridende endringene.

Du kan nå bare åpne filen i en redaktør, søke etter konfliktmarkørene og foreta nødvendige endringer. Når du er ferdig, må filen se nøyaktig ut som du vil at den skal se eller, alternativt kan du fortelle Git at du bare vil gå med en av de redigerte versjonene, kalt vår eller deres .

 Git Checkout --Ours Path / to / conflont-fil.html 

Det er også mange flette verktøyapplikasjoner som kan hjelpe med dette. Kaleidoscope er en flott en for Mac.

Prosjekt og utstedelse ledelse

Det er like viktig som en ledende utvikler å ha et prosjektstyringsverktøy for å håndtere ting som oppgaver og feil, spesielt når utviklerne ikke er kontorbasert. Det er mange løsninger der ute, som Zenhub og Asuna, men jeg tror Githubs innebygde prosjekt og problemsystem er det beste.

Du kan gjøre ting som å sette opp et nytt prosjekt, lage brett eller tildele problemer. Og ikke bare forvirre problemer med problemer: Du kan også bruke den til forbedringer, spørsmål og feil, blant annet.

Her er noen av sine beste funksjoner:

• Innebygd merkingssystem: Lar deg organisere og prioritere arbeidsflyten din og enkelt søke gjennom prosjekter for relevant informasjon.
• Milepæler: Perfekt for tilknyttede problemer med spesifikke funksjoner eller prosjektfaser, for eksempel feil som må løses før en beta-lansering eller oppgaver som skal fylles ut i oktober.
• Multi-oppgaver: Problemene kan tildeles brukere i bulk, og sparer tid og gjør deg mer effektiv.
• Kommenterer: Ingeniører og ledelsesgrupper kan enkelt diskutere fremgang og resultater på hvert trinn på veien ved hjelp av det innebygde kommentarsystemet.
• Oppgavelister: Større problemer kan brytes ned i stadier for å motvirke etableringen av dusinvis av mikroskopiske problemer, slik at alt arbeidet ditt på samme sted.
• Markdown format: Evnen til å bruke Markdown formatering vil vise seg å være populær blant utviklerne, og den kan brukes på de fleste steder rundt Github.
• Prosjektstyr: Disse kan brukes til å huse problemer, trekke forespørsler og notater, kategorisere dem som kort i kolonner av du velger, slik at du kan se på større prosjekter som helhet.
• Høy sikkerhet: Du kan stole på Github for å holde dataene dine trygge, og det er vanskeligere å bryte enn de fleste andre prosjektstyringssystemer.

Sette opp et prosjekt

Hvis du går til Github og deretter leder til en av dine repositorier, vil du se en fane som kalles prosjekter. Derfra kan du velge nytt prosjekt, sette opp prosjektdetaljer og opprette en ny prosjektmal.

Hvis du nå velger fanen Problemer som er langs toppen og velger nytt problem, vil du kunne opprette et nytt problem. Du kan da bruke ulike etiketter - dette er ting som feil, forbedring, spørsmål og duplikat. Du kan også bruke forbedring for en ny funksjon eller forespørsel. Du kan da tildele ulike lagmedlemmer til oppgaven, en milepæl og også prosjektet du nettopp har opprettet.

Tilordnede medlemmer vil da ha en liste over alle oppgavene sine, og du kan til og med bruke prosjektstyret for å holde et spor av hva som for tiden er bygget. Hvis du husker vår tidligere opplæring, snakket vi om flytting av billetter til Sprint Backlog og validering. Så github fungerer veldig bra som et alt-i-ett-verktøy for å overvåke et prosjekt.

Denne artikkelen ble opprinnelig publisert i utgave 311 av nett , verdens bestselgende magasin for webdesignere og utviklere. Kjøp problem 311 her eller Abonner her .

Relaterte artikler:

• Hvordan lykkes som frilansutvikler
• Utvikle gjenbrukbare reaktkomponenter
• 4 tips for å utvikle dine utviklerferdigheter