Rendre le développement de logiciels plus écologique | Ordinateur hebdomadaire
Les exigences du développement logiciel moderne obligent les programmeurs à écrire davantage de code et à fournir de nouvelles fonctionnalités plus rapidement que jamais. L’adage selon lequel il ne faut pas réinventer la roue a donné à de nombreuses personnes les raccourcis dont elles ont besoin pour fournir du code rapidement et, dans la plupart des cas, de manière fiable.
Plutôt que d’écrire quelque chose à partir de zéro, un développeur de logiciels trouvera forcément quelque chose qui lui convient dans une bibliothèque de programmation ou un référentiel de code source. De nos jours, les développeurs ont également la possibilité de tirer parti de la puissance des microservices.
Les microservices modifient radicalement la relation entre le développeur de logiciels et le code requis pour obtenir la fonctionnalité souhaitée, comme l’explique Shaun OMeara, directeur de la technologie chez Mirantis : Dans le passé, vous aviez généralement un développeur ou une petite équipe de développeurs qui développaient chaque composant de le système, chacun acceptant de travailler sur des composants différents.
L’équipe a dû tout créer à partir de zéro, explique-t-il, mais lorsque les bibliothèques de logiciels sont devenues disponibles, le développeur a pu tirer parti des fonctionnalités pré-construites. Le grand changement avec les microservices est que la mentalité des développeurs de logiciels a changé. Ils sont désormais capables de consommer le travail développé par d’autres personnes et peuvent ainsi réaliser des gains massifs de productivité.
L’impact, dit-il, est que le code utilisant des microservices a tendance à consommer une plus grande quantité d’infrastructure informatique que le code développé de manière plus traditionnelle.
La montée de l’inefficacité dans le codage
L’inefficacité est désormais monnaie courante dans le développement de logiciels. Les outils modernes ont rendu les gens paresseux, déclare Andy Powell, directeur de la technologie à l’Université Christ Church de Canterbury. Quand j’écrivais des sites Web, c’était avant l’arrivée de .Net, et en ASP classique [active server pages] vous deviez écrire tous vos propres objets.
Lorsque les gens visitaient des sites Web via une connexion par modem à faible bande passante, dit-il : Il fallait être conscient de la taille de l’image, des feuilles de style et de la taille des pages ; vous deviez être conscient de la quantité de données que vous envoyiez dans le canal, car le temps de chargement était important.
Pour Powell, du point de vue du développement d’applications, cela signifiait que les développeurs prenaient en compte l’efficacité du code. Il fallait être vraiment efficace avec la couche base de données et votre API [application programming interface] couche, dit-il.
Les requêtes adressées aux systèmes transactionnels ont été écrites de manière à renvoyer l’ensemble minimum de données viables, alors que maintenant, dit-il : Vous obtenez 100 000 enregistrements ou tuples et c’est parti, en sélectionnant ce que vous voulez à partir de cet ensemble. [dataset] en mémoire parce que la mémoire est devenue très bon marché.
Lutter contre le gonflement du code
Aujourd’hui, les développeurs considèrent la bande passante presque comme une ressource et une puissance de traitement illimitées, et la mémoire et le stockage sont bon marché et abondants. Cela a conduit à une surcharge du code, où les développeurs ne se concentrent plus sur l’écriture de logiciels qui fonctionnent aussi efficacement que possible et utilisent le moins d’espace de stockage, de mémoire et de puissance de traitement possible.
Mav Turner, directeur des produits et de la stratégie chez Tricentis, souligne que la surcharge du code provient généralement de plusieurs sources, telles qu’une syntaxe trop verbeuse, des fonctionnalités redondantes ou inutilisées et un manque d’optimisation pendant le développement. De plus, il affirme que les bases de code existantes peuvent accumuler une dette technique au fil du temps, conduisant à des implémentations lourdes et alambiquées.
Cependant, comme l’explique Turner : En adoptant des pratiques de codage propres, des principes de conception modulaire et une refactorisation régulière, les développeurs peuvent atténuer la surcharge du code et maintenir des bases de code plus légères et plus faciles à gérer.
Les responsables informatiques doivent prendre en compte les facteurs et les facteurs qui rendent les développeurs de code moins efficaces. Personne n’a l’intention que le code soit gonflé. Les développeurs n’essaient pas de détruire l’environnement, déclare Maurice Kalinowski, directeur produit chez Qt.
Cependant, comme le souligne Kalinowski, de nombreux facteurs entraînent des inefficacités involontaires. À titre d’exemple, il déclare : Très souvent, les prototypes aboutissent à un produit en raison de contraintes de temps qui imposent des cycles de livraison courts aux équipes de développement. Cela conduit à une dette technique plus tard dans le cycle de développement, ce qui, à son tour, a pour effet de nuire à l’efficacité.
Selon Kalinowski, il est important de considérer le domaine d’application et le cas d’utilisation du code en cours de développement. Si vous développez du code à des fins générales, les données d’entrée nécessitent-elles une vérification sémantique ? Le code couvre-t-il tous les scénarios potentiels, y compris ceux qui pourraient ne jamais se produire ?
Même un code très efficace peut être exposé à des cas d’utilisation supplémentaires nécessitant une vérification et un traitement différents. Cela, prévient Kalinowski, conduit à de plus en plus de cas où du code est écrit pour prendre en charge ces exceptions. À mesure que ceux-ci s’accumulent, le code atteint un point où les avantages en termes de performances initialement conçus pourraient bien avoir été perdus.
Kalinowski affirme que les responsables informatiques devraient envisager de refactoriser les parties du code qui sont surchargées. Bien sûr, vous devez d’abord savoir lesquels de vos projets sont gonflés en premier lieu. C’est là que de nombreux outils de développement entrent en jeu, comme l’analyse de code statique et dynamique, le profilage et l’échantillonnage amélioré, ajoute-t-il.
Inefficacités dans les tests
Tricentiss Turner exhorte les décideurs informatiques à adopter le développement piloté par les tests (TDD) comme méthodologie informatique durable. D’après son expérience, TDD propose une technique puissante qui peut contribuer de manière significative à la création d’un code vert, caractérisé par une qualité et une efficacité supérieures.
En mettant l’accent sur la création de tests avant d’écrire du code, TDD garantit que les développeurs ont dès le départ une compréhension claire du comportement et des fonctionnalités attendus de leur code, explique Turner.
En ce qui concerne les tests lors du développement d’applications, Ved Sen, responsable de l’innovation chez TCS UK et Irlande, affirme que les responsables informatiques devraient également prendre en compte l’impact environnemental des tests de régression.
Lorsque vous exécutez des tests de régression, vous finissez par tester beaucoup de choses, encore et encore, juste pour voir si le programme tombe en panne, dit-il. Mais chaque fois que vous effectuez un test de régression, vous consommez plus de ressources, et chacune d’elles génère une petite empreinte carbone.
Selon Sen, il devrait être possible de créer des méthodes de test plus intelligentes, afin que les développeurs n’aient pas à tester encore et encore le même cas d’utilisation.
Sen souligne que si les développeurs de logiciels évitent d’effectuer des tests de force brute, ils peuvent réduire l’empreinte de l’environnement de test et de développement informatique d’une quantité faible mais significative, ce qui, cumulativement, équivaut à un impact plus important pour rendre l’informatique plus verte et moins gourmande en carbone.
Au-delà du codage, les responsables informatiques peuvent également réfléchir à l’impact environnemental global des environnements de développement et de test de logiciels dont leurs développeurs ont besoin.
S’exprimant lors de la KubeCon + CloudNativeCon à Paris en mars, Gualter Barbas Baptista, consultant principal pour l’activation et la stratégie des plateformes chez Deutsche Bahn, a évoqué les efforts en cours des opérateurs ferroviaires pour surveiller et minimiser l’impact écologique de leurs applications basées sur le cloud. Baptista a parlé de l’autonomisation des développeurs, décrivant les développeurs de logiciels comme les décideurs quotidiens en termes de ce qui est mis dans les logiciels.
Si nous n’engageons pas les développeurs et ne leur donnons pas les outils, nous ne pourrons pas changer la façon dont nous développons le code et dont nous gérons l’infrastructure, dit-il.
Au cours des dernières années, la Deutsche Bahn s’est concentrée sur la convergence de filiales entières pour imposer la normalisation. Cela signifie, dit-il, que nous pouvons tirer parti des effets et assurer un niveau plus élevé de normalisation.
Kubernetes est l’outil de création de plate-forme utilisé par la Deutsche Bahn. La surveillance permet aux administrateurs informatiques de voir l’utilisation du processeur et d’ajuster automatiquement les charges de travail des conteneurs, en les optimisant en fonction des besoins des charges de travail.
La planification est également utilisée pour aider la Deutsche Bahn à garantir que les environnements de développement et de test peuvent être mis en veille lorsque les développeurs ne travaillent pas, ce qui permet d’économiser de la puissance de traitement.
Écologiser l’IA
Le paysage informatique est en constante évolution, ce qui signifie que la durabilité informatique est une cible mouvante. Lors d’une table ronde lors de l’événement KubeCon + CloudNativeCon, Chuck Dubuque, responsable du marketing produit direct pour OpenShift chez RedHat, a averti que l’intelligence artificielle (IA) conduisait Kubernetes vers un endroit où il n’était jamais allé auparavant.
Lorsque vous ajoutez de l’IA à une application, vous multipliez par 10 sa consommation d’énergie, a-t-il déclaré.
En examinant les approches visant à rendre l’IA plus verte, Oliver King-Smith, PDG de SmartR AI, affirme que les chercheurs développent des méthodes efficaces de création et d’utilisation de l’IA, telles que la réutilisation de modèles, ReLora, les modèles Mixture of Experts (MoE) et la quantification.
À propos de la réutilisation des modèles, King-Smith explique que la technique consiste à recycler un modèle déjà entraîné dans un nouvel objectif, ce qui permet d’économiser du temps et de l’énergie par rapport à une formation à partir de zéro. Cette approche non seulement préserve les ressources, mais aboutit aussi souvent à des modèles plus performants, dit-il. Meta et Mistral ont tous deux réussi à publier des modèles pouvant être réutilisés.
En ce qui concerne ReLora et Lora, King-Smith affirme que ceux-ci sont conçus pour réduire le nombre de calculs nécessaires lors du recyclage des modèles pour de nouvelles utilisations. Cela permet d’économiser de l’énergie et permet d’utiliser des ordinateurs plus petits et moins gourmands en énergie. Cela signifie qu’au lieu de s’appuyer sur des systèmes volumineux et énergivores comme le DGX de Nvidia, une carte graphique modeste peut souvent suffire pour le recyclage, dit-il.
Les modèles MoE, comme ceux récemment publiés par Mistral, ont moins de paramètres que les modèles conventionnels. Selon King-Smith, cela entraîne moins de calculs et réduit la consommation d’énergie. Les modèles MoE n’activent les blocs nécessaires qu’en cours d’utilisation, un peu comme éteindre les lumières dans les pièces inutilisées, ce qui entraîne une réduction de 65 % de la consommation d’énergie.
King-Smith décrit la quantification comme une technique permettant de réduire la taille des modèles d’IA. En quantifiant un modèle, le nombre de bits requis pour représenter chaque paramètre est réduit. Cela réduit la taille du modèle, permettant l’utilisation de matériel moins puissant et plus économe en énergie, dit-il.
Même si la quantification peut avoir un léger impact sur la précision du modèle, King-Smith affirme que pour de nombreuses applications pratiques, ce compromis n’est pas perceptible.
La lutte contre la surcharge du code et les niveaux inutiles de tests de régression contribuent à rendre le codage plus écologique. Il existe également des options pour utiliser des microservices ou des algorithmes plus efficaces. Mais le consensus général parmi les experts du secteur est qu’il est très difficile de changer quelque chose auquel les développeurs de logiciels sont habitués.
Mirantiss OMeara voit une opportunité de s’attaquer à l’informatique verte dans le développement de logiciels du point de vue de l’infrastructure informatique. Si nous parvenons à supprimer la complexité et à proposer uniquement les composants d’infrastructure informatique nécessaires, nous serons alors en mesure de créer une fine couche sur toute l’infrastructure informatique, dit-il.
Kubernetes peut également être utilisé pour garantir que les environnements de développement et de test de logiciels n’utilisent pas inutilement les ressources informatiques.
De telles techniques permettent à l’infrastructure informatique d’être légère et économe en énergie. Une technique similaire, comme le souligne Qts Kalinowski, peut être utilisée dans le codage pour réduire le nombre de scénarios différents conduisant à des exceptions que le code en cours de développement doit gérer.