De IT-industrie heeft een vreemde fascinatie voor nieuwe technologieën, nieuwe paradigma's en, natuurlijk, nieuwe programmeurs. Het is meer een fascinatie dan realiteit aangezien oude tech nooit echt uitsterft. Oude uitvindingen als de mainframe komen niet meer zo vaak op het nieuws, maar ze draaien nog steeds. Zelfs als je nu nog "Cobol" intypt op de gemiddelde vacaturesite krijg je nog steeds resultaten.

De verhalen over leeftijdsdiscriminatie op de werkvloer hoor je nog regelmatig. De hoofden van jongere programmeurs zijn nog niet gevuld met oude ideeën dus ze leren sneller. Ze zijn beter gefocust en ijveriger. Ze zijn niet snel afgeleid (door hun gezin bijvoorbeeld) en als ze wel worden afgeleid, zitten ze alsnog met hun gezicht tegen hun scherm (smartphone of pc).

Zelfs als al deze redenen terecht zijn (en er is genoeg bewijs dat het niet zo is), dan nog hebben programmeerveteranen een geweldige ervaring die je niet kan vinden in de gemiddelde TED-talk op YouTube of een MOOC. Ze snappen beter hoe computers werken omdat zij al werkten met computers toen deze nog bestonden uit panelen met switches. Ze hadden IDE's optimaliserende compilers en continue integratie om ze uit de brand te helpen. Als ze het niet zelf vanaf de grond opbouwden, werkte het niet. De groentjes kunnen daar niet tegen op.

Wij hebben hier een paar kleine lessen "uit den oude doosch" voor je. Deze lessen kunnen niet worden geleerd door mee te doen met de laatste hype.

Op de volgende pagina: Assembler

De kans is groot dat de gemiddelde programmeur een statement als mov ah, 09h of cmp eax, ebx niet herkent. Veel mensen denken waarschijnlijk dat computers van nature veel accolades nodig hebben aangezien de gemiddelde programmeertaal deze gebruikt om codeblokken af te bakenen. Zelfs de mensen die snappen dat talen als Java of C moeten worden vertaald naar binaire code hebben maar weinig kennis over hoe zij dat zelf voor elkaar moeten krijgen.

Veel oude programmeurs hebben vroeger aardig wat assembler code geschreven. Sommigen konden zelfs de code handmatig omzetten naar hexadecimale bytes. De allerbesten konden de switches op de voorkant van de computer omzetten om deze te programmeren.

Niet dat schrijven vandaag de dag nog geweldig of essentieel is. Het is een hoop geploeter en een hoop repetitie en erg foutgevoelig. De compilers zijn tegenwoordig goed genoeg om complexe patronen te herkennen die kunnen worden geoptimaliseerd. Sommige compiler-bouwers scheppen er maar al te graag over op dat ze betere code kunnen kloppen dan de gemiddelde mens.

Dat mag dan wel waar zijn, maar het voordeel van het leren van ook maar het kleinste beetje assembler is dat je begrijpt hoe een computer werkt (En het komt goed van pas op demoparties). De hogere-klasse-talen leveren veel snelle kortere weggetjes aan voor standaard functies, zoals het aaneengeschakelde strings, maar dat kunnen valstrikken zijn omdat programmeurs gaan denken dat de plus operand ("+") net zoveel tijd in beslag neemt als het optellen of aaneenschakelen van twee strings. Dat is niet zo. Een operatie neemt veel meer tijd in beslag en mensen die assembly code snappen en dus ook weten hoe de JMP (jump)-operatie werkt zullen de juiste beslissing nemen.

Begrijpen hoe objecten worden opgeslagen in het geheugen en hoe deze geladen worden in de CPU is ontzettend handig. Hierdoor weet je dat het kopiëren en overrekenen trage code kan opleveren. Mensen die zijn groot geworden met assembler zullen zich misschien niet veel herinneren van x86 code, maar zij hebben nog steeds de instincten en intuïtie die hen kan helpen met het oplossen van vertragende problemen. De groentjes hebben deze instincten niet, tenzij zij zichzelf trainen door ervaring.

Op de volgende pagina: Geluid en licht

Geluid en licht

Heel lang geleden was ik in gesprek met een programmeur die mij vertelde dat hij Unix haatte. Waarom? Hij begon met programmeren op single-user microcomputers als de Altair of de Sol 20 die maar één blok code per keer kon uitvoeren.

"een Unix computer begint iets anders uit te voeren op willekeurige tijden," vertelde hij mij. "Je hoor de floppy disks starten en je hebt geen idee waarom."

Dat maakte hem van streek omdat hij niet meer volledig begreep wat de computer aan het doen was. Niemand weet precies wat er allemaal gebeurt in een moderne computer. Er zijn talloze softwarelagen die draaien op vier of acht cores. Virussen en wormen kunnen voor altijd actief blijven zonder dat de gebruiker de vertraging opmerkt.

Oude programmeurs zoeken nog steeds naar (audio)visuele aanwijzingen die ze helpt de code te begrijpen en de debuggen. Ze kijken naar het knipperende lichtje op de RJ-45 ethernet-aansluiting wanneer er data wordt verzonden. Ze luisteren naar de harde schijf en horen wanneer de schijf start en van track wisselt. De echt goede programmeurs horen zelfs het verschil wanneer de harde schijf gaat pagen wanneer het geheugen vol is.

De waarde van deze aanwijzingen vervaagt nu harde schijven worden vervangen met solid-state drives en steeds meer data draadloos wordt verplaatst. Maar zolang smartphones dat kleine indicatortje hebben dat aangeeft wanneer er data wordt verplaatst, zullen deze detective-achtige skills niet helemaal uitsterven.

Op de volgende pagina: Bitbanging

Bitbanging

In de goede oude tijd propten programmeurs acht verschillende Boolean-waardes in één byte. Ze flipten de individuele bits omdat zij geen enkele byte wilde verspillen.

De moderne datastructuren zijn verschrikkelijk verkwistend. XML is gevuld met tags en lange namen en moeten ook nog afgesloten worden met een extra slash. Het is niet ongebruikelijk om moderne XML-bestanden te zien die voor meer dan 90 procent zijn gevuld met ongebruikte, toegevoegde data om aan de strenge pars-regels te voldoen.

JSON wordt gezien als een verbetering omdat deze wat kleiner is, maar dan ook alleen omdat er geen sluit-tags meer zijn, alleen accolades. Er zijn nog steeds te veel aanhalingstekens op alle tags en strings.

Het goede nieuws is dat moderne compressiealgoritmes veel van het overtollige vet uit de datastructuren kan persen, maar er zal altijd wat achter blijven. De veteranen weten hoe ze deze elementen weg kunnen. Dat is waarom code als MS-DOS 3.0 sneller en lichter kan werken binnen een partitie die niet groter is dan 32 MB. Zie je de magische sleutelwoorden? "niet meer dan". Dat is 32 miljoen bytes en de maximale grootte van de schijfpartitie.

Dat detail van MS-Dos 3.0 komt vanuit de vroege jaren '80. Een tijd waarin de pc al een algemeen gegeven was en de computerrevolutie al ver voorbij z'n kinderjaren was. Als je iets verder terug gaat zal je zien dat de code van computers uit de jaren '70 nog iets slanker was. De code uit de jaren '60 was helemaal geweldig.

Op de volgende pagina: Binaire wiskunde

Binaire wiskunde

De handelingen voor het testen en flippen van bits waren niet alleen maar leuke nieuwigheden voor programmeurs uit dat tijdperk, ze waren hard nodig. Sommige operations waren zo traag dat programmeurs moesten zoeken naar elk voordeeltje dat ze maar konden krijgen. Het beste was het begrijpen dat delen door twee net zo handig was als het schuiven van een binair nummertje naar rechts, zoals het delen door tien hetzelfde is als het schuiven van een decimaal nummertje naar rechts.

Het schuiven van alle bits is een standaard operatie van de CPU en was vaak bloedsnel vergeleken met standaard delingen. Goede programmeurs maakten daar gebruik van door snellere code te schrijven die niet hoefde te wachten op vermenigvuldigingen en delingen wanneer een verschuiving (shift) hetzelfde kon doen.

We verliezen de verbinding met de macht van twee. Vroeger was het zo dat ontwerpers instinctief kozen voor getallen die de macht van twee hadden omdat deze veel efficiëntie met zich meebrachten. Getallen als 512 of 4096 kwamen zeer frequent voor omdat het makkelijker is te werken met limieten die de macht van twee waren.

Op de volgende pagina: De kleine details

De kleine details die 't 'm doen

Op veel oude processoren duurde sommige operaties langer dan anderen. Op de originele 8086 duurde het delen van een nummer tussen de 80 en 190 kloktikken terwijl het optellen van twee getallen maar drie tikken. Zelfs als de processor op 5MHZ kon draaien. Het maakte daarom ook heel wat uit als deze operatie meerdere malen moest worden uitgevoerd.

Oude programmeurs weten dat niet elke regel code of elke instructie evenveel tijd in beslag neemt om uit te voeren. Ze begrijpen dat rekentijd niet gratis is en dat niet alle regels code gelijk zijn aan elkaar. Het kiezen van de verkeerde operatie kan je machine dramatisch vertragen.

Mensen vergeten dat het kiezen van een verkeerd datatype z'n consequenties kan hebben. Het gebruiken van een double of een long-variabele kan nog steeds trager zijn op sommige chips. Als je de verkeerde datastructuur gebruikt kan het je programma veranderen in een slak wanneer je gaat schalen.

Veel groentjes denken dat berekeningen zo goed als direct worden uitgevoerd en dat CPU's een oneindig aantal berekeningen uit kan voeren binnen een extreem korte tijd. De veteranen herinneren zich de trage CPU's die een beetje pruttelen als er moet worden opgeteld en bijna over hun nek gaan als er moet worden gedeeld. Al deze kleine details en weetjes die je door de jaren heen verzamelt als je aan het hacken en debuggen bent is de beste manier om je kennis uit te breiden en ervoor te zorgen dat ook jij uiteindelijk een echte veteraan wordt.