Présentation du développement

Les logiciels actuels se composent généralement d'une série de composants interagissant les uns avec les autres afin d'effectuer les tâches nécessaires à l'implémentation de l'application. Le développement consiste à créer ces composants en rédigeant du code source dans l'un des nombreux langages disponibles. Ce code définit les actions individuelles fondamentales effectuées par l'ordinateur pour atteindre le résultat final spécifié dans la conception de l'application. Elles peuvent être aussi simples qu'additionner des nombres, attribuer des valeurs aux objets des composants ou exécuter différentes parties du code en comparant les valeurs de variables définies dans le code. Il peut également s'agir de calculs mathématiques plus complexes dans le code, ainsi que de l'application d'opérations logiques pour générer les résultats requis. Le développement comprend d'autres activités, notamment le débogage du code afin de localiser et de corriger les erreurs, le suivi des travaux à l'aide de méthodologies formelles, l'utilisation de référentiels de code partagé et la participation à des réunions de conception, de planification, de commentaires et de révision du code.

Ce document décrit les tâches de développement dans le contexte du cycle de vie de la création d'un logiciel. Il vous aidera à comprendre ce qu'implique d'être responsable d'un développement, les objectifs généraux et les processus exécutés. La figure 1 montre une vue d'ensemble du cycle de vie classique du développement logiciel.

Le cycle de vie du développement logiciel

Figure 1. Le cycle de vie du développement logiciel

Le processus de création d'un logiciel englobe une large variété de tâches, allant de la conception originale au déploiement final et à l'acceptation par le client. La première tâche lors du développement consiste à traduire la conception originale en code de travail à l'aide d'outils tels que Microsoft Visual Studio et de langages tels que Visual Basic, C# et JavaScript. Cette tâche comprend cependant généralement une certaine implication dans le cycle de vie complet du développement logiciel, en particulier si vous travaillez seul ou en équipe très réduite (auquel cas vous effectuez souvent une combinaison de tâches de développement, de test et d'architecture). Les sections suivantes décrivent les principales tâches de développement du cycle de vie d'un logiciel.

Examen de la contribution du client et des objectifs du projet

La première tâche de création d'une application logicielle consiste à récolter des informations et à générer une conception détaillée en fonction des exigences du client. Celle-ci étant traduite dans une documentation plus spécifique et plus centrée sur l'aspect technique, une contribution d'implémentation technique est nécessaire à la formulation de commentaires sur les capacités matérielles et l'implémentation pratique de la conception. Elle peut permettre d'éviter des surprises ultérieures et de s'assurer que la conception finale du logiciel peut être implémentée dans un délai raisonnable et sur le matériel et l'infrastructure disponibles.

Rédaction du code pour les composants

Il s'agit de la principale activité du développement, qui dirige le processus complet de création d'un logiciel. Le créateur du code utilise un cahier des charges ou une liste d'exigences décrivant ce que doit faire un composant ou une partie de l'application, les résultats qu'il ou elle doit produire et la manière dont il ou elle va communiquer avec d'autres parties de l'application. Ce cahier des charges peut prendre différentes formes, par exemple un modèle rédigé dans un langage de modélisation standard, une description des fonctionnalités ou simplement un diagramme sur un tableau blanc.

Lors du développement, les fonctions du langage de programmation choisi sont utilisées pour créer des fichiers de code source contenant les séries d'instructions requises que l'ordinateur va exécuter. Pour résumer, ce code va récupérer un ensemble de valeurs d'entrée, effectuer un traitement de ces valeurs et sortir les résultats. Il peut pour cela utiliser d'autres composants et fonctions du logiciel, ainsi que des bibliothèques de code et de fonctions rédigées par l'équipe ou obtenues via des fournisseurs tiers. Les outils et environnements de développement utilisés, tels que Microsoft Visual Studio (illustré dans la figure 2), peuvent permettre de faciliter la rédaction du code en suggérant les noms des objets et des variables, en vérifiant la syntaxe pour s'assurer que la compilation s'effectue correctement et en indiquant les erreurs.

Environnement de développement Visual Studio 2010

Figure 2. Environnement de développement Microsoft Visual Studio 2010

Examen du code avec les membres de l'équipe

Pour chaque section de code rédigée par les développeurs, il existe rarement une seule solution correcte. Les compétences d'un développeur consistent à utiliser les fonctionnalités et les capacités des langages de programmation pour construire un code effectuant la tâche requise, ce qui peut être atteint de nombreuses manières. Différents développeurs peuvent utiliser des approches légèrement différentes et des combinaisons d'instructions de code différentes.

Un examen du code par des collègues et des responsables permet d'accomplir deux tâches essentielles. D'une part, cela permet d'apporter les différents points de vue de plusieurs développeurs pouvant proposer d'autres approches, signaler des erreurs passées inaperçues ou suggérer des améliorations au code. Cela permet d'optimiser son efficacité et ses performances. D'autre part, cela permet d'élargir les connaissances de tous les membres de l'équipe grâce au partage du savoir-faire, ce qui améliore les performances de l'équipe entière sur le long terme.

Compilation et test du code

En fonction du langage de programmation utilisé, le développement implique de compiler le code source afin de le convertir en formulaire pouvant être exécuté par l'ordinateur. Les outils et environnement de développement effectuent généralement cette tâche. Un membre de l'équipe (en général le créateur initial, puis les testeurs) exécute ensuite le code afin de s'assurer qu'il fonctionne correctement. Si l'équipe utilise une approche de conception conduite par des tests (TDD, Test Driver Design), l'un de ses membres aura au préalable rédigé des tests d'unité pouvant être exécutés pour s'assurer que le code s'exécute correctement et produit les résultats attendus.

La compilation, l'exécution et le test du code est un processus itératif qui s'effectue à mesure de la création du code. Le code minimum de base est généralement créé en premier pour tester le concept et s'assurer que sa compilation et son exécution s'effectuent correctement, puis du code est progressivement ajouté ou mis à jour afin d'optimiser les performances et l'efficacité tout en confirmant qu'il produit les résultats attendus.

Archivage et mise à jour du référentiel du code

La plupart des projets de taille moyenne ou importante utilisent un système de référentiel de code et d'informations d'équipe tel que Team Foundation Server (TFS) pour stocker du code, des documents et des informations sur le projet. Le développeur archive le code qu'il a créé afin qu'il fasse partie du projet global et puisse être compilé dans la solution complète lors des générations normales. Ces générations ont habituellement lieu tous les jours et l'équipe de test travaille avec la nouvelle génération chaque jour pour confirmer que les erreurs existantes signalées ont été corrigées et en localiser de nouvelles.

Le référentiel contient généralement des éléments de travail et des rapports. Le développeur met à jour les éléments de travail relatifs au code créé, y indique les erreurs corrigées et ajoute d'autres informations liées à la tâche qui seront utiles pour les autres membres de l'équipe, notamment les équipes de test et de documentation. L'équipe peut exécuter des rapports fondés sur ces éléments de travail afin de surveiller la progression du projet et découvrir des problèmes en cours. La figure 3 montre Microsoft Visual Studio Team Foundation Server.

Génération de rapports sur le code et les éléments de travail dans Team Foundation Server 

Figure 3. Génération de rapports sur le code et les éléments de travail dans Microsoft Team Foundation Server

Implémentation des modifications, débogage et correction des erreurs

Si le test entraîne le signalement d'erreurs dans le code, un développeur doit revenir en arrière et trouver la cause de ces erreurs, puis modifier le code afin de les corriger. La tâche de débogage consiste à localiser la source des erreurs, pouvant être causées dans n'importe quelle section du code et uniquement mises en évidence lors du test. Elle est parfois désignée comme une « science occulte » car elle nécessite de l'expérience et une approche logique, en particulier si l'erreur n'apparaît que par intermittence ou est difficile à reproduire.

Cependant, les outils et les environnements de développement modernes tels que Visual Studio comprennent des fonctionnalités permettant aux membres de l'équipe de parcourir le code afin de rechercher les valeurs dans les variables et d'observer la manière dont elles changent. Le processus de localisation des erreurs est ainsi bien plus simple et logique. D'autres fonctionnalités et outils fournissant une liste des procédures de code en cours d'exécution et la manière dont le processeur de l'ordinateur les traite, aident l'équipe à localiser les erreurs. En outre, l'équipe peut ajouter une instrumentation (du code pour rédiger des événements dans des fichiers journal par exemple) permettant de surveiller le code durant son exécution et de localiser les erreurs.

Il est également courant lors du test d'acceptation que le client demande des modifications de fonctionnalités de l'application afin d'affiner le logiciel pour qu'il réponde exactement à leurs exigences. Le développeur implémente ces modifications, généralement fondées sur un examen des exigences et une étude détaillée de leur impact sur le reste du logiciel. Une bonne conception originale qui sépare correctement les responsabilités de chaque composant va faciliter l'implémentation des modifications sans affecter les autres parties de l'application.

Le cycle de vie du développement logiciel est un processus itératif. La majorité des tâches décrites sont donc répétées à mesure que le développement se poursuit. Par exemple, l'équipe peut, au cours du développement, créer plusieurs versions complètes ou non du logiciel ou des composants, puis les améliorer ou les modifier en fonction des résultats des tests et des commentaires du client.

Le travail d'équipe

Certains développeurs travaillent seuls ou en petits groupes, tandis que d'autres travaillent au sein de grandes équipes organisées. Dans le premier cas, le développeur peut être responsable de toutes les tâches du cycle de vie du développement, notamment la conception, le test, le déploiement et la maintenance. Dans le second cas, les groupes responsables de la conception, du test, du déploiement et de la maintenance sont généralement séparés. Le développeur se concentre donc davantage sur la tâche principale de rédaction du code.

Les grandes équipes opèrent généralement de manière structurée afin de gérer et de surveiller le cycle de vie et le processus de développement. Il existe de nombreuses approches de la gestion du développement logiciel dans une équipe, notamment le cycle habituel dirigé par la conception fondé sur des tâches préalablement planifiées qui se suivent (l'approche « en cascade ») et l'approche davantage orientée sur les commentaires dans laquelle la planification s'effectue parallèlement aux tâches de développement en fonction des commentaires réguliers du client (l'approche « agile »). La figure 4 montre ces deux principales approches du développement logiciel.

Processus de développement « en cascade » et « agile » 

Figure 4. Comparaison des processus de développement « en cascade » et « agile »

Quelle que soit l'approche utilisée pour le développement, une bonne communication entre les membres de l'équipe et les chefs de projet est essentielle. Bien que de nombreuses équipes se trouvent dans un même lieu, il est de plus en plus courant que les équipes intègrent des membres éloignés géographiquement. Les réunions s'effectuent alors par téléphone et vidéoconférence. Des réunions programmées régulièrement et auxquelles participent tous les membres de l'équipe, notamment les développeurs, les concepteurs logiciels (architectes), les testeurs et les chefs de projet, sont utilisées pour discuter de la progression, planifier les activités et recevoir les commentaires des autres membres de l'équipe et des clients. Les développeurs sont ainsi bien informés de l'évolution inéluctable de la conception du logiciel et peuvent se conformer aux commentaires réguliers pouvant affecter l'implémentation du logiciel.

Résumé

Le développement logiciel est une tâche intéressante et stimulante, pouvant être fortement récompensée. Elle nécessite un esprit logique et une approche structurée et comprend de nombreuses tâches qui ne sont pas directement liées à la simple étude des langages de programmation. Il y a toujours quelque chose de nouveau à apprendre, de nouvelles exigences nécessitant des recherches et de nouvelles technologies à expérimenter. La récompense est de voir l'application logicielle finale fonctionner et de savoir que vous avez joué un rôle dans ce résultat. Les logiciels façonnent le monde actuel. En tant que créateur de logiciel, vous pouvez donc influencer l'avenir.