Nederlandstalige Versie

Dans le monde en perpétuelle évolution du développement logiciel, le code hérité est un sujet souvent abordé, mais finalement très peu compris. Le code hérité peut être défini de différentes manières, mais pour cette discussion, nous considérons qu’il s’agit de tout code qui est encore utilisé par une application importante, mais qui devrait être mis à niveau. Il se peut qu’un nouveau style architectural ou de nouvelles normes soient nécessaires, que des cadres obsolètes soient encore utilisés ou que le code soit écrit dans un langage de programmation qui n’est plus pris en charge. Ou alors le code n’est pas travaillé à la base, et se retrouve donc trop souvent pollué de correctifs rapides. En d’autres termes, il s’agit d’un code devenant de plus en plus difficile à maintenir et qui doit être réécrit, mais qui, pour une raison ou une autre, n’est pas pris en main. Certains parlent également de dette technique (technical debt).

Et si nous allions plus loin en essayant non seulement de gérer ce code, mais en plus de l’améliorer de manière proactive ? Pouvons-nous utiliser de nouvelles technologies comme l’IA pour y parvenir ?

Pourquoi le Code hérité est un problème

Le code hérité entraîne un certain nombre de défis. Le plus important d’entre eux est probablement le fait qu’il ralentit le développement et rend la maintenance difficile, ou qu’il nécessite des connaissances spécialisées et des outils obsolètes. Sans les connaissances et les outils adéquats, il peut représenter un coût énorme pour tout éditeur de logiciels. De plus, si les développeurs qui ont écrit le code original ont également quitté l’entreprise, le problème peut se révéler encore plus grave. En parlant des développeurs, c’est également la  dette technique qui constitue l’un des plus grands désagréments dans leur travail.

Il existe heureusement plusieurs façons de relever ces défis, même en utilisant les technologies les plus avancées, telles que l’intelligence artificielle.

Stratégies de gestion du code hérité

Il n’existe malheureusement pas de solution magique permettant de résoudre tous les problèmes liés aux code hérité en une seule fois. Il faut adopter une approche polyvalente faisant appel à plusieurs tactiques à la fois. Pensons à l’analyse du code, à la construction de nouveaux composants de manière modulaire et à la maintenance continue de la base de code pour s’assurer qu’elle reste à jour et bien adaptée aux besoins futurs.

Une première étape consiste à effectuer une analyse statique. Il s’agit d’examiner le code sans l’exécuter afin d’identifier les problèmes potentiels tels que les dépendances, les failles de sécurité ou les “code smells”. En utilisant des outils d’analyse statique, les développeurs peuvent mieux comprendre la structure du code et identifier les zones problématiques à améliorer. Ces outils sont en partie intégrés dans un bon environnement de développement, mais il est souvent possible de leur ajouter une puissance supplémentaire.

Après l’analyse du code, il est essentiel de mettre en place des bancs d’essai, conformément au paradigme du Test Driven Development (TDD). Cela permet de créer un environnement sûr dans lequel divers tests peuvent être exécutés afin de garantir que le code se comporte comme prévu. Les tests sont essentiels pour détecter rapidement les bogues et les problèmes de performance, avant que des changements ne soient apportés. Par ailleurs, si la couverture des tests est suffisante, il devient beaucoup plus sûr de remanier le code, ce que nous devons continuer à faire tout au long du cycle de vie afin de veiller à ce que le code continue d’être amélioré et n’atteigne surtout pas le legacy status. La mise en place de bancs d’essai soutient en outre les processus d’intégration et de déploiement continus (CI/CD)), qui sont essentiels pour la gestion de la qualité à long terme.

Une autre stratégie importante consiste à remanier le code pour le rendre modulaire. En décomposant une base de code monolithique en modules plus petits et plus faciles à gérer, les développeurs peuvent isoler les fonctionnalités, ce qui rend le code plus facile à comprendre, à maintenir et à tester (et peut-être même à réécrire). Cette modularisation permet également à différentes équipes de travailler simultanément sur différentes parties de la base de code, ce qui augmente la productivité et réduit la probabilité d’erreurs.

Le rôle de l’IA dans la gestion de code hérité

L’intelligence artificielle offre de nouvelles possibilités pour la gestion de code hérité, en particulier aujourd’hui, avec l’évolution rapide de l’IA générative. Bien que les capacités actuelles de l’IA soient souvent limitées à des tâches à petite échelle, son potentiel de transformation de la gestion du code hérité est considérable. L’IA peut aider à analyser le code, à écrire des tests, à remanier et même à générer de la documentation. Cela fait de l’IA un outil précieux pour les développeurs.

• Analyser le code : Les outils d’IA peuvent analyser le code pour en déterminer la structure et la fonctionnalité, ce qui permet d’obtenir des informations qui ne sont pas forcément évidentes pour les développeurs humains. Cela peut s’avérer particulièrement utile lorsqu’il s’agit de systèmes hérités complexes ou mal documentés.
• Rédaction de tests : L’IA peut également aider à générer automatiquement des tests basés sur le comportement du code, ce qui permet de gagner du temps et d’améliorer la qualité du code en identifiant les cas marginaux qui pourraient être négligés lors des tests manuels.
• Refonte du code : Les outils pilotés par l’IA peuvent suggérer des améliorations et aider les développeurs à remanier le code graduellement. Ce processus de remaniement continu permet de garder la base de code propre et maintenable, réduisant ainsi la dette technique au fil du temps.
• Génération de documentation : L’IA peut automatiquement générer et actualiser la documentation dans le cadre de CI/CD, ce qui est particulièrement utile dans les grands projets où la maintenance de la documentation peut être un défi.

Ces tâches peuvent principalement être effectuées par le même type d’outils d’IA : les assistants de codage.  Codacy, Snyk et, bien entendu, github CoPilot en sont quelques exemples.

Conclusion : l’avenir de la gestion de code hérité grâce à l’IA

La gestion de code hérité reste un défi complexe qui nécessite une approche stratégique. Cependant, l’émergence de l’IA en tant qu’outil d’analyse, de test et de remaniement du code offre des possibilités de relever ce défi de manière plus efficace et plus rentable. L’évolution de la technologie de l’IA générative est encore en plein essor, et son rôle dans la gestion de code hérité ne fera probablement que s’accroître, offrant davantage de possibilités d’améliorer les processus de développement de logiciels.

Toutefois, il ne faut pas non plus se focaliser sur l’IA : le meilleur remède contre le code hérité est encore de l’éviter, et ce, en appliquant les bonnes tactiques tout au long du cycle de vie du développement logiciel afin de maintenir la conception et le code aussi propres et à jour que possible. Dans un prochain article de blog, nous examinerons cette question plus en détail, en zoomant sur les différentes phases du cycle de vie afin de discuter de la manière d’éviter le code hérité et de la façon dont l’IA peut être utilisée au cours de chaque phase en vue d’y contribuer.

Version française

In de steeds veranderende wereld van softwareontwikkeling is legacy code een onderwerp dat vaak ter sprake komt, maar zelden goed wordt begrepen. Legacy code kan op verschillende manieren worden gedefinieerd, maar voor deze discussie beschouwen we ze als elke code die nog steeds wordt gebruikt door een belangrijke toepassing, maar die zou moeten worden geüpgraded. Misschien zijn er een nieuwe architectuurstijl of standaarden nodig, worden er nog verouderde frameworks gebruikt, of is de code geschreven in een niet langer ondersteunde programmeertaal. Of er is al te vaak niet meer ten gronde aan de code gewerkt en ze is vervuild geraakt met snelle fixes. Met andere woorden, het is code die steeds moeilijker te onderhouden wordt en die opnieuw moet worden geschreven, maar om een of andere reden niet wordt aangepakt. Sommigen noemen dit ook wel eens technical debt.

Maar wat nu als we een stap verder gaan en deze code niet alleen proberen te beheersen, maar ook proactief verbeteren? En kunnen we hierbij gebruik maken van nieuwe technologieën zoals AI?

Waarom Legacy-Code een Probleem Is

Legacy code brengt tal van uitdagingen met zich mee. De grootste daarvan is waarschijnlijk het feit dat ze de ontwikkeling vertraagt en onderhoud bemoeilijkt; of ze vraagt gespecialiseerde kennis van voorbijgestreefde hulpmiddelen. Zonder de juiste kennis en tools kan dit een gigantische kostenpost worden voor elk softwarebedrijf. Als de ontwikkelaars die de oorspronkelijke code schreven, bovendien ook nog het bedrijf verlaten hebben, kan het probleem nog groter worden. Over de ontwikkelaars gesproken: ook voor hen is technical debt een van de grootste ergernissen bij hun werk.

Er zijn gelukkig een aantal manieren om met deze uitdagingen om te gaan, zelfs met behulp van de meest geavanceerde technologieën, zoals kunstmatige intelligentie.

Strategieën om Legacy Code te beheren

Er bestaat, jammer genoeg, geen magische oplossing die alle problemen met legacy code in een keer oplost. Het vereist een veelzijdige aanpak waarbij meerdere taktieken tegelijkertijd worden toegepast. Denk aan het analyseren van de code, het modulair opbouwen van nieuwe componenten en het continu onderhouden van de codebase, om ervoor te zorgen dat deze up-to-date blijft en goed is aangepast aan toekomstige behoeften.

Een eerste stap is het uitvoeren van statische analyse. Hierbij wordt de code onderzocht zonder deze daadwerkelijk uit te voeren, om zo potentiële problemen te identificeren zoals afhankelijkheden, beveiligingslekken, of zogenaamde ‘code smells’. Met behulp van statische analysetools kunnen ontwikkelaars de structuur van de code beter begrijpen en probleemgebieden aanwijzen die verbetering behoeven. Deze tools zijn voor een deel ingebakken in een goede IDE, maar je kan er vaak nog extra kracht aan toevoegen.

Nadat de code is geanalyseerd, is het opzetten van testbanken essentieel, volgens het Test Driven Development (TDD) paradigma. Dit creëert een veilige omgeving waarin verschillende tests kunnen worden uitgevoerd om ervoor te zorgen dat de code zich gedraagt zoals verwacht. Testen is cruciaal om bugs en prestatieproblemen vroegtijdig op te sporen, voordat er wijzigingen worden doorgevoerd. Als er voldoende test coverage is, wordt het trouwens een stuk veiliger om de code te refactoren, hetgeen we tijdens de volledige levenscyclus zullen moeten blijven doen, om ervoor te zorgen dat de code steeds beter wordt en zeker geen legacy status krijgt. Het opzetten van testbanken ondersteunt daarnaast ook continuous integration en deployment (CI/CD) processen, die essentieel zijn voor kwaliteitsbeheer op lange termijn.

Een andere belangrijke strategie is het refactoren van de code om deze modulair te maken. Door een monolithische codebase op te splitsen in kleinere, beter beheersbare modules, kunnen ontwikkelaars functionaliteiten isoleren, wat de code gemakkelijker maakt om te begrijpen, te onderhouden en te testen (en eventueel zelfs om ze te herschrijven). Deze modularisatie stelt verschillende teams ook in staat om tegelijkertijd aan verschillende onderdelen van de codebase te werken, wat de productiviteit verhoogt en de kans op fouten vermindert.

De rol van AI in het aanpakken van Legacy Code

Kunstmatige intelligentie biedt nieuwe mogelijkheden voor het beheren van legacy code, zeker nu, met de snelle evolutie van generatieve AI. Hoewel de huidige mogelijkheden van AI vaak beperkt zijn tot kleinschalige taken, is het potentieel om legacy codebeheer te transformeren aanzienlijk. AI kan helpen bij het analyseren van code, het schrijven van tests, het refactoren en zelfs bij het genereren van documentatie. Dit maakt AI een waardevol hulpmiddel voor ontwikkelaars.

• Code Analyseren: AI-tools kunnen code analyseren om de structuur en functionaliteit te bepalen, waardoor inzichten ontstaan die mogelijk niet direct duidelijk zijn voor menselijke ontwikkelaars. Dit kan vooral nuttig zijn bij het omgaan met complexe of slecht gedocumenteerde legacy-systemen.
• Tests Schrijven: AI kan ook helpen bij het automatisch genereren van tests op basis van het gedrag van de code, wat tijd bespaart en de codekwaliteit verbetert door randgevallen te identificeren die tijdens handmatige tests over het hoofd kunnen worden gezien.
• Code Refactoren: AI-gestuurde tools kunnen verbeteringen voorstellen en ontwikkelaars helpen om code stapsgewijs te refactoren. Dit continue refactoringsproces helpt om de codebase schoon en onderhoudbaar te houden, waardoor technische schuld in de loop van de tijd wordt verminderd.
• Documentatie Genereren: AI kan automatisch up-to-date documentatie genereren en bijhouden als onderdeel van CI/CD, wat vooral nuttig is in grote projecten waar het bijhouden van documentatie een uitdaging kan zijn.

Deze taken kunnen veelal worden uitgevoerd door dezelfde type AI tools: de zogenaamde code assistants. Een aantal voorbeelden zijn Codacy, Snyk en, uiteraard, github copilot.

Conclusie: de toekomst van legacy codebeheer met AI

Het beheren van legacy code blijft een complexe uitdaging die een strategische aanpak vereist. Maar met de opkomst van AI als hulpmiddel bij het analyseren, testen en refactoren van code, ontstaan er mogelijkheden om deze uitdaging op een meer efficiënte en kosteneffectieve manier aan te pakken. Generatieve AI-technologie is nog in volle ontwikkeling, en haar rol in legacy codebeheer zal waarschijnlijk alleen maar toenemen, wat nog meer kansen biedt voor het verbeteren van softwareontwikkelingsprocessen.

We mogen ons echter ook niet blind staren op AI: het beste medicijn tegen legacy code is ze te voorkomen, en dit door gedurende de volledige softwareontwikkelingslevenscyclus de juiste taktieken toe te passen om het ontwerp en de code zo clean en up-to-date mogelijk te houden. In een toekomstige blogpost zullen we hier nog dieper op ingaan, waarbij we op de verschillende fasen van de levenscyclus inzoomen, om te bespreken hoe we legacy kunnen vermijden, en ook hoe AI tijdens elke fase kan worden ingezet als hulpmiddel daarbij.

Une telle opération présente évidemment des risques importants.

Mais elle représente aussi une réelle opportunité pour adresser un ensemble de problèmes récurrents dans la majorité des organisations, en souffrance depuis souvent trop longtemps.
Nous voulons parler ici de :
– la dette technique (1) ;
– des manquements en matière de transfert de connaissance des seniors vers les juniors ;
– de rationalisation des moyens ;
– de saisie de nouvelles opportunités jusque là négligées.

La dette technique concerne les branches mortes non éliminées dans les anciens programmes, la perte de maintenabilité due aux maintenances successives ( structures de programme ou de données lentement dégradées au cours du temps), le manque de réutilisation (le syndrôme du copier coller), les duplications de données, etc.

Les manquements en matière de transfert de connaissance font trop souvent l’objet de vœux pieux jamais vraiment réalisés. Une opération de migration, si elle se fait dans le cadre d’une bonne mixité juniors-seniors (par ailleurs une des conditions de succès de l’opération), oblige à ce transfert.

La rationalisation des moyens est aussi trop souvent lettre morte, parce que les équipes sont en permanence aux prises avec les exigences quotidiennes. Il s’agit ici de mettre en oeuvre le principe « One concern – One solution » :
– au niveau technique : une seule base de données, un seul langage, un seul outil de développement, un seul outil de scheduling pour les chaînes batch, …
– au niveau fonctionnel : un seul outil de modélisation, une approche décloisonnée sur les données et les fonctionnalités, …

En matière de nouvelles opportunités, il s’agit de s’intéresser à des sujets comme la virtualisation de serveurs (et pourquoi pas également, tant qu’à faire, des desktops), les solutions open source, les outils de gestion de règles métier, l’intégration continue, …

Les différents scénarios possibles doivent être évalués non seulement en fonction des coûts, délais et risques, mais aussi en regard de ce qu’ils apportent ou non par rapport aux quatre critères évoqués plus haut. Il serait dommage de les négliger dans l’analyse de décision.

______________________________________________________________________________________________

(1)
Un projet de développement logiciel inclut une partie de conception (elle correspond à la définition de son architecture et  design technique).  Lors de la programmation, le respect de l’architecture et du design conditionne la qualité du projet.  Écrire le code source en suivant la conception définie en amont lui permet d’être cohérent, et de faciliter les activités de maintenance. On distingue pour l’essentiel deux types de maintenance :
– la maintenance corrective : pour corriger les bug informatiques ;
– la maintenance évolutive : pour modifier ou ajouter de nouvelles fonctionnalités.
Lors des phases de maintenance un non-respect de la conception,  intentionnel ou non,  induit des coûts supplémentaires ultérieurs.  Ce sont les intérêts.  C’est pourquoi l’on parle de dette technique, pour montrer l’analogie avec la dette dans le domaine financier.  Comme dans le domaine financier, il vaut évidemment mieux rembourser la dette rapidement plutôt que de continuer à payer des intérêts sur la dette dans la durée.
En résumé, quand on code au plus vite et de manière non optimale, on contracte une dette technique que l’on rembourse tout au long de la vie du logiciel sous forme de temps de développement de plus en plus long, et de bugs de plus en plus fréquents et difficiles à corriger.