Tag waarde

Zelfs de testpiramide is niet meer heilig!

Ik ben altijd in de veronderstelling geweest dat mijn geautomatiseerde tests een piramidevormige verhouding tot elkaar zouden moeten hebben: aan de basis enorm veel unittests, in het midden een goede hoeveelheid integratietests, en aan de top een bescheiden aantal end to end (E2E) tests. Totdat ik Learning Domain-Driven Design van Vlad Khononov las. (Een aanrader, overigens!)

De ontdekking van strategische subdomeinen

Ik schreef één keer eerder over Domain-Driven Design - en in die blog gaf ik onmiddellijk toe niks van het onderwerp te weten. Precies daarom nam ik me voor om Learning Domain-Driven Design van Vlad Khononov op te pakken. En met succes, want al meteen in het eerste hoofdstuk leerde ik iets nieuws: het bestaan van strategische subdomeinen.

Het probleem met technische schuld op je backlog

Zo gaat mijn team om met het monitoren van technische schuld: we prikken elke Sprint een moment waarop we er met elkaar over praten, en als we het belangrijk genoeg vinden om er wat aan te doen, dan voeren we een Product Backlog Item op om die schuld weg te werken. Die aanpak werkt goed - goed genoeg, in elk geval. De technische schuld van onze huidige applicatie blijft grotendeels binnen de perken. En bovendien - dat is nog veel belangrijker - is iedereen in het team op de hoogte van het feit dat sommige plekken verbetering behoeven, en welke plekken dat zijn. Maar toch zit iets me niet helemaal lekker in die aanpak.

Leren in je codebase

Laatst had ik een gesprek met een collega van me, over een meningsverschil dat hij had met onze leidinggevende over zijn zelfstudieproject. Hij wilde zijn handen vuil maken - dat is hoe hij het liefst leert -, niet in een klein, losstaand codeproject, maar in een branch van onze productiecodebase. Onze leidinggevende vond dat, tot frustratie van mijn collega, een slecht idee. - Daar was ik het, eerlijk gezegd, wel mee eens.

De standaard versus de business

Onze business volgt de QTI-standaard, maar ze gebruiken niet alles. Zo bestaat er - op dit moment - nog geen behoefte om Items te construeren die uit meerdere rijen bestaan. Bij het modelleren van ons domein werden we voor een keus gesteld: volgen we de QTI-standaard bij het uitschrijven van ons model? Of leggen we alleen vast wat de business nodig heeft, en laten we ons eigen model daarmee afwijken van de standaard? Concreet: ondersteunen we meerdere rijen of niet?

Eindgebruikers horen

De snelste weg naar tevreden gebruikers, is door goede software te bouwen die doet wat het moet doen. Dat klinkt makkelijk en dat is het niet. Waarom niet? Omdat software bouwen niet een kwestie van bouwen alleen is. Als dat zo zou zijn, dan zou de beste softwareontwikkelaar een mensenschuwe programmeur zijn, iemand die je het best met rust kunt laten, terwijl ‘ie als een razende specificaties omzet in code.

Enums, switch statements en SOLID - deel 7

Een eeuwigheid geleden - april vorig jaar - schreef ik een reeks blogs over wat logica die rondom een Enum gebouwd was. Bijna een jaar na dato stel ik de vraag: wat probeerde ik nu eigenlijk te bereiken? - Eigenlijk was mijn use case betrekkelijk eenvoudig. Ik wilde wat logica kunnen koppelen aan een Enum-waarde, dat is alles. Sterker nog, die wens is niet alleen eenvoudig, hij is ook ontzettend generiek. Dat is een significante observatie. Gezien de generieke aard van het codeerprobleem, is er eigenlijk geen enkele reden waarom ik code zou moeten schrijven het probleem op te lossen.

Een GIF zegt meer dan duizend woorden

De mogelijkheid om eenvoudig met GIF-jes te kunnen communiceren is één van de meest gewaardeerde features die Microsoft Teams heeft, als je het mij vraagt. Maar waarom? Want strikt genomen kan het doel van die applicatie - asynchrone communicatie bewerkstelligen voor gedistribueerde teams - ook worden bereikt zonder deze feature. Sterker nog, misschien zou onze communicatie wel vlotter verlopen als ik niet elk gesprek ontspoor met bewegend beeld!

De noodzaak van refactoren

Ons team heeft een stakeholder wiens gezicht vertrekt, elke keer als we tijdens een Sprint Review aangeven tijd te hebben gestoken in het refactoren van onze applicatie. In zijn beleving is refactoren een verspilling van je tijd. Als we meer tijd hadden genomen om de wensen van onze gebruikers grondig te analyseren, redeneert hij, dan had zo’n dure, inefficiënte refactorslag kunnen worden voorkomen. Als ik iemand zo hoor redeneren, dan vertrekt míjn gezicht.

Zonde om weg te gooien?

Laatst kwam ik tijdens het refactoren een stuk code tegen dat alleen maar werd gebruikt in unittests. Dat maakt me erg verdrietig, en om dat verdriet niet te hoeven voelen, donderde ik dat stuk code weg zodat ik er nooit meer naar om zou hoeven kijken. Een collega van me maakte bezwaar toen hij mijn pull request bekeek. En, eerlijk is eerlijk, niet helemaal onterecht. Er was veel moeite in deze feature gestopt, zei hij. Was het niet zonde om deze code zonder omzien te verwijderen?