Catalogue Formations Mai 2018 - SOAT · omprendre et définir le périmètre d’action du Scrum2aster Comprendre la différence de positionnement du ScrumMaster par rapport au Chef

Cabinet de conseil IT et agilité

Société d’expertise et de conseil en informatique |

Catalogue Formations

Mai 2018

2 Cabinet de conseil IT et agilité

Notre catalogue Nos formations Agile ......................................................................................................................................................... 6

Agilité - Fondamentaux ........................................................................................................................................................ 6

Scrum - Les fondamentaux de la méthode Scrum pour l’appliquer à vos projets .......... 6

Méthodes Agiles : les fondamentaux .................................................................................................................... 7

Lean- Comprendre l'approche Lean pour passer de l'efficacité à l'efficience ................... 8

Kanban ............................................................................................................................................................................................ 9

Devenir Manager Agile - Initiation .......................................................................................................................... 10

Agilité - Avancé.......................................................................................................................................................................... 12

Scrum Master .......................................................................................................................................................................... 12

Scrum Master Avancé ...................................................................................................................................................... 13

Devenir Coach Agile .......................................................................................................................................................... 14

Agile Games ............................................................................................................................................................................. 16

Amélioration continue ...................................................................................................................................................... 18

Agilité - Organisation ............................................................................................................................................................ 21

Management 3.0 / Certifiante ................................................................................................................................... 21

Agilité à l’échelle ................................................................................................................................................................... 23

Agilité - Culture Produit ..................................................................................................................................................... 25

Product Owner ....................................................................................................................................................................... 25

Product Owner Avancé .................................................................................................................................................. 26

Lean Startup ............................................................................................................................................................................. 27

Agilité - Préparation aux certifications ................................................................................................................ 29

Préparation certification Product Owner PSPO™I ..................................................................................... 29

Préparation certification Scrum Master PSM™ I ......................................................................................... 30

Agilité - Soft skills .................................................................................................................................................................... 31

Ennéagramme ........................................................................................................................................................................ 31

Nos formations Architecture .................................................................................................................................... 33

Architecture - Formations ................................................................................................................................................ 33

Conception d’API .................................................................................................................................................................. 33

Initiation Domain Driven Design ...............................................................................................................................34

Reactive Architecture avec Kotlin ......................................................................................................................... 36

CQRS et Event Sourcing ................................................................................................................................................ 39

Architecture – Masterclass ............................................................................................................................................ 40

Masterclass Reactive Architecture ....................................................................................................................... 40

Masterclass DDD ................................................................................................................................................................. 40


Nos formations Big Data .............................................................................................................................................. 42

Big Data - Formations .......................................................................................................................................................... 42

Introduction au NoSQL .................................................................................................................................................... 42

Elasticsearch ............................................................................................................................................................................43

MongoDB ................................................................................................................................................................................... 46

Redis .............................................................................................................................................................................................. 48

Introduction à Cassandra .............................................................................................................................................. 50

Big Data – Masterclass ........................................................................................................................................................ 52

MasterClass introduction à MongoDB et Cassandra .............................................................................. 52

Nos formations Cloud .....................................................................................................................................................53

Microservices avec Service Fabric .........................................................................................................................53

Introduction à Microsoft Azure ................................................................................................................................. 55

Nos formations Craftsmanship...............................................................................................................................57

Craftsmanship - Java ............................................................................................................................................................57

Refactoring Legacy code Java..................................................................................................................................57

Craftsmanship : Clean code Java ........................................................................................................................... 58

BDD en environnement Java ..................................................................................................................................... 59

TDD Java .................................................................................................................................................................................... 60

Craftsmanship .NET .............................................................................................................................................................. 62

Refactoring Legacy code .NET ................................................................................................................................ 62

Craftsmanship : Clean code C# ............................................................................................................................... 62

BDD en environnement .NET ..................................................................................................................................... 64

TDD C# ........................................................................................................................................................................................ 65

Nos formations Devops ................................................................................................................................................ 67

Devops - Méthodes & Pratiques ................................................................................................................................ 67

Usine logicielle et intégration continue ............................................................................................................ 67

Devops - Gestion de sources ........................................................................................................................................ 70

GIT .................................................................................................................................................................................................... 70

Devops - Tests ............................................................................................................................................................................ 72

Selenium...................................................................................................................................................................................... 72

Devops - Infrastructures....................................................................................................................................................74

Docker ...........................................................................................................................................................................................74

Ansible...........................................................................................................................................................................................75

Devops - MasterClass .......................................................................................................................................................... 77


MasterClass Docker ........................................................................................................................................................... 77

Nos formations Java ....................................................................................................................................................... 79

Java - Architecture et développement ............................................................................................................... 79

Séminaire Microservices ............................................................................................................................................... 79

GIT .................................................................................................................................................................................................... 79

Conception d’API ................................................................................................................................................................. 79

Java 8 : lambdas, streams et collectors ............................................................................................................ 79

Architecture Découplée avec RxJava ................................................................................................................. 81

Spring ............................................................................................................................................................................................ 83

Initiation Domain Driven Design .............................................................................................................................. 84

Kotlin .............................................................................................................................................................................................. 84

Introduction à Cassandra .............................................................................................................................................. 86

Java - Industrialisation des développements ............................................................................................... 87

Craftsmanship : Clean code Java ........................................................................................................................... 87

BDD en environnement Java ..................................................................................................................................... 87

TDD Java .................................................................................................................................................................................... 87

Usine logicielle et intégration continue ............................................................................................................ 87

Selenium..................................................................................................................................................................................... 87

Nos formations Microsoft ........................................................................................................................................... 88

Microsoft - Architecture et développement .................................................................................................. 88

Séminaire Microservices ............................................................................................................................................... 88

GIT .................................................................................................................................................................................................... 88

Microsoft - Mobilité ............................................................................................................................................................... 89

Développement d'applications universelles pour windows............................................................ 89

Xamarin : Cycle complet ............................................................................................................................................... 90

Microsoft - Web ........................................................................................................................................................................ 93

ASP.NET MVC : les fondamentaux ........................................................................................................................ 93

ASP.NET MVC avancé ..................................................................................................................................................... 94

ASP.NET Web API ............................................................................................................................................................... 96

Evoluer vers ASP.NET Core et ASP.NET MVC Core ................................................................................ 97

Microsoft - Tests ................................................................................................................................................................... 100

Craftsmanship : Clean code C# ............................................................................................................................ 100

BDD en environnement .NET .................................................................................................................................. 100

TDD C# ..................................................................................................................................................................................... 100

Microsoft - Cloud ................................................................................................................................................................... 101


Introduction à Microsoft Azure ............................................................................................................................... 101

Microservices avec Service Fabric ...................................................................................................................... 101

Nos formations Mobile ................................................................................................................................................ 102

Reactive Architecture avec Kotlin ....................................................................................................................... 102

Kotlin ............................................................................................................................................................................................ 102

Développement d'applications universelles pour windows.......................................................... 102

Développer une application iPhone avec Swift ....................................................................................... 102

Xamarin : Cycle complet ............................................................................................................................................. 103

Nos formations Web ..................................................................................................................................................... 104

Web - Javascript .................................................................................................................................................................... 104

React ............................................................................................................................................................................................ 104

Angular 4 / 5 ......................................................................................................................................................................... 105

Node JS ..................................................................................................................................................................................... 107

Web - Microsoft ...................................................................................................................................................................... 110

ASP.NET MVC : les fondamentaux ...................................................................................................................... 110

ASP.NET MVC avancé ................................................................................................................................................... 110

ASP.NET Web API ............................................................................................................................................................. 110

Evoluer vers ASP.NET Core et ASP.NET MVC Core .............................................................................. 110

Web - Industrialisation & Tests ................................................................................................................................. 111

Selenium.................................................................................................................................................................................... 111

Web – MasterClass............................................................................................................................................................... 112

MasterClass Front .............................................................................................................................................................. 112


Nos formations Agile Agilité - Fondamentaux

Scrum - Les fondamentaux de la méthode Scrum pour l’appliquer à vos projets

Durée 2 jours Objectifs Comprendre et appliquer Scrum afin d’acquérir les connaissances de base pour pouvoir débuter un projet Agile Public Développeur, Analyste, Chef de projet, Dirigeant Pré-requis Aucun Méthodes pédagogiques 40% de pratique et 60% de théorie Description La gestion de projet agile propose une alternative crédible aux méthodes traditionnelles et les nombreuses entreprises qui ont déjà fait le choix de l’agilité ont pu constater des améliorations significatives de leur performance en gestion de projets. La méthode SCRUM est à ce jour la plus utilisée des méthodes agiles. Réputée comme la plus simple à mettre en œuvre, elle définit un cadre précis d’organisation du projet qui doit être appliqué avec discipline mais qui se prête parfaitement à une adaptation au contexte métier de chaque entreprise. Programme Les origines des méthodes Agiles

Les limites actuelles Pourquoi les méthodes Agiles L’Agilité, définition

Présentation de Scrum SCRUM, définition Les rôles SCRUM

Pratiquer Scrum La planification Le recueil de besoin : les User Stories L’estimation

1


Mettre en place les Sprints Prioriser le backlog Estimer la vélocité Le sprint planning Les indicateurs

Les cérémonies Scrum Le Daily Stand up Meeting (DSM) La rétrospective La démonstration

Pour aller plus loin Le Scrum de Scrum Les outils

Méthodes Agiles : les fondamentaux

Durée 1 jour Objectifs Comprendre la philosophie agile, les bénéfices de sa mise en place et les avantages d’une politique d’amélioration continue. Public Chef de projet, Analyse, Développeurs, Architectes, Dirigeants. Pré-requis Aucun Méthodes pédagogiques 25% de pratique et 75% de théorie Description La gestion de projet agile propose une alternative aux méthodes traditionnelles et de nombreuses entreprises qui ont déjà fait le choix de l’agilité ont pu constater des améliorations significatives de leur performance en gestion de projets. Les méthodes existantes comme Scrum, Kanban, extrem Programming ou Lean se trouvent être radicalement différentes d’une approche dite « traditionnelle ». A travers cette formation synthétique, vous découvrirez la philosophie Agile, centrée sur la qualité et sur l’humain, préconisant des livraisons rapides tout en priorisant les fonctionnalités à forte valeur ajoutée. En exposant les différentes méthodes et en mettant l’accent sur une présentation des méthodes Scrum et Kanban, vous appréhenderez les impacts de l'agilité sur l'organisation des entreprises ainsi que les différentes possibilités de contractualiser le développement d'un projet agile. Programme Les origines des méthodes Agile

Les limites actuelles La réponse agile


Présentation des méthodes Agiles Définition de l’agilité Le Manifeste Agile : Valeurs et Principes Les bonnes pratiques Agiles

Exemples de Méthodes Agiles Focus sur la méthodologie Scrum Focus sur la méthodologie Kanban L’amélioration continue

Lean- Comprendre l'approche Lean pour passer de l'efficacité à l'efficience

Durée 2 jours Objectifs Découvrir les origines du Lean et les principes Lean Adapter les principes Lean au contexte IT. Construire une démarche d’amélioration continue. Comprendre l’intérêt et les bénéfices d’une Démarche Lean globale en entreprise Public Managers, responsables de service, chefs de projet, responsables qualité, responsables méthodes Pré-requis Aucun Méthodes pédagogiques 50% de théorie / 50% retours d’expérience Description Le Lean est une méthode de management visant à l’excellence opérationnelle. Elle promeut les valeurs de l’amélioration continue, de l’efficacité des processus de production, ces mêmes processus à l’origine de la satisfaction des clients de l’entreprise. Cette forme de management passe notamment par la prise de conscience des gains que l’on pourrait espérer par suppression du gaspillage. Le Lean se pratique sur le terrain afin que toutes les équipes concernées trouvent un consensus sur la vraie nature des problèmes d’efficacité à résoudre. Cet engagement collectif qui s’articule autour de la recherche de l’efficacité induit un changement des comportements au quotidien. Le rôle du management pour cette méthode est finalement de soutenir cet effort afin que l’entreprise puisse partager son sens de la qualité offerte au client. Programme INTRODUCTION

L’histoire du Lean Les principes majeurs du « Lean Thinking » Première présentation du Lean Software Development


LES PRINCIPES DU LEAN SOFTWARE DEVELOPMENT Éliminer les gaspillages Construire la qualité intrinsèque Favoriser la connaissance Livrer rapidement Retarder la décision Respecter les personnes Optimiser le système dans son ensemble Retours d’expérience

MISE EN ŒUVRE DES PRINCIPES DU LEAN Réduire le travail partiellement fait Réduire l’excès de fonctionnalités Réduire les problèmes de transmission d’information, d’attentes ou de retard Préserver la capacité de réaction de l’équipe Le feedback permanent Viser la qualité : tests, TDD, TDR, intégration continue Les bonnes pratiques pour la qualité du code : Refactoring, Pair Programming

LES MESURES DU LEAN Le Lean et la vision du produit, la valeur du produit et sa livraison rapide Mesure du temps de cycle Mesure du ROI Mesure de la satisfaction client

LE LEAN ET LES AUTRES MÉTHODES Lean et CCMI Lean et Six-sigma Lean et Agilité

Kanban

Durée 1 jour Objectifs Comprendre Kanban et savoir le mettre en place dans un contexte projet Public Chefs de projet, Analystes, Développeurs, Architectes, Dirigeants. Pré-requis Aucun. Méthodes pédagogiques 60% de théorie / 40% de pratique. Description La gestion de projet agile propose une alternative crédible aux méthodes traditionnelles et de nombreuses entreprises qui ont déjà fait le choix de l’agilité ont pu constater des améliorations significatives de leur performance en gestion de projets. Les


problématiques des entreprises étant à chaque fois spécifiques, de nombreuses méthodologies existent pour répondre à ces contextes variés. La méthodologie Kanban, développée au début des années 2000 par David Anderson, se propose d’apporter une vue en flux de travail, c’est à dire de considérer, et de gérer, l’ensemble des étapes permettant à une tache unitaire de passer de l’état de demande à la mise en production. De cette manière, Kanban vise à fluidifier le parcours de ce flux de valeur, augmenter la qualité de la production et offrir de la prédictibilité sur le délai de réalisation des taches. Mêlant théorie et mise en pratique, cette formation vous donnera les clés pour comprendre la méthodologie Kanban et la mettre en application dans votre organisation. Programme Limites des approches classiques

Les limites des approches traditionnelles La réponse agile

Présentation de la méthode La méthode Kanban Le flux de valeur

Les 6 principes du Kanban Visualiser la chaine de valeur Limiter le travail en cours Gérer le flux Rendre les process explicites Boucles de feedback Améliorer le process

Les métriques Kanban Cumulative Flow Diagram Control Chart

Pour aller plus loin Swimlanes Les classes de service Service Level Agreement Mise en pratique

Devenir Manager Agile - Initiation

Durée 1 jour Objectifs Découvrir les bases de l'Agilité Appréhender les évolutions managériales qu'elles impliquent Public Chef de projet, Manager, Dirigeant


Pré-requis Aucun Méthodes pédagogiques 50% de pratique et 50% de théorie Description La promesse de l’Agilité est de livrer au plus tôt le produit ayant le plus de valeur possible pour nos clients et utilisateurs. Mais avec ses équipes auto-organisées, son rythme de travail radicalement différent et ses nouveaux KPIs, il est parfois difficile pour un manager de trouver sa place. Son rôle reste néanmoins primordial pour permettre aux méthodes Agiles de donner leur plein potentiel. Facilitateur, leader, agent d’innovation… Les postures qu’il sera amené à prendre seront variées et lui permettront de rester au cœur de la production de valeur. Programme Les méthodes Agiles · Pourquoi les méthodes Agiles · Les contraintes · Les bénéfices Les postures du manager · Facilitateur · Leader · Agent d’innovation Piloter un projet Agile · La culture produit · Le pilotage par la valeur · Les KPIs


Agilité - Avancé

Scrum Master

Durée 2 jours Objectifs

Comprendre et définir le périmètre d’action du ScrumMaster Comprendre la différence de positionnement du ScrumMaster par rapport au

Chef de projet Avoir les outils pour appliquer le rôle de ScrumMaster

Public Chefs de projet, ScrumMasters Pré-requis Connaissances et/ou pratique de Scrum Méthodes pédagogiques 25 % de pratique / 75 % de théorie Description A la différence de la gestion de projet traditionnelle, Scrum amène une vision radicalement différente d’un projet informatique et de son organisation. Plutôt que de planifier, contrôler et diriger, le rôle du ScrumMaster sera plutôt d’accompagner et de faciliter le travail de l’équipe. Il a pour responsabilité, dans le cadre du développement d’un produit, d’aider l’équipe à travailler de façon autonome et à s’améliorer continuellement. Cette formation a pour but d’aider les chefs de projets à appréhender ce nouveau rôle et à s’approprier la nouvelle posture de Scrum Master en ayant toutes les clés pour réussir cette transition. Programme LE RÔLE DU CHEF DE PROJET

Qu’est-ce qu’un projet ? Retour sur le rôle de chef de projet

LE RÔLE DE SCRUM MASTER Qu’est-ce qu’un produit ? Retour sur le rôle du ScrumMaster

LES PRINCIPAUX CHANGEMENTS Estimation Planification Engagement Suivi Cadre de travail

1


LES ÉCUEILS À ÉVITER SM Novice SM Directif SM Micro manageur SM Débordé SM en dehors de l’équipe SM pointilleux Quizz sur la posture du Scrum Master et du Chef de projet

LES OUTILS DU SCRUM MASTER Pourquoi avoir des outils spécifiques Management Visuel Outils Logiciels

Scrum Master Avancé

Durée 4 jours non consécutifs sur 4 mois Objectifs Identifier et Partager les bonnes pratiques de ScrumMaster à appliquer au jour le jour Approfondir les compétences à maîtriser en tant que ScrumMaster Apprendre des outils pratiques à utiliser avec son équipe Public ScrumMaster Pré-requis Avoir une expérience récente en tant que ScrumMaster Méthodes pédagogiques 75% de pratique et 25% de théorie Description Le Scrum Master occupe un rôle clé dans un projet Scrum et il n’est pas toujours facile de trouver la meilleure façon de l’appliquer dans le contexte de nos projets. Cette formation permet de rappeler le rôle du Scrum Master et d’identifier les dérives à éviter. C’est une occasion idéale pour échanger sur des bonnes pratiques entre Scrum Master de différentes équipes et différentes entreprises. Le format de cette formation (une première journée, puis une journée tous les mois) permet également aux participants de se fixer des objectifs réalistes à mettre en place sur les projets et à re partager ensuite avec le groupe et le formateur pour améliorer petit à petit l’application concrète de Scrum et des principes Agile dans les projets. Programme JOURNEE 1

Le rôle de Scrumaster

Rappel du rôle de ScrumMaster


Les contraintes du ScrumMaster

Les dérives à éviter

Les dérives du ScrumMaster L’animation des cérémonies Les dérives de Scrum

Echanges et définition d’objectifs

Identification d’objectifs réaliste pour la prochaine session

JOURNEE 2-3-4

Présentation d’un thème Agile

Approfondissement d’un thème o Amélioration continue o Agile Games o Culture produit et Product Owner

Problématiques concrètes rencontrées sur les projets

Identification des points à partager Ateliers collectifs Approfondissement d’un sujet utile pour le groupe

Revue des objectifs

Partage sur les objectifs fixés précédemment Nouveaux objectifs

Devenir Coach Agile

Durée 2 jours Objectifs Comprendre le rôle de coach Agile Connaître les principaux outils du coach Agile Identifier les risques du coaching Disposer d’une bibliographie pour approfondir les notions et connaissances abordées Public Scrum Master expérimenté, Product Owner expérimenté, Manager Agile expérimenté. Pré-requis Connaissance approfondie des méthodes Agiles. Expérience de projets Agiles.


Méthodes pédagogiques 60% de théorie / 40% de pratique Description Dans de nombreuses entreprises, le passage aux méthodes Agiles constitue souvent une rupture profonde de l’organisation et des méthodes de travail en place. Le coach Agile a alors pour vocation de faciliter l’adoption de ces nouvelles méthodes. Son rôle multi-compétences est parfois mal connu/compris. Son intervention nécessite à la fois une bonne maitrise des méthodes agiles et des techniques de coaching d’équipes. Mal préparée, l’intervention peut être mal vécue à la fois par l’équipe ou l’entreprise accompagnée, mais aussi par le coach lui-même et les conséquences peuvent être très importantes. L’objectif de cette formation est principalement de présenter le rôle du coach Agile et les outils à sa disposition. Egalement, nous présenterons une bibliographie fournie afin d’approfondir les notions traitées et aborderons les risques et dérives possibles. Programme JOUR 1 Définition du coaching

In and Out Compétences et savoir-être Mandat et périmètre

La posture du coach Posture haute / Posture basse Spécificité de la posture de coach

Grilles de lecture psychologique Triangle de Karpman Position de vie MBTI Process Com Analyse transactionnelle

Les outils du coach Questiologie Ecoute Management visuel PNL Solution Focus et thérapie brève Management 3.0

JOUR 2 Démarche de coaching Agile

Audit Formation Accompagnement et Mentoring

Facilitation Règles de facilitation Cadre sécurisée et bienveillance


Facilitation graphique

Relations dégradées et gestion de conflit Traiter les objections Réagir à l’agressivité Gérer le conflit

Risques du coaching Sécuriser l’intervention Dérives de la posture de coach Styles de coaching

Supervision et déontologie Supervision et pair coaching Coach retreat Perfection Game & Feedback

Bibliographie

Partage d’expérience

Agile Games

Durée 2 jours Objectifs Découvrir et maîtriser un panel de serious games à utiliser dans vos missions agiles, pour répondre de manière ludique à toutes vos problématiques. Public Développeurs, Analystes, Chefs de projet, Dirigeants, Scrum Masters, Product Owners, Coachs Agile. Pré-requis Avoir un début de pratique des méthodes agiles sur des projets. Méthodes pédagogiques 20% de théorie / 80% de pratique. Description Les serious games (ou jeux sérieux) sont reconnus pour leur efficacité en contexte projet par leur approche ludique des problématiques professionnelles. En parfait accord avec la philosophie Agile, les serious games occupent une place incontournable dans la construction d’un projet Agile, que l’on nommera alors Agile Games. Que ce soit pour construire, démarrer, découper un projet, pour partager des bonnes pratiques ou simplement animer une cérémonie Agile, une large panoplie d’Agile Games existe, que nous vous proposons de découvrir et d’appliquer au cours de cette formation.


Le + SOAT : Vous serez amenés à choisir, parmi une trentaine d’Agile Games, ceux que vous souhaitez découvrir et pratiquer pendant ces deux jours. Vous serez ainsi capables de proposer le jeu adéquat face à chaque problématique rencontrée dans votre cycle de vie projet. Programme Présentation des Agiles Games

Introduction sur les Agile Games

Sélection des jeux Sélection des jeux de la journée Création des groupes de joueurs

Mise en pratique des jeux Pour chaque jeu retenu

o Pratique du jeu o Rétrospective

Jeu commun avec tout le groupe Présentation du jeu Pratique d’un jeu géant avec tous les participants

Sélection des jeux Sélection des jeux de l’après midi Création des groupes de joueurs

Mise en pratique des jeux Pour chaque jeu retenu

o Pratique du jeu o Rétrospective

Comment animer les Agile Games Comment animer vos Agile Games ? Rétrospective sur la formation

QUELQUES EXEMPLES DE JEUX AGILES AU CHOIX DES PARTICIPANTS

Kanbanzine Thèmes : Kanban, flux tirés, classes de service

Business Value Game Thèmes : Développement itératif, priorisation, valeur métier

Color game Thèmes : Points de complexité, estimation relative, engagement

Nasa game Thèmes :Intelligence collective, priorisation, estimation relative

Lego 4 Scrum Thèmes : Scrum dans son ensemble (différents aspects de l méthodologie)


Multitasking game Thèmes : Coût du multitasking

Backlog in the eye of the beholder Thèmes : Priorisation, vision

Dessinez c'est gagner Thèmes : Auto-gestion, micro-management, relation au client

The marshmallow challenge Thèmes : Design collectif, travail itératif

Kaizen game Thèmes : Amélioration continue dans l'équipe et entre les différentes équipes

Amélioration continue

Durée 1 jour Objectifs

Comprendre les objectifs de l’amélioration continue Détecter les meilleures possibilités d’amélioration de son processus Mettre en place une politique d’amélioration continue à l’échelle d’un projet ou

d’un service

Public Managers, responsables de service, chefs de projet, responsables qualité, responsables méthodes. Pré-requis Aucun. Méthodes pédagogiques 60% de théorie et 40% de pratique. Description Théorisé pour la première fois dans les années 50 au sein de Toyota sous le nom de Kaizen, l’Amélioration Continue est au cœur des Méthodologies Agiles. Le principe sous-jacent est simple : il y a toujours un moyen d’améliorer un processus, quel qu’il soit. Cette formation a pour but de vous donner les clés nécessaires à la mise en place d’une structure d’amélioration continue au sein de votre organisation. Nous étudierons ainsi les possibilités d’amélioration au sein d’une équipe, le partage de bonnes pratiques entre les équipes, les techniques permettant de susciter l’innovation et l’émergence de nouvelles idées ainsi que celles aidant à la résolution des problèmes. Nous conclurons par la présentation de la théorie des contraintes qui vise à détecter les points les plus profitables où appliquer les améliorations. Programme Introduction


Origine du Kaizen Pourquoi mettre en place de l’amélioration continue

L’amélioration au sein des équipes Les différents formats de rétrospective Comment animer les rétrospectives Prioriser les améliorations Techniques de problem solving Mise en pratique : le Kaizen Game

L’amélioration entre les équipes Mise en place de rétrospectives croisées Communautés d’intérêt

Détecter les opportunités La théorie des contraintes Mise en pratique de la théorie des contraintes Les Innovation Games Mise en pratique des Innovation Games

Politique de montée en compétence Pourquoi faire monter les collaborateurs en compétence Skill matrix & wish matrix Partage de connaissance : formation, pair programming et mentoring

Devenir Manager Agile – Perfectionnement

Durée 4 jours non consécutifs sur 4 mois Objectifs Apporter aux managers de nouvelles postures, de nouvelles clés de compréhension du monde et de nouvelles pratiques pour leur permettre d’encadrer efficacement leurs équipes. Public Manager, Chef de projet, Dirigeant Pré-requis Avoir une expérience récente de Manager dans un contexte Agile Avoir la capacité d’appliquer les acquis en condition réelles sur la période de formation Méthodes pédagogiques 50% de pratique, 50% de théorie Description Face à un monde de plus en plus complexe, l’Agilité doit de plus en plus s’inscrire au coeur de la stratégie des entreprises. Or cette mutation implique un changement à tous


les niveaux : structurel, culturel, humain. Elle exige des managers une profonde évolution. L'objectif de cette formation est de leur apporter de nouvelles postures, de nouvelles clés de compréhension du monde et de nouvelles pratiques pour leur permettre d’encadrer efficacement leurs équipes. Le format de cette formation (une première journée, puis une journée tous les mois) permet également aux participants de se fixer des objectifs réalistes à mettre en place sur les projets et à re partager ensuite avec le groupe et le formateur pour améliorer petit à petit l’application concrète des principes Agile dans les projets Programme Jour 1 : Donner les clés de compréhension

Agilité et Évolution du management Pensée complexe et pensée systémique

Évoluer de posture Expérimenter une nouvelle posture avec le solution focus brief therapy

Jour 2 Créer une culture de l’apprentissage

Célébrer les apprentissages avec la Celebration Grid Piloter l’apprentissage avec les OKR, Travailler sur la motivation intrinsèque pour booster les collaborateurs avec

l’atelier Moving Motivator et Ikigai Forger une culture en travaillant sur les valeurs et l’identité du groupe Aligner les collaborateurs sur une vision

Jour 3 Comment développer une structure organisationnelle performante

Déléguer pour responsabiliser les collaborateurs avec l’atelier Delegation Poker Expérimenter l'échelle du leadership pour créer des leaders à tous les niveaux Découvrir les patterns organisationnels des entreprises libérées Comprendre les enjeux de l’Agile@scale

Jour 4 Comment embarquer tous ses collaborateurs

Change management : inviter tout le monde au changement avec l’open space Agility

Équilibrer la structure organisationnelle, entre hiérarchie et réseau Culture de l’apprentissage et du feedback


Agilité - Organisation

Management 3.0 / Certifiante

Durée 2 jours Objectifs Comprendre le Management 3.0 et l’Agilité Savoir responsabiliser les Equipes et les auto-organiser Savoir motiver les Personnes et développer leurs Compétences Savoir gérer les changements et accompagner la croissance des Structures Public Direction générale, Directeur de projet/pôle, Manager, Responsable de produit, Chef de projet, Ressources Humaines, Coach Agile, ScrumMaster, Product Owner. Pré-requis Aucune expérience pratique des méthodes agiles n’est nécessaire. Il peut cependant être utile de connaître les principes et pratiques Agiles. Méthodes pédagogiques 50% Théorie / 50% Pratique. A la fin de chaque chapitre, au minimum un atelier permettant de mettre en pratique les notions et concepts vus auparavant. Description Le management n'est pas inné. A l’instar d’une technologie, il doit évoluer afin de s'adapter au mieux à l'évolution des systèmes d'organisation et des mentalités. Dans un monde de plus en plus complexe, il est primordial de cultiver de nouvelles formes de management et de leadership pour dépasser les modes de gestion classiques devenus souvent des freins dans les entreprises. Ainsi, le Management 3.0 est un modèle de leadership agile développé par Jurgen Appelo à travers ses deux ouvrages "Management 3.0 Leading Agile Developers" et "Management 3.0 : workout". Cette formation s'adresse principalement aux managers et leaders souhaitant développer le potentiel de leurs équipes et organisations agiles, mais également à toute personne désirant trouver sa place dans les nouvelles formes d'organisations. A l'issue de la formation, chaque participant sera validé en vue de l'obtention du certificat de participation à la formation Management 3.0 Workout. Ce certificat signé par Jurgen Appelo et notre formateur certifié Management 3.0 sera envoyé par mail aux participants quelques semaines après la session. Programme Management et Leadership L’évolution du management Les enjeux du 21e siècle Introduction à Marty Leadership et management


Le manager-coach Atelier : TOP 3 CHALLENGES La Pensée complexe Les erreurs du management traditionnel Différence entre complexe et compliqué Les 8 principes pour gérér la complexité Atelier : création d'un système complexe Motivation des personnes Différence entre motivation extrinsèque et intrinsèque Les 10 désirs intrinsèques Comprendre ce qui est important pour les personnes de votre équipe Atelier : MOVING MOTIVATORS Responsabilisation et délégation Les fondamentaux de l’auto-organisation Exemples d’entreprises libérées Remplacer la hiérarchie par des échanges d'autorité Les 7 niveaux de délégation Atelier : DELEGATION POKER Changer sa posture de manager Le manager Coach Les interactions orientées solutions Atelier : Initiation au coaching bref Solution Focus Faire émerger une nouvelle culture Culture et valeurs Savoir créer le cadre pour permettre l’auto-organisation Values Days et culture books La culture, nourricière de comportements vertueux Atelier : BIG VALUE LIST Développer les compétences Développer les compétences nécessaires à l'équipe Les échelles de niveau de compétence Atelier : TEAM COMPETENCE MATRIX Enrichir les compétences individuelles Développer la communication dans une équipe Atelier : IMPROVE COMMUNICATION Développer l'entraide Créer des tensions créatives Agrandir la structure Agrandir une structure organisationnelle comme une fractale Différentes formes d’organisations agiles Trouver l'équilibre entre hiérarchie et réseau


Créer une structure avec des patterns organisationnels Atelier : MEDDLERS GAME Célébrer les succès et l'apprentissage L’apprentissage, élément stratégique de l'entreprise Droit à l'erreur et expérimentation Atelier CELEBRATION GRID

Agilité à l’échelle

Durée 2 jours Objectifs Découvrir les enjeux de l’Agilité à l’échelle Connaître les bonnes questions à se poser Comprendre les avantages et inconvénients des différents frameworks existants Public Manager, chef de projet, Product Owner, Product Manager… Pré-requis Connaissance basique des méthodes Agiles (Scrum, Kanban…) Méthodes pédagogiques 40% de pratique et 60% de théorie Description Les produits informatiques sont de plus en plus complexes, nécessitant le travail de plusieurs équipes. Les dépendances sont nombreuses au sein d’un SI et coordonner l’activité de plusieurs dizaines de personnes pour produire de la valeur rapidement peut s’avérer un challenge que la mise en place d’Agilité au sein des équipes de réalisations ne suffit pas à résoudre. L’Agilité à l’échelle a pour objectif d’organiser le travail d’un large groupe d’individus dans le but de maximiser la valeur produite au niveau d’une organisation. Pour l’appréhender, nous proposons une approche non dogmatique qui, plutôt que de défendre tel ou tel framework, va nous amener à prendre en compte le contexte d’application de notre Agilité à l’échelle en listant l’ensemble des points à envisager pour construire le cadre de travail le plus efficient pour votre contexte. Programme La culture produit

Enjeux et avantages d’une vision produit large Contraintes organisationnelles

Les grands principes de l’Agilité à l’échelle Les enjeux de l’Agilité à l’échelle Comprendre son contexte pour faire les bons choix Les questions à se poser


Organisation des équipes (Feature teams, Holacratie…) Analyse de différents Framework existants – Points forts, domaines d’applications, limites

SAFe LeSS Nexus DaD


Agilité - Culture Produit

Product Owner

Durée 2 jours Objectifs Comprendre et définir le périmètre du Product Owner au sein d’une équipe Scrum. Public Maîtrises d'ouvrage, responsables fonctionnels, chefs de projet, product owner. Pré-requis Connaissance ou pratique de Scrum. Méthodes pédagogiques 70% de pratique et 30 % de théorie. Description Rôle incontournable d’une organisation SCRUM, le Product Owner (PO) est un personnage aux activités multiples. Cette formation propose de comprendre et préciser le périmètre d’action d’un Product Owner. Vous y apprendrez à maitriser les concepts et outils inhérents à un projet Scrum, ainsi que les techniques qui permettent d'alimenter une équipe. Vous découvrirez comment gérer et prioriser le Product Backlog, planifier les versions et les sprints, calculer la valeur ajoutée des users stories, suivre l'avancement et interagir avec la ou les équipes. Programme Les rôles de Scrum

Retour sur méthodes Agiles & Scrum Organisation des rôles (en particulier celui du PO)

Lancer un projet Le cadrage d’un projet Le recueil des exigences La planification Mise en pratique des notions étudiées

Gérer le backlog L’écriture des user stories L’estimation La priorisation Mise en pratique des notions étudiées

Le rythme du Product Owner La recette et la validation Le suivi et les métriques


Mise en pratique des notions étudiées

Product Owner Avancé

Durée 4 jours non consécutifs sur 4 mois Objectifs

Identifier et partager les bonnes pratiques de Product Owner à appliquer au jour le jour

Acquérir et/ou approfondir les compétences à maîtriser en tant que Product Owner

Public Product Owner Pré-requis Avoir une expérience récente de Product Owner ou de Product Manager Avoir la capacité d’appliquer les acquis en condition réelles sur la période de formation Méthodes pédagogiques 70% de pratique et 30 % de théorie Description Le rôle de Product Owner (PO) est un rôle incontournable d’une organisation Scrum. La gestion de produit est une activité à plein temps et à multiples facettes : de l’émergence des besoins à la livraison d’un produit utile à ses utilisateurs. Cette formation se déroule sur une période étendu. L’objectif de l’espacement de ces journées est de permettre aux participants de se fixer des objectifs réalistes de mise en pratique sur leur contexte réel, pour ensuite pouvoir partager, avec le groupe et le formateur leur ressenti. Ce partage permet d’améliorer la montée en compétence en favorisant les échanges entre confrères. Autre particularité, cette formation est montée de façon modulaire, ce sont les participants qui pourront construire leur programme en fonction des éléments qu’ils souhaitent le plus approfondir. Programme Module 01 (obligatoire)

Présentation du format Alignement sur le rôle de Product Owner

Autres modules (au minimum 6 seront vus) Agilité à l'échelle Budget Cadrage Contractualisation agile


Culture produit

Gestion de roadmap Gestion des contraintes Idéation Leadership Lean Startup et entreprenariat Priorisation Systèmes d’organisation

Lean Startup


Découvrir la démarche Lean Startup Savoir l’appliquer Connaitre les pièges à éviter

Public Tout public Pré-requis Aucun. Méthodes pédagogiques 40% de pratique et 60% de théorie Description Cette formation a pour but de présenter l'origine et les concepts du Lean Startup qui ont permis à de nombreuses jeunes entreprises de prospérer. Les concepts de bases sont vus en détails et une mise en application sera proposée pour bien appréhender l’application concrète. Enfin nous présenterons rapidement des exemples de réussites de mise en place dans des cas pratiques concret d’entreprises existantes et nous verrons les pièges à éviter. Programme

Introduction au Lean Startup

Historique L'approche Lean Les données comme validation

Les principes du Lean Startup

Les entrepreneurs sont partout L’entreprenariat est du management


Valider son apprentissage Mesurer l’innovation Construit – Mesure – Apprend

Les concepts du Lean Startup

Le MVP Déploiement continue Test A/B Les métriques Le Pivot Fail Fast

Appliquer le Lean Startup

Construit – Mesure- Apprend Elevator Pitch Le Lean Canvas

Exemples de Startup

Les pièges à éviter ou à connaître


Agilité - Préparation aux certifications

Préparation certification Product Owner PSPO™I


Comprendre et définir le périmètre du Product Owner au sein d’une équipe Scrum

Préparation à la certification PSPO™ I

Public Maîtrises d'ouvrage, Responsables Fonctionnels, Chefs de Projet, Product Owners Pré-requis Connaissance ou pratique de Scrum Lire le « Scrum guide » en anglais (http://www.scrumguides.org/scrum-guide.html) Comprendre l’anglais Méthodes pédagogiques 50% de pratique et 50 % de théorie Description Cette formation a pour objectif de préparer au passage à la certification PSPO™ I. Le rôle de Product Owner (PO) est un rôle incontournable d’une organisation Scrum. Cette formation propose de comprendre et préciser son périmètre d’action et sa participation à la création d’un incrément logiciel au sein d’une équipe Scrum. Composée de cours théoriques, d’exercices pratiques et d’examens blancs elle se clôture par la mise à disposition d’un token permettant le passage en ligne de la certification PSPO™ I. Programme

Scrum et le rôle du PO

But, définition et valeurs Les rôles officiels et leurs responsabilités, notamment celui du PO Les cérémonies et leurs objectifs Les artéfacts et leur utilisation Ateliers de mise en pratique

Examens blancs (minimum 2)

Un 1er examen blanc le premier jour pour cibler les points à approfondir Un 2nd examen blanc le second jour pour préparer les derniers ajustements

Remise du token de passage de la certification PSPO™ I

http://www.scrumguides.org/scrum-guide.html


Préparation certification Scrum Master PSM™ I


Comprendre et définir le périmètre du Scrum Master au sein d’une équipe Scrum Préparation à la certification PSM™ I

Public Maîtrises d'œuvre, Leads dev, Chefs de Projet, Scrum Masters Pré-requis Connaissance ou pratique de Scrum Lire le « Scrum guide » en anglais (http://www.scrumguides.org/scrum-guide.html) Comprendre l’anglais Méthodes pédagogiques 50% de pratique et 50 % de théorie Description Cette formation a pour objectif de préparer au passage à la certification PSM™ I. Le rôle de Scrum Master (SM) est un rôle incontournable d’une organisation Scrum. Cette formation propose de comprendre, précise son périmètre d’action et sa participation à la création d’un incrément logiciel au sein d’une équipe Scrum. Composée de cours théoriques, d’exercices pratiques et d’examens blancs, elle se clôture par la mise à disposition d’un token permettant le passage en ligne de la certification PSM™ I Programme

Scrum et le rôle du SM

But, définition et valeurs Les rôles officiels et leurs responsabilités, notamment celui du SM Les cérémonies et leurs objectifs Les artéfacts et leur utilisation Ateliers de mise en pratique

Examens blancs (minimum 2)

Un 1er examen blanc le premier jour pour cibler les points à approfondir Un 2nd examen blanc le second jour pour préparer les derniers ajustements

Remise du token de passage de la certification PSM™ I

http://www.scrumguides.org/scrum-guide.html


Agilité - Soft skills

Ennéagramme

Durée 2 jours Objectifs Mieux se connaître et mieux appréhender sa relation aux autres en identifiant les mécanismes qui fondent sa personnalité ainsi que ceux de son entourage. Pré-requis Aucun Méthodes pédagogiques 50 % théorie / 50 % pratique Description Une grande difficulté de la communication vient de la conviction de parler la même langue que l'autre, de donner le même sens aux mots et de considérer les mêmes choses comme importantes. Et s'il en était autrement ? L'énneagramme est un modèle subtil et dynamique décrivant 9 grands profils de personnalité. Il se distingue par le fait qu'il s'intéresse avant tout aux motivations des personnes plus qu'à leurs comportements visibles tout en respectant la richesse et l'unicité de chacun. Ainsi, découvrir ces 9 manières de voir le monde, c'est comprendre en quoi nous sommes semblables et en quoi nous sommes différents. C'est apprendre à identifier ce qui est important pour nous, ce qui est important pour l'autre et communiquer de manière plus épanouie sans se soucier de savoir qui a raison." Programme

JOUR 1 : MIEUX SE CONNAITRE

Approfondir sa connaissance de soi

· Identifier les particularités de son caractère : points forts, points faibles

· Reconnaître ses attitudes positives et limitantes dans la relation à l’autre

· Identifier ses sources d’irritation, ses zones de stress

· Étudier la manière dont les autres nous perçoivent

Appréhender la notion de personnalité

· Découvrir différentes manières d’appréhender le monde

· Comprendre la structure d’une personnalité


· Découvrir les 3 centres d’intelligence : définition, caractéristiques, hiérarchie

JOUR 2 : MIEUX COMPRENDRE LES AUTRES

Découvrir l'ennéagramme

· Découvrir l’Ennéagramme : définition, utilisation, éthique

· Découvrir les 9 profils de personnalité : mots-clés, thèmes, attitude générale, don naturel, points d’attention, modes de communication

· Intégration et désintégration de la personnalité

· Identifier son profil dominant et les axes de progression


Nos formations Architecture Architecture - Formations

Conception d’API


Appréhender l’intérêt d'ouvrir son système d'information sous forme d'APIs Élaborer des stratégies pour la conception et la mise en œuvre d’APIs Connaître les aspects techniques de la conception d'une API Savoir connecter des APIs à des systèmes existants Maîtriser les techniques d’accès à ses APIs

Public Développeur, Architecte Pré-requis Connaissance d’un langage de programmation Méthodes pédagogiques 40 % théorie / 60% pratique Description Que vous soyez en position de créer une API afin d'exposer les données et les fonctionnalités de vos produits qui ont atteint un certain niveau de maturité ou que vous souhaitiez vous ouvrir à de nouveaux marchés tels que la mobilité ou l'IoT, la conception (ou design) d'une API est un enjeu majeur. Cette conception d'API est d'autant plus importante dans la mesure où une API mal conçue ne sera vraisemblablement pas ou peu utilisée. L'activité de conception soulève plusieurs problématiques telles que la granularité des APIs, la gestion de version. Et il n'existe pas de standards qui sont massivement adoptés. A l’issue de cette formation, les participants seront en mesure de savoir démarrer la mise en œuvre d'une API en connaissant les bonnes pratiques et en maîtrisant les différents aspects techniques de la conception d'API tels que la sécurité, la documentation ou le versionning. Programme

Introduction

Qu'est-ce qu'une API? La notion de produit Le concept de conversation Différences avec les Web services Les impacts organisationnels


Enjeux techniques & enjeux organisationnelles Les nouveaux besoins technologiques

API Architecture

Notion d'Interface Les nouvelles architectures orientées services Focus sur les architectures Microservices Détail de la notion de façade L'impact sur son existant Mise en place d'API avec ses architectures existantes

Conception d'API

Des principes de base: simplicité, identification de la granularité, etc L'aide du Domain Driven Design (DDD) à la conception d'API Les différences de visibilité: API privé vs API public Problématiques d'exposition des données métiers Schéma des données et validation Gestion des erreurs Stratégies de gestion de versions dans le temps L'idempotence et l'impact sur le SI

Description et Documentation d’API

Pourquoi documenter? Les règles Illustration avec Open API Specification/Swagger Présentation d'alternatives: WADL

Initiation Domain Driven Design


Comprendre les bénéfices du Domain Driven Design (DDD) Savoir distinguer la complexité technique de la complexité de son métier Etre en mesure de prendre la décision d’appliquer ou non DDD à son contexte Permettre d’aligner les concepts DDD avec ses propres pratiques issues de son

expérience Maîtriser et appliquer les patterns DDD stratégiques Connaître les techniques d’introduction du domaine dans le code Avoir une expérience d’implémentation (architecture + code) concrète de DDD Connaître et utiliser les principales briques DDD tactiques

Public Architecture, Développeur confirmé (ayant une bonne expérience, idéalement de plusieurs années sur des domaines complexes)


Pré-requis Connaissances d'un langage orienté objet Méthodes pédagogiques 40 % théorie / 60 % atelier de conception Description Depuis ces dernières années, la complexité des problèmes métiers ne cessent de s’accroître, et très souvent, les applicatifs ne répondent pas correctement aux besoins des utilisateurs. On s’aperçoit ainsi que le but ultime n’est pas d’écrire du code ou même de construire des logiciels mais principalement de résoudre des problèmes. Pour répondre à la construction de domaines métiers complexes, DDD est une philosophie fournissant un ensemble de pratiques, de principes et de patterns pour dé-complexifier le métier et produire des applications répondants mieux aux besoins des utilisateurs, et ceux quel que soit le langage de programmation ou l’environnement technologique. Cette formation vous permettra de mieux comprendre le vaste et complexe sujet DDD. Tout au long de la formation, un fil rouge applicatif est co-construit afin de comprendre la mise en œuvre des différents principes, pratiques et patterns d’une conception dirigée par le métier. Programme

Introduction

Les challenges de la création logicielle Une première définition de DDD Plus de 10 ans déjà ! Pourquoi s’intéresser au DDD ? A quoi ressemble une application conçue avec DDD ? Les conditions pour appliquer DDD Les prérequis à sa mise en place

Analyse et exploration du métier

Techniques de collaboration avec les experts métiers Création d’un « ubiquitous language » Focus sur le « Event Storming » Expérimentation du « design » émergeant

Modèle et Bounded Context

Définition et application d’un mode Différents types de modèles possibles : Anemic, Transaction Script, CRUD Le « Rich Domain model » Subdivision et catégorisation en sous-domaines Notion de « Bounded context » Création d’un « Navigation Map » Maintien du « Domain Model » avec le « Bounded Context » Mise à jour du Domain Model Context Mapping Intégration des « Bounded Context »


Patterns de modélisation

Application de l’hexagonal Architecture Utilisation des building blocks Entity, Value Objects, Domain Services et Modules Aggregats, Repositories et Factories Focus la séparation du « Data Model » vs « Domain Model » Règles de validation & Spécifications

Reactive Architecture avec Kotlin


Pratiquer le langage Kotlin Écrire des applications Android les concepts Reactive Mettre en place le concept d’injection dépendance

Public Développeurs et Architectes Pré-requis Java, Développement Android avec un niveau de connaissance à maîtrise Méthodes pédagogiques 50 % de théorie et 50 % pratique Description “One More Thing”, c’est par la célèbre phrase de Steve Jobs que Stephanie Saad Cuthbertson, Product Manager chez Android, conclut son intervention lors de la conférence du Google IO 2017 qui s’est tenue le 17 mai 2017 à Mountain View. Après avoir prononcé ces trois mots, elle annonce l’officialisation du support du langage Kotlin pour la plateforme Android. Lors de cette même édition, Google a mis en avant les concepts de Clean Architecture tout en intégrant de plus en plus des notions de Reactive Architecture avec Room ou en utilisant RxJava. Cette formation fera un tour d'horizon des différentes fonctionnalités du langage Kotlin, ce qu’elles peuvent vous apporter et comment les appliquer sur vos projets. Puis exposera ce qu’est et comment mettre en oeuvre la Clean Architecture et l’Architecture Reactive sur votre application Android. Programme Kotlin - 1.5 jours Syntaxe

Val versus var


Nouveaux types Paramètre nommé, par défaut, Langage fonctionnel If statement versus when statement Object / class / data class / sealed class

Utilisation avancé

Méthode d’extension Type réifier Infix annotation Inlining de code Operator

Migration Java / Kotlin

Interopérabilité Option Kotlin

Kotlin pour Android Utilisation de Kotlin avec l’API Android Bibliothèque de référence en Kotlin

Coroutine : écriture de code asynchrone Kotlin Puzzle Architecture Android - 0.5 jour MVP + Clean Architecture

Définition MVP Définition de la Clean Architecture Position de Google Définition du pattern Repository

Injection dépendance

Concept Exemple avec Dagger Alternative en Kotlin : Kodein, Koin

Reactive Architecture - 1 jour Couplage

Définition Différent type de couplage Différent moyen de découplage

RxJava

Historique Concept RxJava 2


Observable

Nature d‘un observable Représentation d'un observable Type d’observable Création d’observable Manipulation observable Concept de monade Méthode create Programmation fonctionnelle Effet de bord

Observer

Contrat RxJava onNext / onError / onCompleted Subscriber

Opérateurs

Opérateur map Opérateur flatmap Opérateurs de compositions (merge zip…) Opérateurs de filtre Création d’un opérateur

Asynchronisme

Concept de Scheduleur ObserveOn ScheduleOn Quel scheduleur pour quel usage? Test scheduleur Écrire son scheduleur

Pratique de RxJava

Composition de web service Utilisation avec un brocker de message Gestion des erreurs Test applicatif Utilisation de Single Utilisation de Completable

Nature d’Observable

Hot Observable Cold Observable

Abonnement

Concept d’abonnement Désabonnement


Pression arrière Concept Utilisation Implémentation

RxJava Clean Architecture

CQRS et Event Sourcing


Comprendre les enjeux et les apports des patterns CQRS et event sourcing Entre en mesure de déterminer l’adéquation de cette architecture dans un

contexte donné Mettre en place et maîtriser les patterns CQRS et Event Sourcing

Public Architectes, lead developers, développeurs séniors Pré-requis Maîtrise d'un langage orienté objet Méthodes pédagogiques 50 % théorie / 50 % atelier de conception Description L’utilisation des motifs CQRS et Event Sourcing de manière combinée s’avère particulièrement efficace pour résoudre les problématiques récurrentes dans les applications métiers. Que ce soit en termes de prise en compte du métier, de maintenabilité ou de mises à l'échelle, les bénéfices sont multiples. Si cette architecture logicielle pose quelques défis pour en tirer pleinement parti, nous restons persuadé qu’elle permet de résoudre avec succès certains challenges couramment rencontrés par les applications aujourd’hui. Cette formation vous permettra de comprendre les tenants et aboutissants de ces patterns. Elle se base sur un fil rouge fonctionnel, afin d’ancrer, dans le concret les mécanismes en jeu. Programme CQRS

Introduction : le déséquilibre command/query et le modèle de données unique Explication du pattern :partir d'un modèle unique et arriver à CQRS Command Handlers et modèle d'écriture Dénormaliseurs et modèle de lecture CQRS in-proc, mise en place de CQRS dans une application monolithique Modèles de lecture et d'écriture séparés physiquement CQRS distribué, & microservices


Event Sourcing Introduction : pourquoi nous contenterons-nous de ne conserver qu'une

photographie de nos données? Evénements métiers & agrégats Le magasin d’événement Projections. Compensation d’événements Versionnage des événements

CQRS + Event Sourcing : évolutivité et écueils Monitorer son système efficacement De la nécessité d'une bonne conception & DDD De nouvelles opportunités d’évolutions

Architecture – Masterclass

Les MasterClass sont des sessions animées par des Soatiens pour des Soatiens. Chaque intervenant, experts dans son domaine donne la possibilité de monter en compétence : un moment de partage et de transmission de leurs connaissances et savoir-faire. Nous les ouvrons gratuitement sur candidature.

Masterclass Reactive Architecture

Durée 1 session de 2h30 Objectifs Découvrir les architectures réactives : pourquoi on en parle ? Quels problèmes elles essayent de résoudre et comment ? Pourquoi tout le monde n’en aurait pas besoin. Programme

Architectures Distribuées Couplage temporelle Reactive Manifesto Asynchrone ? Resiliance & Circuit Breaker Exemple d’implémentation (RxJava, Akka, async/await) Message delivering : at most once, at least once, exaclty once CAP theorem Saga Pattern / CQRS / Event Sourcing

Masterclass DDD

Durée 3 sessions de 2h30


Objectifs Appréhender les principes et les pratiques d’une conception orientée Métier. Programme

SESSION 1 : Collaborativ Design - On apprend différentes techniques qui nous permettent de comprendre le besoin métier comme par exemple Event Storming.

SESSION 2 : Strategic Design - On apprend comment découper un système complexe et des différentes stratégies pour communiquer entre les parties de notre système.

SESSION 3 : Tactical Design - On apprend des design patterns qu'on peut mettre en place dans le modèle domaine pour diminuer la complexité de notre système.


Nos formations Big Data Big Data - Formations

Introduction au NoSQL

Durée 1 jour Objectifs Comprendre le mouvement NoSQL et l’impact dans les organisations Connaître les caractéristiques des principales solutions NoSQL Savoir choisir et intégrer une ou plusieurs solutions NoSQL dans ses applicatifs Comprendre les impacts des environnements distribués Public Développeur, Architecte Pré-requis Première utilisation d’une solution stockage Méthodes pédagogiques 70 % théorie / 30 % pratique Description L’arrivée du Web a fait émerger de nouvelles solutions de stockage avec de nouveaux paradigmes, que cela soit en termes d’architecture de serveurs, de modélisation de la donnée ou de scalabilité horizontale. A l’issue de cette formation vous connaîtrez les différentes typologies des solutions NoSQL, ainsi que leurs possibilités et leurs limites. Vous saurez évaluer l’opportunité de mettre en œuvre une solution NoSQL dans vos projets en prenant en compte l’ensemble des acteurs d’une organisation. Programme

POURQUOI LE NOSQL ?

• Un mouvement avant tout • Historique du mouvement • Les promesses • Des retours d’expériences • Les points d’attention

L’HÉRITAGE RDBMS

• Caractéristiques des bases de données relationnelles • Normalisation du schéma relationnel (structuration forte) • Processus de jointure


• Les propriétés ACID • Mais des problèmes! • Des cas d’utilisation non adaptés

LES NOUVELLES EXIGEANTES NOSQL

• L’émergence des nouvelles architectures • La flexibilité de modélisation • Le fort besoin de scalabilité et de performance • Le besoin de répondre à de nouveaux cas métiers • Focus sur le besoin des environnements BigData et IoT • Pattern CQRS et NoSQL

NOSQL ET ENVIRONNEMENTS DISTRIBUÉS

• Scale out vs Scale up • Les modèles de distributions (peer-to-peer et master-followers) • Focus sur le « CAP Theorem ». Est-ce un critère? • La scalabilité linéaire • Focus sur l’ « eventual consistency » et impact métier • Qualités transactionnelles BASE

TAXONOMY NOSQL

• Les tentatives de catégorisation des bases NoSQL • Les bases clé-valeur, orienté colonne, document et graphe • Focus et mise en pratique avec Cassandra, MongoDB et Redis • Les critères de choix

LA MODÉLISATION DES DONNÉES

• L’importance de l’activité de modélisation • Modélisation selon des patterns d’accès aux données (query-driven-design) • Nature, Volume et Variété des données • Les solutions NoSQL orientées agrégats et non-agrégats • Prise en compte de la performance. Illustration avec Redis pour la réduction de l’empreinte mémoire

L’IMPACT DU NOSQL DE NOS ORGANISATIONS

• L’accompagnement des exploitants • Le choix des outils de supervision • Savoir évaluer le coût de mise en place (différent entre nouveau projet et projet de migration

Elasticsearch

Durée 3 jours


Objectifs Appréhender Elasticsearch et son API Découvrir les concepts essentiels (mapping, analyse) Apprendre quel type de recherches est adapté à chaque use-cases et comment modéliser Comprendre le fonctionnement d’Elasticsearch pour l’utiliser efficacement Public Développeurs, Architectes Pré-requis Notions sur http Méthodes pédagogiques 50 % théorie / 50 % pratique Description Elasticsearch est un moteur de recherche conçu dès le départ pour être distribué et gérer des volumes de données massifs. Il se base sur la librairie Apache Lucene et lui ajoute des fonctionnalités supplémentaires pour la mise en cluster, la haute disponibilité ainsi qu’une API puissante. Cette formation a pour objet de présenter Elasticsearch et toutes les notions importantes pour développer de façon efficace avec Elasticsearch. Elle est aussi l’occasion de jeter un œil sous le capot pour comprendre plus en profondeur le fonctionnement d’Elasticsearch et en tirer le meilleur. Programme

INTRODUCTION

Pourquoi un moteur de recherche ? Pourquoi Elasticsearch ?

NOTIONS DE BASE

Node Cluster Index Type Shard Document Mapping Score

PRISE EN MAIN

Installation Configuration Mise en cluster Structure de l’api REST


INDEXATION DE DOCUMENTS

Création d’un index et d’un type Indexation d’un document Suppression d’un document Mise à jour de documents Version

ANALYSE DE DOCUMENT

Mapping et types de champs Propiétés des champs Customisation du mapping Définition d’analyseurs Cas d’usage

REQUÊTES

Structure d’un index Queries Filtres Relations entre documents

AGRÉGATIONS

Fonctionnement Notion de scope Types d’agrégations

PERCOLATION

BENCHMARK

GESTION DES INDEX

API indices Templates

CLUSTERING

Communication entre nœuds Rôles des nœuds Notion de master La vie d’une requête distribuée

ELASTICSEARCH EN PRODUCTION

Performance Configuration Indexation en masse Monitoring Répartition des index


Backups API cat

PLUGINS

Types de plugins Rivers Installation

MongoDB

Durée 2 jours Objectifs Découvrir MongoDB et les concepts associés Écrire des applications Java utilisant MongoDB Concevoir une structure de données adaptée pour MongoDB Public Développeurs Java Pré-requis Maîtrise de Java Méthodes pédagogiques 50 % théorie/ 50 % pratique Description Le volume de données explose tout comme la pression exercée sur nos bases de données traditionnelles jusqu’à les pousser dans leurs limites. MongoDB est une alternative pour stoker plus, tout en encaissant plus de trafic. Foursquare utilise MongoDB, Expedia utilise également MongoDB… Avec plus de 5 millions de téléchargements et plus de 600 grand comptes : MongoDB fait partie des « bases leader » dans le domaine des bases de données Big Data. Quelles sont les caractéristiques de cette base ? Les uses cases ? Quels sont les avantages et les défauts de MongoDB ? Cette formation vous permettra de comprendre le fonctionnement de MongoDB et de concevoir des applications utilisant cette base de données NoSQL. Programme

MONGODB ET LE NOSQL

Le NoSQL ? Caractéristique de MongoDB Base de données orientée Document JSON / BSON

REQUÊTAGE MONGODB


Découverte de MongoShell Création d’un document Recherche de documents Mise à jour de documents Ecriture en masse (Bulk)

REQUÊTAGE MONGODB EN JAVA

Utilisation du Driver Java Découverte des alternatives

DESGIN DE MODÈLE DE DONNÉES

Design pour la performance Penser aux limites des documents Penser sans transaction

WRITECONCERN ET GARANTI D’ÉCRITURE

Niveau de WriteConcern Journaled

INDEX

Index simple Index composé Index unique

INDEX AVANCÉ

Sparse Index Index géolocalisé Index TTL

MONGODB DANS LE WORKFLOW DE PRODUCTION D’UN DÉVELOPPEUR

Gestions des données (import/export) Écrire des tests unitaires Mise à jour des structures de données

FRAMEWORK D’AGGREGATION

Opérateurs Pipiline

REPLICATION

Concept Scénario d’utilisation

SHARDING


Concept Scénario d’utilisation

OPTIMISATION DES REQUÊTES

RECOMMANDATION DE CONFIGURATION

GRIDFS

Redis

Durée 2 jours Objectifs Savoir mettre en œuvre Redis à travers ses principaux cas d’usage Utiliser Redis comme boîte à outils Maîtriser le custering et la réplication de Redis Connaître les techniques d’optimisation de Redis Public Développeur, Architecte, Ingénieur de la donnée Pré-requis Connaissances basiques d’un langage de programmation Méthodes pédagogiques 40% théorie / 60 % pratique Description Redis est une base de données NoSQL de type clé-valeur, s’exécutant en mémoire et fournissant en option de la persistance. Le modèle de données Redis met à disposition des structures de données avancées afin de multiplier les cas d’usages par rapport aux bases de données de la même topologie. Très proche du système, Redis se distingue par sa capacité à fournir une faible empreinte mémoire, sa faible latence et sa très grande fiabilité. Cette formation permet de parcourir l’ensemble des fonctionnalités de Redis en découvrant la richesse de son API, son mode de fonctionnement en cluster et comment surveiller des processus Redis. Cette formation permet également d’acquérir les techniques pour optimiser son modèle de données, en particulier sur l’empreinte mémoire. Programme

INTRODUCTION À REDIS

• Vision et promesses du NoSQL • Positionnement de Redis


• Quand utiliser Redis et quand ne pas l’utiliser ? • Les principaux utilisateurs • Première installation et configuration

PRINCIPALES STRUCTURES DE DONNÉES ET MANIPULATION

• String, List, Set, Hash et Sorted Set • Les principales commandes associées

L’ARCHITECTURE REDIS

• Protocole de communication et format de données • Atomicité des opérations • Processus de démarrage • Event loop & les différents événements • Durabilité des données • Réplication Master-Slave

DÉVELOPPER AVEC REDIS

• Les langages d’accès client • Les APIs Java en détail • Gestion des transactions • Des scripts côté serveur avec Lua • Les clients Redis • Focus sur Jedis et Spring Data Redis

HAUTE DISPONIBILITÉ & CLUSTERING

• Fonctionnement des réplicas et cycle de vie des données • Clustering Redis • Haute Disponibilité avec Redis Sentinel

OPTIMISATION DES DONNÉES

• Expiration des données • Pipelining & Multiple Argument commands • Logical Types vs Physical Types • Patterns appliqués à la conception de données

STRUCTURES & ORGANISATION AVANCÉE DES DONNÉES

• Publish/Subscribe • HyperLogLog • BitMap • Les problématiques de requêtes complexes

MONITORING DU TRAFIC

• La commande “monitor” • Analyse des événements et History • Les différents outils du marché


POUR ALLER PLUS LOIN

• Sécurité et Encryption • Les principales recommandations de conception et de configuration • Étendre Redis avec les Redis Module • Savoir debugger ses scripts Lua • Les principales topologies de déploiement chez les grandes références de Redis

AU-DELÀ DE REDIS

• Ce qu’il n’y a pas dans Redis • La solution Entreprise Redis Labs • Les alternatives & les potentiels successeurs

Introduction à Cassandra


Découvrir Apache Cassandra et les concepts associés Comprendre les impacts des environnements distribués Identifier les cas d’utilisation de Cassandra Concevoir un modèle de données dans une base “orientée colonnes” Écrire des applications Java utilisant Cassandra

Public Développeurs et Architectes Pré-requis Connaissance de java Notions de shell Méthodes pédagogiques 50 % de théorie et 50 % de pratique Description L’arrivée du Web a fait émerger de nouvelles solutions de stockage avec de nouveaux paradigmes, que cela soit en termes d’architecture de serveurs, de modélisation de la donnée ou de scalabilité horizontale. La base NoSQL Apache Cassandra est l’une d’entre elles. Aujourd’hui devenue très populaire, elle a été adoptée par de grandes sociétés du web, telles que Facebook, Twitter, Netflix, Spotify, pour ses performances, sa scalabilité linéaire et sa grande tolérance aux pannes. Quelles sont les caractéristiques de cette base ? Quels en sont les bons cas d’utilisation ? Quelles en sont les forces, ainsi que les points faibles ? Cette formation vous permettra de comprendre le fonctionnement de Cassandra et de concevoir des applications utilisant cette base de données “orientée colonnes”.


Programme

POURQUOI CASSANDRA ?

Historique du projet La communauté Open Source DataSTax L’héritage des RDBMS Les problèmes liés à la volumétrie Pannes et disponibilité Cas d’utilisation

CASSANDRA, UNE BASE DISTRIBUÉE

Systèmes distribués : points forts et faiblesses Le partitionnement et la répartition des données Topologie en ring La communication au sein d’un cluster Scalabilité horizontale

MODELISATION DES DONNEES DANS CASSANDRA

Une modélisation orientée colonne (Design by query) Langage de requêtage CQL Index secondaires Light Weight Transaction Batches Le driver java DataStax Performance vs. cohérence Répartition de charge

CASSANDRA ET LA TOLÉRANCE AUX PANNES

Une architecture P2P sans SPOF Replication Factor Cassandra et le théorème CAP Eventual Consistency Tunable Consistency (Consistency Level) Résilience (hinted handoff, repair)

PERFORMANCE DE CASSANDRA

L'accès aux données (write path, read path, commit log, MemTables, SSTables) Les mécanismes d’optimisation (caches, bloom filters, configuration hardware) Algorithmes de compaction et gestion des DELETE Multi DataCenter


Big Data – Masterclass


MasterClass introduction à MongoDB et Cassandra

Durée 6 sessions de 2 heures Objectifs

Découvrir MongoDB et Apache Cassandra, ainsi que les concepts associés. Comprendre les impacts des environnements distribués. Identifier les cas d’utilisation. Concevoir un modèle de données dans une base “orientée document”. Concevoir un modèle de données dans une base “orientée colonnes” Écrire des applications Java utilisant Cassandra.

Public Développeurs, Architectes Pré-requis Connaissance de java Notions de shell Méthodes pédagogiques 50 % théorie / 50 % pratique Description L’arrivée du Web a fait émerger de nouvelles solutions de stockage avec de nouveaux paradigmes, que cela soit en termes d’architecture de serveurs, de modélisation de la donnée ou de scalabilité horizontale. Les bases NoSQL MongoDB et Apache Cassandra en font partie. Aujourd’hui devenues très populaires, elles ont été adoptées par de grandes sociétés du web, telles que Facebook, Twitter, Netflix, Spotify, pour leurs performances, leur scalabilité ou leur grande tolérance aux pannes. Quelles sont les caractéristiques de ces bases ? Quels en sont les bons cas d’utilisation ? Quelles en sont les forces, ainsi que les points faibles ? Cette masterclass vous permettra de comprendre le fonctionnement de MongoDB et de Cassandra et de concevoir des applications les utilisant. Programme Sessions de 1h30 + 30min de pause 2 sessions MongoDB 4 sessions Cassandra (alternance sessions théoriques / pratiques)


Nos formations Cloud Microservices avec Service Fabric


Appréhender les concepts des architectures micro-services Mettre en place et manager un cluster Service Fabric dans Azure et on-premise Déverrouiller le potentiel de Service Fabric grâce à son SDK

Public Développeur & Architecte .Net Pré-requis Développeur ou architecte .Net connaissant : - Visual Studio 2017 - .Net Core - Web API Méthodes pédagogiques 60% théorie / 40% pratique Description Service Fabric est le moteur de microservice utilisé par Microsoft en tant que plateforme interne pour des produits tel que Microsoft azure, DocumentDB, Bing et Cortana. Il est dorénavant disponible publiquement afin de pouvoir construire vos applications sur cette plateforme. Sur Windows ou linux, ce middleware installable à la fois sur Azure, on-premise, ou sur des machines virtuelles vous permettra d’acquérir des fonctionnalités natives d’un cluster tel que l’état de santé de vos services, la scalabilité et la haute disponibilité. Programme

Microservices : une évolution vers des architectures modernes

Emergence des micro-services

Les principaux acteurs des microservices Les antipatterns Les cas d’utilisations des microservices

Introduction à Service Fabric


Historique chez Microsoft Les avantages de Service Fabric Différents types de services Sécuriser vos applications et votre cluster Monitorer vos applications Bonnes pratiques d’architecture et de développement

Service Fabric Outils

Visual Studio & Service Fabric Gestion d’un cluster local Utiliser PowerShell pour gérer son cluster

Service Fabric Installation

Installer Service Fabric sur Azure Installer Service Fabric en local

Service Fabric : Scalabilité

Scalabilité verticale Scalabilité horizontale

Service Fabric : Monitoring

Monitorer vos applications avec Event Tracing for Windows Exporter vos logs grâce à Event Flow

Service Fabric : TP Premiers services

Rappel sur la programmation asynchrone Créer son premier service stateless Créer son premier service stateful Créer ses premiers Actor Packager un Guest exécutable dans Service Fabric

Service Fabric : TP Communication

Communication entre les services Communication via http & https Communication avec Service Remoting Communication via WCF Communication via des protocoles personnalisés

Service Fabric : TP Partitionnement

Partitionner ces services avec un singleton Partitionner ces services de manières uniformes Partitionner ces services de manières nommées

Service Fabric : TP Gérer son cluster


Déployer son application avec Powershell Mettre à jour ses applications Monitorer ses applications

Introduction à Microsoft Azure

Durée 2 jours Objectifs Appréhender les concepts du Cloud Computing Avoir une bonne vision des opportunités qu’offre la plateforme Cloud de Microsoft Déployer ces premiers services dans Azure Public Développeurs et Architectes .Net Pré-requis Connaissances du langage C# et notions d’ASP.Net MVC Méthodes pédagogiques 60 % théorie / 40 % pratique Description Microsoft Azure est la plateforme de Cloud publique de Microsoft. Annoncé en 2008 lors de la PDC à Los Angeles, elle est aujourd’hui utilisée par plus de 80% des entreprises du fortune 500 (CAC40 américain). Depuis ces débuts, la plateforme s’est vu dotée de nombreux services qui font d’elle un leader dans le domaine du IaaS et du PaaS selon Gartner. Cette formation a pour objectif de vous faire découvrir les différents services offerts par Azure. Au cours de la formation, vous pourrez développer des applicatifs et les déployer sur la plateforme. Au cours des travaux pratiques, vous allez appréhender les concepts de développement pour un environnement Cloud, voir comment il est possible de déployer sur celui-ci, et où récupérer les informations nécessaires pour assurer l’infogérance de vos applications. Afin de correspondre aux besoins de l’ensemble des participants, cette formation sera réalisée en deux temps. La première partie sera théorique avec une présentation des fonctionnalités de la plateforme agrémentée de diverses démonstrations. La deuxième partie sera essentiellement pratique et proposera différents exercices au choix des participants. Programme

Introduction au Cloud Computing

Définition du Cloud Computing Quels sont les acteurs du marché ?


Pourquoi utiliser une solution de type Cloud ?


Ensemble des offres de la plateforme Infrastructure et principes de fonctionnements Différents rôles pour différentes applications Technologies supportées

Combien coûte votre application

Appréhension des coûts sur Azure Comment calculer ceux-ci Astuces pour diminuer les coûts

Travaux pratiques au choix

TP : Héberger votre site sur Azure Websites

Déployer sur Azure Websites Mise en place de l’intégration continue via Git Gestion des diagnostiques Mise en place de l’autoscaling

TP : Héberger votre site sur Azure Cloud Services

Déployer un site Web sur Azure Cloud Services Déployer un worker sur Azure Cloud Services Communiquer entre vos différents rôles Découverte des fonctionnalités spécifiques à Azure Cloud Services

TP : Héberger votre backend sur Azure Mobile Services

Héberger votre backend sur Azure Mobile Services Créer une application qui utilise ce backend Modifier le comportement des méthodes de type CRUD Créer une API personnalisée

TP : Découvrir les options de stockage sur Azure

Stocker vos fichiers dans Azure Blob Storage Stocker vos données dans SQL Database Stocker vos données dans Azure Table Storage Stocker vos données dans Azure DocumentDb


Nos formations Craftsmanship Craftsmanship - Java

Refactoring Legacy code Java


Comprendre ce qu’est le refactoring de code et l’identifier dans du code legacy Découvrir les différentes méthodes de refactoring et leurs cas d’applications

Public Développeurs Java Pré-requis Expérience du développement en Java Connaître les notions de base de la programmation orientée objet Connaitre les notions de tests unitaires Méthodes pédagogiques 40 % de théorie, 60 % de démonstrations et mise en pratique Description Le code propre c’est bien. Mais comment faire lorsque l’on travaille avec une application comportant un historique de plusieurs années. Cette formation va vous permettre d’analyser votre code « Legacy » et vous montrer sur quels éléments vous appuyer afin de démarrer un cycle d’amélioration de votre qualité de code et la maintenabilité de votre application. Programme Introduction ?

Qu’est-ce que le refactoring Pourquoi refactorer Quand refactorer

Legacy Code Bad Smells Code non testable

Methodes de refactoring Clean the Deck Extract or Inline Move methods Substitution


Craftsmanship : Clean code Java


Comprendre ce qu’est un code de qualité et comment mettre en place de bonnes pratiques

Rédiger un code propre, facile à maintenir et expressif Comprendre les principes de la programmation orientée objet (principes SOLID)

Public Développeurs Java Pré-requis Expérience du développement en Java Connaître les notions de base de la programmation orientée objet Méthodes pédagogiques 50 % de théorie, 50 % de démonstrations et mise en pratique Description En mettant le focus sur la qualité du code tout en restant pragmatique, il est possible de rendre le code lisible, testable et testé. De ce fait, l’application devient alors plus robuste tout en étant évolutive et maintenable. Peu importe le type de projet, les techniques abordées au cours de cette formation sont simples à mettre en œuvre et permettront une mise en production rapide sans crainte d'impact négatif sur la production dû à des introductions de bugs et/ou de régressions. Programme Qu’est ce qu’un code propre ? Code Style

Nommage Formatage Commentaires

Code design POO

o Conception par contrat o Gérer les états invalides et les invariants

Composition vs Héritage o Loi de Demeter o Command Query Separtion

Design Pattern o Création o Structure o Comportement

SOLID o Single responsibility o Open/closed


o Liskov substitution o Interface segregation o Dependency injection

IOC vs DI DRY, KISS and YAGNI

BDD en environnement Java


Découvrir les principes du BDD Appréhender le langage Gherkin Découvrir l’outillage associé en environnement Java

Public Développeurs Java, chef de projets techniques, analystes métier Pré-requis Maîtrise du langage Java Notions de TDD sont un plus Méthodes pédagogiques 50% théorie / 50% pratique Description Le Behavior Driven Developpement (alias Developpement piloté par le comportement) est une méthodologie agile issue du Test Driven Developpement. Cette formation a pour but de faire découvrir les principes proposés par cette méthode et à quelles problématiques elle répond ainsi que de présenter les outillages associés en environnement Java. A l’issue de la session, les participants seront en mesure d’exprimer un besoin utilisant le langage Gherkin et d’exécuter des tests écrit dans ce langage dans leur environnement de développement habituel. Programme Introduction au BDD

Historique Objectifs Compléments avec TDD et ATDD

Principes associés Notion de comportement Langage d’ubiquité Format Gherkin

BDD en Java avec Cucumber Mise en place d’un premier scenario Organisation des tests


Architecture des tests Utilisation avancée de Cucumber

Reporting en Java avec Serenity BDD Mise en place d’un exemple de reporting Automatisation avec intégration continue

TDD Java


Découvrir les tests et le principe du TDD Écrire des tests pérennes Appréhender l’ensemble d’un workflow de test

Public Développeur Pré-requis Connaissances de Java Méthodes pédagogiques 50 % théorie/ 50 % pratique Description La pratique de tests unitaires dans le développement d’application est considérée comme un incontournable pour assurer la qualité technique d’un projet. Le TDD, « Test Driven Developpement » est une pratique permettant d’allier efficacité et qualité pour rédiger des tests dans un environnement agile. Issue de l’eXtreme Programming, elle a pour objectif la mise en place de tests avant d’implémenter le code fonctionnel et ce, par cycle itératif. Ce procédé implique une vision et une compréhension complète des fonctionnalités avant de générer la moindre ligne de code, afin de constituer un corpus de tests le plus exhaustif possible. Cette formation vous permettra de comprendre la portée et l’efficacité du développement en mode TDD. Programme Test Driven Development

Test unitaire Composition d’un test : Acteur, action, assertion Faire simple : Principe du Kiss

Framework de test : jUnit Création d’un test Vérification de comportement : Framework d’assertions de jUnit Cycle de vie d’un test Différence avec TestNG


Framework d’assertions : assertJ Écrire des assertions compréhensibles : Présentation d’assertJ Utilisation d’assertJ Présentation des assertions d’assertJ Présentation d’assertions avancées, pour les collections, ...

Framework de mock : Mockito Créer de faux comportement : Présentation de Mocktio Définition d’un Mock Configuration d’un mock Intercepter les bons appels : Utilisation d’Argument Matcher Définition d’un Spy Vérification du comportement d’un mock/spy Interception des arguments : Argument Captor

Legacy Code : les techniques Le couplage fort Tester une méthode private Couverture de code

Binomage Concept : le pilote et le co-pilote Animation possible avec le pattern ping pong

Test d’intégration avec une base de données Cycle de vie d’un test avec une base de données Présentation de DbSetup Insérer et supprimer des données : Opérations DbSetup Optimiser la durée des tests : Utilisation de DbSetupTracker

Utilisation avancée de jUnit Écrire des tests paramétrés avec les Theory. Écrire des composants de test réutilisables avec les Rules Écrire des tests maintenables : Bonnes pratiques


Craftsmanship .NET

Refactoring Legacy code .NET


Comprendre ce qu’est le refactoring de code et l’identifier dans du code legacy Découvrir les différentes méthodes de refactoring et leurs cas d’applications

Public Développeurs .NET Pré-requis Expérience du développement en C# Connaître les notions de base de la programmation orientée objet Connaitre les notions de tests unitaires Méthodes pédagogiques 40 % de théorie, 60 % de démonstrations et mise en pratique Description Le code propre c’est bien. Mais comment faire lorsque l’on travaille avec une application comportant un historique de plusieurs années. Cette formation va vous permettre d’analyser votre code « Legacy » et vous montrer sur quels éléments vous appuyer afin de démarrer un cycle d’amélioration de votre qualité de code et la maintenabilité de votre application. Programme Introduction ?

Qu’est-ce que le refactoring Pourquoi refactorer Quand refactorer

Legacy Code Bad Smells Code non testable

Methodes de refactoring Clean the Deck Extract or Inline Move methods Substitution

Craftsmanship : Clean code C#

Durée 3 jours


Objectifs

Comprendre ce qu’est un code de qualité et comment mettre en place de bonnes pratiques

Rédiger un code propre, facile à maintenir et expressif Comprendre les principes de la programmation orientée objet (principes SOLID)

Public Développeurs C# Pré-requis Expérience du développement en C# Connaître les notions de base de la programmation orientée objet Méthodes pédagogiques 60 % de théorie, 40 % de pratique Description En mettant le focus sur la qualité du code tout en restant pragmatique, il est possible de rendre le code lisible, testable et testé. De ce fait, l’application devient alors plus robuste tout en étant évolutive et maintenable. Peu importe le type de projet, les techniques abordées au cours de cette formation sont simples à mettre en œuvre et permettront une mise en production rapide sans crainte d’impact négatif sur la production dû à des introductions de bugs et/ou de régressions. Programme Qu’est ce qu’un code propre ? Code Style

Nommage Formatage Commentaires

Code design POO Conception par contrat Gérer les états invalides et les invariants Composition vs Héritage Loi de Demeter Command Query Separtion Design Pattern Création Structure Comportement SOLID Single responsibility Open/closed Liskov substitution Interface segregation Dependency injection IOC vs DI DRY, KISS and YAGNI


BDD en environnement .NET


Découvrir les principes du BDD Appréhender la langage Gherkin Découvrir l’outillage associé en environnement .NET

Public Développeurs .NET, chef de projets techniques, analystes métier Pré-requis Maîtrise du langage C# Notions de TDD sont un plus Méthodes pédagogiques 50% théorie / 50% pratique Description Le Behavior Driven Developpement (alias Developpement piloté par le comportement) est une méthodologie agile issue du Test Driven Developpement. Cette formation a pour but de faire découvrir les principes proposés par cette méthode et à quelles problématiques elle répond ainsi que de présenter les outillages associés en environnement .NET. A l’issue de la session, les participants seront en mesure d’exprimer un besoin utilisant le langage Gherkin et d’exécuter des tests écrit dans ce langage dans leur environnement de développement habituel. Programme Introduction au BDD

Historique Objectifs Compléments avec TDD et ATDD

Principes associés Notion de comportement Langage d’ubiquité Format Gherkin

BDD en .NET avec SpecFlow Mise en place d’un premier scenario Organisation des tests Architecture des tests Utilisation avancée de SpecFlow

Reporting en .NET avec Pickles Mise en place d’un exemple de reporting Automatisation avec intégration continue


TDD C#


Découvrir les tests et le principe du TDD Écrire des tests pérennes Appréhender l’ensemble d’un workflow de test

Public Développeur Pré-requis Connaissances de C# Méthodes pédagogiques 50 % théorie/ 50 % pratique Description La pratique de tests unitaires dans le développement d’application est considérée comme un incontournable pour assurer la qualité technique d’un projet. Le TDD, « Test Driven Developpement » est une pratique permettant d’allier efficacité et qualité pour rédiger des tests dans un environnement agile. Issue de l’eXtreme Programming, elle a pour objectif la mise en place de tests avant d’implémenter le code fonctionnel et ce, par cycle itératif. Ce procédé implique une vision et une compréhension complète des fonctionnalités avant de générer la moindre ligne de code, afin de constituer un corpus de tests le plus exhaustif possible. Cette formation vous permettra de comprendre la portée et l’efficacité du développement en mode TDD. Programme Test Driven Development

Test unitaire Composition d’un test : Acteur, action, assertion Faire simple : Principe du Kiss

Framework de test : nUnit Création d’un test Vérification de comportement : Framework d’assertions de nUnit Cycle de vie d’un test

Framework d’assertions : nFluent Écrire des assertions compréhensibles : Présentation d’nFluent Utilisation d’ nFluent Présentation des assertions nFluent Présentation d’assertions avancées, pour les collections, ...

Framework de mock : nSubstitute Créer de faux comportement : Présentation de nSubstitute


Définition d’un Mock Configuration d’un mock Intercepter les bons appels : Utilisation d’Argument Matcher Définition d’un Spy Vérification du comportement d’un mock/spy Interception des arguments : Argument Captor

Legacy Code : les techniques Le couplage fort Tester une méthode private Couverture de code

Binomage Concept : le pilote et le co-pilote Animation possible avec le pattern ping pong


Nos formations Devops Devops - Méthodes & Pratiques

Usine logicielle et intégration continue


Connaître l’état de l’art des pratiques de l’Intégration continue Comprendre et maitriser les principes de l’intégration continue et savoir la mettre

en œuvre au sein des projets Manipuler un gestionnaire de contrôle de version Comprendre les mécanismes de construction et savoir gérer les dépendances de

construction de ses composants Savoir mettre en œuvre les principaux outils de métriques d’analyse de code

Public Développeurs, architectes, chefs de projet techniques, intégrateurs, responsables qualité Pré-requis Connaissances de base en développement logiciel Méthodes pédagogiques 40 % théorie / 60% pratique Description L’intégration continue est un ensemble de pratiques issues du génie logiciel qui participent, au même titre que les méthodes agiles, à l’industrialisation des développements. Elle permet de s’assurer à chaque évolution du code source que l’ensemble des modifications n’introduit pas de régression. Le but est de détecter au plus tôt les éventuels problèmes d’intégration lors du développement et d’en limiter ainsi les coûts de correction. Elle s’inscrit au travers d’un ensemble d’outils constituant l’usine logicielle qui permet dans une démarche d’automatisation des constructions, des déploiements et des suites de tests, de générer des audits de fabrications, des rapports de tests accessibles à tous les membres de l’équipe et d’améliorer ainsi la productivité globale du projet. A l’issue de cette formation, les participants seront en mesure de mettre en œuvre un environnement d’intégration continue, d’exploiter les fonctionnalités de Jenkins et des différents outils qui constituent l’usine logicielle (Jenkins, Maven, Nexus/Artifactory, SonarQube) et d’automatiser les différentes tâches liées au développement logiciel et au déploiement sur les plates-formes d’intégration.


Programme

Introduction • Les principes et apports de l’intégration continue • Les prérequis • Les différents outils de l’intégration continue • Les points de démarrage de la mise en place de processus d’intégration continue

Changement, déclenchement et processus d’intégration • Détail des différentes étapes d’un processus d’intégration • Les types de déclenchement du processus • Notion d’ordonnanceur

Le gestionnaire de contrôle de version • Les pourquoi ? • Rappel des bonnes pratiques de branch & merge • Les différents gestionnaires de sources • Les problématiques d’intégration des changements

Automatisation de la construction logicielle • Les enjeux • Comparaison de l’utilisation des IDE et de l’intérêt d’un moteur d’intégration couplé à un script de construction • Comment démarrer son automatisation ? • Sensibilisation au temps de construction globale d’une application • Validation et traçabilité de la chaîne de construction • Focus sur la mise en œuvre avec Maven et Gradle

L’automatisation des tests • Rappel des pratiques TDD et BDD • Penser et tester en termes d’APIs • Automatisation des tests unitaires et d’intégration • Configuration des rapports • Mesurer la couverture de test • Les environnements de tests.

Construction logicielle

• Paradigme « Construire 1 fois, Livrer n fois » • Mise à disposition des livrables à l’aide d’un dépôt de binaires (stockage et gestion des librairies) • Exploration de JFrog Artifactory et Sonatype Nexus • Focus sur l’intégration Maven et sa gestion de dépendances • Fourniture de scripts d’installation automatique de l’application • Savoir aller plus loin : signature des livrables

Jenkins • Historique & positionnement • Panorama des fonctionnalités • Les plugins les plus utilisés • Les pièges à éviter • Les modèles de jobs de construction


• Mises-en œuvre avec des projets Java et les outils de build Maven et Gradle • Version de la configuration des jobs

La mise en place des métriques : qualité du code • La génération de rapports d’analyse • Les outils d’analyse et de reporting (Checkstyle, Findbugs, PMD…). • Mise en œuvre avec Maven et Gradle ; et intégration avec Jenkins • La publication des résultats et illustration avec SonarQube

L’usine Logicielle en entreprise • Choix de version « Jenkins LTS » • Usine Monolithique vs Usine dédiée • Gestion de la sécurité • Problématiques de mise à jour


Devops - Gestion de sources

GIT


Être autonome avec l’outil Connaitre les concepts de Git Apprendre à versionner son code avec Git Travailler à plusieurs sur un même dépôt Apprendre à utiliser les principaux workflow Git

Public Développeurs, Architectes, Chefs de projet Pré-requis Aucun Méthodes pédagogiques 50% Théorie / 50% Pratique Description Git est l’outil favori de nombreux développeurs pour gérer leurs sources. C’est aussi le point central de Github. Ce gestionnaire de versions distribué (DVCS) permet de collaborer au sein d’une équipe de développement, et de s’adapter à celle-ci. En effet, Git permet tout aussi bien de mettre en place des workflows très simples, mais aussi beaucoup plus évolués, pour répondre aux besoins des équipes. Dans cette formation, nous montrerons comment utiliser les commandes de base de Git, comment bien gérer ses branches, travailler avec un dépôt distant. Nous expliquerons également les workflows traditionnels pour travailler avec Git. Programme INTRODUCTION

Historique Principe de fonctionnement d’un gestionnaire de source Fonctionnement de Git

MANIPULATION D’UN DÉPÔT LOCAL Créer un dépôt Ajouter des fichiers Consulter l’état du son dépôt Faire des commits Parcourir l’historique Reset et revert

GESTION DES BRANCHES Créer et manipuler les branches Fusionner des branches


Rebase Comparer les branches Les tags

UTILISATION D’UN DÉPÔT DISTANT Cloner un dépôt distant Envoyer des commits sur un dépôt distant Récupérer les modifications

TRAVAIL EN ÉQUIPE Présentation des différents workflow Git Gestion des conflits Utilisation du cherry-pick Utilisation de bisect

FONCTIONS AVANCÉES Les hooks Les submodules Les subtree

LES DIFFÉRENTS OUTILS GitHub et GitLab TortoiseGit Gerrit Lab TortoiseGit Gerrit


Devops - Tests

Selenium


Découvrir les tests d’une application Web Prendre en main l’API WebDriver Mettre en place des scénarios de tests dans leur intégralité

Public Développeur/Testeur d’application Web Pré-requis Connaissances de Java, Html, Css, Xpath Savoir utiliser un IDE (Eclipse, IntelliJ, … ) Méthodes pédagogiques 50 % théorie / 50 % pratique Description Lors de l’élaboration d’un projet, la recette identifie les anomalies et/ou les régressions en passant des batteries de tests fonctionnels. Ces tests deviennent de plus en plus complexes au fur et à mesure de l’évolution du projet et difficiles à maintenir. A l’image des tests unitaires pratiqués par les équipes de développement, Selenium offre, au travers de scénarios de tests, une solution de validation fonctionnelle des IHM pouvant être exécutée plus tôt dans le cycle de vie d’un projet. Au travers de cette formation, des différents exemples et cas d’application qui y seront développés, vous apprendrez notamment à utiliser l’outil Selenium, son API WebDriver. Programme INTRODUCTION AUX TESTS

Différents niveaux de test Tests d’intégration Tests fonctionnels Tests unitaires

INTRODUCTION À SELENIUM SELENIUM IDE

Description du plugin Selenium IDE pour Firefox Interagir avec une page web : commandes d’actions, commandes d’actions

asynchrones Accéder à des éléments : les accessors Vérifier des éléments : les assertions Différents moyen d’accéder à des éléments : xpath, id, …

SELENIUM WEBDRIVER (VIA JAVA)


Piloter un navigateur via une API Différents type de Drivers pour différents navigateurs Pilotage du navigateur Firefox Sélection d’un ou plusieurs éléments au sein d’une page (par id, tag, xpath,

classname, …) Sélection de sous-éléments. (exemple : balise imbriquée) Création d’action à travers le Builder Pattern Récupération d’attribut d’une balise Manipulation de <form>, <select>, … Contrôle des boutons du navigateur (back, forward, refresh) Réalisation de capture d’écran automatique Gestion des promps, alerts, messageBox et des fenêtres Configuration des Cookies / timeout Export de test SeleniumIDE pour Selenium WebDriver

PAGE OBJECT PATTERN Concept PageFactory & injection du Driver Utilisation de @FindBy : binding d’élement via name, id, xpath, … Utilisation de @FindAll : binding d’une liste d’éléments Utilisation de @CacheLookup Scénarios utilisant le Page Object Pattern

SELENIUM GRID Démarrage d’une grille selenium (hub et node) Utilisation d’une grille selenium via le RemoveWebDriver Url exposée par le Hub Configuration et sélection de navigateur via les DesiredCapabilities Capture d’écran avec une grille selenium Parallélisation des tests avec jUnit et Maven Utilisation de SauceLabs

INTÉGRATION CONTINUE Présentation du concept d’intégration continue Exemple de configuration d’un jenkins Utilisation d’un navigateur headless : phantomjs

SAUCELABS Utilisation de SauceLabs : Selenium Grid dans le cloud

CUCUMBER : SPÉCIFICATIONS EXÉCUTABLES Présentation de Cucumber Écriture d’un scénario Cucumber Type de Step Cucumber Gestion des langues Intégration avec jUnit


Devops - Infrastructures

Docker


Savoir installer et utiliser Docker Maîtriser la gestion des images Docker et les Dockerfile. Maîtriser les notions réseaux spécifiques à Docker Maîtriser les concepts avancés et subtilités de Docker et des Dockerfiles Connaître les bonnes pratiques de sécurité autour de Docker

Public Développeurs, Architectes, Administrateurs systèmes Pré-requis Connaissances de base d’un système Unix (Savoir se débrouiller dans un terminal) Méthodes pédagogiques 40% Théorie / 60% Pratique Description Docker est une technologie très récente mais qui suscite déjà un engouement énorme dans la communauté des développeurs. Cette technologie de conteneurs permet de faciliter l’isolation, le packaging et le déploiement de tous les types d’applications, indépendamment du langage et facilite la mise en place d’architectures de type “microservices”. Cette formation portera sur différents aspects de Docker. Installation, prise en main, création d’images, gestion du réseau, persistance de données, orchestration de conteneurs. Programme INTRODUCTION AUX CONTENEURS

Présentation du concept de conteneur Linux Cas d’utilisation des conteneurs Linux Les différences entre conteneurs et machines virtuelles Présentation de Docker et de son architecture

CRÉER SES PREMIERS CONTENEURS DOCKER Installation de Docker Le cycle de vie d’un conteneur Lancer un conteneur avec docker run (en mode interactif, en mode detaché…) Interagir avec un conteneur depuis le host (exec, inspect, logs…)

LES IMAGES DOCKER Qu’est-ce qu’une image Docker Créer une image à partir d’un conteneur Créer une image à partir d’un Dockerfile


Stocker et récuperer des images depuis le Docker Hub Mettre en place un registry privé et y stocker ses images

LE RÉSEAU AVEC DOCKER Comprendre la stack réseau de Docker Utiliser les links Docker Créer des networks Docker et connaître les drivers réseaux

LA PERSISTANCE DES DONNÉES AVEC DOCKER Créer et persister des volumes Docker (host/conteneur, inter-conteneurs) Bonnes pratiques de persistance de données avec Docker

L’ÉCOSYSTÈME DOCKER Créer des instances Docker avec Docker Machine Créer sa stack logicielle avec Docker Compose Orchestrer le déploiement de conteneurs sur plusieurs machines avec Docker

Swarm

CONCEPTS AVANCÉS Mettre en place une architecture microservices avec Docker (Service Discovery,

automatisation…) Sécuriser son infrastructure Docker (TLS, App Armor, SELinux…) Docker in Docker

Ansible


Comprendre l’organisation de Ansible (rôles, tâches, playbooks, modules…) Savoir utiliser et créer des playbooks pour gérer votre infrastructure

Public Développeurs, Architectes, Administrateurs systèmes Pré-requis Connaissances de base d’un système Unix (Savoir se débrouiller dans un terminal) Méthodes pédagogiques 40% Théorie / 60% Pratique Description Petit dernier des solutions de “Configuration Management”, Ansible a réussi à s’imposer face à ses grands frères (Chef, Puppet…) en proposant une solution alternative plus simple et moins contraignante. Ansible permet d’automatiser simplement et efficacement la mise en place d’infrastructures complexes et le déploiement d’applications.


Après avoir décrit les concepts autour d’Ansible (“Configuration Management”, “Infrastructure as Code”), cette formation vous apprendra à manipuler cet outil, gérer ses playbooks, ses rôles, les modules, et comment les appliquer sur votre infrastructure. Programme INTRODUCTION

Les concepts de Gestion de configuration et d’Infrastructure as Code Les différents outils de configuration et de déploiement (Puppet, Chef) Les spécificités Ansible

DÉMARRAGE AVEC ANSIBLE Installation et Configuration Commandes de base du CLI Ansible Gestion des accès SSH et des droits sudo L’inventaire Ansible

LES COMMANDES AD-HOC Commandes Shell et Parallélisme Les packages avec yum/apt Gestion des users et des services

LES PLAYBOOKS ANSIBLE Syntaxe Yaml La command ansible-playbook Définition des tâches Les rôles ansibles Utiliser des variables

LES MODULES Gestion des utilisateurs et des groupes Bases de données Travailler avec des services Cloud (Amazon, OpenStack) Utiliser et partager des rôles depuis Ansible Galaxy

STRUCTURES DE CONTRÔLE Les facts Les boucles & conditions Les inclusions

LES TEMPLATES Syntaxe de base Structures de contrôle Filtres

NOTIONS AVANCÉES Tester ses playbooks Ansible Développer ses propres modules Créer ses propres filtres


Devops - MasterClass

MasterClass Docker

Les MasterClass sont des sessions animées par des Soatiens pour des Soatiens. Chaque intervenant, experts dans son domaine donne la possibilité de monter en compétence : un moment de partage et de transmission de leurs connaissances et savoir-faire. Nous les ouvrons gratuitement sur candidature. Durée

4 sessions de 2 heures

Objectifs

Savoir installer, configurer et utiliser docker Connaître les caractéristiques d'un conteneur Linux Créer et manipuler des images avec les dockerfile Maîtriser les concepts de réseaux et de volumes Savoir utiliser les outils docker compose, docker swarm et la docker machine Intégrer docker au sein de ses projets

Programme LES CONTENEURS

Principe de conteneur Linux Cas d'utilisation Différences entre conteneur / VM Docker et son architecture TP0 : Installation de Docker TP1 : Créer et lancer ses premiers conteneurs TP2 : Interaction avec le Host

LES IMAGES Anatomie d'une image Persistence d'un conteneur Le Dockerfile TP3 : Créer ses premières images DockerHub Les registries TP4 : Publication d'une image

LES RESEAUX La stack de réseaux Docker Notion de ports Les drivers réseau TP5 : Manipulation des réseaux

LES VOLUMES La persistance des données Bonnes pratiques TP6 : Manipulation de volumes


L'ECOSYSTEME DOCKER LA DOCKER-MACHINE

Création de docker Hosts Configuration du docker CLI Travailler avec plusieurs Hosts

MANIPULER DES STACKS LOGICIELLES L'outil docker-compose Descripteur Yaml Build & Run Ajouter des instances TP7 : Création d'une stack logicielle avec docker-compose

ORCHESTRATION DE CONTENEURS Les orchestrateurs Docker Swarm Les stacks Les services

CONCEPTS AVANCES Architecture microservices Packaging et déploiement Clustering Isolation Service discovery

SECURISATION SSL et Certificats Communication sécurisée avec le Docker Host


Nos formations Java Java - Architecture et développement

Séminaire Microservices

Cf Programme dans le chapitre Architecture

GIT

Cf Programme dans le chapitre Devops

Conception d’API


Java 8 : lambdas, streams et collectors


Présenter la nouvelle syntaxe introduite en Java 8 : les « lambda expressions » Appréhender le nouveau concept d’interface fonctionnelle introduit en Java 8 Présenter l’API Stream et Collectors, API nouvellement créées

Public Développeurs Java Pré-requis Bonne connaissance du langage Java et de ses principales API, notamment l’API Collection. Connaissance de base des génériques. Méthodes pédagogiques 50% théorie, 50% pratique Description L’introduction des lambdas en Java 8 constitue une révolution pour le développeur. Des modifications profondes du langage sont introduites, ainsi que des patterns, notamment ceux du framework Collection. Les habitudes de développement introduites en 1998 sont en train d’évoluer et permettent de traiter les collections de très grande taille (entre autres) avec efficacité. Cette formation a pour objet de présenter les nouveautés du langage (les lambdas) au travers d’exemples précis issus de projets réels. Elle introduit la nouvelle API Stream, construite pour tirer parti de ces nouveautés dans le cas du traitement des collections de très grande taille. L’API Collector est également présentée en détails. Les nouveaux


patterns introduits par ces deux API sont tous examinés en détails, sur des exemples concrets. Programme

Présentation

Traitement de données jusqu’en Java 7, rappels sur le pattern iterator. Présentation de l’algorithme map / filter / reduce, application avec l’API

Collection.

Expression lambda

Introduction des expressions lambda sur quelques exemples. Règles d’écriture détaillées des expressions lambda. Notion d’interface fonctionnelle, compatibilité ascendante. Syntaxe method reference, exemples. Accès à l’état englobant d’une expression lambda. Utilisation du mot-clé this dans une expression lambda. Implémentation et performances.

Interfaces fonctionnelles

Définition d’une interface fonctionnelle, exemples. Interfaces fonctionnelles dans le JDK 8. Écriture d’interfaces fonctionnelles, exemples. API Collection et lambda expressions : évolutions des interfaces existantes. Nouvelles interfaces Java 8 : méthodes par défaut, méthodes statiques.

Perspectives Java 9. Utilisation pour de nouveaux patterns, exemples du JDK 8.

L’API Collection en Java 8

Panorama des nouvelles fonctionnalités. Patterns for-each, replace-if, do-if-absent, do-if-present. Fusion de tables de hachage.

L’API Stream en Java 8

Problématique de l’implémentation du map / filter / reduce avec l’API Collection. Notion de Stream : définitions, exemples. Patterns de création de streams. Opérations intermédiaires et terminales sur les streams, exemples. Étape de réduction, patterns. Problématiques des streams vides, introduction d’optional. Utilisation avancée d’optionals, exemples, patterns fondamentaux.

Notion de collector

Réduction simple et réduction complexe. Notion de réduction mutable, exemples. Notion de collector, patterns, exemples.


Classe Collectors. Écriture de collectors non disponibles dans le JDK.

Architecture Découplée avec RxJava


Découvrir RxJava et les concepts associés Écrire des applications Java utilisant RxJava Concevoir et mettre en place une architecture découplée avec RxJava

Public Développeur/Architecte Pré-requis Connaissance langage Java Méthodes pédagogiques 50 % théorie / 50 % pratique Description Auparavant, les applications se connectaient à une seule base de données. Aujourd’hui, elles doivent communiquer avec un ensemble de bases de données et composer avec des services web distants. Ce ne sont plus des blocs monolithiques, mais distribués sur différents serveurs, sur différentes zones géographiques. Elles sont “scalables” mais elles doivent désormais attendre les réponses d’autres applications. Comment profiter de ces temps d’attente ? Comment casser ce couplage temporel ? Comment transformer un couplage applicatif fort en couplage lâche ? Cette formation permettra de réaliser un tour d’horizon de RxJava, d’appréhender la mise en place cette bibliothèque sur un projet et dans une équipe. Egalement nous aborderons la façon d’utiliser ces bibliothèques pour découpler votre architecture. Programme

Couplage

Définition Différent type de couplage Différent moyen de découplage

RxJava

Historique Concept

Observable

Nature d‘un observable


Représentation d'un observable Type d’observable Création d’observable Manipulation observable Concept de monade Méthode create Programmation fonctionnelle Effet de bord

Observer

Contrat RxJava onNext / onError / onCompleted Subscriber

Opérateurs

Opérateur map Opérateur flatmap Opérateurs de compositions (merge zip…) Opérateurs de filtre Création d’un opérateur

Asynchronisme

Concept de Scheduleur ObserveOn ScheduleOn Quel scheduleur pour quel usage Test scheduleur Écrire son scheduleur

Pratique de RxJava

Composition de web service Utilisation avec un brocker de message Gestion des erreurs Test applicatif Utilisation de Single Utilisation de Completable

Nature d’Observable

Hot Observable Cold Observable

Abonnement

Concept d’abonnement Désabonnement

Pression arrière


Concept Utilisation Implémentation

Aller plus loin

Intégration avec Hystrix Intégration dans un contexte Java EE Intégration dans un contexte microservices Intégration dans une application Android

Spring


Découvrir et utiliser le framework Spring pour développer des applications java Comprendre les concepts et les avantages de la Programmation Orientée

Aspects (AOP) Développer une application Web avec Spring MVC Gérer la sécurité d’une application Spring

Public Développeur Java et chef de projet. Pré-requis Connaissance du langage Java Méthodes pédagogiques 50% théorie/ 50 % pratique Description Spring est le framework le plus populaire du monde Java et s’est imposé comme un standard des applications d’entreprises. Il offre un cadre de développement efficace afin de produire des applications robustes et évolutives. Cette formation a pour objectif de présenter les concepts fondamentaux de Spring ainsi que son fonctionnement dans un environnement réel. Afin d’utiliser au mieux les capacités de ce framework dans un cas pratique, vous aborderez la création d’une application web avec Spring, de l’accès aux données jusqu’à la sécurité de celle-ci. Programme

Introduction à Spring

Présentation de Spring Core et des différents projets satellites Les différents modules au sein de Spring

Le conteneur léger de Spring


Injection de dépendance Inversion de contrôle (IoC) Le cycle de vie des beans Les annotations et la configuration XML

La Programmation Orientée Aspect (AOP)

Concept de la Programmation Orientée Aspect Cas d’utilisation de l’AOP Les différents types de greffons (advices) : around, before, after, throws Les points de jonction (Join point) et coupe (Pointcut)

Accès aux données et JDBC avec Spring

Couplage Spring/JDBC (JdbcTemplate) Utilisation du pattern DAO (Data Access Object) Gestion des transactions dans Spring

Intégration de Spring avec Hibernate

Introduction au mapping objet-relationnel (ORM) L’API de normalisation de persistance (JPA) Configuration d’Hibernate et de Spring Le cache de second niveau et le lazy loading

Spring dans une application Web

Le pattern MVC (Modèle-Vue-Contrôleur) Les contrôleurs La gestion des vues Mise en œuvre du pattern MVC avec Spring MVC

Spring security

La sécurité d’une application web Gestion et Configuration de l’authentification et des autorisations La chaine de filtre de Spring Security

Initiation Domain Driven Design


Kotlin


Pratiquer le langage Kotlin Utiliser les nouveaux leviers apporter par le langage dans ces applications Migrer une application Java vers Kotlin


Public Développeurs et Architectes Pré-requis Connaissances Java Méthodes pédagogiques 50% de théorie et 50% de pratique Description “One More Thing”, c’est par la célèbre phrase de Steve Jobs que Stephanie Saad Cuthbertson, Product Manager chez Android, conclut son intervention lors de la conférence du Google IO 2017 qui s’est tenue le 17 mai 2017 à Mountain View. Après avoir prononcé ces trois mots, elle annonce l’officialisation du support du langage Kotlin pour la plateforme Android. S’ensuit une explosion de joie dans l’amphithéâtre qui se propage massivement sur les réseaux sociaux. Pourquoi et comment un produit dont Google n’est même pas l’auteur, peut-il provoquer autant d’engouement ? Cette formation fera un tour d'horizon des différentes fonctionnalités du langage Kotlin, ce qu’elles peuvent vous apporter et comment les appliquer sur vos projets. Programme

Syntaxe

Val versus var Nouveaux types Paramètre nommé, par défaut, Langage fonctionnel et lambda If statement versus when statement Object / class / data class / sealed class Collections en Kotlin Optional en Kotlin ? Les Exceptions

Utilisation avancé

Méthode d’extension Destructuring Variables Type réifier Infix annotation Inlining de code Operator : création et utilisation Generics : Invariance et Contravariance Delegates

Outils et écosystème

Utilisation du REPL Kotlin Utilisation de Kotlin avec un outil de build : Maven et Gradle


Chaine de compilation avec Kotlin

Migration Java / Kotlin

Interopérabilité : utilisation de Java avec Kotlin. Interopérabilité : utilisation de Kotlin avec Java. Compatibilité de bibliothèque de référence Java en Kotlin : Spring, JPA

Asynchrone

Coroutine Reactive Streams

Kotlin pour Android

Utilisation de Kotlin avec l’API Android Bibliothèque de référence en Kotlin Kotlin/Native KotlinJS Kotlin Puzzle : les pièges de Kotlin

Introduction à Cassandra

Cf Programme dans le chapitre Big Data


Java - Industrialisation des développements

Craftsmanship : Clean code Java

Cf Programme dans le chapitre Craftsmanship

BDD en environnement Java


TDD Java


Usine logicielle et intégration continue


Selenium



Nos formations Microsoft Microsoft - Architecture et développement

Séminaire Microservices


GIT



Microsoft - Mobilité

Développement d'applications universelles pour windows

Durée 3 jours Objectifs Développer une application universelle Windows & Windows Phone Store Optimiser ses développements et le partage de code Public Développeurs .NET Pré-requis Connaissance du langage C# et de XAML Méthodes pédagogiques 40% théorie / 60% pratique Description Ces dernières années, Microsoft a orienté sa stratégie de développement d’applications vers une unification des développements et poussé encore plus loin la mutualisation et le partage de code. Avec le concept d’application universelle, créer une application Windows 8.1 et Windows Phone 8.1 n’a jamais été aussi simple. Programme INTRODUCTION

Historique Windows Runtime & Windows Phone API Outils & Emulateurs

NAVIGATION ET CYCLE DE VIE Cycle de vie d’une application Navigation & Paramètres de navigation Etats de pages, Etats d’application URI & extensions de protocoles

MICROSOFT DESIGN LANGUAGE Concepts clés Les contrôles

ASYNCHRONISME Principe et enjeux Mots clés async/await

DONNÉES ET FICHIERS Manipulation de fichiers


Stockage local & Roaming de données Base de données locale

INTÉGRATION À LA PLATEFORME Les capacités d’une application Les vignettes (tuiles) Les contrats, launchers et choosers Les notifications Géolocalisation Tâches d’arrière-plan

Xamarin : Cycle complet


Appréhender les concepts propres à la mobilité Comprendre le fonctionnement et l’architecture de Xamarin Appréhender les architectures multiplateformes et les techniques de partage de

code Développer une application iOS et Android avec Xamarin Appréhender les concepts avancés propres à iOS et Android

Public Développeurs .NET voulant découvrir le développement d’application mobile avec la plateforme Xamarin. Pré-requis Connaissances du langage C# et de Visual Studio Avoir des notions en développement d’applications mobiles est un plus. Méthodes pédagogiques 50 % théorie / 50 % pratique Description Xamarin permet de développer des applications pour iOS et Android en C#. Cette technologie permet de capitaliser sur ses connaissances .NET et les mettre à profit du développement mobile, sans avoir à apprendre de nouveau langage. Xamarin ouvre ainsi de nouvelles possibilités de partage de code pour une application multiplateforme. Cependant, cela ne dispense pas des connaissances et problématiques liées à chaque OS. Cette formation permet de comprendre le fonctionnement de la plateforme Xamarin, d’appréhender les paradigmes liés à la mobilité, développer des interfaces et optimiser le partage de code. Programme Introduction au développement Mobile Xamarin

Se familiariser avec le modèle d’exécution de Xamarin Les modèles d’environnement et d’exécution Android / iOS


Stratégie de partage de code Outillages et distribution

Introduction au développement iOS avec Visual Studio Créer sa première application Xamarin.iOS Se familiariser avec le designer Xamarin.iOS Contrôles usuels et évènements de base Gestion des écrans et l’iconographie

Introduction au développement Android avec Visual Studio Comprendre la structure d’une application Android Se familiariser avec le designer Xamarin.Android Contrôles usuels et évènements de base Introduction au concept d’Activité Gestion du SDK Android

Android, Activités et Intents Comprendre et gérer une activité Navigation et passage d’arguments entre activités Récupérer les résultats d’une activité S’interfacer avec les activités systèmes

TableViews au sein d’iOS Introduction aux Tables View dans iOS Utiliser les styles de Cell par défaut Implémenter les comportements de sélection Implémenter la réutilisation des Cells

ListViews et adaptateurs dans Android Remplir une ListView avec un ArrayAdapter Gérer les évènements de la ListView Implémenter un adaptateur personnalisé Recyclage de données et le pattern « View Holder »

Les concepts de navigation dans une application iOS Progresser dans une application avec une navigation de type stack Utiliser la navigation par onglets La navigation hiérarchique (de type master/details) Organiser des pages d’information avec la navigation par page.

Les concepts de navigation dans une application Android La navigation de type stack Comprendre la notion de fragments La navigation par onglets Introduction à l’ActionBar Implémenter la navigation de type Drawer navigation

Introduction à Xamarin.Forms Qu’est ce que Xamarin.Forms ? La structure d’une application Xamarin.Forms Pages, Controls et Layout Utiliser des fonctionnalités spécifiques à la plateforme


Personnaliser les Table Views sous iOS Personnaliser les cells d’un table view dans le code Personnaliser les cells d’un table view à l’aide du designer Grouper des données dans un table view

RecyclerView et CardView dans Android Afficher une collection à l’aide d’un RecyclerView Répondre aux actions utilisateurs Mettre à jour l’UI après des changements de données Afficher des données dans un CardView

Travailler avec SQLite dans une application mobile Les options de stockages de données Travailler avec SQLite SQLite et asynchronisme

Développement Cross-Platform avancé Abstraction de comportements et fonctionnalités spécifiques L’inversion de contrôle Le pattern de type « Factory » Comprendre le « Service Locator » Se familiariser avec l’injection de dépendances L’injection de dépendances et les containeurs IoC

Performances et gestion de la mémoire Tâches et traitements asynchrones Comprendre Le Garbage Collector Tips de performances pour iOS Tips de performances pour Android

AutoLayout avancé et contraintes Activer Auto Layout dans le Designer Utiliser Auto Layout dans le designer Créer des contraintes dans le code-behind Animer des contraintes


Microsoft - Web

ASP.NET MVC : les fondamentaux


Comprendre l’architecture MVC et les principes de structuration du code. Mettre en œuvre les bonnes pratiques de développement d’une application avec

ASP.NET MVC. Acquérir une culture globale des différentes facettes du Framework ASP.NET

MVC.

Public Développeurs, chefs de projet techniques peu familiarisés à ASP.NET MVC ou souhaitant améliorer leur niveau afin d'avoir une vision d'ensemble de la plateforme. Pré-requis Maîtrise d’un langage .NET (idéalement C#) et connaissance du langage HTML. Méthodes pédagogiques 40 % théorie / 60 % pratique Description Depuis quelques années, Microsoft met en avant une approche radicalement différente d’ASP.NET WebForms pour la conception d’applications Web intranet et internet. Cette approche est essentiellement liée au Framework ASP.NET MVC ainsi qu’à quelques autres projets qui gravitent autour (WebPages, ASP.NET Web API, etc.). Cette formation a pour objectif de rendre opérationnel un développeur ou un chef de projet technique en lui présentant les différents aspects d’ASP.NET MVC. A l’issue de la formation, les participants seront en mesure de développer l’intégralité d’une application ASP.NET MVC classique, ou de travailler efficacement sous la supervision d’un responsable technique pour les scénarios les plus complexes. L’ensemble de bonnes pratiques et des réflexes acquis au cours de la formation permettront aux participants d’élaborer des livrables robustes et de qualité. Programme Introduction

La plate-forme Web de Microsoft Statefull et stateless L’outillage pour démarrer Pourquoi ASP.NET MVC ?

Vue d’ensemble Présentation du paradigme Structure d’un projet ASP.NET MVC Contrôleurs, actions et vues Modèle et liaison de données


Conception de formulaires Qu’est-ce qu’un modèle ? Annotations pour l’affichage Cinématique d’utilisation d’un formulaire Annotations pour la validation

Conception de vues (1) Introduction aux moteurs de vues La syntaxe de Razor HTML Helpers

Conception de vues (2) JavaScript et Jquery Validation côté client Bundling et minification Vues mobiles

Routage L’importance du SEO Paramétrer des routes Déboguer la table de routage

Personnalisation des contrôleurs Les types de retour d’une action Les filtres d’action Les sélecteurs d’action

Web API REST Création d’une API Les petits plus de Web API

Déploiement Ce qui doit être déployé Déploiement vers un serveur IIS Les transformations de configuration

ASP.NET MVC avancé


Comprendre les rouages internes d’ASP.NET MVC. Découvrir les bonnes pratiques pour créer des applications ASP.NET MVC

robustes. Identifier les points d’extensibilité du Framework ASP.NET MVC.

Public Développeurs, chefs de projet techniques ayant de solides bases sur le développement d’applications avec ASP.NET MVC.


Pré-requis Maîtrise d’un langage .NET (idéalement C#), connaissance du langage HTML, connaissance et pratique des différents aspects d’ASP.NET MVC. Méthodes pédagogiques 60 % théorie / 40 % pratique Description Cette formation a pour but de faire évoluer les participants vers des rôles de développeurs ou chefs de projets techniques spécialisés dans le développement d’applications ASP.NET MVC. Elle apporte le niveau de détails nécessaire à l’encadrement technique d’une équipe ou au développement de composants personnalisés répondant à des problématiques d’entreprise complexes. A l’issue, les participants seront en mesure d’appliquer l’ensemble des bonnes pratiques requises pour assurer un développement de qualité et rendre les applicatifs plus pérennes. L’approche utilisée par la formation consiste à analyser le fonctionnement interne d’ASP.NET MVC afin d’identifier et de mettre en œuvre des développements autour de ses points d’extensibilités. Elle permet aux participants d’acquérir un certain niveau d’abstraction et une méthodologie de réflexion afin de les rendre autonomes dans la découverte et la maîtrise des prochaines versions du Framework. Programme Gestion des métas donnés

Création d’attributs personnalisés Extensibilité de JQuery Validate pour supporter un validateur personnalisé Création d’un gestionnaire de métas donnés personnalisé

Moteurs de vues Gestion des moteurs de vues Fonctionnement de Razor Extensibilité des moteurs de vues Extensibilité des HTML Helpers Extensibilité des vues mobiles

Routage Le cheminement d’une requête Création de contraintes Extensibilité du routage

Les contrôleurs Le cheminement d’une requête Les contrôleurs asynchrones Area et structure d’une solution complexe

Sécurité Gestion des utilisateurs Se munir contre le XSS Cross Site Request Forgery

Optimisations et performances Utilisation du cache


Améliorer le rendu des vues Instrumenter les performances

Concepts avancés Se préparer pour l’international Injection de dépendances Tests unitaires

ASP.NET Web API


Comprendre l’historique et les enjeux liés à la conception d’une API Découvrir et mettre en œuvre le Framework ASP.NET Web API Apprendre les techniques pour concevoir, déployer et tester une API

Public Développeurs, chefs de projet techniques étrangers ou peu familiarisés à ASP.NET Web API ou souhaitant améliorer leur niveau afin d'avoir une vision d'ensemble de la plateforme. Pré-requis Maîtrise d’un langage .NET (idéalement C#) et connaissance du langage HTML. Une expérience avec ASP.NET MVC est un plus. Méthodes pédagogiques 40 % théorie / 60 % pratique Description L’explosion de nouvelles typologies de clients (tablettes, téléphones, etc.) et l’arrivée d’applications Web riches (SPA) s’accompagne pour les entreprises de la nécessité de trouver des compétences autour du développement d’API en exposant une interface souple et évolutive, qui respecte les standards mondiaux, tout en restant sécurisée et capable de supporter une montée en charge. A l’issue de cette formation, les participants seront en mesure de concevoir et de développer une API basée sur ASP.NET Web API. Ils auront acquis toutes les connaissances nécessaires pour exposer des données en respectant les différents standards utilisés en entreprise (REST, OData), de manière sécurisée et assez souple pour supporter des évolutions futures. Les participants auront également été initiés aux différentes pratiques liées à la qualité et à son industrialisation (tests unitaires, tests d’intégration), et au déploiement de leurs APIs. Programme Introduction

ASP.NET Web API .NET et la programmation asynchrone

HTTP et Rest


XML-RPC et SOAP Penser ressources – Guide de design d’une AAPI Les liens hypermédia et HATEOAS

Création d’une API Ecriture d’une API Gestion de la configuaration d’un projet Web API La négociation de contenu Validation du modèle entrant

Routage Utilisation de la table de routage Routage par attribut Gestion du versionnage d’une API Mise en place de liens hypermédias

Gestionnaires de messages Le cheminement d’une requête et d’un message Requêtes groupées Création d’un gestionnaire personnalisé (gestion d’un jeton CSRF)

Concepts avancés Injection de dépendances Tests unitaires Tests d’intégration

OData Qu’est-ce que OData ? Activation de OData avec Web API Ecriture de fonctions OData

Sécurité Authentification basique et authentification Windows Utilisation de oAuth CORS

Déploiement d’une solution ASP.NET Web API Vers un serveur IIS Mode autonome OWIN et Katana Analyse des performances et journalisation

Evoluer vers ASP.NET Core et ASP.NET MVC Core


Maîtriser le fonctionnement de base d’ASP.NET Core et de .NET Core. Identifier les fonctions essentielles de la plate-forme Etre en mesure de migrer un projet ASP.NET MVC existant vers ASP.NET MVC

Core


Public Développeurs, chefs de projet techniques utilisateurs d’ASP.NET MVC. Pré-requis Maîtrise d’un langage .NET (idéalement C#) et pratique d’ASP.NET MVC 4 ou ASP.NET MVC 5. Méthodes pédagogiques 40 % théorie / 60 % pratique Description Cette formation a pour but de faire évoluer un développeur ASP.NET MVC 4/5 vers la plate-forme ASP.NET Core et ASP.NET MVC Core. Le programme met l’accent sur les principes fondamentaux du runtime derrière ASP.NET Core, sur toutes les routines de bases disponibles au travers du framwork et sur les nouvelles fonctionnalités d’ASP.NET MVC Core. A l’issue de la formation, les développeurs et les chefs de projet techniques sont en mesure d’être autonomes pour démarrer le développement d’une nouvelle application ASP.NET MVC Core ou pour commencer la migration d’une application existante vers ASP.NET MVC Core. Programme Introduction

La plate-forme Web de Microsoft Statefull et stateless Pourquoi migrer vers ASP.NET Core et ASP.NET MVC Core ?

Outillage Développement sous Windows Développement sous Linux Développement sous Mac OS X Kestrel

OWIN et Katana L’origine du besoin et la spécification OWIN Comprendre et débuter avec Katana Personnalisation et usages avancés de Katana

ASP.NET Core et .NET Core .NET Core Démarrage d’une application Commandes Gestion de la configuration et OptionsModel Injection de dépendances

Vue d’ensemble Présentation du paradigme Structure d’un projet ASP.NET MVC Contrôleurs, actions et vues Modèle et liaison de données


Conception de vues Localisation des vues Tag Helpers Composants de vues Grunt, gulp et bower Vues mobiles

Evolutions notables Le routage Les web APIS Les contrôleurs POCO

Déploiement Ce qui doit être déployé Déploiement vers un serveur IIS Déploiement vers Azure Déploiement vers Docker Les transformations de configuration

Migration d’une application existante Migrer une application vers .NET Core Migrer de ASP.NET MVC 5 à ASP.NET MVC Core Migrer de ASP.NET Web API 2 à ASP.NET MVC Core


Microsoft - Tests

Craftsmanship : Clean code C#


BDD en environnement .NET


TDD C#



Microsoft - Cloud


Cf Programme dans le chapitre Cloud

Microservices avec Service Fabric

Cf Programme dans le chapitre Cloud


Nos formations Mobile Reactive Architecture avec Kotlin


Kotlin

Cf Programme dans le chapitre Java

Développement d'applications universelles pour windows

Cf Programme dans le chapitre Microsoft

Développer une application iPhone avec Swift


Maîtriser les bases du langage Swift Connaître les bonnes pratiques liées au langage Créer une application iPhone avec Swift

Public Développeurs avertis tous langages Développeurs Objective-C souhaitant appréhender le nouveau langage d'Apple Pré-requis Développer dans d'autres langages orientés objet (niveau débutant à intermédiaire) Méthodes pédagogiques 40% théorie / 60% pratique Description Vous avez toujours voulu réaliser des applications iPhone ou iPad mais Objective-C vous a découragé ? Vous connaissez déjà Objective-C et vous souhaitez vous tenir à jour ? Vous souhaitez appréhender le nouveau moyen de développer des applications pour l'éco-système Apple ? Découvrez Swift, le nouveau langage d'Apple annoncé comme l'avenir de la plate-forme. Au travers de cette formation pratique, vous apprendrez de manière pratique les bases essentielles du langage et ses spécificités avant de réaliser une application iPhone simple en utilisant avec Swift les nombreuses API d'Apple Programme

PRISE EN MAIN : PLATE-FORME


Principes de la plate-forme Découverte d’Xcode Documentation Composants du modèle d’application Réalisation d’une application mono-écran Architecture MVC Cycle de vie d’une application

PRISE EN MAIN : SWIFT

Structures algorithmiques var/let, mutabilité/immutabilité Écriture et appel de fonctions Collections d’éléments Structures algorithmiques

Avancé : SWIFT

Structures de données (tuple, struct, enum, class) Concept d’Optional Protocol Closure

ARCHITECTURE : IOS

Outils de navigation Organisation des contrôles avec Autolayout Réalisation d’une application avec navigation par liste et onglets

AVANCÉ : IOS

Charger des données d’internet Écrire des informations sur l'appareil Test des performances Déploiement sur un appareil physique

Xamarin : Cycle complet



Nos formations Web Web - Javascript

React


Découvrir l’écosystème ReactJS Comprendre le fonctionnement et l’intérêt de ReactJS Appréhender et mettre en place Redux Créer une application simple en Single Page

Public Développeurs désireux de découvrir une solution simple et puissante pour construire de nouvelles applications modernes et performantes Pré-requis Une bonne connaissance du JavaScript (ES2015 est un plus) et de solides notions en développement “front”. Méthodes pédagogiques 50 % théorie/ 50 % pratique Description Bien plus qu’une mode ou qu’une alternative à AngularJS, ReactJS tend à s’imposer comme la librairie de référence pour la création d’applications riches, rapides et agréables à développer. Durant ces deux jours de formation, aussi théorique que pratique, nous aborderons ce qu’est ReactJS, découvrirons son écosystème, et commencerons à créer une application simple. Nous aborderons également les concepts clés de ReactJS afin de pouvoir les appliquer au cours des différents travaux pratiques centrés sur une même application. Programme INTRODUCTION ● Historique ● Quelques chiffres ● Pourquoi ReactJS plutôt qu’un autre framework ? RÉCAPITULATIF ES2015 ● ES2015 et l’ES5 avec ReactJS ● Les features ES2015 à connaître CONCEPTS ● Virtual DOM et Reconciliation ● Components, ceux qui existent…


● … Et ceux que l’on définit ● Un mot sur le JSX COMPONENTS ● Cycle de vie d’un Component ● State et Props ● Le rôle de la méthode render OUTILS DE DÉVELOPPEMENT ● Installation des outils via NPM ● Babel, ses presets, ses plugins ● Utilisation de Webpack pour créer les fichiers JavaScript ● Test avec Enzyme, Mocha et Chai ● Create React App REDUX ● Flux et Redux ● Pourquoi Redux, cas d’application complexe ● Concepts important, immutabilité, un seul « State », … ● Comprendre ce que sont les stores, les actions et les reducers SINGLE PAGE APPLICATION ● SPA ou Isomorphisme ? ● Une single page application avec react-router LES FORMULAIRES ● Quelques concepts clés, Component contrôlé ou non contrôlé ● Création de formulaires avec react-form ISOMORPHISME ● Qu’est-ce que l’isomorphisme… ● … Et qu’apporte-il ? ● Un mot sur Node.JS

Angular 4 / 5


Maitriser les caractéristiques du nouveau framework Mettre en œuvre une architecture par composants avec flux unidirectionnel Mesurer la qualité du code par les tests

Public Développeurs et architectes web


Pré-requis Pratique d’HTML, CSS et Javascript Méthodes pédagogiques 50 % théorie/ 50 % pratique Description Le passage d'Angular 1 à Angular 2 et les versions suivantes n'a pas été qu'une simple évolution, c’est un tout nouveau framework qui nous a été proposé. Nouveau langage avec TypeScript, nouvelle syntaxe de vues, orientation web components, programmation réactive, flux unidirectionnel et architectures de type Flux sont les nouveaux concepts à appréhender. Les imperfections inhérentes à la première version ont disparu au profit d’une meilleure évolutivité et d’une meilleure performance. Dans cette formation vous aborderez Angular 2 ainsi que les nouveautés de la version 5.. Programme Environnement et principes

Présentation générale, dépendances du framework Mise en œuvre d’un environnement de développement autonome avec Webpack

TypeScript / ES6 L’objet : classes, constructeurs, variables et méthodes privées, publiques et

statiques, héritage et super. Typage de variable, interfaces, retours de fonctions Fonctions, paramètres, affectations déstructurées Maitriser this avec les arrow functions Les annotations Modules, import et export

Modules Bootstrap de l’application principale Organiser son application en modules Stratégies de déclarations et instanciations

Components Une hiérarchie de components Paramètres de l’annotation @Component Cycle de vie, détection du changement et hiérarchie

Vues / Syntaxe Templates et template string, expressions Input, output, input-output Directives ngFor, ngIf, ngSwitch. ngClass, ngContent, ngStyle

Services et injection de dépendance L’annotation Injectable Providers, instanciation et injection des services, hiérarchie et portée

Flux unidirectionnel avec Redux Gestion d’état de l’application, immutabilité des données et fonctions pures. Composition du Store, connection, action creators, reducers, middlewares


Pipes

Pipes fournis (uppercase, lowercase, percent, currency, async…) Créer ses Pipes

Router Mode Html5 et base href Configuration des routes, imbrication de routes Directives du router Navigation et manipulation d’url Interception des changements de route

HTTP Http, Response, Headers Les méthodes et paramètres Http. (GET, POST, PUT, DELETE, JSONP) Rappel sur les promises, gestion du résultat par Observable Gestion des erreurs

Directives Directives structurelles Directives attributs

Formulaires Directives de formulaires Soumission, validation et gestion des erreurs Groupes de contrôles, objet Control

Tests unitaires Configuration karma Jasmine / assertion Stratégies de tests : component, directive, service, pipe Mock des données, Spy des services Gestion de l’asynchrone Tester le router

Node JS


Installer et configurer un serveur Node.JS Comprendre les concepts utilisés par Node.JS Maîtriser l’écosystème et les outils comme NPM ou Grunt Être capable de créer des applications web

Public Développeur serveur, avec des bases en JavaScript souhaitant créer des applications rapides et robustes


Pré-requis Connaissances en développement côté serveur (PHP, Python, Ruby, Java...). Connaissances minimales de la syntaxe JavaScript et de ses spécificités (Closure, Prototype, Scope, …) Méthodes pédagogiques 50% théorie / 50% pratique Description Node.JS a beaucoup fait parler de lui au cours des 5 dernières années. Utilisant le moteur V8 de Google, reposant sur des concepts innovants et terriblement efficaces comme un système d'IO non bloquant ou une boucle d'événements unique, Node offre d'excellentes performances. Utiliser des technologies nouvelles comme MongoDB ou encore permettre une communication serveur/client immédiate via les WebSockets est très simple avec Node JS. Au cours de cette formation, nous aborderons l’installation de l’exécutable Node et développerons une application web aussi complète que productive. Programme Présentation de Node.JS

Bref historique sur Node.JS Intérêt du JavaScript côté serveur Node.JS, NPM et modules

Installation de Node.JS Installation de Node.JS Installation de NPM

Concepts principaux de Node.JS et leur représentation dans le code Qu'est-ce que l'Event Loop (Boucle D’événement)? Que signifie "Non-Blocking IO" (IO Non Bloquant)? Difficultés de la programmation asynchrone (Callbacks, …) Création d’événements personnalisés avec la classe EventEmitter

Aides à la programmation asynchrone Les Promises La librairie Bluebird

L’API Node.JS Présentation de quelques modules importants Un outil puissant de gestion de flux: les streams Les variables globales : process, require, __dirname, … Interactions avec d’autres fichiers grâce à fs ou path Interactions avec l’environnement via les modules os ou child_process

Module NPM CommonJS et "require" NPM Anatomie d'un package NPM Création d’un module


Architecture

Serveur Web avec Express Utilisation de l'API de base mise à disposition par Node.JS (net/http) Découverte d'Express (Framework Web) Création de routes personnalisées Gestion des erreurs

Middleware Définition du Middleware Utiliser et définir des middlewares dans Express

Task Runners Comprendre ce qu’est un task runner Utiliser l’outil Gulp

Templates et langages Comprendre ce qu'est un moteur de template Avoir une vision simple de la syntaxe Jade “Apprendre” de nouveaux langages Utiliser Gulp pour des travaux de “compilations”

Persistance des données - MongoDB Un mot sur le SQL - les ORM (Object-Document Mapper) Bookshelf et Sequelize MongoDB et le JavaScript Utiliser l'ODM (Object-Document Mapper) Mongoose

Authentification - Passport Aborder l’authentification en Node.JS grâce à la librairie Passport Être capable de se connecter à un serveur

Les WebSockets Introduction au concept Alternatives : Polling/Long Polling Utiliser le framework Socket.io côté serveur Un mot sur le client

Tests Tests unitaires avec Mocha et Chai


Web - Microsoft

ASP.NET MVC : les fondamentaux


ASP.NET MVC avancé


ASP.NET Web API


Evoluer vers ASP.NET Core et ASP.NET MVC Core



Web - Industrialisation & Tests

Selenium



Web – MasterClass


MasterClass Front

Durée 4 sessions de 2 heures Objectifs

Découvrir le front, se sensibiliser à l'UI, le CSS et le responsive design Apprendre le JavaScript, les bases, les caractéristiques du langage Mettre en place un projet complet avec Webpack Utiliser un framework orienté UI : React ... Une state machine aux patterns structurants : Redux

Méthodes pédagogiques

50% de théorie et 50% de pratique

Programme

L'idée générale étant de pouvoir se mettre à niveau, combler ses lacunes potentiels, ne pas faire l'impasse sur le CSS ou le responsive design, qui font partie intégrante du front, et enfin avoir de bonnes notions sur la création d'un projet en partant de zéro et en utilisant React et Redux

Documents

Catalogue Formations Mai 2018 - SOAT · omprendre et définir le périmètre d’action du Scrum2aster Comprendre la différence de positionnement du ScrumMaster par rapport au Chef