Wat maakt een senior senior?

Wat maakt een senior ontwikkelaar, eh, senior? – Die vraag stellen, is je ook afvragen: wat maakt een junior junior en een medior medior?

*

Een voor de hand liggend antwoord is: het vaardigheidsniveau van de ontwikkelaar. Een junior heeft weinig vaardigheid, een medior iets meer, en een senior een heleboel.

De vraag wordt dan: vaardigheid waarin? Die vraag raakt aan de kern wat softwareontwikkeling nu eigenlijk inhoudt.

Een naïef antwoord is: code schrijven. Maar software ontwikkelen is meer dan alleen code schrijven. Het is niet zo dat de ontwikkelaar die de meeste code schrijft (of zelfs wie de beste code schrijft) het meest senior is. Als dat zo zou zijn, dan zouden we ontwikkelaars vandaag nog kunnen vervangen door AI.

*

De mate waarin een softwaresysteem succesvol is, wordt bepaald door de mate waarin het een bepaald probleem oplost. Software ontwikkelen is een probleem oplossen – en om een probleem goed op te kunnen lossen, moet je haar eerst doorgronden.

Maar: welk probleem? Of liever: welke problemen? Het essentiële probleem is dat waar je opdrachtgever mee kampt. De accidentele problemen zijn de software-specifieke moeilijkheden die je moet overwinnen om dat essentiële probleem op te kunnen lossen.

Een junior ontwikkelaar zal eerst moeten leren de accidentele problemen op te lossen, voordat deze zich bezig kan houden met het essentiële probleem. Als je niet weet hoe je code schrijft, kun je je opdrachtgever nog niet helpen met het oplossen van zijn probleem.

Maar dat betekent niet dat een junior geen enkel oog moet hebben voor het essentiële probleem. De vaardigheden om accidentele problemen op te lossen, worden veelal opgedaan in de context van het oplossen van een essentieel probleem. Groei vindt nooit slechts plaats op één van beide assen, de stap naar medior en senior bestaat eerder in een verschuiving van focus.

*

Maar wat een ontwikkelaar kan is niet het hele verhaal. Wat een junior junior maakt en een senior senior ligt voor een groot deel ook in wat je van beide mag verwachten.

Ik bedoel niet: wat je van hen mag verwachten qua vaardigheidsniveau. Het onderscheid wordt soms zo geschetst: een junior mag je verwachten dat diegene kleine bugs zelfstandig op weet te lossen en kleine features met hulp van een ervaren collega; van een medior dat diegene bugs en kleine features zelfstandig oplost en grote features met hulp; en van een senior verwacht je dat ‘ie alles zelf kan.

Dat is, denk ik, de verkeerde insteek. Die zienswijze veronderstelt dat de essentie van software ontwikkelen ligt in het produceren van code.

Het veronderstelt bovendien dat het produceren van code een in essentie eenzame onderneming is. Maar de meest senior ontwikkelaars die ik heb ontmoet, zoeken juist continu hun collega’s op om mee te sparren en te pairen.

*

Laat ik de vraag zo stellen: waar is een junior, medior en senior verantwoordelijk voor?

Ik hanteer de volgende vuistregel: een junior is ervoor verantwoordelijk zichzelf te verbeteren, een medior om het product te verbeteren, een senior om z’n omgeving te verbeteren.

De niveaus bouwen op elkaar voort. Het is dus niet zo dat een medior er niet meer verantwoordelijk is om zichzelf te verbeteren, en een senior niet meer verantwoordelijk is voor het product. De verantwoordelijkheden veranderen niet naarmate je groeit als ontwikkelaar; ze breiden zich uit.

*

Een junior is er verantwoordelijk voor zichzelf te verbeteren, omdat deze pas het product kan verbeteren als deze een bepaald vaardigheidsniveau heeft bereikt.

Een medior is verantwoordelijk voor het verbeteren van het product, omdat deze voldoende accidentele problemen heeft opgelost om zich volledig op de essentiële problematiek te kunnen richten. Maar een medior houdt er natuurlijk niet mee op te leren.

Een senior is verantwoordelijk voor het verbeteren van zijn omgeving – zijn collega’s, het proces – opdat de junioren sneller opklimmen tot medior en de mediors sneller opklimmen tot senior. Hoe beter de omgeving functioneert waarbinnen software wordt ontwikkeld, hoe beter de ontwikkelde software. Maar een senior helpt junioren en medioren ook wanneer ze vastzitten. Hij schrijft ook code, wel degelijk – maar minder dan vroeger.

Wat ik formuleer in termen van verantwoordelijkheid, zou je ook kunnen formuleren in termen van impact. De impact van een junior is lokaal: zichzelf en het eigen leerproces. Die van een medior is beperkt: de kwaliteit van de code, de implementatie van features. Die van een senior omvangrijk: eerst het team, dan de afdeling, uiteindelijk misschien wel de organisatie.

*

Een junior bezoekt kennissessies, de medior geeft kennissessies, de senior organiseert kennissessies.

Maar misschien zeg ik dat alleen omdat ik graag kennissessies (en boekenclubs) organiseer.

carrièrepad · kernwaarden · leercultuur · leiderschap · professionaliteit · verantwoordelijkheid