Hoe kan ik omgaan met managers die het gebruik van gangbare software engineering ontwerppatronen weigeren?
Achtergrond
Ik ben een software engineer en een TDD beoefenaar in mijn bedrijf. Mijn manager is ook verantwoordelijk voor het coderen (indien nodig), en het managen van zijn engineer ondergeschikten.
Ik ben onlangs in een paar verhitte debatten met mijn manager terechtgekomen over het gebruik van software design patronen.
Het probleem
Vaak wanneer ik de opdracht krijg om een functie en code te implementeren, word ik door mijn manager uitgedaagd tijdens code reviews voor mijn gebruik van gemeenschappelijke software design patronen. Hij denkt dat het niet nodig is en dat men zo ‘simpel mogelijk’ moet coderen. Ik zet citaten op straightforward, omdat we het niet eens lijken te zijn over wat de reikwijdte van een ‘feature’ zou moeten zijn. In veel gevallen is de functie niet zo ‘eenvoudig’ als mijn manager denkt en vereist het gebruik van ontwerppatronen om verantwoordelijkheden te scheiden en de impact op de (meestal ongeteste) codebasis te minimaliseren.
Er zijn twee veelgebruikte gevallen waarin ik ontwerppatronen zal toepassen om een probleem op te lossen:
Implementeren van nieuwe functies die veranderingen vereisen in een onbetwistbare, legacy klasse
Aanpakken van onzekerheden door het interfacen van de onbekenden
We zijn in een paar argumenten gekomen als gevolg van vergelijkbare ontwerpbijeenkomsten. In een verhit argument werd mij zelfs verteld dat “[hij] al meer dan 20 jaar programmeert!”, wat betekent dat ik niet eens aan zijn gezag zou moeten durven twijfelen.
Wat ik heb geprobeerd om dit probleem te verzachten
- Schriftelijk gedetailleerd commentaar op enkele niet zo voor de hand liggende componenten waarom ik die nodig had en welk doel ze dienen
- Passief aangetoond dat mijn ontwerp veel meer aanpasbaar is aan veranderingen
- Een component die ik heb gebouwd heeft significant minder fouten dan de meeste andere componenten
- Correct geanticipeerd op een verandering in de eisen, wat leidde tot een minimale codewijziging die nodig is om aan die eis te voldoen
- Heeft zijn zorgen op voorhand geuit door mijn denkproces en redenering uit te leggen - Ik word echter nog steeds berispt voor over-engineering code.
- Informeel besproken met mijn collega’s en gevraagd naar hun mening in privé
- De meesten van hen waarderen mijn goed onderbouwde aanpak en een van hen noemde zelfs dat hij veel van mij geleerd heeft. De meeste van de engineers bespreken graag hun codeerproblemen met mij, omdat ik hen meestal nuttig advies kan geven of hen kan wijzen op iets wat ze misschien hebben gemist
- Het houden van informele presentaties om mijn collega engineers (en manager) te leren waarom ik hier en daar een ontwerppatroon gebruik
Ik wil niet arrogant klinken door te zeggen dat mijn codeervaardigheden absoluut beter zijn dan die van mijn manager, maar ik heb echt geen ideeën meer om hem te overtuigen, zelfs niet na de demonstraties, de uitleg, en de objectieve resultaten die hem worden getoond. Aan de ene kant wil ik een bugvrije, goed geteste en ontworpen code leveren. Aan de andere kant blijf ik kritiek krijgen omdat mijn ontwerp niet goed aanvoelt en mijn code zeker ‘gecompliceerd’ is door het naar de ‘goedgekeurde’ manier te forceren.
Hoe kunnen we een middenweg vinden?
- *
Update
Aangezien ik veel commentaar krijg over mijn dogmatische, zelfs overijverige houding om de software engineering principes te volgen, denk ik dat ik moet verduidelijken:
Ik probeer niet dogmatisch of overijverig te zijn. Ik do geef om mensen die mijn code lezen en begrijpen, of ze nu wel of niet ontwerppatronen gebruiken/begrijpen. Ik heb mijn collega’s gevraagd of ze mijn code begrijpen of niet. Ze zeiden dat ze dat doen en ze begrijpen waarom ik een onderdeel op zo'n manier ontwerp. Bij een gelegenheid hielp mijn gebruik van ontwerppatronen om de configuratie lookup logica op één locatie te centraliseren in plaats van het te laten verspreiden over tientallen locaties, die vaak veranderd moeten worden.
Om eerlijk te zijn ben ik nogal teleurgesteld om zoveel reacties te zien met een sterk stereotype “Why you engineers can’t think like managers”. Uiteindelijk kun je zeggen dat alles over-engineering is: Waarom velden markeren als private
in plaats van alles bloot te leggen, waarom unit test als geen enkele gebruiker slechts een enkele unit gaat uitvoeren, etc.
Mijn motivatie in het gebruik van ontwerppatroon of in feite elke software engineering is om risico’s en waarde voor het bedrijf te minimaliseren (bijvoorbeeld door het verminderen van de onnodige verspreiding van logica in de codebasis, zodat ze kunnen worden beheerd op een enkele locatie).
Sorry als dit klinkt als een tierelantijntje. Ik ben op zoek naar antwoorden in de trant van ‘hoe kunnen we een middenweg vinden’ in plaats van enkele neerbuigende antwoorden zoals ‘ingenieurs denken dat ze slim zijn door ontwerppatronen toe te passen die niemand begrijpt’.