Un remède à la complexité dans le développement de logiciels

J’ai récemment lu l’excellent article d’InfoWorld de Scott Carey qui se concentre sur la complexité des applications en tant qu’agent pour réduire la productivité et les moyens de subsistance des développeurs.

L’article contient de bonnes idées, notamment en se concentrant sur la maîtrise de la complexité en utilisant des services tiers standardisés et d’autres techniques. Il s’agit d’une stratégie qui, j’en conviens, a de la valeur pour de nombreuses organisations.

Cependant, l’article indique également que les architectures de microservices sont plus complexes que l’application fonctionnellement équivalente dans une architecture monolithique, et l’utilise pour faire avancer la cause que la complexité tue. Je ne suis pas d’accord avec cette évaluation.

Le message implicite que je retiens de ce point de vue est que les architectures de microservices créent une complexité qui réduit l’efficacité des développeurs. Ce n’est pas vrai. Les architectures de microservices créent une application globale plus complexe qu’une application équivalente construite comme un monolithe, mais cela ne signifie pas que le travail du développeur ou de l’architecte est par conséquent plus complexe.

Complexité de l’architecture des microservices

De nombreuses entreprises ont construit de grandes applications monolithiques pour constater qu’elles sont alourdies par la complexité. Trop de développeurs travaillant dans une seule base de code, il est difficile d’ajouter indépendamment des fonctionnalités et de corriger les défauts. Cela limite le nombre de projets simultanés sur lesquels les développeurs peuvent travailler dans une seule application. De plus, des projets individuels apportent des modifications qui peuvent avoir un impact important sur la base de code, un impact qui devient plus difficile à comprendre lorsque l’application devient plus volumineuse et plus complexe. Ensemble, ces problèmes entraînent davantage de défauts, une qualité inférieure et une dette technique accrue à mesure que la complexité continue d’augmenter.

Lorsque vous divisez une application en modules ou parties distincts, vous essayez de diviser cette complexité afin de réduire le nombre de développeurs qui doivent travailler dans une seule base de code. De plus, vous réduisez l’ampleur de l’impact de vos changements. Cela tend à créer un code plus stable, un code plus supportable, moins de dette technique et une qualité globale des applications et une productivité des développeurs plus élevées.

L’amélioration de la qualité et de la stabilité des applications et l’amélioration de la productivité des développeurs permettent également d’améliorer l’expérience des développeurs, réduisant ainsi la fatigue, l’épuisement et, en fin de compte, le roulement de l’équipe de développement.

Il existe de nombreuses façons de modulariser une application, certaines plus efficaces que d’autres. Le meilleur modèle de modularisation des applications consiste à utiliser une architecture d’application basée sur des microservices.

En combinant une architecture de microservices avec un modèle solide pour organiser vos équipes de développement et leur propriété et responsabilité, vous vous retrouvez avec une organisation où les développeurs individuels peuvent concentrer leur attention sur une base de code plus petite. Ces développeurs finissent par être plus efficaces et productifs, et créent un code de meilleure qualité avec moins de dette technique. Ces développeurs éprouvent une plus grande satisfaction au travail et moins d’épuisement professionnel.

L’application dans son ensemble peut être plus complexe, mais la pièce individuelle sur laquelle un développeur doit se concentrer est nettement moins complexe. Ainsi, le modèle de microservice améliore l’expérience des développeurs.

Tous les microservices ne sont pas également micro

Cependant, le simple passage à une architecture basée sur des services ou des microservices ne vous donne pas automatiquement cet avantage. Au contraire, vous devez concevoir votre application de manière rationnelle et organiser vos équipes de manière appropriée. Il y a deux choses auxquelles vous devez faire attention en particulier : le dimensionnement du service et l’organisation de l’équipe.

Dimensionnement des services

La taille de vos services a un impact important sur la complexité pour les développeurs. Si vous dimensionnez vos services trop petit, votre application se retrouve avec un très grand nombre de services interconnectés. Cette connectivité interservices augmente considérablement la complexité inhérente. Votre application dans son ensemble devient plus complexe. Vos développeurs voient cette complexité et doivent y faire face, contrecarrant l’objectif initial de passer aux services.

Si vous dimensionnez trop vos services, vous perdez les avantages offerts par les architectures de microservices. Vos services deviennent des mini-monolithes, avec tous les inconvénients de complexité des plus grands monolithes. Une fois de plus, les développeurs individuels doivent faire face à une complexité accrue et vous êtes simplement passé à plusieurs applications complexes plutôt qu’à une seule application complexe. Ces mini-monolithes peuvent alléger la charge de complexité des développeurs à court terme, mais pas à long terme.

Ce n’est que lorsque vous dimensionnez vos services de manière appropriée que vous atteignez le bon équilibre qui réduit efficacement la complexité et la charge cognitive de vos développeurs individuels.

Organisation de l’équipe

La taille de l’équipe, la structure, les responsabilités de propriété et les lignes d’influence sont tout aussi essentielles à la création de votre application que le code lui-même. Afin de gérer efficacement une architecture de service, vous devez organiser vos équipes de développement autour de votre architecte d’application de manière appropriée. De plus, vos équipes doivent recevoir la responsabilité, l’autorité, la propriété et l’assistance nécessaires pour assurer la gestion complète de leurs services.

Le fait de ne pas fournir cette organisation et ce soutien ajoutera un autre type de complexité qui sera tout aussi destructeur pour votre organisation. L’organisation de l’équipe avec des affectations d’équipe appropriées et la définition des responsabilités et de la propriété est essentielle pour réduire la charge cognitive de l’application pour les développeurs individuels.

Je recommande le modèle d’organisation standard STOSA, qui décrit un modèle pour créer votre organisation et attribuer des responsabilités au niveau de l’équipe dans une architecture d’application basée sur les services. Je couvre largement le modèle STOSA dans mon livre OReilly Media, L’architecture pour l’échelle.

Outillage pour réduire la complexité du codage

Pour en revenir à l’article original de mes collègues, qui se concentre sur la réduction de la complexité pour les développeurs, il existe d’autres techniques que vous pouvez utiliser pour y parvenir également, au-delà de l’exploitation des architectures de microservices et des organisations STOSA.

Une direction technologique qui aura d’énormes avantages pour réduire la complexité des développeurs à l’avenir est le développement assisté par logiciel. Il s’agit de la capacité à utiliser des outils, souvent assistés par l’intelligence artificielle (IA) et des techniques d’apprentissage automatique, pour aider le développeur à écrire du code, à diagnostiquer les problèmes de code et à gérer la complexité globale du code.

De nombreuses entreprises se concentrent sur les outils de développement assisté par logiciel pour les programmeurs. L’assistant GitHubs Copilot AI pour Visual Studio Code utilise l’IA pour aider les développeurs à écrire un code plus fiable avec moins de défauts. Des sociétés de surveillance des performances telles que Datadog et New Relic ont récemment annoncé des outils offrant une assistance haut de gamme aux développeurs pour diagnostiquer les problèmes dans leur code. Enfin, des outils sans code et à faible code tels que la plate-forme de développement d’applications OutSystems fournissent une assistance de création de services de niveau supérieur qui réduit la charge cognitive nécessaire pour créer et déployer des services et des applications individuels.

La complexité des applications est un problème auquel la plupart des organisations doivent faire face, et la façon dont vous la traitez aura un impact sur l’avenir de votre application, la santé et la stabilité de votre organisation de développement et l’avenir de votre entreprise. Mais il existe de nombreuses façons de gérer la complexité des applications. Les approches évoquées par Scott Carey, qui incluent la création d’une plate-forme interne et la normalisation des services externes au sein de votre organisation, sont d’excellentes stratégies.

Mais accordez également une attention particulière aux architectures de microservices. Bien que les microservices puissent augmenter la complexité globale de votre application, ils permettent de réduire la charge cognitive et la complexité visible pour les développeurs individuels. Cela conduira à un code de meilleure qualité, une plus grande disponibilité, une dette technique plus faible et un meilleur moral des développeurs.