Code legacy : comment utiliser un code legacy de façon optimale

Le code source constitue le cœur d’un logiciel. La fonctionnalité du programme et les fonctionnalités disponibles dépendent des instructions et des commandes enregistrées dans ce code. Les programmeurs éditent et entretiennent ce code régulièrement afin d’offrir aux utilisateurs la meilleure convivialité possible. Chaque modification apportée au code peut provoquer des erreurs logicielles ou mettre en péril la fonctionnalité du programme.

Pour les développeurs et les programmeurs, la maintenance et la mise à jour du logiciel sont toujours particulièrement problématiques lorsqu’ils doivent travailler avec un code qu’ils n’ont pas écrit personnellement ou qui a été écrit pour des systèmes d’exploitation obsolètes n’étant plus supportés dans des versions tout aussi obsolètes du langage de programmation sous-jacent. Dans cet article, vous découvrirez ce que recouvre exactement le code legacy, et comment le traiter au mieux.

Le terme « code legacy » est utilisé en informatique et peut être traduit par « ancien code » ou « code hérité ». Il s’agit d’un code ancien qui ne fait généralement plus l’objet d’un développement actif. À certains égards, le code legacy est le contraire du clean code qui est compréhensible de façon intuitive, particulièrement simple à entretenir et facilement adaptable. Le code legacy est un code plus volumineux, répétitif et désordonné, pouvant entraîner de nombreux problèmes. La signification accordée à ce terme dépend fortement du point de vue du développeur et de la situation concernée. En principe, le code legacy se distingue toutefois par les aspects suivants :

• Le code n’est plus entretenu pas les développeurs initiaux.
• À l’origine, le code a été écrit pour des systèmes d’exploitation qui ne sont plus supportés.
• Le code ne permet pas la réalisation de tests automatisés.

Pourquoi le code legacy est-il utilisé s’il présente autant d’inconvénients ? Tout simplement parce qu’il n’est pas toujours possible de l’éviter : au cours d’un projet, il n’est pas rare qu’un nouveau programmeur prenne en charge la maintenance et le développement du code. Alors que le développeur initial comprenait le code intuitivement dans la plupart des cas, les nouveaux membres de l’équipe doivent tout d’abord acquérir cette compréhension. Dans ce cadre, il se peut qu’ils ignorent ou ne comprennent pas parfaitement des parties du code.

Lorsque sur de nombreuses années, un code est entretenu, amélioré et édité de toute autre façon par de nombreux développeurs, il peut, au fil du temps, devenir un véritable patchwork toujours plus difficile à comprendre et à modifier. Le problème est qu’à partir d’un certain point, les mises à jour ou les modifications nécessaires ne peuvent plus être réalisées lorsque plus personne ne comprend le code et son effet.

Autre inconvénient du code legacy : il est impossible de réaliser les tests de régression, c’est-à-dire les tests automatisés, en raison de la densité, de la diversité et de l’incommodité de la programmation. Les développeurs devant travailler avec du code legacy doivent donc procéder à des tests manuels nettement plus conséquents. Les erreurs sont ainsi plus difficiles à corriger et les mises à jour sont plus difficiles à mettre en œuvre.

Les développeurs n’apprécient guère devoir travailler sur du code legacy, et ce pour différentes raisons. L’un des principaux problèmes de ce code est qu’il rend impossible la réalisation de tests automatisés pour détecter les bugs et les erreurs. Par conséquent, que peuvent faire les développeurs lorsqu’ils sont soudainement confrontés à du code legacy dans le cadre d’un nouveau projet ?

La meilleure solution est sans conteste le refactoring (en français « refonte »). Cette approche de développement consiste à restructurer le code sans modifier sa fonction initiale. Toutefois, avant de pouvoir procéder à la refonte, les programmeurs doivent tout d’abord comprendre à quoi servent les différents éléments du code. Par ailleurs, l’ensemble des fonctionnalités doivent être sécurisées par des tests.

On procède uniquement à la refonte effective lorsqu’il est clairement établi que le code fonctionne. Dans ce cadre, le code est optimisé fragment par fragment en supprimant et en réécrivant les parties de code superflues, en simplifiant et en regroupant les classes de code et les variables et en ajustant et en réécrivant les méthodes de commande. En définitive, une refonte s’apparente à une révision générale du code legacy. À terme, on obtient un code intelligible, facile à entretenir et rapide à adapter.