Close

Negatieve snelheid: hoe verhoog je de complexiteitslimiet

Tekenen dat je softwareteam te maken heeft met te veel organisatorische complexiteit en hoe je dit kunt verbeteren

Headshot van Andrew Boyagi
Andrew Boyagi

Senior Evangelist


Een van de meest voorkomende doelen van een technische organisatie is snel hoogwaardige software leveren.

Bekijk de visieverklaring van je CIO of CTO en luister naar wat ze zeggen. De kans is groot dat ze dit doel op hun eigen manier nastreven. Hoewel het een gemeenschappelijk doel is, is er een groot verschil tussen teams die dit ultieme doel bereiken en teams die vastzitten in het leveren van software. Sommige teams brengen voortdurend nieuwe code op de markt met weinig incidenten of negatieve gevolgen voor de klant, terwijl andere teams moeite hebben met releases per kwartaal.

Compass-logo.

Compass gratis uitproberen

Verbeter je ontwikkelaarservaring, catalogiseer alle services en verbeter de gezondheid van je software.

Hoe zijn deze prestatieverschillen te verklaren?


Wat de levering van software complex maakt, is het verschil tussen hoogwaardige software snel leveren en … niet. Het is het verschil tussen elke week de vlag uithangen na een succesvolle release en een team dat zich niet meer betrokken voelt bij de levering van software, gefrustreerd dat maandenlang werken aan de nieuwste release tot zes nieuwe bugs en een rollback heeft geleid.

Vergelijk de snelheid en kwaliteit waarmee startups nieuwe producten en functies leveren met die van een gevestigde, grote organisatie. In de financiële sector hebben fintech-startups het afgelopen decennium bijvoorbeeld marktaandeel van grote, gevestigde banken afgesnoept. Grote banken wijzen vaak op de oneerlijke concurrentie van fintech-startups, die aan minder regelgeving hoeven te voldoen en geen verouderde, monolithische toepassingen hoeven te onderhouden. Een kleiner team biedt meer flexibiliteit en de mogelijkheid om te schakelen op basis van de behoeften van de klant. In wezen hebben fintechs niet de complexiteit van gevestigde banken, waardoor ze sneller en met minder risico kunnen handelen. Hoewel het softwareteams kan vertragen, is complexiteit niet altijd een slechte zaak.

Wereldwijd netwerk
gerelateerd materiaal

Wildgroei van software inperken

Pictogram van drie ringen
Oplossing bekijken

Verbeter je DevEx met Compass

Complexiteit bij het leveren van software


Complexiteit kan een goede zaak zijn: het is enorm lonend om lastige problemen op te lossen. Het motiveert teams om de uitdaging aan te gaan, moeilijke problemen op te lossen en een branche op zijn kop te zetten. Er is daarentegen een punt waarop complexiteit niet langer gaat over een lastig probleem oplossen, maar negatieve gevolgen heeft voor softwareteams.

Organisatorische complexiteit speelt een belangrijke rol bij het afnemen van de effectiviteit van softwareteams. In het Collins-woordenboek wordt complexiteit gedefinieerd als 'de toestand waarin veel verschillende onderdelen op een ingewikkelde manier met elkaar verbonden of gerelateerd zijn'. In de praktijk is organisatorische complexiteit de combinatie van informatie, afhankelijkheden, wijzigingen, andere teams, tools en verzoeken die softwareteams nodig hebben om met de rest van de organisatie te communiceren.

Hogere organisatorische complexiteitsniveaus maken het uiteraard lastiger om snel hoogwaardige software te leveren, omdat teams meer tijd besteden aan het navigeren binnen de organisatie dan aan het oplossen van lastige problemen. Groeiende organisaties komen er al snel achter dat softwareteams een complexiteitslimiet bereiken – het aantal complexiteitsteams dat kan navigeren voordat dat invloed heeft op werktevredenheid en de kwaliteit en snelheid van de geproduceerde software. Het lijkt dus logisch dat teams door organisatorische complexiteit te verminderen, zich kunnen concentreren op het oplossen van lastige problemen en op software sneller en met een hogere kwaliteit leveren. Laten we eens kijken waarom dit niet altijd het geval is.

De impact van complexiteit op een softwareteam


De introductie van een microservices-architectuur is een goed voorbeeld van de impact die complexiteit op softwareteams kan hebben. De definitie van complexiteit is ook een perfecte omschrijving van een microservices-architectuur, 'de toestand waarin veel verschillende onderdelen op een ingewikkelde manier met elkaar verbonden of gerelateerd zijn'. Het is waar dat microservices teams in staat stellen om onafhankelijk te werken, sneller te leveren en systemen veilig op te schalen. Ik ben groot fan van microservices, maar het zorgt ontegensprekelijk voor een aanzienlijke complexiteit.

Laten we de effectiviteit eens bekijken van softwareteams bij Atlassian tijdens de jarenlange transitie naar een microservices-architectuur.

Aan het begin van het microservicetraject van Atlassian, zagen de DORA-statistieken er geweldig uit! Kleinere stukjes code maakten testen en implementeren eenvoudiger, waardoor teams veilig en sneller konden werken en de werktevredenheid hoog was. Tijdens deze fase hebben teams van de verwachte voordelen geprofiteerd van een microservices-architectuur. Hoewel de complexiteit toenam, zagen we geen negatieve effecten op teams.

aan het begin van een microservicetraject

Afbeelding 1. Het begin van het microservicetraject

Vanwege de voordelen begon een groter deel binnen de organisatie een microservices-architectuur toe te passen, waardoor de complexiteit van de organisatie uiteraard toenam. Meer autonome teams vereisten meer samenwerking, en meer microservices betekenden meer afhankelijkheden. Het tempo van de veranderingen nam enorm toe. Dit zijn alle tekenen van een software-explosie. Door de toegenomen complexiteit nam de effectiviteit van softwareteams af, wat blijkt uit een daling van de veranderingssnelheid, en werd cognitieve belasting een probleem voor softwareteams.

Afbeelding 2. De effectiviteit van het team neemt af naarmate de complexiteit de limiet nadert

Afbeelding 2. De effectiviteit van het team neemt af naarmate de complexiteit de limiet nadert

Zonder tussenkomst bereikte de organisatie uiteindelijk een complexiteitslimiet en nam de effectiviteit van het softwareteam af. De voordelen van snelheid, autonomie en kwaliteit die aan het begin van het microservicetraject werden ervaren, maakten een ommekeer, wat een begrijpelijke daling van de ontwikkelaarstevredenheid veroorzaakte. Deze tekenen wijzen op een organisatie die haar complexiteitslimiet heeft bereikt. Het softwareteam doet meer moeite om met de complexiteit van de organisatie om te gaan dan om ernstige problemen op te lossen. Dat is niet leuk.

de complexiteitslimiet bereiken

Afbeelding 3. De effectiviteit van teams neemt af naarmate de organisatie de complexiteitslimiet bereikt

Hoe weet je wanneer je de complexiteitslimiet bijna hebt bereikt


De complexiteitslimiet bereiken lijkt misschien onvermijdelijk, maar er zijn een aantal indicaties dat teams hun limiet bijna hebben bereikt. Ik moet ook zeggen dat er geen absolute statistiek is die je vertelt hoe dicht je bij de complexiteitslimiet zit, maar deze indicaties kunnen je helpen om vast te stellen hoe dichtbij je bij de limiet zit.

De duidelijkste indicatie dat een team de complexiteitslimiet heeft bereikt, is wanneer ze meer tijd besteden aan het omgaan met organisatorische complexiteit dan aan het oplossen van lastige problemen waarop ze zich zouden moeten concentreren. De statistieken over de doorlooptijd van DORA voor wijzigingen (snelheid) en het uitvalpercentage van wijzigingen (kwaliteit) laten zien of teams na verloop van tijd langzamer of sneller werken. Hoewel er nog andere factoren van invloed zijn op deze statistieken, zijn ze een goede indicatie voor de effectiviteit van het team.

De tevredenheid van ontwikkelaars is een andere indicatie van met hoeveel organisatorische complexiteit softwareteams te maken krijgen. Ontwikkelaars besteden hun tijd graag aan het oplossen van lastige problemen, maar ze hebben ook een hekel aan overbodige taken waar ze last van hebben. Een lage tevredenheid van ontwikkelaars is een goede aanwijzing dat de organisatorische complexiteit een issue is voor je softwareteam.

Vereenvoudiging is een slechte strategie


Wanneer bedrijven zich realiseren dat hun teams omkomen in de complexiteit, starten ze vaak een 'vereenvoudigingsproject', met als doel hun organisatie te vereenvoudigen. Vereenvoudiging is om twee redenen een slechte strategie; de complexiteit neemt sneller toe dan organisatie hun omgeving kunnen vereenvoudigen, en deze 'vereenvoudigingsprojecten' worden uitgevoerd in precies dezelfde complexe omgeving die ze willen vereenvoudigen.

Vereenvoudiging begint vaak met het verminderen van het aantal toepassingen door waar mogelijk buiten gebruik te stellen of te consolideren. Om een toepassing buiten gebruik te stellen, moet het team inzicht hebben in alle upstream en downstream afhankelijkheden, wie de toepassing gebruikt, hoe de functionaliteit moet worden vervangen, waar en hoe de gegevens worden gearchiveerd of gemigreerd, en nog veel meer problemen oplossen die met dit werk gepaard gaan. Helaas wordt de aanzienlijke inzet die vereist is om dit te doen niet beloond met een even aanzienlijke vermindering van de complexiteit. Het aantal toepassingen dat een bedrijf buiten gebruik kan stellen zonder dat dit gevolgen heeft voor de kernactiviteiten of de gebruikerservaring is beperkt, maar het aantal nieuwe softwarecomponenten dat ingenieurs aan kunnen maken is niet beperkt.. In de 12 maanden die nodig zijn om één toepassing buiten gebruik te stellen, zijn er waarschijnlijk honderden nieuwe microservices aangemaakt. Aangezien een gezonde technologische omgeving na verloop van tijd groeit, is het niet praktisch om de omgeving te beperken tot een vast aantal toepassingen of softwarecomponenten om de complexiteit te verminderen.

Vereenvoudigingsprojecten bestaan vaak uit het aanpassen van de organisatiestructuur om de communicatiestroom minder ingewikkeld te maken. De minst ingewikkelde organisatiestructuren hebben grote hiërarchische teams en alle medewerkers bevinden zich op dezelfde locatie. De meest ingewikkelde organisatiestructuren hebben kleine, verspreide en autonome teams. Uit de wet van Conway blijkt dat grote hiërarchische teams waarschijnlijk monolithische toepassingen produceren, terwijl kleine verspreide teams waarschijnlijk toepassingen produceren met behulp van modulaire architecturen zoals microservices. Snelle productie van hoogwaardige software wordt mogelijk gemaakt door modulaire architectuurpatronen, zoals een microservice-architectuur, wat betekent dat de complexere organisatiestructuur eerder tot succes leidt. Hoewel het 'vereenvoudigen' van de organisatiestructuur het begrijpelijker maakt, werkt dat contraproductief voor het uiteindelijke doel van het vereenvoudigingsproject.

Vereenvoudiging is belangrijk en de moeite waard, maar kan het beste worden ingebouwd als continue verbetering voor softwareteams (en teams bestaande uit teams) in plaats van als een eenmalige activiteit. Vereenvoudiging kan het bereiken van de complexiteitslimiet uitstellen, maar brengt een organisatie niet terug naar de vrijheden die een startende omgeving geniet.

De complexiteitslimiet verhogen


Om softwareteams effectiever te maken, moeten organisaties de complexiteitslimiet verhogen. De complexiteitslimiet verhogen betekent in wezen dat elk team zich kan aanpassen aan organisatorische complexiteit, voordat dit invloed heeft op de werktevredenheid en kwaliteit en snelheid waarmee het team software produceert.

Platformontwikkeling is een belangrijk concept in de zoektocht om de complexiteitslimiet voor een organisatie te verhogen. Teams voor sterke platformontwikkeling richten zich op het verminderen van de cognitieve belasting van softwareteams door organisatorische complexiteit uit hun dagelijkse werk te filteren. Mits correct geïmplementeerd, stelt platformontwikkeling teams in staat om de meeste inspanningen om lastige problemen op te lossen weer in evenwicht te brengen, waarbij minder tijd wordt besteed aan organisatorische complexiteit.

de complexiteitslimiet verhogen

Afbeelding 4. De complexiteitslimiet verhogen

Om deze reden heeft Atlassian Compass aangemaakt, een ervaringsplatform voor ontwikkelaars. Compass helpt de complexiteitslimiet te verhogen door het voor softwareteams eenvoudiger te maken om te gaan met organisatorische complexiteit via de componentencatalogus, statistieken en scorecards, en zich te concentreren op het creëren van een gezonde technische cultuur. Het belangrijkste hierbij is dat organisatorische complexiteit binnen Atlassian niet is afgenomen; de complexiteit bleef zelfs groeien naarmate een groter deel van de organisatie overstapte op een microservices-architectuur. We hebben de tijd die softwareteams besteden aan die complexiteit gereduceerd, wat het verschil is tussen een vereenvoudigingsproject en de complexiteitslimiet verhogen.

Atlassian heeft meer dan 10.000 werknemers en meer dan 17.000 softwarecomponenten, maar onze softwareteams werken grotendeels met startup-achtige vrijheid en leveren snel hoogwaardige software. Onze sleutel tot succes? De complexiteitslimiet verhogen om de effectiviteit van het softwareteam te verbeteren.

Hier volgen twee acties om je complexiteitslimiet te verhogen:

  • Houd je DORA-statistieken bij en evalueer ze. Hoe zien de DORA-statistieken eruit voor jouw team? Als je ze niet al bijhoudt, worden de DORA-statistieken klaar voor gebruik meegeleverd met Compass.
  • Begrijp en beoordeel de tevredenheid van ontwikkelaars. Hoe voelen de ontwikkelaars in jouw softwareteams zich? De meeste organisaties voeren medewerkerstevredenheidsonderzoeken uit. Vraag naar de resultaten, ingedeeld per functiegebied, om inzicht te krijgen in de tevredenheid van ontwikkelaars. Belangrijke vragen zijn onder andere de volgende beweringen beoordelen:
    • Ik ben trots op leveringen
    • De hoeveelheid stress in mijn werk is beheersbaar
    • Ik begrijp hoe mijn werk bijdraagt aan de bedrijfsdoelen

Compass verzamelt deze informatie ook tijdens het CheckOps-proces, waarbij teams vertellen wat ze van de afgelopen week vonden en wat er beter had gekund.

De complexiteitslimiet verhogen vereist een combinatie van tools, processen en gewoontes. Een ervaringsplatform voor ontwikkelaars zoals Compass kan je helpen inzicht te krijgen in de systeemstatus, afhankelijkheden in kaart te brengen en doorlopende processen aan te maken, om zo de complexiteitslimiet te verhogen en het potentieel van softwareteams binnen je organisatie te benutten.

Probeer Compass vandaag nog gratis uit.

Andrew Boyagi
Andrew Boyagi

Andrew is Head of DevOps Evangelism bij Atlassian en heeft meer dan 20 jaar ervaring in softwarelevering en servicebeheer in bedrijfsorganisaties. Hij biedt een praktisch perspectief op hoe teams en organisaties de voordelen van DevOps kunnen maximaliseren op basis van ervaringen uit de praktijk.


Deel dit artikel
Volgend onderwerp

Aanbevolen artikelen

Bookmark deze resources voor meer informatie over soorten DevOps-teams of voor voortdurende updates over DevOps bij Atlassian.

Toelichting DevOps

Compass-community

illustratie obstakels overwinnen

Tutorial: Een component aanmaken

Afbeelding van kaart

Ga gratis aan de slag met Compass

Meld je aan voor onze DevOps-nieuwsbrief

Thank you for signing up