We zijn aangekomen bij het laatste deel van onze serie.
We hebben het al gehad over de eerste stappen in het vak.
Over wat het echt waard is om te leren. Over Code Review, Clean Code en het dagelijkse werk in een team.
Er blijft één vraag over: Wanneer stop je eigenlijk met Junior te zijn?
Die vraag wordt heel vaak gesteld.
Na een jaar? Na twee jaar? Na vijf? Of misschien wanneer je weer een framework leert?
Het antwoord kan je verrassen. - Er bestaat geen enkel juist aantal.
We hebben programmeurs gezien met tien jaar ervaring die bij complexere projecten nog steeds sturing nodig hadden. We hebben ook mensen gezien met drie jaar ervaring die zelfstandig oplossingen ontwierpen, jongere collega's ondersteunden en verantwoordelijkheid namen voor complete modules van systemen.
Daarom zijn ervaringsjaren in IT slechts één onderdeel van de puzzel.
Een Senior weet niet alles
Dat is waarschijnlijk de grootste mythe in de branche.
Veel Juniors stellen zich een Senior Developer voor als iemand die op elke vraag het antwoord weet. De realiteit ziet er heel anders uit.
Een goede Senior zegt heel vaak: "Ik weet het niet."
Maar voegt meteen toe: "We gaan het uitzoeken."
Dat is een enorm verschil.
Een Senior hoeft niet de hele documentatie uit zijn hoofd te kennen. Hij hoeft niet elke library te kennen. Hij hoeft niet alles uit het hoofd te schrijven.
Wat hij wel weet:
- waar informatie te vinden is,
- hoe een oplossing te verifiëren,
- welke risico's verbonden zijn aan een bepaalde beslissing,
- wanneer "ik weet het niet" te zeggen in plaats van te gokken.
Dat is een van de belangrijkste kenmerken van een volwassen programmeur.
Programmeur of engineer?
Aan het begin van je carrière focussen de meesten op code.
Hoe schrijf je een functie? Hoe maak je een API? Hoe verbind je een database?
Na een tijd begin je te zien dat code slechts een gereedschap is.
De echte taak is het oplossen van een zakelijk probleem.
De klant koopt geen applicatie omdat die in een bepaalde taal is geschreven. Hij koopt een oplossing voor zijn probleem.
Dat is het moment waarop de programmeur begint te denken als een engineer.
De beste feature is soms degene die je niet schrijft
Klinkt vreemd? En toch.
Stel je voor dat een klant vraagt om een nieuwe module. Je kunt meteen beginnen met ontwerpen. Maar je kunt ook een paar vragen stellen.
Waarom is deze functionaliteit nodig?
Hoe vaak zal het gebruikt worden?
Bestaat er al een vergelijkbare oplossing?
Kan hetzelfde resultaat op een eenvoudigere manier worden bereikt?
Heel vaak blijkt dat het probleem opgelost kan worden zonder honderden nieuwe regels code te schrijven. En juist voor zulke beslissingen betaalt de klant. Niet voor het aantal commits.
Verantwoordelijkheid begint waar code eindigt
Een Senior is niet alleen verantwoordelijk voor zijn eigen deel van het project. Hij kijkt breder.
Hij vraagt zich af:
- hoe de wijziging andere modules beïnvloedt,
- of de oplossing schaalbaar zal zijn,
- of de nieuwe functionaliteit makkelijk te onderhouden is,
- welke risico's de uitrol met zich meebrengt,
- of gebruikers er echt baat bij zullen hebben.
Dat is een totaal andere manier van denken.
Een goede Senior creëert nieuwe Seniors
Dat is een van de mooiste dingen in onze branche.
De beste programmeurs die we hebben ontmoet, waren nooit bang om kennis te delen. Integendeel.
Ze waren blij wanneer iemand in het team sneller groeide. Want een sterk team wint altijd van een enkele held.
Gedurende meer dan twintig jaar hebben we mogen zien hoe mensen die bij ons stage begonnen, volwaardige teamleden werden. Een van die verhalen beschrijven we in het eerste deel van deze serie.
Vandaag leidt die persoon zelfstandig veeleisende taken, ontwerpt oplossingen en ondersteunt jongere programmeurs.
Is dat van de ene op de andere dag gebeurd? Natuurlijk niet. Het is het resultaat van honderden uren leren. Tientallen Code Reviews. Ontelbare vragen. Gemaakte fouten. En een enorme nieuwsgierigheid naar de wereld.
AI vervangt geen goede programmeur
Dit onderwerp mocht niet ontbreken. Verandert kunstmatige intelligentie onze branche? - Ja. Erg sterk.
Maakt het programmeurs overbodig? - Integendeel.
Het karakter van het werk verandert. We besteden steeds minder tijd aan het schrijven van repetitieve code.
Meer en meer aan:
- analyse van problemen,
- architectuurontwerp,
- verifiëren van oplossingen,
- gesprekken met klanten,
- het nemen van beslissingen.
AI is een uitstekende assistent. Maar de verantwoordelijkheid voor het project blijft bij de mens. En dat zal nog lang zo blijven.
Wat je niet in je CV zet
Je CV toont:
- programmeertalen,
- frameworks,
- certificaten,
- ervaring.
Het toont echter niet de dingen die vaak het succes bepalen.
Kun je je fout toegeven?
Kun je om hulp vragen?
Respecteer je de tijd van anderen?
Houd je je aan afspraken?
Kun je rustig conflicten oplossen?
Neem je verantwoordelijkheid voor je beslissingen?
Juist die eigenschappen zorgen ervoor dat een team met jou wil werken.
Als we maar één advies mochten geven...
Na meer dan twintig jaar softwareontwikkeling zouden we over technologieën kunnen praten.
Over architectuur. Over frameworks. Over kunstmatige intelligentie.
Maar als we je maar één advies konden meegeven, zou het dit zijn: Blijf nooit stoppen met nieuwsgierig zijn.
Technologieën zullen veranderen. Programmeertalen zullen evolueren. Frameworks zullen ontstaan en verdwijnen.
Maar nieuwsgierigheid, nederigheid, de wil om te leren, het vermogen om vragen te stellen - dat zijn vaardigheden die altijd nodig zullen zijn.
Woordenlijst
Senior Developer
Een ervaren programmeur die niet alleen hoogwaardige code schrijft, maar ook oplossingen ontwerpt, technische beslissingen neemt, het team ondersteunt en verantwoordelijkheid draagt voor uitgevoerde projecten.
Softwarearchitectuur
De wijze waarop een applicatie en de relaties tussen haar onderdelen zijn ontworpen, wat invloed heeft op ontwikkeling, prestaties en onderhoudsgemak van het systeem.
Schaalbaarheid
Het vermogen van een systeem om een toenemend aantal gebruikers, data of processen te verwerken zonder prestatiedaling.
Commit
Het vastleggen van wijzigingen in versiebeheersysteem Git, waarmee de ontwikkelinggeschiedenis van een project gevolgd kan worden.
Mentoring
Het proces van kennis- en ervaringsoverdracht naar minder ervaren teamleden, ter ondersteuning van hun professionele ontwikkeling.
Samenvatting van de hele serie
Als je alle vier de delen hebt gelezen, heb je misschien gemerkt dat we zelden over specifieke frameworks schreven.
Dat was bewust.
Technologieën veranderen sneller dan ooit tevoren.
Wat vandaag populair is, kan over een paar jaar slechts een curiositeit zijn.
Maar de manier van denken van een goede programmeur blijft onveranderd; Analyse. Verantwoordelijkheid. Communicatie. Teamwork. Nieuwsgierigheid.
Juist die eigenschappen zorgen ervoor dat je van Junior naar Mid Developer groeit, en na verloop van tijd Senior wordt.
Bij Web24 maken we al meer dan 20 jaar software voor klanten uit verschillende sectoren. In die tijd hebben we één ding geleerd. Je herkent de beste programmeurs niet aan het aantal programmeertalen dat ze kennen. Je herkent ze aan hoe ze problemen oplossen, samenwerken met mensen en hoeveel ze geven om de kwaliteit van wat ze maken.
Als je net je weg in IT begint, wensen we je dat je nooit je nieuwsgierigheid verliest.
Want juist daarmee begint elke goede carrière.
