Gérer la complexité est le lot des ingénieurs logiciels. Les programmeurs prennent des décisions qui ont une incidence sur le coût de tout ce qui suit.
Écrire un logiciel parfait coûte nettement moins cher qu’écrire un logiciel de qualité douteuse. Cela peut coûter davantage au départ en temps et en ressources, mais vos équipes économiseront plusieurs fois ce coût si elles écrivent correctement le code dès le début.
Les personnes qui composent vos équipes logicielles sont la clé de voûte de vos projets. C’est pourquoi l’amélioration continue des équipes et l’apprentissage continu des collaborateurs sont les meilleurs investissements que vous puissiez faire. Lorsque vos équipes ne disposent pas de ce dont elles ont besoin pour fonctionner efficacement, la réussite devient moins probable.
Voici les principaux tueurs d’efficacité de vos équipes logicielles :
1 : Absence d’adéquation produit-marché
Peu importe l’efficacité ou la performance de votre organisation logicielle si votre produit ne correspond pas aux attentes du marché. La valeur de ce que vous produisez ne dépend que de celle que lui accorde le marché.
2 : Mauvaise qualité
Les erreurs dans le code entraînent non seulement de mauvaises expériences client, mais aussi du travail de reprise pour l’équipe, ce qui augmente les coûts de main-d’œuvre et détourne l’équipe de la poursuite du développement du système.
De plus, l’absence de tests automatisés fiables rend coûteuses et risquées les modifications visant à simplifier le code, ce qui ralentit encore davantage l’équipe.
3 : Coût du changement
À moins de prendre délibérément des mesures pour réduire la complexité, tout ajout à une base de code accroît naturellement cette complexité. Il devient ainsi de plus en plus long, et donc coûteux, d’apporter des modifications ultérieures au code. La pression des parties prenantes ou de la direction pour passer rapidement à la tâche suivante pousse les équipes à sauter les étapes de refactorisation nécessaires pour maintenir le coût du changement à un niveau bas.
Les effets de ce phénomène ne sont pas toujours détectés au moment où ils surviennent, et sa conséquence ultime est de rendre les modifications du système inabordables, tout en privant les équipes de la capacité nécessaire pour corriger les problèmes dans lesquels elles se sont empêtrées. Pour une petite entreprise de logiciels, la capacité — ou l’incapacité — à maîtriser l’emballement du coût du changement peut être une question de vie ou de mort.
4 : Mauvaise dynamique d’équipe
Une équipe dysfonctionnelle ne peut pas fonctionner correctement — c’est aussi simple que cela. Recruter des personnes dotées de qualités qui en font de bons coéquipiers, laisser aux équipes le temps de franchir les étapes de « formation-confrontation-normalisation-performance » et maintenir les équipes performantes en place sur le long terme permettent de créer des organisations plus performantes.
5 : Goulots d’étranglement
Les organisations peuvent commettre l’erreur de ne pas doter suffisamment un ou plusieurs postes en personnel lorsqu’elles définissent des processus de développement impliquant des transferts d’une fonction à une autre, à mesure que le code avance vers la production.
L’assurance qualité est souvent la première victime dans ce cas. Certaines organisations structurent leurs équipes de telle sorte que plusieurs équipes dépendent des livrables d’autres équipes, lesquelles peuvent être incapables de fournir en temps voulu tout ce dont les équipes en aval ont besoin. L’ensemble de l’organisation n’est rapide qu’à hauteur du goulot d’étranglement le plus lent de la chaîne de valeur.
6 : Travail manuel et répétitif
Dans le logiciel, le travail standard n’existe pas. Si votre équipe en trouve, elle doit rapidement l’automatiser pour le faire disparaître. Le travail manuel répétitif est sujet aux erreurs et coûteux, et les processus manuels ne passent pas à l’échelle au même rythme que votre système.
Les déploiements, les correctifs système et autres tâches manuelles peuvent rapidement absorber un temps dont l’équipe ne dispose pas.
7 : Complexité superflue
Lorsque l’édition, la compilation, les tests et le déploiement des logiciels prennent beaucoup de temps, la progression s’en trouve ralentie. Des tests automatisés lents, écrits à l’aide d’outils de test de bout en bout, allongent la durée de cycle d’une équipe. Il en va de même pour les tests manuels, les longs processus de déploiement et les processus de revue de code insérés au milieu du cycle allant de l’édition au déploiement.
De nos jours, tout est question de réduction de la complexité. Mais les organisations doivent se rappeler ce qui affaiblit, voire détruit, l’efficacité du développement logiciel. La force, la santé et la cohésion de vos équipes sont ce qui fera le succès ou l’échec de vos projets. Pour réussir dans un rôle, il n’est pas nécessaire que les collaborateurs soient qualifiés à 100 % selon les exigences spécifiées pour le poste : nombre de ces exigences peuvent être acquises en cours de route.
Prendre en compte les compétences comportementales — communication, collaboration, etc. — lors des recrutements contribuera à constituer des équipes plus solides. Assurer une formation continue sera également utile. Gardez à l’esprit les sept tueurs d’efficacité évoqués ci-dessus tandis que vous créez une communauté d’ingénierie logicielle plus efficace et performante.
À propos de l’auteur :
Susan Davis est CTO de Certn