Feature Branching: Common Practices en de voordelen!

Als software-ontwikkelaar is het belangrijk om een gestroomlijnde workflow te hebben bij het werken aan een project met meerdere teamleden. Een van de manieren om dit te bereiken is door middel van feature branching. In deze blog bespreken we de best practices en voordelen van feature branching.

Wat is Feature Branching?

Feature branching is een ontwikkelingsmethode waarbij elk teamlid een eigen afgezonderde tak (branch) maakt van de main branch om aan nieuwe features te werken. Het teamlid werkt vervolgens in zijn of haar branch tot de nieuwe feature of verbetering klaar is om te worden gemerged met de main branch.

Best practices:

1. Gebruik een duidelijke benaming voor branches: het is belangrijk om branches een duidelijke naam te geven die de inhoud van de branch weergeeft, zodat het voor andere teamleden helder is wat er in die branch gebeurt.
2. Maak kleine branches: het is beter om kleine branches te maken die slechts één functie of verbetering bevatten in plaats van grote branches met meerdere functies of verbeteringen. Dit helpt om het samenvoegen van branches soepeler te laten verlopen.
3. Werk samen: het is belangrijk dat teamleden samenwerken bij het samenvoegen van branches om ervoor te zorgen dat er geen conflicten ontstaan tijdens het samenvoegen.
4. Regelmatig samenvoegen: het is belangrijk om branches regelmatig samen te voegen met de main branch. Hierdoor voorkom je dat er te veel code moet worden samengevoegd en verminder je de kans op conflicten.
   

Feature branching in een CI/CD-pipeline

Een CI/CD-pipeline is een geautomatiseerd proces dat ontwikkelingsteams helpt hun code wijzigingen snel en betrouwbaar te bouwen, testen en implementeren. Bij het implementeren van feature branching in een CI/CD-pipeline, moet de pipeline de branching strategie weerspiegelen door stages te hebben voor het bouwen, testen en implementeren van wijzigingen naar verschillende omgevingen.

Laten we eens kijken naar een voorbeeldpipeline die feature branching gebruikt:

# .gitlab-ci.yml
stages:
- build
- test
- deploy_dev
- deploy_test
- deploy_acceptance
- deploy_production

# Define the jobs for each stage
build:
stage: build
script:
- echo "Building…"

test:
stage: test
script:
- echo "Running tests"

deploy_dev:
stage: deploy_dev
script:
- echo "Deploying to the dev environment"
rules:
- if: $CI_PIPELINE_SOURCE == 'merge_request_event'

deploy_test:
stage: deploy_test
script:
- echo "Deploying to the test environment"
rules:
- if: '$CI_COMMIT_BRANCH == "main"

deploy_acceptance:
stage: deploy_acceptance
script:
- echo "Deploying to the acceptance environment"
rules:
- if: '$CI_COMMIT_BRANCH == "main"

deploy_production:
stage: deploy_production
script:
- echo "Deploying to the production environment"
rules:
- if: '$CI_COMMIT_BRANCH == "main"

Deze GitLab pipeline volgt de feature branching strategie. De pipeline heeft jobs voor build, testen en het deployen naar verschillende omgevingen, namelijk dev, test, acceptance en production. Elke deploy job heeft regels ingesteld die bepalen op welke branch de job moet worden uitgevoerd. De deploy_dev job wordt alleen uitgevoerd wanneer de merge request gericht is op de dev branch. De deploy_test job wordt alleen uitgevoerd als de merge request gericht is op de test branch en zo verder. De deploy_production job wordt alleen uitgevoerd wanneer er een push is gedaan naar de main branch.

Voordelen van feature branching

1. Efficiëntie: feature branching maakt het voor teamleden mogelijk om geïsoleerd aan een bepaalde functie of verbetering te werken zonder dat ze de rest van de codebase beïnvloeden. Hierdoor wordt de efficiëntie van het ontwikkelingsproces verhoogd.
2. Minder conflicten: teamleden werken in afgezonderde branches en de branches regelmatig worden samengevoegd met de hoofdcodebase. Hierdoor worden conflicten tussen de verschillende wijzigingen geminimaliseerd.
3. Traceerbaarheid: het gebruik van feature branching zorgt voor een betere traceerbaarheid van wijzigingen in de codebase. Teamleden kunnen de geschiedenis van elke branch bekijken om te zien welke wijzigingen er zijn aangebracht en waarom.
   

Uitdagingen rondom feature branching

Wanneer je overweegt hier gebruik van te maken, zijn er ook een aantal zaken waar je rekening mee moet houden:

1. Complexiteit: feature branching kan leiden tot een complexe branch-structuur, vooral als er veel ontwikkelaars aan een project werken. Dit kan het moeilijk maken om het overzicht te bewaren en de juiste branch te vinden.
2. Langere integratietijd: elke feature wordt in een aparte branch ontwikkeld. Hierdoor kan het integreren van alle features in de hoofdbranch (meestal genoemd "master" of "main") langer duren en kan het leiden tot vertragingen in de oplevering van de software.
3. Mogelijke conflicten: wanneer verschillende ontwikkelaars aan dezelfde functie werken in verschillende branches, kan het samenvoegen van de branches leiden tot conflicten in de code. Dit kan leiden tot extra werk om deze conflicten op te lossen voordat de code kan worden samengevoegd.
4. Testen van de geïntegreerde code: het kan moeilijk zijn om de geïntegreerde code te testen als elke feature in een aparte branch is ontwikkeld. Dit kan leiden tot vertragingen en extra werk om ervoor te zorgen dat de code goed getest is voordat deze wordt samengevoegd met de hoofdbranch.
5. Vertraging in het vrijgeven van nieuwe functies: doordat elke feature in een aparte branch wordt ontwikkeld, kan het voorkomen dat er vertraging ontstaat bij het vrijgeven van nieuwe functies. Het integreren van alle features en het testen van de code kan namelijk langer duren.
6. Mogelijke vermindering van de samenwerking tussen teamleden: omdat elk teamlid aan een eigen feature werkt, kan dit de samenwerking tussen teamleden verminderen. Dit kan vooral het geval zijn als de teams fysiek gescheiden zijn doordat ze op verschillende locaties werken. Dit kan leiden tot communicatieproblemen en een verminderde productiviteit.
   

Wat is ons advies?

Feature branching is een nuttige methode voor software-ontwikkeling die teamleden in staat stelt om efficiënt te werken aan nieuwe functies en verbeteringen zonder de rest van de codebase te beïnvloeden. Deze strategie is wel complex en vergt de nodige kennis van het proces. Hierdoor kan het moeilijker zijn voor beginnende teamleden. Door het volgen van best practices kunnen teams de voordelen van feature branching maximaliseren.

Wil je hier meer over weten? Neem dan contact op met onze collega Gerard!