Feature branch

Vad är en feature branch?

En feature branch, som också kan översättas till funktionsgren, är en kopia av huvudkodbasen där en enskild person eller ett team av programutvecklare kan arbeta med en ny funktion tills den är klar.

När många ingenjörer arbetar i samma kodbas är det viktigt att ha en strategi för hur individerna ska arbeta tillsammans. För att undvika att överskrida varandras ändringar skapar ingenjörerna egna kopior av kodbasen, så kallade grenar. I analogi med ett träd kallas mastergrenen ibland för stammen. Processen att införliva ändringarna i en individs kopia i huvudstammen kallas sammanslagning.

Processen för utveckling av feature branch

Vid utveckling av feature branches sammanfogar enskilda ingenjörer eller team av ingenjörer inte sin branch förrän en feature är klar, och ibland arbetar de i veckor eller månader åt gången på en separat kopia. Den här långa tidsperioden kan försvåra sammanfogningsprocessen eftersom stammen eller huvudfilen sannolikt har ändrats på grund av att andra ingenjörer har sammanfogat sina grenar. Detta kallas för en sammanfogningskonflikt.

Utveckling av feature branches och sammanslagning av källkod hanteras i versionshanteringsprogram som Git, mest känt som tjänsten Github. Huvudgrenen och feature branches finns i detta kodförvar (eller repo) och utvecklare checkar ut kod för att skapa en ny gren att arbeta från.

När ändringarna har gjorts i koden gör utvecklaren en så kallad pull request, eller en begäran om att andra utvecklare i teamet ska göra en kodgranskning för att säkerställa att den lokala grenen inte innehåller några fel och att den inte heller kommer att orsaka några fel när den slås samman med huvudgrenen. När en gren har granskats grundligt kan den sedan slås samman med huvudgrenen och bli en del av mainline-repoet.

Utveckling av Git-filialer är en metod för att hantera många ingenjörer som arbetar med samma kodbas. Moderna team förlitar sig ofta på kontinuerlig integration och trunk-based development för att undvika problem med buggfixar och sammanfogningskonflikter som uppstår från förgreningsmodellen för kodutveckling. Detta hjälper till att förhindra problem med flera personer som arbetar på samma kodbas och håller en detaljerad logg över vilken kodbit som lades till av vem, när och var. Den här processen kallas även rebasing.

Vad ska man göra om det uppstår problem med en feature branch?

En av fördelarna med att utveckla i en feature branch är att den inte påverkar din mainline-kod förrän du sammanfogar den igen. Med hjälp av ett git-arbetsflöde kan du rulla tillbaka till tidigare versioner med hjälp av versionskontrollfunktionerna.

Här är ett par vanliga git-funktioner som hjälper till att diagnostisera och rulla ut en hotfix

• Använd git pull för att ladda ner den senaste koden från huvudgrenen. Om du drar från huvudgrenen är det här kommandot en synonym för git pull master origin.

• Använd git push för att skicka tillbaka koden som du har uppdaterat till din utvecklingsgren.

• Git branch var sannolikt det kommando du körde för att förgrena dig från din huvudgren.

• Git checkout gör att du kan växla till olika versioner av en gren. Detta talar om för Git till vilken version du vill registrera ändringar som du gör i koden innan du skickar ut den igen.

• Gitmerge är i huvudsak motsatsen till en git-gren, så att du kan slå samman dina ändringar tillbaka till huvudlinjekoden du förgrenade dig från och städa upp genom att ta bort din gren.

Med hjälp av dessa kommandon kan devops-teamet utvärdera sitt utvecklingsarbete och använda versionskontrollsystemet för att felsöka specifika versioner och rulla tillbaka där det behövs. Om du är i en organisation med många teammedlemmar som arbetar med samma kodbas och använder feature branches kan detta hjälpa till att diagnostisera problem snabbt.

Varför använda förgreningsstrategier

Genom att använda feature branches isoleras varje feature till ett eget område som övervakas av versionshanteringsprogrammet (vanligtvis git). Detta gör det möjligt att arbeta med nya, experimentella funktioner utan att påverka mainline-koden direkt, men ändå dra ner alla nya versioner och uppdateringar som kan ha hänt medan du arbetade med den nya funktionen. Detta är särskilt användbart i team där flera teammedlemmar arbetar med samma centrala kodarkiv.

En separat gren isolerar problem och utveckling till en releasegren, som kan slås samman igen när den är klar. Att ha ett git-arbetsflöde och tydliga kommunikationslinjer mellan utvecklare och ingenjörer kan hjälpa till att ta bort konflikter och göra det möjligt att utveckla olika kodgrenar samtidigt utan att störa varandra.

Som en del av en grenstrategi är det viktigt att inte bara fokusera på git-flödet, utan också feature branch-arbetsflödesmetoder som namnkonventioner för grenar och kodgranskning. Versionskontrollen är en exceptionellt användbar funktion som gör det möjligt för flera teammedlemmar att granska kod innan den skickas ut.

Några vanliga namngivningskonventioner för feature branches:

• Var beskrivande, vilken funktion är det som

• Var kortfattad, använd inte fler ord än nödvändigt. Om det behövs mer förklaring, lägg till det i beskrivningen

• Skriv så att andra utvecklare och ingenjörer kan förstå vad som arbetas med

Även om du arbetar med flera nya funktioner samtidigt är det fortfarande bra att skapa grenar för varje enskild funktion så att de inte kommer i konflikt med varandra.

När du är redo kan du använda en pull request för att låta andra teammedlemmar granska din kod och sammanfoga den tillbaka till det centrala arkivet. Det är dålig praxis att sammanfoga och granska din egen kod. Det kan alltid finnas oförutsedda problem med just din funktion som andra kanske kan fånga upp i granskningen.

Kontinuerlig integration och feature branches

Ett alternativ till feature branch-arbetsflödet är kontinuerlig integration, som är en metod för programvaruutveckling som innebär att nya kodändringar kontinuerligt integreras i huvudlinjen eller stammen i stället för att vänta tills en ny feature branch har utvecklats i veckor eller månader och har avvikit från huvudgrenen.

Kontinuerlig integration, även känd som trunk-based development, hjälper till att minimera konflikter genom att kontinuerligt sammanfoga ändringar till en enda källa för att förhindra feature branch. Kontinuerlig integration, tillsammans med metoder som feature flags, kan hjälpa utvecklare att distribuera kod snabbare med mindre tidsåtgång för att försöka förena olika versioner av kod.