Une bonne usine logicielle

Usine Logicielle

Un peu d’histoire.

Les technologies et les méthodes de développement informatique ont énormément évoluées ces dernières années. Le développement d’internet et des réseaux a permis l’essor des développements open source qui ont contribué à fournir de nombreux outils pour aider au développement. Il y a 15 ans il était courant de dépenser plus de 15 k€ d’outils avant même d’avoir démarrer un projet ! Le traditionnel cycle en V a été progressivement remplacé sur une majorité de développements par des méthodes dites ‘agiles’, permettant, par une succession d’itérations courtes (d’une durée maximum de 6 semaines), de faire tendre les fonctionnalités du logiciel vers le besoin réel et opérationnel du client. Le succès de ces méthodes n’est plus à démontrer : Eclipse par exemple, qui réunit le code de plus de 400 ‘commiters’ est développé selon cette méthode. Autour de ces méthodes agiles, se sont développés des outils collaboratifs permettant d’optimiser au maximum les développements.

Une bonne usine logicielle ?

Une usine logicielle est un ensemble d’outils et de méthode(s) permettant aux développeurs et architectes logiciels de mener à bien leur mission. Pour développer de manière agile et itérative, il est nécessaire de respecter certains critères comme :

• la gestion d’un ‘backlog’ indiquant les taches à réaliser (évolutions, bugs, etc…)
• la mise à disposition automatique d’une version fonctionnelle du logiciel disponible à tout moment.
• la mise en place de tests unitaires dès le début du projet afin de garantir la non régression tout au long du développement
• la mise en place de rôles précis : scrum master, product owner, architectes, développeurs…
• la mise en place d’une organisation projet rigoureuse : réunion journalière permettant d’identifier les points bloquants dès leur apparition, bilan d’itération, etc…
• la mise en place d’outils de suivi de l’avancée du backlog

Tous ces outils existent aujourd’hui et peuvent être utilisés de manière locale (installés sur un serveur privé), ou accessibles sur le cloud (installés sur des serveurs internet). Selon les besoins du projet il sera possible de choisir l’une ou l’autre des solutions d’hébergement.

Les différents outils de l’usine logicielle.

Une bonne usine logicielle doit contenir les outils suivants :

• un atelier de développement
• un tracker
• un gestionnaire de sources
• un système de test unitaires
• un outil d’intégration continue
• un outil de surveillance du code établissant des métriques
• un outil revue de code

Les paragraphes suivants proposent des outils adaptés à une bonne usine logicielle. N’hésitez pas à commenter cet article si vous avez des suggestions !

Eclipse

Eclipse (https://www.eclipse.org) est un atelier de développement intégré pouvant travailler avec différents langages (c, lua, c++, java, etc…). Agé d’une bonne dizaine d’année, Eclipse s’est imposé comme l’outil de référence dans l’industrie pour le développement universel. En effet Eclipse fonctionne indifféremment sur mac, windows et linux, et adresse toutes les composantes de développement : code embarqué, application web, application stand alone, OSGi, etc… Couplé à d’autres outils tels que mylyn, egit, ou d’autres, Eclipse est le réceptacle standard pour paramétrer l’atelier de développement sur mesure nécessaire pour développer une application complexe.

JIRA

Jira (https://fr.atlassian.com/software/jira) est un ‘tracker’ c’est à dire un outil permettant de répertorier toutes les ‘issues’ d’un projet. Cet outil est totalement configurable et extensible notamment pour gérer l’agilité grâce à son plugin ‘greenhopper’ (https://www.atlassian.com/software/jira/agile). L’association de ces deux outils permet de travailler proprement en respectant les itérations de développement et en ayant des métriques très précises sur l’avancement du projet.

JIRA permet de gérer des issues de différents types : des bugs, des évolutions, des améliorations, des taches ou des issues spécifiques sur mesure que l’on peut définir. A chaque type d’issue il est également possible de gérer un workflow spécifique (issue pour un Process en particulier, pour décrire un test, une affaire, …).

JIRA sert également de base pour de nombreux outils de management. Cf cet article : 10 Best Test Management Tools For Jira In 2021.

Enfin, JIRA est totalement intégré à Eclipse avec le connecteur Mylyn approprié (https://www.eclipse.org/mylyn), permettant de visualiser les issues directement dans des vues spécifiques d’Eclipse et de suivre leur avancement.

Git

Git est un gestionnaire de code source. La gestion du code source consiste à pouvoir tracer l’historique de toutes les modifications de code effectuées par les différents développeurs. De nombreux outils plus ou moins performants existent pour effectuer cette tache. Aujourd’hui, l’outil qui sort son épingle du jeu est sans conteste ‘git’ (https://git-scm.com). Cet outil offre de nombreux avantages, dont deux principaux :

• la possibilité de modifier et de livrer du code sans connexion réseau
• la capacité de créer et de fusionner des branches de manière simple contrairement aux autres outils.

Git est devenu en quelques années l’outil de référence pour la gestion de source. C’est par exemple l’outil utilisé pour gérer le développement d’ubuntu (implémentation linux) effectué par des centaines de développeurs. Tout le code de la plateforme Eclipse est également passée sur git en fin d’année 2012. L’utilisation de git ne nécessite aucune installation côté serveur. Un dépôt avec un accès réseau standard peut être utilisé. Si l’on souhaite faire héberger son code il est possible de le publier gratuitement sur github (https://www.github.com) de manière publique, ou sur bitbucket (https://www.bitbucket.org), où il est possible également de créer jusqu’à 5 projets privés gratuitement. Enfin, git est totalement intégré à Eclipse avec le plugin egit, qui offre toutes les fonctionnalités à portée de clic.

Tests unitaires

Les tests unitaires permettent de contrôler la validité du code. Pour être efficace, chaque test doit être codé de manière reproductible (mise en place d’un contexte de test stable), focalisé sur une seule fonctionnalité à tester, explicite en cas de problème (pour pouvoir corriger facilement le problème). Dans son ensemble le système de tests unitaires doit pouvoir se lancer facilement directement de l’atelier de développement (ou dans l’outil d’intégration continue), et il doit être alimenté au fur et à mesure du développement du projet. Pour le code écrit en Java, la plateforme de test Junit est utilisée.

Jenkins.

Jenkins (https://jenkins-ci.org) est un outil open source d’intégration continue extrêmement simple à mettre en œuvre. L’intégration continue est le mécanisme qui permet de livrer une version de produit à période régulière (journée, semaine), ou à chaque modification du code. Jenkins est utilisé par des centaines de projet dans le monde, et permet grâce à son système de configuration en plugins de s’interfacer avec tous les outils du marché (ant, maven, git, …). Installé dès le départ d’un projet, Jenkins permet de sécuriser le développement en garantissant la présence d’une version intermédiaire du projet sans se lancer dans un processus manuel couteux pour le batir. En parallèle de la construction des composants logiciels et de leur intégration, Jenkins permet de lancer les tests unitaires du projet et d’en établir des rapports, ainsi que de contrôler les métriques du projet (nombre de warnings de compilation, nombre de classes, etc…). Jenkins est l’outil nécessaire pour pouvoir appliquer un des principes de base de l’agilité : la mise à disposition d’un exécutable récent pouvant servir à l’évaluation des fonctionnalités disponibles.

Sonar

Sonar (https://www.sonarqube.org) est un outil de contrôle statique du code. Il permet de détecter des erreurs classiques effectuées lors du développement (fuites mémoire possibles, etc…) et d’obtenir des métriques représentatives (complexité du code, taux de commentaire, code dupliqué, etc…). Cet outil peut se brancher sur l’outil d’intégration continue (et remonter les erreurs lors de la construction du produit), ou plus en amont sur l’atelier de développement.

Gerrit

Gerrit (https://code.google.com/p/gerrit/) est un outil permettant de faciliter la revue de code de projets gérés sous git. Il agit comme un filtre avant la livraison définitive du code, en permettant à d’autres membres du projet d’accepter le code fourni. Cette pratique permet également de diffuser la connaissance entre les développeurs et de partager les bonnes pratiques. Cet outil nécessite d’avoir une organisation des ressources de développement où des ‘valideurs’ sont désignés parmi l’équipe de développeurs. Gerrit est un ‘plus’ sur un projet mais n’est pas indispensable dans une usine logicielle. Il conviendra néanmoins de statuer sur son utilisation au cours de la vie du projet. Toutefois si l’équipe de développement est répartie, sans que les gens ne se connaissent vraiment, il peut être indispensable de la mettre en oeuvre