Close

Negatieve snelheid: hoe verhoog je de complexiteitslimiet


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.

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.

The benefits of SOA

SOA's modularity and standardized protocols enable services to communicate effectively, promoting reusability, interoperability, and scalability. These key benefits translate into tangible advantages for companies:

  • Reusability: Reusing existing services reduces development time and costs and promotes consistency and quality. Companies can accelerate development cycles and improve overall efficiency.
  • Interoperability: Services can communicate and exchange data regardless of their underlying technology or programming language. This facilitates enterprise-wide data integration and collaboration. Interoperability streamlines business processes and helps companies adapt to evolving technologies.
  • Scalability: SOA's modular design enables independent scaling of services to meet fluctuating demands. It ensures applications can handle spikes in traffic or expanding user bases without compromising performance or stability. Companies can adapt their infrastructure to changing needs without costly rewrites or redesigns.

Wereldwijd netwerk
gerelateerd materiaal

Wildgroei van software inperken

Pictogram van drie ringen
Oplossing bekijken

Beheer je componenten 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.

Benefits of microservices

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.

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.

Feature

SOA

Microservices

Architectural style

  • Coarse-grained, centralized

Service granularity

  • Larger, more comprehensive services

  • Smaller, focused services

Independence

  • Services are interdependent
  • May share a database for data storage

  • Services are highly independent
  • Decoupled and autonomous

Communication

  • Synchronous, often message-oriented
  • Uses shared data

  • Asynchronous, often RESTful
  • Avoids data sharing

Data storage

  • Centralized data management
  • Services share database

  • Distributed (decentralized) data management
  • Each service is responsible for its own data management

Scalability

  • Horizontal scaling
  • Scaling specific services can be intricate due to shared resources and centralized communication

  • Horizontal and vertical scaling
  • More granular and focused scaling as services operate independently

Deployment

  • Typically involves deploying the entire application as a single unit

Coupling

  • Services exhibit a degree of coupling due to shared resources and centralized communication

  • Loose coupling with minimal dependencies between services

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


What are the challenges of adopting SOA and microservices?

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.

Can SOA and microservices coexist?

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.

How does each architecture impact deployment and DevOps practices?

Both SOA and microservices deployments benefit from Open DevOps practices. However, the specifics will differ depending on the architecture. 

SOA typically involves monolithic deployments, where teams deploy an entire application as a single unit. This approach requires careful coordination between teams. It can be time-consuming and complex, especially for large applications.

DevOps emphasizes collaboration and automation between development and operations teams to address these challenges. This enables more frequent and reliable deployments. By automating testing, configuration management, and infrastructure provisioning, DevOps can help streamline SOA deployments and minimize errors.

Microservices architecture enables more granular deployments. Teams deploy each microservice independently. 

DevOps principles are also essential for microservices deployments. DevOps practices such as continuous integration and continuous delivery allow teams to automate the process of testing, deploying, and building microservices. This facilitates rapid and frequent releases.


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