Dans cet article, je vous présente une méthode pour coder plus vite et donc gagner en productivité dans vos développements. Elle permet aussi d’améliorer la qualité de vos logiciels. La méthode est simple à mettre en œuvre en 4 étapes.
Coder plus vite vous permettra, par exemple, de mieux respecter les délais et surtout d’être plus serein. Fini les journées qui se terminent à 22h !
Habituellement, lorsque vous développez un morceau de code, vous commencez par écrire le code et puis vous lancez votre application pour vérifier si ce que vous avez écrit fonctionne comme il faut. Si c’est bon, vous enregistrez votre projet et passez à la tâche suivante. Sinon, vous corrigez le comportement. Cette méthode de travail est la méthode classique que l’on apprend généralement à l’école.
Néanmoins, elle pose plusieurs problèmes :
lorsque vous testez, vous testez l’intégralité de votre application et donc pas uniquement le code que vous venez d’écrire (risque d’effets de bords)
les tests sont manuels et longs car il faut sans cesse démarrer l’application complètement et arriver au niveau de la fonctionnalité à tester,
les tests sont faits à la main et sont donc fastidieux et peu intéressants.
Comment coder plus vite ?
Il y a quelques années, je me suis posé la question pour savoir comment faire autrement. J’ai donc fait des recherches sur les différentes méthodes de développement, j’ai lu beaucoup sur le sujet.
Aujourd’hui, je ne travaille plus du tout comme ça. La méthode de travail que j’utilise me permet de développer plus vite et surtout de ne pas avoir à lancer l’application complète mille fois par jour (à chaque fois que je change une virgule dans le code).
La méthode simple pour coder plus vite
La méthode dont je vous parle est basée sur TDD (Test Driven Development). Il s’agit d’une méthode de travail qui préconise de commencer par écrire les tests unitaires avant de développer une fonctionnalité.
Au quotidien, j’ai simplifié cette méthode pour la rendre plus accessible et moins contraignante.
Voici ce que je fais lorsque je développe un nouveau module ou une fonctionnalité :
Je commence par écrire le minimum de code nécessaire,
Je réfléchis ensuite à une manière de la tester grâce à des tests unitaires. J’écris donc des tests pour vérifier qu’elle fonctionne.
Je fais toujours du refactoring pour, au minimum, extraire le code et créer des méthodes communes afin d’éviter à tout prix le code dupliqué,
Après le refactoring, je relance les tests pour vérifier que ça fonctionne toujours.
Cette méthode est très proche de TDD à une exception près : je ne commence pas par les tests unitaires.
La méthode fonctionne
Cette méthode fonctionne et vous fait vraiment gagner du temps. Voici pourquoi :
Avant : vous lancez votre application web, vous cliquez là où il faut pour afficher sur l’écran que vous souhaitez tester. Vous faites les saisies nécessaires et vérifiez le résultat « à la main ». Un cycle de test vous prend au minimum une minute (vraiment au minimum).
Avec la méthode TDD simplifiée, vous utilisez des tests unitaires automatisables, il suffit de quelques secondes pour lancer votre test et en vérifier le résultat. De plus, grâce aux tests qui s’exécutent de manière automatique, vous n’avez plus besoin de cliquer partout pour arriver à votre formulaire à tester.
Et en bonus, grâce aux tests unitaires et aux tests de couverture, vous pouvez prouver le pourcentage de code réellement testé dans votre application. Pouvez-vous en faire autant avec une méthode « à la main » ?
Le plan d’action
Pour passer à l’action, je vous propose tout simplement de l’essayer et d’en vérifier le résultat.
