Informations sur le développement

Le développement de logiciels implique la tâche clé consistant à transformer la vision d'un architecte logiciel en code opérationnel d'applications qui génère le résultat voulu, fonctionne dans des conditions prédéfinies, est solide et fiable, s'exécute dans le cadre des paramètres spécifiés et réalise toutes ces opérations avec une efficacité optimale et en utilisant les ressources disponibles. Cela peut sembler être une tâche insurmontable, mais les techniques, les outils, les environnements de développement et les méthodologies modernes permettent aux équipes en charge de la création des logiciels d'aborder la tâche de façon logique et ordonnée, afin de maximiser le taux de succès et de minimiser les efforts inutiles.

Compétences de développement

Bien qu'une mauvaise conception initiale n'aboutisse généralement pas à un bon logiciel, il existe de nombreux outils et techniques pour les architectes, les concepteurs et les développeurs qui peuvent augmenter considérablement les chances qu'une conception réussie produise un bon logiciel. Les développeurs doivent suivre les spécifications de conception, mais une partie des compétences de ce métier est d'être en mesure de visualiser comment les systèmes et les composants de travail interagissent, de comprendre les limitations induites par le matériel et l'infrastructure sur lesquels les applications s'exécuteront, et de prendre les bonnes décisions sur les compromis qui sont nécessaires.  

Cela signifie qu'il n'est pas suffisant de simplement savoir comment utiliser un langage de développement comme C# ou Visual Basic. Les structures et les langages de programmation modernes fournissent des interfaces virtualisées qui masquent la majeure partie de la complexité sous-jacente du matériel d'exécution. Cependant, les développeurs doivent toujours comprendre comment le code s'exécute, comment les différentes instructions de programmation interagissent avec l'infrastructure sous-jacente, et comment implémenter les communications entre des composants qui doivent travailler ensemble (souvent lorsque qu'ils sont à distance et accessibles par un réseau comme Internet).

Une bonne conception logicielle tente de maximiser un ensemble de facteurs importants comme la sécurité, la convivialité, la testabilité, la facilité d'entretien, les performances et plus encore. Les développeurs doivent comprendre comment leurs implémentations de la conception peuvent avoir un impact sur ces facteurs et être préparés à travailler avec l'architecte ou le concepteur du logiciel lorsqu'il s'agit d'effectuer les compromis appropriés pour chacun de ces facteurs.

Langages de programmation

Il existe un large choix de langages pour écrire un logiciel. Certains sont spécifiques à des types particuliers d'applications, alors que d'autres sont utilisés dans la plupart des types d'applications. Lorsque vous travaillez seul, utilisez le plus souvent le langage avec lequel vous êtes le plus familier pour un ensemble de types d'applications. Lorsque vous travaillez en équipe, le choix du langage est généralement spécifié par les chefs de projet.

Toutefois, certaines applications peuvent nécessiter l'utilisation de plusieurs langages ou technologies de programmation. Le développement Web est un bon exemple, où le code qui s'exécute sur le serveur Web pour créer les pages peut utiliser Web Forms ASP.NET ou Web Pages WebMatrix, les pages elles-mêmes peuvent contenir du code JavaScript qui s'exécute dans le navigateur de l'utilisateur pour apporter de l'interactivité, et le code principal qui interagit avec la base de données peut être écrit avec un langage .NET Framework comme C# ou Visual Basic.

Cela signifie que vous devez souvent être familier avec plusieurs langages. Ce n'est généralement pas difficile car la plupart des langages utilisent une approche similaire pour définir les instructions du code source et elles se différencient principalement par leur syntaxe, même si chaque langage à ses propres nuances avec lesquelles vous devez vous familiariser. Cependant, en général, une fois que vous comprenez les fondamentaux de la programmation et que vous apprenez un langage, il devient beaucoup plus facile d'apprendre les autres.

Aujourd'hui, une grande majorité des applications sont écrites à l'aide de langages de programmation orientés objet et déterminés par les événements. Ces types de langages de programmation utilisent des instructions et des constructions de code comme les commandes de boucle et de décision pour exécuter une série de tâches. Ils contiennent des procédures et des fonctions qui sont appelées depuis le code principal, souvent de façon répétée à partir de différents endroits du code. Les objets sont définis dans le cadre du code pour représenter des éléments du monde réel comme les clients, les commandes et les comptes que le code doit manipuler.

Ces objets ont des propriétés qui exposent les données qu'ils contiennent, et des méthodes qui peuvent être exécutées pour manipuler les données. Les objets font remonter les événements lorsqu'une action se produit et le code gère ces événements comme requis. Les langages de programmation orientés objet et déterminés par les événements utilisés sur une plateforme Microsoft sont généralement C#, Visual Basic, C++, F# et JavaScript.

Structures, bibliothèques de codes et modèles

L'utilisation de structures, de bibliothèques de codes et de modèles est un des facteurs clés dans la simplification de la tâche de développement d'applications de plus en plus complexes nécessaires aujourd'hui. La plupart des gens n'aiment pas réécrire le même code encore et encore (c'est répétitif et gaspille du temps et de l'énergie) et préfèrent se concentrer sur les parties du processus de développement qui concernent directement les exigences de l'application qu'ils sont en train de construire. Une méthode qui permet de minimiser le temps, les coûts et les efforts nécessaires, consiste à réutiliser un code existant qui exécute des tâches prédéfinies spécifiques.

Un code réutilisable peut se trouver sous différentes formes. Les équipes de développement créent souvent des bibliothèques de fonctions et de procédures qu'ils utilisent dans plusieurs composants et dans plusieurs applications. Les exemples typiques sont des fonctions pour implémenter la journalisation, gérer les exceptions, mettre en cache les données et accéder aux bases de données. Il est également possible d'obtenir ou d'acheter des structures et des bibliothèques de codes qui exécutent ces fonctions et un vaste ensemble d'autres tâches. La réutilisation d'un code qui a déjà été testé et approuvé pour fonctionner correctement, peut considérablement réduire les efforts nécessaires lors de la construction d'un logiciel. La compétence du développeur consiste à savoir quelles structures conviennent et quand et comment les appliquer avec succès.

Lorsqu'aucune structure ou bibliothèque réutilisable n'est disponible, l'équipe de développement doit écrire le code requis. L'équipe de développement doit également écrire le code « d'assemblage » qui relie les composants et appelle les fonctions dans les structures et les bibliothèques de codes. C'est sur ce point qu'une connaissance approfondie des langages de programmation est requise. Cependant, il existe une autre manière de profiter du travail des autres, même lorsqu'il n'y a pas de code physique disponible. Il s'agit de l'utilisation de modèles de logiciels.

Les modèles sont un concept conçu pour formaliser les connaissances et l'expérience accumulées dans le temps lors de la résolution de problèmes courants dans le développement de logiciels. Les scénarios qui nécessitent une solution de code ont souvent été traités plusieurs fois par d'autres et une solution optimale a été élaborée sur la base des analyses et de l'expérience d'experts du domaine. Ces scénarios sont documentés en tant que modèles de conception de logiciels et incluent des définitions génériques de la solution, qui ne sont spécifiques à aucun langage de code. Toutefois, elles proposent des techniques approuvées pour résoudre le problème. La tâche du développeur consiste alors à être au courant des modèles adaptés et d'écrire le code spécifique à leur application, mais en s'appuyant sur la solution générique décrite par le modèle. Ceci peut aider à minimiser les erreurs et d'éviter les erreurs courantes rencontrées dans chaque scénario.

Techniques et méthodologies de programmation

Même les personnes les plus expérimentées font des erreurs lors de l'écriture d'un code. Les applications complexes contiennent de nombreuses variables et le code qui semble être correct peut s'exécuter de façon inattendue sous certaines conditions qui n'étaient pas évidentes lors de l'écriture du code. Dans le temps, les techniques et les méthodologies qui aident à minimiser les erreurs ont évolué et ont été formalisées. Vous devriez être familier avec ces techniques et méthodologies, même si vous travaillez seul plutôt qu'en équipe.

Une des méthodologies majeures utilisée aujourd'hui est la conception conduite par des tests (TDD, Test Driven Design). Cette méthodologie a pour objectif de faire réfléchir le développeur à propos des exigences du code et de formuler les résultats exigés avant d'écrire le code. Le processus implique la création d'une série de tests d'unité, chacun d'entre eux exerçant une fonction spécifique de la conception pour la section de code créée. Par exemple, si le code applique un dépôt sur le compte d'un client, le test prend le montant du dépôt et le solde actuel du compte, les envoie vers la fonction dans le code créé, puis certifie que le résultat est correct en vérifiant le solde du compte.

Les tests d'unité sont écrits en premier, puis le code qui implémente les fonctions requises est créé dans l'application. Ce code peut ensuite être vérifié en utilisant une structure de test (ou un atelier de test) pour exécuter tous les tests d'unité et afficher les résultats de toutes les assertions. À mesure que vous écrivez le code, le modifiez et l'améliorez en permanence, les tests peuvent être exécutés à nouveau pour s'assurer que les résultats sont toujours valides.

Évidemment, les tests d'unité ne peuvent pas s'exécuter sur les données réelles et ne doivent pas accéder à d'autres parties de l'application qui sont en cours de construction. Au lieu de cela, le développeur crée des composants fictifs qui représentent la réalité, mais qui s'exécutent localement sur l'ordinateur de développement. Cela permet de s'assurer que les tests utilisent uniquement le code créé et que les résultats ne sont pas affectés par d'autres facteurs extérieurs.

La TDD est souvent associée à d'autres méthodologies de programmation. Par exemple, la programmation par paires est souvent utilisée pour valider le code et minimiser les erreurs. Deux développeurs travaillent côte à côte sur un ordinateur, se relayant pour écrire le code et exécuter les tests d'unité. Les développeurs travaillent ensemble, partagent et combinent leurs expériences et connaissances, et critiquent le code que l'autre développeur écrit. Les entrées supplémentaires et la compétition entre développeurs peuvent aboutir à un meilleur code.

Tests, transit et déploiement

Le code créé lors du développement est souvent uniquement une section de l'application ou du système général et il doit être intégré à l'application ou au système complet par intervalles régulières pour s'assurer qu'il n'y a pas de problème avec l'interaction entre chaque composant ou chaque section du code. Une approche courante consiste à vérifier le code par intervalles régulières, après quoi le build complet de l'application ou du système est initié. Cela permet de révéler tous les conflits lors de la compilation et des tests, lesquels doivent être résolus avant le build intégré suivant.

Une fois que l'application complète est construite et soumise au cycle des tests, elle peut être déplacée vers un serveur ou un ordinateur de transit pour les tests d'acceptation finaux. Contrairement à l'ordinateur de développement et les serveurs de build, le serveur de transit est une réplique de l'environnement d'exécution final, et cela permet au logiciel d'être testé dans les mêmes conditions qu'il rencontrera une fois en production. À nouveau, l'équipe de développement doit résoudre tous les problèmes survenus lors du cycle de tests d'acceptation de transit.

Les applications requièrent généralement une sorte de programme d'installation ou de configuration qui leur permet d'être déployées à la fois sur les systèmes de transit et de production finale. L'équipe de développement doit créer les programmes de configuration requis qui installent les composants de l'application, les configurent ainsi que l'environnement d'exécution et préparent le système comme exigé. C'est souvent un problème complexe, spécialement pour les logiciels de série qui peuvent être installés sur une variété de plateformes d'exécution avec un large ensemble de matériel sous-jacent que d'autres applications présentent.

Travail en équipe de projet

Travailler au sein d'une équipe de projet peut être très enrichissant, mais nécessite des compétences supplémentaires pour obtenir de meilleurs résultats. Lorsque les développeurs travaillent en équipe, ils doivent être capables de communiquer et d'interagir correctement avec plusieurs autres personnes. Cela inclut le management, les architectes et les concepteurs, les équipes de tests, les équipes de documentation et beaucoup d'autres.

Des styles de management de projets différents exigent de la part des développeurs d'utiliser différentes compétences. Certains projets sont menés par des lignes « en cascade » traditionnelles, où chaque tâche est compartimentée et terminée avant que la tâche suivante ne débute. Toutefois, les projets sont de plus en plus souvent menés sur une base plus interactive. Cela s'est avéré être plus avantageux dans de nombreux scénarios de développement d'applications.

Par exemple, un projet peut fonctionner en utilisant la méthodologie Agile, où des itérations courtes de développement, des réunions quotidiennes et des réunions hebdomadaires de planification des analyses et des itérations sont utilisées pour garder le projet sur les rails. Le développement Agile met en avant les entrées du client et des parties prenantes extérieures via des publications régulières du logiciel en cours de développement, et met également en avant les commentaires en continu. Généralement, un référentiel contenant les éléments de travail est utilisé pour suivre l'évolution du projet, mais il n'y a pas de conception initiale majeure autre que celle requise pour mettre le projet en route.       

Une autre approche courante est l'Extreme Programming (XP), dans laquelle le développement du logiciel est déterminé par l'implémentation préalable des exigences les plus importantes, par une communication et des tests continus et une livraison régulière du logiciel pendant le développement. Les approches Agile et XP mettent en avant la création de logiciels en production par rapport à la conception initiale et se concentrent sur l'obtention de résultats qui correspondent aux attentes, plutôt que sur le développement de fonctions inutiles. Cela signifie que les membres de l'équipe doivent être productifs et qu'ils travaillent de façon efficace, gérée et contrôlée pour achever les tâches hebdomadaires, ainsi que de bien communiquer avec les autres parties impliquées dans le processus.

La communication interpersonnelle est centrale dans les équipes de développement de logiciels modernes. Elle est facilité et généralement plus productive lorsque l'équipe travaille dans le même bâtiment, voir dans la même pièce. Cependant, les équipes séparées géographiquement ont montré qu'elles travaillent bien à condition que les individus gèrent bien la communication avec les autres membres de l'équipe. Les réunions sont tenues en utilisant le téléphone ou un logiciel de vidéoconférence, le référentiel des informations est disponible par Internet et les membres de l'équipe doivent respecter un agenda très strict pour les réunions quotidiennes et hebdomadaires. Cela exige de la part des individus d'ajuster les restrictions de décalage horaire and d'interagir efficacement avec des membres d'équipe de différentes nationalités, ainsi que d'utiliser les systèmes de communication de façon à faciliter la participation à part entière de tous les membres de l'équipe.

Apprentissage et expérience

Il existe peu d'autres industries où les technologies, les pratiques et les environnements de travail changent aussi rapidement que dans le monde de l'informatique. Les projets majeurs de construction et d'ingénierie mécanique durent souvent plusieurs années, alors que même les applications logicielles les plus importantes doivent avoir une durée de conception/développement/déploiement qui s'étende sur moins d'un an, et souvent beaucoup moins. En même temps, les outils, structures, infrastructures et technologies disponibles changent très rapidement, parfois en l'espace d'un an.

Cela signifie que le développeur doit être préparé à passer du temps pour se mettre à jour des changements en apprenant les nouvelles techniques, les nouveaux langages de programmation et les autres avancées technologiques. Cela nécessite également de comprendre les tendances dans le monde changeant de l'informatique, en considérant comment celles-ci affecteront les logiciels développés aujourd'hui, et d'être capable d'adapter leurs propres compétences de programmation pour maximiser l'utilisation de ces nouvelles capacités.

Parmi toutes les compétences d'un développeur, l'expérience est celle qui a le plus d'impact sur le succès, et elle ne peut être acquise que sur la durée. Travailler en équipe, interagir avec d'autres développeurs et mettre à jour vos compétences sont des exigences fondamentales. Combiner ceci avec un talent pour les pensées logiques, une aptitude à la création et une passion pour la perfection construisent l'ensemble de compétences idéal pour un développeur de logiciels.