Tag boeken
Test third party code
Het updaten van third party code is net zozeer een risicovolle onderneming als het niet updaten ervan. In beide gevallen loop je kans op de introductie van bugs. Er is een uitweg uit dat probleem. En die uitweg is - zoals meestal in softwareontwikkeling - testen, testen, testen.
Van rader in het geheel naar bron van talent
Hoe ziet een bedrijf haar personeel? Een hint van een antwoord zit ‘m in de daaraan toegewijde afdeling: human resource management. Personeel is een resource, een hulpbron - net als het IT-systeem, maar dan menselijk - die gemanaged moet worden. Die metafoor heeft enkele interessante consequenties, die inderdaad regelmatig haar uitwerking vinden in de praktijk: medewerkers zijn raderen in het geheel, ze moeten op hun prestaties beoordeeld worden en kunnen eenvoudig vervangen worden wanneer ze een negatieve impact hebben op dat geheel. Die zienswijze is hopeloos achterhaald, betoogt Rob van den Berg in Futureproof talentmanagement.
Pull requests als documentatie
Hoe vaak denk je na over de titel en omschrijving van je pull request? Als je een beetje op mij lijkt, dan is het antwoord: veel te weinig. Het goede nieuws is: je hoeft er niet over na te denken, want dat hebben de vriendelijke ontwikkelaars van Google al voor je gedaan. Onlangs las ik hun Code Review Developer Guide door, en vond daar een schat aan informatie.
Samen je ontwikkel-ik ontdekken
Praten over je eigen leer- en ontwikkelingsproces is een moeilijke opgave. Maar weinig mensen hebben de taal om hun ideeën daarover uit te kunnen drukken - als ze er überhaupt al een idee over hebben. En de kans dat ze die ideeën, en de bijbehorende taal, in hun eentje zullen ontwikkelen, is nagenoeg nul. Je hebt anderen - andere mensen, perspectieven, leerdoelen en -stijlen - nodig om gestalte te kunnen geven aan je eigen ontwikkeling. Maar hoe ga je het gesprek aan als je er de taal voor ontbeert? Daar hebben Manon Ruijters, Gerritjan van Luin en Robert-Jan Simons Ons ontwikkelen ontward voor, eh, ontwikkeld
Succesvol falen
Van fouten kun je leren, zegt men. Daaruit volgt: hoe meer fouten je maakt, hoe meer leerkansen je creëert. Eigenlijk zou je het maken van fouten dus moeten vieren. Hoe meer er mis gaat, hoe meer je leert – en hoe meer je leert, hoe minder er mis zal gaan. Toch is dat niet hoe het in veel organisaties werkt. Daar wordt er hard gewerkt om fouten te voorkomen. Erger nog, medewerkers die de mist in gaan, worden afgerekend op hun misstappen. Dat maakt hen voorzichtig, conservatief. En daardoor staan ze hun eigen groei – en die van de organisatie – in de weg.
Test-driven development is een ontwerpdiscipline
Een collega benaderde me laatst met een vraag over een stuk code. Hij was bezig met het implementeren van een feature om een toets met afbeeldingen om te zetten naar een PDF-representatie ervan. Zijn vraag was: hoe kom ik aan die afbeelding? Of liever: waar kom ik aan die afbeelding? Zijn eerste ingeving was om via dependency injection de relevante repository mee te geven aan de ImagePdfGenerator. - Het is een klassiek geval van het verknopen van het ophalen van data en het manipuleren ervan. Ik bleef wel met een knagend gevoel achter: hoe makkelijk blijkt het om dankzij een DI-container de verantwoordelijkheden van classes te verwateren - en wat moeten we daarmee?
Hoe hersenwetenschap programmeurs kan helpen
Er is in de vakliteratuur over softwareontwikkeling geen gebrek aan gepeperde meningen over hoe goede code eruit dient te zien. Goede code is naar hun mening eenvoudig, bijvoorbeeld, of testbaar of uitbreidbaar. Je zou kunnen zeggen dat hun redenen erop geënt zijn software zo goed mogelijk te kunnen onderhouden. Wie dat zou moeten doen en hoe ze dat aan moeten pakken, daar zijn de meningen minder gepeperd over. Veel professionals lijken code te beschouwen als iets wat op zichzelf staat, zonder veel oog te hebben voor de programmeurs die dat onderhoud zouden moeten plegen. Dat geldt niet voor Felienne Hermans. In The Programmer’s Brain behandelt ze vragen als: wat gebeurt er in het brein als je code leest? Hoe leer je zo efficiënt mogelijk nieuwe programmeertalen en -concepten? En hoe kun je deze kennis inzetten om betere code te schrijven?
Hoe review je eigenlijk code?
Hoe lees je eigenlijk code? Waar begin je? En in welke volgorde loop je code door? - En zit er verschil tussen het lezen van code tijdens je programmeerwerk en tijdens een code review? Ik stelde mezelf onlangs die vragen, na in Felienne Hermans' The Programmer’s Brain te hebben gelezen dat gevorderde programmeurs op een andere manier code lezen dan nieuwelingen.
Objectgeoriënteerd en functioneel BTW berekenen - Revisited
Ik plaatste een tijd geleden wat kanttekeningen bij mijn aanpak Enrico Buonanno’s uitdaging om een objectgeoriënteerde BTW-calculator te schrijven. Zo zette ik mijn vraagtekens bij het feit dat ik zijn oorspronkelijke model één op één overnam. Die keuze bracht met ertoe een aparte VatCalculator-class te definiëren. En hoewel die objectgeoriënteerd was opgezet, viel deze makkelijk om te schrijven naar een functionele variant. De vraag wierp zich op: hoe objectgeoriënteerd is die oplossing? Is de vergelijking daarmee wel eerlijk? Hoe zou een “echt” objectgeoriënteerde oplossing eruit zien?
De elf rollen van variabelen
Pas wanneer de vanzelfsprekendheid van code in het geding komt, gaan we nadenken - écht nadenken - over wat er op je scherm staat en waarom. Pas dan wordt de vraag “Wat doet deze variabele hier precies?” relevant. Goed, vraag jezelf nu eens af: als dat moment komt, hoe beschrijf je de rol van een variabele dan? - Heb je enig idee waar je moet beginnen bij het beantwoorden van die vraag?