Blog ENI : Toute la veille numérique !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Le département informatique au service des organisations
  3. Développer des applications fiables
Extrait - Le département informatique au service des organisations Stratégie, gouvernance et pilotage
Extraits du livre
Le département informatique au service des organisations Stratégie, gouvernance et pilotage Revenir à la page d'achat du livre

Développer des applications fiables

Le développement dirigé par les tests

Le développement dirigé par les tests, mieux connu sous le nom anglais Test Driven Development et abrégé sous l’acronyme TDD, est une approche appliquée à la création de logiciels informatiques, bien que cette approche puisse également s’appliquer à d’autres périmètres. Il s’agit de préparer les tests qui seront effectués avant même d’écrire le code qui sera testé plus tard. Ainsi, chacun des tests, dits tests unitaires, permettent de vérifier qu’une partie de code fonctionne comme souhaité.

Dans ce contexte, il s’agit généralement de suivre trois grandes étapes :

  • la définition des tests visant à clarifier le résultat attendu de chaque fonction ;

  • l’implémentation qui doit permettre de satisfaire les tests écrits ci-dessus ;

  • la refactorisation de l’implémentation dans le but de fournir du code de qualité, c’est à dire aisément maintenable.

Le test unitaire doit totalement être indépendant des autres tests. Ainsi, il est nécessaire de toujours réinstancier des objets, et non de réutiliser des objets existants. Il se décompose en quatre grandes parties :

  • L’initialisation : chargement des objets nécessaires à l’exécution du test, et uniquement de ceux-ci.

  • L’exécution : la fonction à tester est appelée en passant les paramètres adéquats.

  • La vérification : le résultat...

La propreté du code (clean code)

Le clean code, ou encore le code propre est un concept visant à s’assurer que le code soit lisible et simple à maintenir. Ainsi, au-delà des résultats qu’il produit, le code doit être de qualité et respecter un certain nombre de règles partagées entre les équipes, mais aussi dans la communauté au sens large. Cette communauté, ou tout du moins certains de ses membres, feront partie intégrante d’un projet ou même de l’équipe. Pour cela, il s’agit de respecter quelques règles de base :

  • Des noms de classes, de méthodes, de variables ou de fonctions explicites qui ont pour but de faire comprendre rapidement ce qu’est ou ce que fait l’élément nommé. Cela réduit la nécessité de commentaires inutiles et facilite l’identification de l’élément adéquat durant le développement, sans devoir lire la documentation, pour autant qu’il y en ait.

  • Des commentaires en complément : bien que le code lui-même devrait être auto-explicatif autant que possible, il peut y avoir des cas où un commentaire est nécessaire pour expliquer le contexte, la justification ou la complexité d’une certaine partie du code. Ces commentaires devraient expliquer le « pourquoi »...

Le développement dirigé par le comportement

Le développement dirigé par le comportement, également connu comme le Behaviour Driven Development, est une méthodologie qui vise à promouvoir les aspects métiers, le comportement, plus que les aspects techniques. Il s’agit de décrire le fonctionnement attendu en utilisant un langage commun entre tous, neutre et naturel, totalement indépendant de la solution à mettre en œuvre en présentant des scénarios clairs et explicites.

Un des intérêts de cette approche est principalement l’utilisation d’un langage commun permettant alors d’améliorer la collaboration entre le département informatique et les équipes métier, sans demander à ceux-ci d’apprendre à développer des applications. Par ailleurs, les scenarios étant explicites, il est plus simple de définir ce qui est attendu sans laisser place à l’interprétation. Les tests peuvent alors être plus aisément automatisés. Par ailleurs, il est plus simple d’identifier les scenarios qui ne fonctionnent pas comme attendu ou encore de définir de nouveaux scenarios.

Pour formaliser le comportement, il est fréquent de faire appel aux récits utilisateur « AS A… I WANT TO ... SO THAT » ou encore...

Le pair & mob programming

Le pair et le mob programming sont des approches de développement logiciel visant à promouvoir la collaboration et le partage au sein d’une équipe. Cette collaboration peut se faire entre deux développeurs ou dans un groupe plus élargi. Dans ce premier cas, nous parlerons de pair programming tandis que le mob programming est le terme utilisé pour le développement en groupe. Le principe est d’avoir un pilote et des navigateurs. Le premier, appelé le pilote, code alors que les autres, les navigateurs, vérifient ce que le premier fait et réfléchissent aux impacts que provoquent les modifications de code. 

Les avantages de ces approches sont multiples :

  • Le code est revu en temps réel et la qualité du code devrait dès lors être augmentée.

  • La connaissance et les idées sont partagées.

  • Les erreurs sont identifiées en amont.

  • L’équipe se soude puisque la responsabilité est partagée et que l’ensemble fonctionne explicitement avec un but commun.

Notons que pour beaucoup, cette approche est compliquée à mettre en œuvre, principalement dû au fait d’avoir des observateurs. Les objectifs doivent dès lors être totalement explicites et l’ensemble des indicateurs et des discussions doivent porter sur l’équipe...

L’importance de la refactorisation

La refactorisation est une pratique importante dans le développement logiciel. Il s’agit d’améliorer la structure du code sans pour autant modifier le comportement du logiciel lui-même. En lien avec la propreté du code et le développement dirigé par le comportement, la refactorisation peut se faire plusieurs fois dans le cycle de vie d’un logiciel, et ce pour différentes raisons. Les activités liées à la refactorisation sont nombreuses : la réduction de la complexité, l’amélioration de la maintenabilité du code et bien d’autres. Concrètement, la refactorisation est :

  • la suppression de code non utilisé ;

  • l’utilisation de standards, tant au travers de librairies que de modèles de code et d’approches de développement ;

  • la refonte de code, que ce soit l’extraction de code dans une fonction, le déplacement d’une fonction d’une classe à l’autre, la combinaison de classes ;

  • le renommage tel que nous en avons parlé dans la propreté du code ;

  • la réduction des dépendances ;

  • la séparation des préoccupations ;

  • et encore bien d’autres.

En conséquence, la mise à jour des applications s’avère plus simple et les bogues moins...