Waarom een senior programmeur simpele code schrijft

In mijn allereerste baan, al wel een poosje geleden, was ik programmeur. Junior programmeur zelfs, met de inkt van mijn doctoraal diploma nog nat. Ik mocht gelijk beginnen met wat nieuwe code, en ik deed mijn best. Aan het eind van de dag keek de team leider ernaar, en hij fronste. Hij zei “dat heb je wel mooi gemaakt, heel compact. Maar ik weet niet of alle externe programmeurs die hier het onderhoud doen, er heel blij mee zijn. Die zijn niet allemaal even goed opgeleid”. Dit was in de tijd dat een academische opleiding voor een programmeur nog niet de norm was. “Ik wil je vragen om het wat minder compact te maken, wat meer verboos, wat meer regels, zodat iedereen het snel begrijpt”. Ik deed wat ‘ie had gevraagd, en ik heb bij dat bedrijf, een kleine bank, nog heel veel code gemaakt.

Pas veel later begreep ik de kloe van het verhaal. Veel later, toen ik veel code had gezien die door anderen was gemaakt, goede en minder goede code, code van beginners en code van ervaren programmeurs, begon ik te zien dat die team leider wel een punt had.

Code (source code, software) is niet moeilijk te lezen, als je de taal kent. Een heel programma, of een heel systeem, doet wel een beroep op je hersencelletjes om het allemaal in één beeld te bevatten. Dat is waarom een programmeur die in een flow zit niet om zes uur naar huis gaat: het is zonde om het werk niet af te maken als de hersencelletjes het hele model van de software net mooi hebben opgeslagen. De volgende ochtend kost het weer tijd om de flow op gang te krijgen en het model weer uit te beelden in je hoofd.

Code is niet moeilijk te lezen, als ze mooi is opgeschreven, als ze zo is opgeschreven dat je er snel doorheen leest. Vaak betekent dat dat het visueel goed gestructureerd is, met genoeg open ruimte. Maar soms zijn er een paar regels waar een programmeur heeft gedacht “waarom 20 regels schrijven als het ook in één kan?” Die ene regel is dan wel heel vernuftig, maar je moet er wel een paar keer naar kijken en even nadenken voordat je ziet wat er gebeurt. Dat verstoort je leestempo. En waarom zou je code zo compact mogelijk maken? Niet voor de computer, die vertaalt je code, of ze nu compact is of ellenlang uitgesponnen, tot precies dezelfde instructies. Denk aan de handleiding van de magnetron. Je kunt die samenvatten in tien regels, of je kunt er een mooi handzaam boekje van maken. Als je snel iets wilt opwarmen, dan pak je dat boekje, en ga je niet een uur zitten puzzelen op die tien regels. Terwijl die tien regels ongetwijfeld veel “knapper” zijn.

Afgelopen jaar heb ik een project gedaan waarin ik code heb gezien van veel verschillende applicaties, gemaakt door verschillende mensen, verschillende bedrijven. Dan valt op dat je code die is geschreven volgens algemene standaarden veel sneller doorhebt. Het valt ook op dat je code die iets meer breedsprakig is, sneller leest en sneller doorhebt. Ik zeg “iets meer”, je kunt ook overdrijven. Je moet de juiste balans vinden tussen lekker compact en toch snel te lezen.

Inmiddels ben ik zo ver dat ik code meestal maar simpel opschrijf. Ik gebruik Lambda expressies omdat ze handig zijn, maar waar ze verwarrend zouden zijn, schrijf ik alles wel gewoon uit. Ik gebruik de Java stream API omdat die efficient en mooi is, maar er zijn gevallen dat de code er wat onnodig onoverzichtelijk van wordt, dan doe ik het anders. Ik schrijf code met in mijn achterhoofd “over twee jaar kijkt een nieuw iemand naar deze code, met de opdracht binnen een uur een bug te fixen”.

Ik heb soms het idee dat jonge slimme programmeurs helemaal tot het gaatje gaan in het schrijven van ultra-compacte code omdat ze denken dat ze iets te bewijzen hebben. “Ik ben goed in mijn vak als ik de laatste snufjes demonstreer en laat zien dat ik ook de laatste paar letters in mijn code kan wegwerken”. Zoals ik in mijn eerste baan dacht dat ik iets te bewijzen had, tegenover de oude rotten in mijn team. Ik zou zeggen, probeer je liever te bewijzen tegenover de mensen die na jou komen, die jouw code gaan onderhouden.

Ik probeer simpele code te schrijven. Code waarvan ik hoop dat een ander, misschien over vele jaren, in één oogopslag ziet wat het doet. Omdat ik ook vaak die “ander” ben geweest die heeft zitten puzzelen om onnavolgbaar complexe code te analyseren die uiteindelijk iets heel eenvoudigs bleek te doen.

Leave a Reply

Your email address will not be published. Required fields are marked *