Comment puis-je traiter avec des responsables qui refusent d'accepter l'utilisation de modèles de conception communs en génie logiciel ?
Contexte
Je suis ingénieur en logiciel et praticien TDD dans mon entreprise. Mon directeur est également responsable du codage (si nécessaire) et de la gestion de ses subordonnés ingénieurs.
J'ai récemment eu quelques débats animés avec mon directeur concernant l'utilisation de schémas de conception de logiciels.
Le problème
Lorsque je suis chargé de mettre en œuvre une fonctionnalité et du code, je suis souvent mis au défi par mon directeur lors de la révision du code pour mon utilisation de schémas de conception de logiciels communs. Il pense que ce n'est pas nécessaire et qu'il faut coder de la manière la plus “simple” possible. Je mets des guillemets sur “simple”, parce que nous ne sommes pas d'accord sur la portée d'une “fonctionnalité”. Dans de nombreux cas, la fonctionnalité n'est pas aussi “simple” que le pense mon responsable et nécessite l'utilisation de schémas de conception pour séparer les responsabilités et minimiser l'impact sur la base de code (le plus souvent non testé).
Il y a deux cas d'utilisation courants dans lesquels j'utiliserai des schémas de conception pour résoudre un problème :
Implémenter de nouvelles fonctionnalités qui nécessitent des modifications d'une classe héritée et non testable
S'attaquer aux incertitudes en interfaçant les inconnues
Nous avons eu quelques disputes en raison de réunions de conception similaires. Au cours d'une discussion animée, on m'a même dit que “[il] programme depuis plus de 20 ans !”, ce qui implique que je ne devrais même pas oser remettre en question son autorité.
Ce que j'ai essayé d'atténuer ce problème
- Commentaires détaillés écrits sur certains composants pas si évidents ; pourquoi j'en avais besoin et à quoi servaient-ils
- A démontré passivement que ma conception est beaucoup plus adaptable aux changements
- Un composant que j'ai construit a un nombre de bogues nettement inférieur à la plupart des autres composants
- A correctement anticipé un changement des exigences, ce qui a conduit à une modification minimale du code nécessaire pour satisfaire à cette exigence
- A répondu à ses préoccupations dès le début lorsque j'ai été mis au défi en expliquant mon processus de réflexion et mon raisonnement
- Cependant, je suis toujours réprimandé pour avoir suringénierie le code.
- A discuté de manière informelle avec mes collègues et leur a demandé leur avis en privé
- La plupart d'entre eux apprécient mon approche bien raisonnée et l'un d'entre eux a même mentionné qu'il avait beaucoup appris de moi. La plupart des ingénieurs aiment discuter de leurs problèmes de codage avec moi, parce que je peux généralement leur donner des conseils utiles ou leur signaler quelque chose qu'ils auraient pu manquer
- Organiser des présentations informelles pour apprendre à mes collègues ingénieurs (et à mon directeur) pourquoi j'applique un modèle de conception ici et là
Je ne veux pas paraître arrogant en disant que mes compétences en codage sont absolument meilleures que celles de mon directeur, mais je suis vraiment à court d'idées pour le convaincre, même après les démonstrations, les explications et les résultats objectifs qui lui sont présentés. D'une part, j'aimerais livrer un code sans bogue, bien testé à l'unité et bien conçu. D'autre part, je continue à être critiqué parce que ma conception n'est pas bonne et a certainement “compliqué” mon code en le forçant à suivre la voie “approuvée”. Comment trouver un juste milieu ? Je me soucie des gens qui lisent et comprennent mon code, qu'ils utilisent ou comprennent des modèles de conception ou non. J'ai demandé à mes collègues de me dire, lors de la révision de mon code, s'ils le comprenaient ou non. Ils m'ont répondu que oui et qu'ils comprennent pourquoi je conçois un composant de cette manière. Dans un cas, mon utilisation des design patterns a permis de centraliser la logique de recherche de configuration en un seul endroit, au lieu de la répartir dans une douzaine d'endroits, ce qui doit être changé souvent.
Pour être honnête, je suis assez déçu de voir autant de réponses avec un stéréotype fort “Pourquoi vous, les ingénieurs, ne pouvez pas penser comme des managers”. En fin de compte, on peut dire que tout est suringénierie : Pourquoi marquer les champs comme private
au lieu de tout exposer, pourquoi faire des tests unitaires si aucun utilisateur ne va exécuter une seule unité, etc.
Ma motivation dans l'utilisation de modèles de conception ou en fait de toute ingénierie logicielle est de minimiser le risque et apporter de la valeur à l'entreprise (par exemple en réduisant la propagation inutile de la logique dans la base de code, de sorte qu'ils puissent être gérés à un seul endroit).
Désolé si cela ressemble à une diatribe. Je cherche des réponses du type “comment trouver un juste milieu” plutôt que des réponses condescendantes du type “les ingénieurs pensent qu'ils sont intelligents en appliquant des modèles de conception que personne ne comprend”.