Liste des formations

Des difficultés à comprendre quels sont les comportements attendus du logiciel en relisant le code ? Des soucis d'alignement entre les attentes du métier et ce qui est livré en production ? À partir d'une User Story , il est compliqué de savoir par où commencer, quoi tester, quand s'arrêter et ce qu'on en attend ? Si tel est votre cas, le Behavior-Driven Development peut vous aider ! Le Behavior-Driven Development (BDD) est une façon de penser, concevoir et coder les fonctionnalités, pilotée par les comportements attendus. Sa double boucle ATDD/TDD permet d'outrepasser les limitations du bottom-up inhérentes au Test-Driven Development seul. Il permet une fluidification de la communication avec les expert·e·s métier, un meilleur alignement du code avec le besoin, l'écriture de tests fonctionnels solides et la documentation efficace du logiciel. La formation s'effectue sous forme d'ateliers pratiques et de séquences théoriques interactives. : Découverte à travers l'Exemple Mapping : Découvrir le besoin. Ancrer le langage commun, faire émerger les différents scénarios métiers d'un cas fonctionnel, faciliter la communication entre le métier et les développeurs et développeuses. Formulation : Décrire les scénarios fonctionnels, Quand et comment utiliser (ou non) le Given When Then Automatisation : Bien structurer ses tests, comment découpler ses tests des données de tests. Implémentation via la double boucle ATDD/TDD. Jour 1 matin – Introduction et découverte des besoins Introduction au BDD : historique, principes, place dans l'agilité. Le rôle des Three Amigos : Métier, Développeur, Testeur. La conversation avant la documentation : “Shared documents aren't shared understanding”. Atelier pratique : Jeu de découverte et Example Mapping Identifier les règles, exemples et questions. Faire émerger un langage commun et des cas limites. Structurer les échanges autour d'un besoin fonctionnel simple. Jour 1 après-midi – Structurer et formuler les scénarios fonctionnels Introduction à la formulation De la découverte à la documentation. Structure Gherkin : Given (contexte) / When (action) / Then (résultat) . L'acronyme BRIEF : B – Business language : langage métier partagé. R – Real data : données concrètes révélant les règles. I – Intention revealing : exprimer le “pourquoi”, pas le “comment”. E – Essential : aller à l'essentiel. F – Focused : un scénario = une règle métier. Atelier pratique : Scénarios cliniques Analyse de scénarios “pathologiques”. Réécriture collective selon BRIEF. Partage et validation en groupe. Jour 2 matin : Cas d'école – Pandemic Introduction du cas d'école : Pandemic Présentation du jeu et de ses règles principales. Identification des fonctionnalités à modéliser : propagation ( infection ) et éclosion . Discussion sur la notion de “comportement attendu”. Découpage des règles en features Reformulation des règles en comportements observables. Sélection des règles prioritaires pour l'atelier. Atelier pratique : Example Mapping Construction des cartes “règle / exemple / question”. Détection des ambiguïtés et clarifications collectives. Formulation des scénarios BDD Passage des exemples aux scénarios Given / When / Then . Application du cadre BRIEF (Business language, Real data, Intention revealing, Essential, Focused). Implémentation avec Cucumber (Java ou Kotlin) Création du projet et mise en place de la structure de test. Implémentation et exécution des scénarios. Discussion sur la valeur ajoutée du couplage Example Mapping → Formulation → Automation . Jour 2 après-midi : Cas pratique collectif Choix du sujet Exemple proposé : Shomulator (simulateur du modele social de Shodo). Ou cas concret apporté par les participants (besoin réel d'un projet). Atelier : Example Mapping complet Définition du périmètre et du vocabulaire métier partagé. Identification des règles, exemples et questions. Construction du langage commun. Rédaction et partage des scénarios Structuration des scénarios avec Given / When / Then . Vérification de leur cohérence et de leur lisibilité. Discussion sur la transposition potentielle vers l'automatisation. Débrief collectif et synthèse Retours d'expérience : aspects humains, techniques et méthodologiques. Discussion sur la mise en place concrète du BDD dans les projets des participants. Mise en perspective : apprentissages du cas Pandemic vs contexte réel.

Avez-vous déjà observé qu'il n'est pas toujours facile d'aligner le développement logiciel ou l'architecture du système d'information avec les besoins métier ? Les concepts fonctionnels discutés peuvent être confus et la technique pollue souvent les discussions avec les expert·e·s du métier si bien que l'on pousse souvent des solutions avant d'avoir une compréhension profonde du besoin. D'ailleurs, il n'est pas forcément très simple de se comprendre, car chaque personne peut avoir une compréhension différente du même concept fonctionnel. Comment s'y prendre pour avoir un découpage du système d'information et/ou du logiciel aligné sur le métier tout en prenant en compte les contraintes opérationnelles ? Le Domain-Driven Design est une philosophie qui vise à remettre le métier au centre du développement logiciel en s'intéressant tout particulièrement à l'art de la modélisation. Les patterns du Domain-Driven Design Stratégique visent à dissocier, cartographier et modéliser l'espace du problème de celui de la solution afin de faire émerger un langage commun partagé par toutes et tous. Ceci permet de construire une compréhension et une vision collective du besoin à adresser. Le Domain-Driven Design Stratégique permet de construire solutions d'architecture alignées sur le besoin métier qui prennent en compte les différents rapports de force opérationnels (priorisation, organisation…). La formation s'effectuera sous forme d'ateliers de mise en pratique ainsi que de cours théoriques: Demi-journée 1 : L'art de la modélisation : Comprendre pourquoi le Domain-Driven Design, ce qu'est la modélisation de l'espace du problème et de la solution. Demi-journée 2 : EventStorming : Modéliser son système en évènements métier afin de faire émerger les sous contextes métier (bounded-contexts), langage commun et omniprésent (ubiquitous language), les dynamiques de communication interpersonnelles et la compréhension collective du métier. Demi-journée 3 et 4: Context Map : Cartographie des domaines métiers avec leurs interdépendances, leur niveau de couplage et l'interaction des équipes en charge de ces domaines.

Kubernetes, Docker, Terraform, Prometheus, MinIO, Rclone, … Derrière toutes ces technologies, un point en commun: le langage Go, aussi appelé Golang. Né au début des années 2010, dans les bureaux de Google, ce langage compilé s'est imposé dans les environnements cloud et microservices. Avec une syntaxe souvent considéré comme simple à apprendre, mais difficile à maîtriser, il est un tournant des métiers dev et devops de demain. Découvrez les bases du langage au travers d'un exemple concret: construire une API HTTP, avec un backend SQL. Matin – Découverte et prise en main de Go Présentation du langage : histoire, philosophie et principaux cas d'usage Installation et utilisation de l'outil en ligne de commande go : compilation, exécution, formatage et tests Découverte des ressources officielles : Tour de Go, documentation, playground Premiers pas avec la syntaxe : Packages et modules Variables et types de base Structures de contrôle (conditions, boucles) Structures de données (slices, maps, structs) Fonctions et méthodes attachées Après-midi – Création d'une API HTTP Présentation du projet fil rouge : une API REST simple avec persistance SQL Manipulation de bases de données avec la librairie standard database/sql et introduction aux ORMs Création d'un serveur HTTP avec net/http : Gestion des routes et réponses JSON Introduction à un framework web léger et aux middlewares

Cette formation explore les fonctionnalités avancées du langage Go, comme les génériques et les interfaces. Elle s'inscrit aussi dans une démarche de Software Craft. Elle intègre des principes d'architecture et de conception logicielle comme SOLID et l'architecture hexagonale, d'un point de vue théorique mais aussi pratique, pour produire un code plus modulaire, maintenable et robuste. La formation inclut également une exploration approfondie des outils et techniques de gestion de la concurrence en Go, permettant aux participants de concevoir des applications hautement performantes et capables de tirer parti des capacités multi-cœurs des systèmes modernes. Grâce à une approche pratique et des exemples concrets, les apprenants seront en mesure de maîtriser les bases et les patterns avancés de concurrence en Go, tout en intégrant une démarche de qualité logicielle dans leurs projets. Matin – Fonctionnalités avancées et structuration de projets Génériques en Go Contraintes de type et écriture d'une première fonction générique Identification des cas d'usage pertinents Interfaces Mise en application et utilisation dans les tests unitaires Composition d'interfaces pour un code modulaire Software Craft Principes clés et introduction à SOLID Après-midi – Concurrence et patterns avancés Concurrence en Go Différence entre concurrence et parallélisme Premiers pas avec goroutine , channel et sync.WaitGroup Package sync et primitives de synchronisation Mutex, gestion des accès concurrents et race detector Channels Bufferisés et non-bufferisés, opérations, signaux et instruction select Patterns de concurrence Scatter/gather, redundant requests, hedged requests Sémaphores simples et pondérées

Go, également connu sous le nom de Golang, est un langage de programmation moderne conçu par Google, reconnu pour sa simplicité, sa performance et sa capacité à gérer efficacement les systèmes distribués et les applications cloud. Adopté par de nombreuses entreprises pour sa robustesse et sa scalabilité, il est idéal pour construire des applications fiables et maintenables. Cette formation propose une approche théorique et pratique pour comprendre la gestion des tests, l'utilisation des logs et le traitement des erreurs dans les projets développés en Go. Les participants et participantes découvriront comment concevoir des tests robustes et évolutifs, implémenter des stratégies de logging efficaces pour le suivi et le débogage, et appliquer les meilleures pratiques pour gérer les erreurs conformément aux standards du langage. Cette formation inclut également une introduction aux bonnes pratiques en matière de sécurité, pour protéger les applications contre les vulnérabilités courantes, ainsi qu'à l'analyse des performances, pour optimiser le comportement des applications. Ces compétences permettent d'améliorer significativement la qualité et la fiabilité des applications. Matin – Gestion des tests en Go Comprendre la pyramide des tests : unitaires, intégration, end-to-end Écrire des tests unitaires avec le package testing : Principes F.I.R.S.T. et pattern AAA Table-driven tests et parallélisation Mesure de la couverture de tests Créer des doublures de tests (mocks HTTP et SQL) Introduction à la librairie de tests testify Mettre en place des tests d'intégration : Utilisation des build tags Introduction à testcontainers pour gérer les dépendances externes Après-midi – Gestion des erreurs, logs et performances Traitement des erreurs Comprendre le type error : erreurs basiques, erreurs sentinelles, interface error Enrichir les erreurs avec l' error wrapping Gérer les panic avec defer et recover Gestion des logs Mettre en place des logs structurés avec log/slog Propager un logger via context.Context et gérer les informations dynamiques Tests de performance Découvrir le benchmark testing Écrire ses premiers benchmarks pour mesurer les performances de fonctions critiques

Cette formation se concentre sur la gestion des workflows complexes dans les applications distribuées en Go. Les participants exploreront les concepts théoriques clés comme les transactions ACID, les patterns SAGA et les modèles d'orchestration et de chorégraphie, qui sont essentiels pour la gestion des processus métiers transactionnels et interconnectés. Après une première approche from scratch pour comprendre les concepts, l'accent sera mis sur les outils modernes d'orchestration tels que Camunda, uTask, Conductor et Temporal, qui permettent de simplifier et d'automatiser la gestion de workflows distribués. Le module propose un focus approfondi sur Temporal, une plateforme puissante permettant de gérer des workflows longs et complexes, avec une approche forte sur la fiabilité, la tolérance aux pannes et la gestion des états. À l'issue de cette formation, les participants auront une compréhension solide des bonnes pratiques d'orchestration et de chorégraphie, ainsi que des compétences pratiques pour implémenter et gérer des workflows à grande échelle dans des applications Go avec Temporal. Matin – Introduction aux workflows et à l'orchestration Comprendre les workflows Exemples concrets et principes ACID Introduction au pattern SAGA pour la gestion de la cohérence Chorégraphie et orchestration Présentation et mise en pratique d'une chorégraphie par événements Présentation et mise en pratique d'une orchestration centralisée Panorama des outils d'orchestration Différences entre orchestrateurs as-file et as-code Découverte de quelques outils : Camunda, Conductor, uTask, Temporal Après-midi – Focus sur Temporal Concepts clés de Temporal : workflows, activities, workers, historique Installation et prise en main de l'outil Notion de déterminisme et impact sur le code Gestion des erreurs et stratégies de reprise (retries, timeouts) Écriture de workflows complexes : signaux, timers, Intercepteurs, parallélisme et child workflows

Le Domain Driven Design (DDD) permet de modéliser efficacement les besoins métier afin de mieux gérer la complexité des logiciels. Traditionnellement associé à la Programmation Orientée Objet, les patterns tactiques du DDD peuvent toutefois être adaptées pour utiliser cette approche avec la Programmation Fonctionnelle. La Programmation Fonctionnelle est un paradigme qui favorise des techniques comme l'immutabilité, les fonctions pures et la composition fonctionnelle pour créer un code plus prévisible et maintenable. Le langage TypeScript est à cheval entre les approches objets et fonctionnelles, et présente des particularités qui peuvent rendre difficile l'adoption du DDD selon l'un de ces deux paradigmes. Cette formation vous propose de découvrir des approches adaptées spécifiquement à TypeScript qui intègrent les avantages de la programmation fonctionnelle avec la structuration de données sous forme d'objets dans un cadre DDD. Vous apprendrez comment implémenter des modèles métier efficacement et en restant pragmatique sur l'utilisation du paradigme fonctionnel pour créer des logiciels robustes et maintenables.

Cette formation d'initiation permet d'acquérir les bases de l'algorithmie à travers le langage Go. Les participants découvrent les fondamentaux de la programmation (types, variables, structures de contrôle, fonctions) puis mettent en pratique ces connaissances en implémentant des algorithmes classiques de tri et de recherche. La formation adopte une approche résolument pratique avec 2/3 du temps consacré aux exercices. Jour 1 - Matin 1. Découverte du langage Go Historique et philosophie du langage Installation de l'environnement et commandes de base ( go run , go build ) Exercice : vérifier l'installation et exécuter un premier programme 2. Premiers pas Types de base : bool , int , float64 , string , rune Opérations (booléennes, arithmétiques, comparaison) et déclaration de variables Exercices : manipuler les types de base, créer et utiliser des variables 3. Structures de contrôle Conditions ( if , else , switch ), boucles ( for , range ), break et continue Exercice : déterminer si un nombre est premier 4. Structures de données Slices : création, accès, modification et opérations courantes Maps : paires clé-valeur, accès, suppression et itération Pointeurs et structs Exercices : comparer deux slices, compter des occurrences avec les maps Jour 1 - Après-midi 5. Fonctions et packages Déclaration, paramètres, valeurs de retour et récursivité Organisation du code en packages et bibliothèque standard ( fmt , math , strings , os ) Exercice : déclarer et appeler des fonctions 6. Algorithmes de tri et de recherche Tri par sélection et tri à bulles : principe et implémentation Recherche linéaire et recherche binaire : principe et implémentation Exercices : implémenter chaque algorithme en Go Jour 2 - Matin 7. Tests unitaires Package testing : conventions, écriture et exécution de tests ( go test ) Exercice : écrire les tests pour valider les algorithmes développés