Introduction

• La rupture culturelle par rapport aux méthodes classiques de gestion de projet.
• L’alliance Agile, le manifeste Agile. Les principes.
• Panorama des principales méthodes Agiles.
• Les méthodes agiles en chiffres.

Mise en situation
“Bilan des projet S.I“ : un projet SI : objectifs, facteurs de risques, facteurs de réussites, ralentisseurs. Découverte de l’approche agile.

La formalisation des exigences en agile

• Techniques de description des besoins fonctionnels et des exigences qualité
• Les features, les Users Stories.
• La notion de “Backlog du produit”. Comment construire le backlog initial, comment le mettre à jour.
• Comment rédiger les User Stories.
• L’actualisation des stories : les feedbacks de la démarche itérative, le product grooming.
• La valeur d’une story, la Business Value.
• Les tests d’acceptation : une aide à l’expression des besoins, une approche pour valider les exigences.
• Construire des stories tests.

Travaux pratiques
Initialiser un projet en identifiant les principales stories. Description sommaire des stories.

Priorisation des “User Stories”

• La planification basée sur la valeur.
• Utilité du modèle de Kano. La méthode Moscow.
• Calculer les valeurs ajoutées – la valeur client pour chaque story à planifier dans la release.
• Priorisation des stories basée sur le risque et sur la valeur client.

Travaux pratiques
Prioriser les stories en fonction de la valeur client.

La planification des releases

• Le découpage du projet en releases. Construire la roadmap
• Définir les sprints ou les itérations du projet
• Evaluer des charges, évaluation de la taille des stories : le Planning Poker.
• Définition de la vélocité de l’équipe.

Travaux pratiques
Mise en situation : approche de la relativité des estimations de charges. Story Mapping pour réaliser la Roadmap du projet.

Planification et organisation des itérations

• Construire le Backlog de sprint, identification des tâches, planification.
• Mise en œuvre d’une amélioration continue : l’animation des revues et les rétrospectives de fin d’itération.
• La planification journalière : daily scrum ou standing meeting : l’objectif, l’organisation.
• L’organisation du développement. Le WIP, les itérations de développement de XP.
• Les principes d’ingénierie : conception simple, amélioration du code par la réécriture, intégration continue.
• Préciser la définition du fini (done) d’une release, d’un sprint, d’une tâche…
• Les indicateurs d’avancement : la release et le sprint Burndown Chart , le Work In Progress de Kanban.
• Les autres indicateurs utiles.

Exercice
– Elaborer un backlog de sprint. Découpage des stories en tâches. Planification d’un sprint. – Mise en situation Daily Scrum. – Mise en situation : séance de revue. – Prise en compte des éléments de suivi, actualisation des burndown du projet.

Les clés du management de l’équipe Agile

• Les rôles en agile : le Product Owner, le Scrum Master, l’équipe de développement, le testeur, le tracker, le coach.
• Communication adaptée au management agile.
• Le leadership, l’intelligence émotionnelle pour la gestion de l’équipe.
• Distribution des responsabilités en management du projet.

Jeu de rôle
Jeu de rôle sur les différentes responsabilités intervenant au sein des projets agiles.

Mise en œuvre des méthodes agiles

• Les outils agiles. Les tableurs, les outils spécialisés. Présentation des principales fonctionnalités offertes.
• Spécialisation. Comment passer du cadre générique de l’offre agile à une démarche adaptée à l’entreprise et au projet ?
• Les étapes de la transition d’une démarche classique vers une approche agile.
• L’accompagnement du changement. Le contexte, définir les objectifs du changement. Le rôle du coach.

Réflexion collective
Cartographier les concepts agiles par intérêt pour son organisation. Rechercher des axes de progrès.

Le Framework Scaled Agile

• L’équipe Agile intégrée dans un programme, dans une solution large et dans un portefeuille.
• Les principes SAFe®.
• Autres principes issus du Lean et du Manifeste Agile.
• Exemples de techniques utilisées par les équipes agiles.

Travaux pratiques
Expérimentation de la réduction du travail en cours. Expérimentation de l’impact de la taille des “batchs”.

Collaboration entre équipes agiles

• La constitution d’une équipe agile.
• L’importance de la colocalisation.
• S’organiser pour produire de la valeur.
• Scrum Master et Product Owner.
• Présentation de ce qu’est un Agile Release Train (ATR).
• ART avec plusieurs équipes. Les rôles spécifiques.

Mise en situation
Serious Game de cohésion d’équipe (exemple : Ball Game).

Planifier l’itération d’un ensemble d’équipes

• Les différents Backlogs (contenu et gestion).
• Comprendre la différence entre Epic, Capability, Feature et User Story.
• Le Backlog de chaque équipe avec des User Stories.
• Estimation et vélocité.
• Planification d’une itération.

Travaux pratiques
Ecriture de User Stories avec des critères d’acceptation. Estimation et calcul de vélocité.

Le déroulement d’une itération (vue par l’équipe)

• Organisation des activités (visualiser et mesurer le flow).
• La qualité et les tests au quotidien.
• DevOps, intégration et déploiement continu.
• Daily Meeting et affinage du Product Backlog.
• La revue de fin d’itération.
• La rétrospective d’équipe.

Travaux pratiques
Construction d’un board de suivi. Exécution d’un Daily Meeting, exécution d’une rétrospective.

Le déroulement d’un Program Increment (par plusieurs équipes)

• Le PI Planning : déroulement, compréhension des objectifs, fonctionnement détaillé.
• Comment les équipes se synchronisent au quotidien ?
• Apprendre ensemble : l’itération “innovation et planning”.

Exercice
Identification des dépendances.

Préparation à l’examen “SAFe 5 Practitioner”

• Conseils pour le passage de l’examen.
• Vidéo d’explication du déroulement.

Origine et définition de l’Agilité

• Pourquoi l’Agile ? Les limites des méthodes traditionnelles.
• Une nécessaire adaptation à l’écosystème actuel.
• Une rupture culturelle par rapport aux méthodes classiques de gestion de projet.
• Les raisons d’être de l’Agilité. Lever les idées reçues.
• Le Manifeste Agile, les principes. Les bénéfices.
• La proposition de valeur de l’Agilité.

Aperçu des pratiques Agiles les plus répandues

• Un panorama des principales méthodes Agiles (Scrum, eXtreme Programming, Kanban, Lean Start’up, management visuel…).
• Les notions de framework Agile : méthodes, principes et pratiques.
• Un nouveau paradigme de gestion de produits. Exemple avec le Lean Start’up.
• Un aperçu des grands principes et des méthodes Scrum et Kanban.
• L’intérêt et le fonctionnement du management visuel.

Mise en situation
Atelier : illustration du processus Scrum.

Les impacts de l’Agilité sur l’organisation

• Ce qui change pour les rôles (Scrum Master, Product Owner, Parties prenantes…), les responsabilités et les équipes.
• Un positionnement managérial différent (Command and Control versus Servant Leadership).
• Le pilotage des projets par la valeur : impacts sur la gestion des budgets et la contractualisation.
• L’organisation des projets : outils de management, rythme de travail, mode managérial, communication…
• La planification des projets : itérations, estimation des charges, différents niveaux de planification…

Mise en situation
Atelier : Speedboat sur les changements vers les rôles Agiles.

Le projet de Transformation Agile

• Définir son projet de Transformation Agile : les objectifs, le périmètre, les acteurs et le projet.
• Les opportunités (une meilleure efficacité tout en sécurisant les équipes) et les risques d’une Transformation Agile.
• Définir la mesure et les conditions du succès.
• Les clés d’une conduite de changement spécifique.
• La rétrospective de la session.

Inviter la culture agile dans les projets de l’entreprise

• Adapter la culture de l’entreprise à l’évolution de son environnement concurrentiel.
• Répondre aux exigences du “time to market” : comment faire ?
• Comprendre les différents « mouvements » agiles : Scrum, Kanban, XP, Lean, Lean startup, Design Thinking.
• Saisir les bénéfices de la culture agile face à un monde en constante évolution.
• Impliquer les équipes dans la démarche agile.

Mise en situation
Atelier Serious Game : rythme et organisation des équipes agiles.

Réaliser ses produits et services, une dynamique d’équipe avec Scrum

• Comprendre les rôles et responsabilités dans Scrum.
• Intégrer les outils et rituels agiles : « événements » et « cérémonies » dans Scrum.
• Structurer l’expression du besoin en mode agile.
• Stimuler l’amélioration continue.
• Assurer la constance du feedback.

Mise en situation
Ateliers Serious Game : priorisation, gestion du risque et dynamique d’équipe sur un projet agile. Expression du besoin en agile : orale ou écrite ? quand ? pourquoi ?

Faire vivre son activité et ses produits avec Kanban

• Gérer son flux de création de valeur avec l’outil Kanban.
• Optimiser son flux de création de valeur avec l’outil Kanban.
• Finir ce que l’on commence en délimitant son périmètre de travail.
• Adopter le management visuel : les bénéfices.

De l’idée au produit : un cheminement agile

• Stimuler la créativité et faire émerger les idées : brainstorming, Lean Canvas …
• Créer des “Personas” : penser “utilisateur” pour bien cibler ses produits et services.
• Bâtir son approche stratégique : faire émerger les chemins critiques.
• Organiser son approche tactique : visualiser et organiser les activités.
• Estimer et planifier : planning poker, wall planning, plan de release.
• Utiliser le storytelling.

Travaux pratiques
Ateliers : “Lean Canvas “, “Personas”, “Impact Mapping”, “User Story Mapping”, “Backlog et User Stories”, “Estimation et projection”.

Reprendre en main ses produits

• Conduire le changement agile dans son organisation.
• Adapter son positionnement et sa posture.

Besoin d’une Agilité efficace à l’échelle

• Limites au modèle industriel des organisations.
• Enjeux de la complexité croissante des entreprises.
• Limites des différentes méthodes Agiles classiques.
• Extension de l’Agilité au hardware et aux opérations.

Conditions nécessaires au passage à l’échelle

• Lien entre contexte organisationnel et méthode de pilotage.
• Comportements et valeurs à cultiver dans les équipes.
• Accompagnement du changement, sa nécessité et ses pièges.
• Nouveaux rôles et défis du management face au ScrumBut.

Comparaison des frameworks « Agile à l’échelle »

• Scrum à grande échelle avec LeSS (Large Scale Scrum).
• Framework « Scaled Agile Framework » (SAFe®).
• DaD (Disciplined agile Delivery).
• Comparaison, atouts et restrictions des frameworks du marché.

Présentation de Nexus, l’exosquelette Scrum à l’échelle

• Qu’est-ce que Nexus ?
• Rôles, Nexus Integration Team, événements, artéfacts Nexus.
• Règles de fonctionnement de Nexus.
• Découverte des 50 pratiques Nexus.

Outils à destination des équipes connexes à Nexus

• L’apport de la valeur aux clients : personas et cartes d’empathie.
• Le « Why » de Simon Sinek.
• Les pratiques orientées solution client.
• La culture de l’itération business, le « Lean Startup » par Eric Ries.
• L’Agilité business avec le Business Model Canvas (BMC).

Facilitants Nexus

• Gestion des dépendances et affinage multi-équipes.
• Avancement visuel du « Product Backlog » à l’échelle : le « TreeMap ».
• « Impact Map » : la visualisation objectif livrable issue de l’armée.
• Estimation de la valeur : « opportunity canvas » et « story mapping ».
• Mesure de l’expérience utilisateur avec le « NetPromoter Score ».

Pratiques et outils indispensables à Nexus

• Le « Definition of Done » à l’échelle.
• L’intégration continue et ses solutions, le versioned API management.
• Acceptance Test Driven Development (ATDD).
• Test Driven Development (TDD).
• Solutions de tests automatisés du marché.

Plan et trajectoire : Agile à l’échelle, Nexus, et transformation numérique

• Le paradoxe de Solow et les leçons de croissance des startups.
• Les modèles de transformation numérique.
• L’impact sur les métiers : DevOps, Managers, Experts, Designers, Chefs de projets, etc.
• Le traitement de la résistance des équipes connexes, la budgétisation de l’Agilité à l’échelle.

Introduction

• Le contexte et les origines des méthodes Agiles.
• La gestion de projet classique.
• Les raisons d’être de l’agilité.
• Dans quel contexte l’approche Scrum est-elle efficace ?
• Présentation des grands principes retenus par la méthode Scrum : une vue globale.

Mise en situation
Ateliers : comprendre la problématique des projets “classiques”. Découvrir les concepts agiles.

La démarche et l’organisation dans un projet Scrum

• Le cycle de vie d’un projet Scrum.
• Une approche itérative et incrémentale : les release, les stories.
• L’intérêt d’itérations identiques.
• L’auto-organisation et la collaboration.
• L’amélioration continue.
• Présentation de la responsabilité de chaque acteur Scrum : le Product Owner, le Scrum Master, l’équipe de développement.
• Quelles sont les compétences souhaitées ?
• D’autres rôles : le coach, le facilitateur, les stakeholders.
• Vue synthétique des processus dans un projet Scrum.
• La gestion des changements dans Scrum.

Mise en situation
Atelier : Compréhension des différents rôles intervenant sur le projet Scrum.

Les points-clés et les artefacts dans le projet Scrum

• Le cycle de vie d’un projet Scrum.
• L’itération, la notion de Sprint.
• Exigences produit, le Backlog produit (liste des “User Stories”).
• Tâches à réaliser sur un sprint, le Sprint Backlog.
• La notion de “Reste à Faire”, les Burndown Charts.
• Le Sprint Planning Meeting, la planification du Sprint.
• Le plan de releases, la Release Planning Meeting.

Echanges
Définir pour le projet la signification du “fini” pour une release, un sprint, une User Story.

Définition des exigences et des priorités

• Définition détaillée de la “User Story” (histoires d’utilisateurs).
• La notion de “valeur business” d’une Story.
• Workshop d’écriture des Users Stories, Product Backlog Grooming.
• Ecriture du test de recette qui valide une Story.
• Les fonctionnalités retenues, le Backlog produit (“le carnet de produit”).
• Prioriser les fonctionnalités, le modèle de Kano.
• Les outils pour la gestion des exigences.

Exercice
Décrire une User Story à partir des différentes méthodes proposées. Partant d’un besoin exprimé par le client, identifier, décrire et prioriser les Users Stories correspondantes. Aborder la notion de “valeur business” des Users Stories, pour les prioriser.

Les principes de planification Scrum

• Découpage d’un projet en releases.
• Les points d’effort pour une User Story.
• Le Planning Poker pour estimer l’effort.
• Mesure de la capacité de réalisation de l’équipe.
• La planification de la release : associer les éléments du backlog aux sprints.
• Construire le plan de release, la Roadmap.

Exercice
Découvrir l’estimation des charges sur Scrum. Du story mapping à la Roadmap : conduire une séance de Planning Poker. Identifier les différents sprints et construire un plan de release.

Organisation et déroulement d’un sprint

• La réunion de planification du sprint (Sprint Planning Meeting).
• Définition du périmètre du sprint.
• Comment déduire les tâches à partir des stories du backlog de produit.
• Définition du plan contenant la liste des tâches (Le backlog du sprint).
• Estimation collective des charges pour chaque tâche. Engagements de l’équipe.
• Tâches prioritaires. Affectation des tâches non réalisées sur les sprints précédents.
• Affectation des tâches par les membres de l’équipe pour le démarrage du Sprint.
• Valider les prérequis au lancement d’un sprint .
• L’organisation du travail au quotidien, le Daily Meeting.
• Définir l’avancement, la notion de “Done”.
• La fin et la revue d’un Sprint, “Sprint Review”.
• Le feedback, l’amélioration continue.

Exercice
Daily Meeting, l’intérêt d’une vue partagée du projet. Élaborer un blacklog de sprint : identifier les tâches des stories du premier sprint. Atelier groupe : mettre à jour les burndows de sprint et de release à la fin du premier sprint.

Mettre en place Scrum

• Scrum et la sous-traitance.
• Motivation et rythme de l’équipe. L’accompagnement du changement.
• Outils et leurs valeurs ajoutées. Présentation de différents outils dédiés à Scrum.
• Ingénierie logicielle : conception simple, programmation en binôme, intégration continue.

Mise en situation
Atelier : rétrospective sur la mise en place de Scrum dans son organisation.

Introduction de Scrum dans le contexte SAFe®

• Concepts du développement agile.
• Le manifeste agile et la mise à l’échelle.
• Les bases de Scrum.
• Une équipe agile dans une entreprise SAFe®.
• Les principes et les rôles SAFe®.
• Événements spécifiques à la gestion de l\\’agile release train.
• Le rôle du ”release train engineer”.

Réflexion collective
Les valeurs Scrum et la transparence.

Le rôle du Scrum master

• Les responsabilités du Scrum master vis-à-vis de l’équipe.
• Les responsabilités du Scrum master dans un contexte SAFe®.
• Les compétences d’un Scrum master efficace.
• Constituer des équipes performantes.
• Coacher l’équipe agile.
• Collaborer avec d’autres équipes.
• Gérer les conflits d’équipe.

Réflexion collective
Rôle et responsabilités du Scrum master. Un jour dans la vie d’un Scrum master. La pire et la meilleure réunion organisée.

Planification d’un increment program (PI planning)

• Préparation de l’événement.
• Créer et revoir la planification du program increment (PI).
• Finaliser les plans et les objectifs du PI.
• S’engager sur les objectifs du PI.
• Faciliter le processus de planification de l\\\\’incrément.

Travaux pratiques
Écriture de features. Écriture de user stories avec des critères d\\\\’acceptation. Estimation de complexité en points. Simulation du déroulement d’un PI planning.

Faciliter l’exécution de l’itération

• Planifier une itération.
• Suivre l’avancement de l’itération.
• Affiner le backlog.
• Faciliter la revue de l’itération.
• Faciliter l’amélioration continue.
• DevOps et la livraison à la demande.

Travaux pratiques
Simulation de la planification d’une itération dans l’équipe. Scrum master et DevOps.

Terminer un program increment

• Coacher l’itération ”innovation et planification”.
• Le system demo.
• Mesure de la performance du PI.
• Les ateliers de résolution de problème.
• Le rôle du Scrum master dans l’inspection et l’adaptation.

Travaux pratiques
Quels techniques et outils pour coacher l’itération IP, le system demo et la résolution de problème ?

Préparation à l’examen ”SAFe® Scrum master (SSM) ”

• Conseils pour le passage de l’examen.
• Vidéo d’explication du déroulement.

Pourquoi l’agilité ?

• Les avantages apportés par l’empirisme pour l’organisation, point de vue du manager.
• Pourquoi agile ? Comment les leaders agiles connectent les professionnels à leur \”Pourquoi\” ?
• Les obstacles à l’agilité. Le leader fait la différence dans un voyage vers le changement. Les zones de focus.

Les leaders développent les individus et les équipes

• Les étapes possibles vers la maturation des équipes.
• Les styles de leadership et leur impact sur la maturité professionnelle des équipes.
• Les dépendances de croissance entre les différentes responsabilités.

Les mesures de l’agilité

• Les mesures des progrès d’une transformation agile par une approche basée sur les faits.
• Les mesures du succès des équipes agiles.
• Les parties prenantes et les métriques organisationnelles. Rassemblement.

Les leaders développent l’agilité

• Le rôle clé du leadership, auto-amélioration et développement des équipes. Scénarios.
• Les passages du management au leadership. Techniques de libération de l’agilité.
• Relation entre complexité et empirisme.

Les défis d’un leader agile

• Les types de focus d’un leader agile. Les défis posés par une transformation agile au leadership.
• Relations entre le leadership agile et les rôles Scrum. La facilitation.
• Culture de l’amélioration continue, de l’auto-développement, du travail d’équipe et des valeurs.

L agilité

• Pourquoi l Agilité ? Des nouveaux besoins, les motivations, une culture, les principes, quels bénéfices ?
• Le Manifeste Agile et les 12 principes.
• Ses champs d application.

Le Scrum Guide

• Théorie de Scrum : processus empirique, les piliers, les valeurs Scrum.
• Les artéfacts : incrément, Product Backlog, Sprint Backlog, Definition of Done.
• Vue globale des événements et présentation de la notion de Sprint.
• Les événements : Sprint planning, Daily Scrum, Sprint Review, Sprint Retrospective.
• Les rôles : l équipe Scrum, le Product Owner, le Scrum Master, l équipe de développement.
• Les interactions entre les différents rôles et du Scrum Master avec l organisation.
• Les bonnes pratiques : estimation et vélocité, techniques, User Story, suivi et radiateurs d informations.

Les techniques de développement Agile

• Point de départ : le Product Backlog.
• Programmation par paire, refactoring.
• L importance des standards de développement à l intérieur d une équipe (dette technique et règles de base).
• Architecture, design patterns et cross-cutting concerns.
• Le traitement des bugs (bug report, cycle de vie).
• Les mesures.

Les techniques de tests Agile

• La classification des tests : structurels, fonctionnels, unitaires, intégration, validation, acceptation.
• Tester avant de coder, le TDD : principes et avantages.
• Behaviour Driven Development, le BDD.
• L acceptante par les tests, l ATDD.

Intégration continue et automatisation

• Concepts et avantages.
• Mise en place et recommandations.
• Gestion de configuration : concepts, processus, schéma de branches.
• Gestion de configuration : centralisée, décentralisée.
• Gestion de configuration : check-out et commit.
• Gestion de configuration : merge.
• Gestion de configuration : baseline et changements

Infrastructure et outils

• Vue globale.
• ALM – Application Lifecycle Management.
• Outils – Environnement de développement.
• Outils – Tests unitaires.
• Outils – BDD.
• Outils – Intégration continue.

Examen

• Conseils pour l examen.
• Examen blanc avec correction commentée.

Examen
Passage de l examen Scrum.org Professional Scrum Developer ® (PSD®).

Un apport complémentaire à Scrum

• Le professionnalisme Scrum et le principe du « Scrum And ».
• La gestion du flux avec Scrum. Mythes et fausses idées répandues à propos de Scrum et du flux.
• Liaisons et causes de l’amélioration de Scrum par le flux.

La théorie soutenant Kanban

• WIP, Cycle time, Batch, et les concepts du flux.
• Le Guide Kanban. Les types de pratique Kanban.
• Ce qu’il faut savoir pour expérimenter Kanban en pratique (le jeu Kanban).

Kanban en pratique

• Exploration et expérimentation avec Kanban.
• L’impact des concepts du flux sur la pratique. Stratégies et décisions.
• Utilisation de Kanban et impacts sur Scrum.

Scrum avec Kanban : la visualisation du Sprint

• Le cadre Scrum et l’apport de pratiques complémentaires.
• Impacts sur le Sprint Backlog. Visualisation.
• Workflow et définitions. La création d’un Kanban board.

Impacts sur les évènements

• Impacts sur le Sprint Planning et le Daily Scrum. Capacités d’équipes.
• Impacts sur la Sprint Review et la Sprint Retrospective. Impacts pour les parties prenantes.
• Les métriques de flux au sein des différents évènements.

Impacts sur les rôles, l’incrément et le Sprint

• Impact sur les Développeurs. Impact sur le Scrum Master.
• Impact sur le Product Owner. Exploration des flux de valeurs.
• Transparence de l’incrément, livraison continue et DevOps. Le rôle de Scrum et Kanban.

Etre un Product Owner/Product Manager dans l’entreprise Lean

• SAFe® pour les entreprises Lean.
• Comprendre ce que sont les flux de valeur.
• La prise de décision dans l’esprit Lean-Agile.
• Les responsabilités du Product Owner/Product Manager.

Echanges
Comment les principes SAFe® peuvent-ils avoir un impact sur les prises de décision d\\\\’un PO ou PM ? Elaboration d’une Mind-Map des parties prenantes clés.

Préparer un Program Increment (PI) Planning

• Définir le Program Increment (PI).
• Préparer et décrire la vision.
• Identifier les travaux à réaliser à l\\\\’aide de feuilles de route (roadmaps).
• Décomposer les Epics en Features.
• Gérer le Program Backlog / Kanban.

Travaux pratiques
Impact des facteurs externes. Création d’Epics pour réaliser la vision. Décomposition d\\’Epics en Features. Préparation d’un PI Planning

Conduire un PI Planning

• Communiquer la vision et la roadmap.
• Etablir les objectifs du PI Planning et identifier la valeur métier.
• Gérer les dépendances.
• Gérer les risques.

Travaux pratiques
Comment communiquer la vision ? Repérer les moyens permettant d\\’identifier les problèmes de dépendances et savoir les résoudre. Conduite d’un PI Planning.

Exécuter les itérations

• Créer les user stories avec leurs critères d’acceptation.
• Planifier les itérations.
• Gérer le flux avec l’équipe kanban.
• Affinage continu du Backlog.
• Revue de fin d’itération et retrospectives.
• DevOps et la livraison à la demande (Release on Demand).

Travaux pratiques
Décompositions des features en user stories. Elaboration d\\’une story map. Estimer les stories. Execution d’itérations.

Exécuter un PI

• Participer au PO Sync.
• Participer aux démonstrations système (System Demo).
• Innover tout au long du Program Increment.
• Inspecter et adapter (performance, prévision, etc.).

Travaux pratiques
Comment tirer parti des réunions de synchronisation pour s\\’assurer de l\\’alignement de l’ART ? Atelier de résolution de problème et de restrospective. Exécution d\\\\’un PI.

Information sur l’examen ”SAFe® 5 Product Owner / Product Manager”

• Conseils pour le passage de l’examen.
• Vidéo d’explication du déroulement de l\\’examen

Prospérer à l’ère digitale avec  ”business agility ”

• Prospérer à lère digitale.
• Décrire SAFe® comme un système de fonctionnement de ”business agility.
• Expliquer les 7 compétences de base de business agility.

Réflexion collective
Échange autour des problématiques communes aux entreprises.

Devenir un leader lean et agile

• S’approprier l’état d’esprit lean.
• Appliquer lean et agile à l’échelle avec les principes SAFe®.

Exercice
Évaluer l’état d’esprit Lean de votre organisation. Évaluer l’impact sur les principes agiles du passage à l’échelle.

Mettre en place les équipes et l’agilité

• Construire des équipes agiles pluridisciplinaires.
• Produire avec une qualité intégrée.
• Organiser des trains de release agile (ART) autour des flux de valeur.

Travaux pratiques
Quelles sont les caractéristiques des équipes performantes ?

Construire des solutions avec  Livraison agile de produits

• Appliquer  ”la centricity clien” avec le design thinking.
• Prioriser le backlog du programme.
• Participer à un PI planning (planification de l’incrément de programme).
• Développer en cadence, livrer à la demande.
• Construire un pipeline de livraisons continues avec DevOps.

Echanges
Prioriser les demandes avec WSJF (Weighted shortest job first). Simuler la planification de l’incrément de programme (PI planning).

Explorer la gestion de portefeuille lean

• Définir un portefeuille SAFe®.
• Relier le portefeuille à la stratégie de l’entreprise.
• Maintenir la vision du portefeuille.
• Mettre en œuvre le flux au niveau du portefeuille.
• Budgéter les chaînes de valeur.

Exercice
Rédiger une initiative d’entreprise (Epic).

Conduire le changement

• .Conduire le changement.
• Conduire par  ”l’exemple ”.

Exercice
Identifier trois actions de transformation SAFe® à mener sous un mois dans votre entreprise

Agile vue d’ensemble

• Agile et la gestion de projet.
• Contexte et origines.
• Le manifeste Agile.
• Valeurs et principes des méthodes Agiles.

Mise en situation
Agile game : découvrir l’expression des besoins dans une démarche itérative.

Présentation générale de Scrum

• Principes de Scrum.
• Les différents rôles. Les cérémonies.
• Suivi et avancement.

Product Owner

• Ses rôles et responsabilités.
• Le Product Owner et les autres acteurs.
• Le Product Owner délégué.

Mise en situation
Agile game : rôles et responsabilités du Product Owner. Cas fil rouge : présentation du projet.

Définir un backlog initial

• Etablir la vision produit, le backlog initial.
• Construire la roadmap.
• Les éléments du Product Backlog.
• Les techniques de recueil du besoin métier.
• Les user stories, les features, les épics.

Mise en situation
Cas fil rouge : déterminer le périmètre projet, analyser un diagramme de contexte. Identification des features, Users Stories. Agile game : construire la Product box d’un projet.

Formaliser les exigences

• Rédiger les features, les User Stories.
• Description structurée des User Stories.
• Prioriser les exigences, les techniques de priorisation.
• Le modèle de Kano.
• La notion de Business Value en story point.
• Organiser et actualiser le Product Backlog.
• Affiner le Product Backlog.

Mise en situation
Agile game : apprendre à prioriser. Cas fil rouge : description libre et structurée des Users Stories, classement des exigences, calcul de la valeur client.

La validation des solutions

• Quand passer les tests ?
• Rédiger les tests d’acceptation.
• Le pilotage par les tests. Résultat des tests.

Mise en situation
Cas fil rouge : rédaction des conditions d’acceptation.

Le Product Owner et les cérémonies agiles

• Les bases d’une cérémonie.
• Les séances de planification.
• Le Product Owner et la revue de sprint.
• Le daily Scrum.
• La rétrospective de sprint.

Mise en situation
Cas fil rouge : planifier les releases, préparer les cérémonies Scrum. Agile game :”Keep Drop Start” : cartographier les concepts Agiles par intérêt, rechercher les axes d’amélioration.

Appliquer le framework Scrum

• Rappel sur l’agilité et le manifeste.
• Scrum, processus empirique et ses valeurs.
• Les cérémonies, la collaboration avec tous les membres de l’équipe.
• Le Product Backlog, definition of done, etc.

La gestion de produit agile

• Product Owner, représentant de la vision du produit.
• Notion de lean UX.
• Identification de la valeur du produit.
• Relations avec les parties prenantes et stratégie métier.
• Optimisation du ROI (Return on investment) et du TCO (Total cost of ownership).
• Notions de MVP (Minimum viable product) et de MMF (Minimum marketable features).

Travaux pratiques
Identification des éléments de valeur sur un exemple concret de produit.

La gestion du Product Backlog par le Product Owner

• Anticipation des besoins ou risques.
• Contenu du Product Backlog, types et caractéristiques des éléments.
• Définition des besoins (User Stories).
• Affinage du Product Backlog avec l’équipe de développement.
• Outils pour prioriser le Product Backlog.
• Problématique que le PO doit intégrer dans la gestion du Backlog : dette technique, architecture évolutive, risques.

Travaux pratiques
Story mapping ou comment faire émerger les besoins des utilisateurs. Écriture de user stories avec leurs critères d’acceptation. Utilisation des différentes techniques de découpage.

Le Product Owner et le plan de release

• Estimation en point, compréhension des stories.
• Utilisation de la vélocité de l’équipe.
• Planification des releases et Roadmap produit.
• Valeur globale du Product Backlog, mesure de la valeur produite.

Travaux pratiques
Construction d’un tableau de bord pour un Product Owner (PO).

Mise à l’échelle de Scrum

• Scrum de scrums.
• Nexus : le contexte et le cadre de travail, les rôles et les événements.

Certification

• Conseils pour l’examen.
• Mise en situation à blanc dans les conditions d’examen.

Examen
Passage de l’examen Scrum.org Professional Scrum Product Owner® II (PSPO II®).

Posture et activités du coach Agile

• Qu’est-ce que le coaching ?
• Les rôles, les missions, la position.
• Coach agile et méthode Scrum.

Réflexion collective
Réflexion sur la définition du coach Agile, ses différentes activités et facettes.

Transformation Agile

• L’acceptation du changement, une valeur Agile.
• Apprendre à devenir acteur du changement vers l’agilité.
• La transformation agile, pratiques et objectifs.

Mise en situation
Atelier sur la notion d’apprentissage. Définir des objectifs SMART. Réflexion collective : comment lever les peurs liées au changement ?

Mettre en place l’amélioration continue

• Plan Do Check Act, l’amélioration continue, un des principes fondateurs de l’agilité.
• Les pratiques de la rétrospective Agile.
• Résolution de problème dans la rétrospective.

Exercice
Mise en évidence de gaspillages, de points d’amélioration potentiels. Atelier rétrospective, exercices de facilitation en groupe.

Construire une équipe Agile (Team Building)

• Identifier les différentes approches managériales.
• Psychologie des groupes et des individus.
• Outils de communication et de facilitation.
• Les attitudes du leader.

Mise en situation
Identifier les principes clés de la gestion d’équipe Agile. Atelier en équipe Agile.

Accompagner une équipe Agile

• Optimiser le niveau de motivation de l’équipe.
• L’auto-organisation de l’équipe.
• Gestion des conflits. L’assertivité et les autres comportements.
• Gestion du stress et recycling.

Travaux pratiques
Atelier sur la cohésion d’équipe et l’auto-organisation. Jeu de rôle pour désamorcer les conflits, analyse comportementale, application des techniques de gestion du stress.

Contrôler et comptabiliser les opérations liées aux achats

• Conditions de fond et de forme des factures.
• Comptabiliser et valider les imputations comptables.
• Gérer les opérations en devises.
• Enregistrer les différentes écritures de régularisation.

Exercice
Enregistrer différentes factures d’achat.

Contrôler et comptabiliser les opérations liées aux ventes

• Comptabiliser les différentes opérations de ventes.
• Gérer les opérations en devises.
• Gérer et enregistrer les impayés.
• Enregistrer les différentes écritures de régularisation.

Exercice
Enregistrer différentes factures de ventes.

Comprendre et maîtriser le traitement de la TVA

• Rappel des grands mécanismes.
• TVA sur les débits, les encaissements.
• Enregistrer la TVA collectée, déductible, la TVA à payer ou crédit de TVA, l’autoliquidation de la TVA.
• Contrôler les comptes de TVA lors de la déclaration.

Exercice
Enregistrer la liquidation de TVA.

Enregistrer les différentes opérations de trésorerie et de banque

• Savoir gérer les différents modes de règlement.
• Comptabiliser les effets de commerce.
• Enregistrer les prêts, les emprunts.
• Comptabiliser les valeurs mobilières de placement (achat, cession).

Exercice
Enregistrer des effets de commerce ainsi que des écritures de trésorerie et de banque.

Gérer les opérations d’investissement

• Définir les caractéristiques des immobilisations.
• Effectuer l’inventaire physique des immobilisations.
• Comptabiliser les dépenses d’entretien, de réparation.

Exercice
Comptabiliser l’acquisition et la cession d’une immobilisation.

Contrôler et justifier les comptes

• Analyser et lettrer les comptes de tiers.
• Comprendre la démarche de contrôle des comptes.
• Justifier les soldes des comptes.

Exercice
A partir d’une balance avant inventaire, lettrer et justifier des comptes.

Les fondements de la programmation

• Qu’est-ce qu’un programme ? Qu’est-ce qu’un langage ? Les différents paradigmes. Quel langage pour quelle application ?
• Les compilateurs. Les exécutables.
• Les responsabilités d’un programmeur.
• Qu’est-ce qu’un algorithme ?
• Les besoins auxquels répond un algorithme.
• Le concept de pseudo-langage.

Travaux pratiques
Présentation de différents langages (Java, C#, Visual Basic, C, C++). Ecriture d’un premier algorithme en pseudo-langage.

Genèse d’un premier programme

• Ecriture d’un programme simple : syntaxe et instructions.
• Compilation et exécution du programme.
• Qu’est-ce qu’une librairie ? Son rôle, son usage.

Travaux pratiques
Découverte de l’environnement de développement et d’exécution. Ecriture, compilation et exécution d’un premier programme.

Règles de programmation

• Convention de nommage.
• Convention syntaxique.
• Utilisation des commentaires. Pourquoi commenter les développements ?
• Améliorer la lisibilité des programmes : indentation du code, découpage du code…

Les variables

• Qu’est-ce qu’une variable ?
• Pourquoi typer une variable ?
• Les types primitifs : entiers, chaînes de caractères, nombres réels, autres.
• Déclaration, définition et initialisation d’une variable.
• Les constantes.
• Saisie, affichage, affectation, conversion de type.
• Organiser ses données sous forme de tableaux.
• Les types évolués : enregistrement, matrice, arbre.

Travaux pratiques
Ecriture de plusieurs programmes simples manipulant les variables.

Opérateurs et expressions

• Les différents opérateurs (multiplicatif, additif, comparaison, égalité, logique, affectation).
• Combinaison d’opérateurs.
• Expression booléenne.

Travaux pratiques
Manipulation des opérateurs et des expressions booléennes.

Les structures de contrôle

• Les sélections alternatives (si, si-alors-sinon, sélection cas).
• Les blocs d’instructions (notion de Début… Fin).
• Les boucles itératives (tant que-répéter, répéter-jusqu’à, pour-de- à).
• Imbrication des instructions.
• Les commentaires.

Travaux pratiques
Utilisation des structures de contrôle pour implémenter un algorithme.

Les procédures et les fonctions

• Définitions : procédure, fonction.
• Pourquoi sont-elles incontournables en programmation (réutilisabilité, lisibilité…) ?
• Le passage de paramètres.
• Le code retour d’une fonction.
• Sensibilisation aux limites du passage de la valeur d’une variable.
• Notion de passage par adresse.
• Appel de fonctions.

Introduction à la programmation Objet

• Les concepts associés à la programmation Objet : classe, attribut, méthode, argument.
• La modélisation Objet à partir des exigences fonctionnelles.
• Introduction aux bonnes pratiques d’organisation de conception et d’organisation d’un programme.

Travaux pratiques
Illustration des concepts Objets.

L’accès aux bases de données

• Organisation et stockage des données.
• Les traitements de base (connexion, requêtes, récupération des données).
• Application cliente et serveur de données.
• Affichage et manipulation des données dans l’application cliente.

Travaux pratiques
Création d’un formulaire de recherche d’informations dans une base de données.

Maintenance, débogage et test des programmes

• Savoir lire et interpréter les différents messages d’erreurs.
• Utiliser un débogueur : exécuter un programme pas à pas, points d’arrêts, inspecter les variables pendant l’exécution.
• Prévoir les tests unitaires.

Travaux pratiques
Utilisation d’un débogueur pour contrôler l’exécution des programmes.

Rappels

• Classes d’allocation mémoire.
• Construction, initialisation, embarquement d’objets.
• Les fuites mémoire.
• Constance, le mot-clé mutable, Lazy Computation.
• Amitié (friendship) C++ et contrôle d’accès.
• Destruction virtuelle.
• Stratégie de gestion des exceptions.
• Les espaces de nommage (namespace).

Les nouveautés langage de C++11

• nullptr et autres littéraux.
• Les directives =delete, =default.
• Délégation de constructeurs.
• Les énumérations “type safe”.
• Le mot-clé auto et boucle sur un intervalle.
• Référence rvalue et impact sur la forme normale des classes C++.
• Les lambda expressions.

Travaux pratiques
Réécriture d’un code C++ existant en C++11, comparaison des deux implémentations.

Gestion des opérateurs

• Opérateurs binaires et unaires.
• L’opérateur d’indirection, cas d’usage.
• L’opérateur de référencement.
• Les opérateurs d’incrémentation/décrémentation préfixés et post-fixés.
• Les autres opérateurs : comparaison, affectation…
• La surcharge de l’opérateur [], des opérateurs d’insertion (<<) et d’extraction (>>).
• Les foncteurs et la surcharge de l’opérateur (), avantage par rapport aux fonctions.

Travaux pratiques
Création de foncteurs et de proxies (libération mémoire, comptage de références) avec les opérateurs étudiés.

Conversion et RTTI

• Opérateurs de conversion. Constructions implicites, le mot-clé explicit.
• Les opérateurs de casting const_cast, static_cast, reinterpret_cast.
• Conversion dynamique et Runtime Type Information.
• L’opérateur typeid, les exceptions liées.
• La classe type_info.
• Contrôle du “downcasting” à l’aide de l’opérateur dynamic_cast.

Travaux pratiques
Mise en œuvre des idiomes “is-a” et “is-kind-of” avec dynamic_cast.

La généricité

• Introduction aux patrons de classe. Généricité et préprocesseur.
• Fonction générique. Classe générique. Composition générique. Généralisation générique.
• Spécialisation partielle et totale.
• Introduction à la méta-programmation.
• La généricité, principe fédérateur des librairies STL et Boost.

Travaux pratiques
Démarrage de l’étude de cas qui sera complétée avec la STL et Boost. Mise en œuvre de la composition et de la généralisation génériques. Création de plug-ins génériques.

La STL (Standard Template Library)

• Composants de la STL : types complémentaires, conteneurs, algorithmes, itérateurs, objets fonctions, les adaptateurs.
• Les chaînes de caractères STL, la classe template basic_string et ses spécialisations.
• Les conteneurs séquentiels et associatifs : définition, rôle et critères de choix.
• Les allocateurs et la gestion de la mémoire des conteneurs.
• Les méthodes d’insertion, de suppression, d’itération et d’accès aux principaux conteneurs : Vector, List, Set, Stack…
• Le concept d’itérateur. Parcours d’un conteneur.
• Les différents groupes d’algorithmes STL : non mutants, mutants, de tri et de fusion, numériques.
• Manipulation de conteneurs (manipulation, recherche de valeurs…).
• Paramétrer les algorithmes génériques par des objets “fonction”.
• Les “adapteurs” et la modification du comportement d’un composant.
• La STL et les traitements sur les flux (fichiers, mémoire…).
• Principe du RAII : les pointeurs automatiques et la classe auto_ptr.
• Les exceptions standard de la STL.

Travaux pratiques
Implémentation des relations avec les collections de la STL. Utilisation d’algorithmes standard quelconques.

Les nouveautés C++11 de la librairie standard

• Evolution historique : Boost –> TR1 –> C++11.
• Les nouveaux conteneurs : array, forward_list, unordered_set, unordered_map.
• La classe tuple.
• Les pointeurs intelligents (smart pointer) : shared_ptr, weak_ptr, unique_ptr.
• Les nouveaux foncteurs et binders.
• Introduction à la gestion des threads.
• Les expressions régulières.

Travaux pratiques
Mise en œuvre de la robustesse avec les smart pointers. Utilisation d’expressions régulières.

Boost

• La Pointer Container Library (destruction des données pointées d’un conteneur).
• Les structures de données boost::any et boost::variant.
• Programmation événementielle (connexions et signaux).
• Gestion des processus, mécanismes de communication interprocessus et mémoire partagée.

Travaux pratiques
Amélioration de l’implémentation de l’étude de cas par l’utilisation la Pointer Container Library.

Utilisation avancée de l’héritage

• Héritage versus embarquement. Héritage privé. Héritage protégé.
• Exportation de membres cachés avec la Clause Using.
• Héritage multiple et gestion des collisions de membres.
• Héritage en diamant. Héritage virtuel et dynamic_cast.
• Principes de conception : substitution de Liskov, principe d’ouverture/fermeture, inversion des dépendances.
• Règles d’implémentation des interfaces en C++.

Travaux pratiques
Combinaison de l’héritage multiple, privé et de l’exportation pour concevoir des classes robustes et hautement évolutives.

L’avènement de C++11

• Les différentes normes C++98, C++03 et C++0x, C++11.
• Les nouveautés de C++11 et les objectifs de cette norme. Le devenir de Boost, STL.
• La question de la compatibilité des codes anciens.
• La disponibilité des outils de développement (compilateurs, débogueurs, IDE …).

Travaux pratiques
Vérification de l’outillage à l’aide d’un code C++11 fourni.

Les améliorations du langage

• Les énumérations fortement typées.
• Les tableaux à taille fixe.
• Le mot-clé auto pour simplifier le typage.
• La boucle basée sur un intervalle.
• Autres améliorations : templates à arguments variables, pointeur nul, littéraux…

Travaux pratiques
Mise en œuvre des améliorations.

Les modifications au niveau des classes

• La délégation de constructeurs, les contraintes liées à l’héritage.
• La nouvelle sémantique du déplacement et le constructeur par déplacement (move constructor).
• Adaptation de la forme normale des classes aux nouveautés (move constructor).
• Les directives =delete, =default.
• Les initialiseurs de conteneurs.
• LeS données membres.

Travaux pratiques
Création de classes C++11.

L’utilisation des threads

• Déclaration et exécution d’un thread. Attente de fin d’exécution avec join().
• La gestion des données locales à un thread, l’usage de volatile.
• Récupérer un résultat avec future<> et async().
• Obtenir des informations sur les capacités d’exécution de la plateforme avec hardware_concurrency().

Travaux pratiques
Multithreader un code séquentiel et mesurer le gain en termes de temps d’exécution.

Autres nouveautés de la bibliothèque standard

• La gestion du temps avec le namespace chrono.
• Le nouveau conteneur tuple.

Travaux pratiques
Mise en œuvre des nouveautés.

La programmation fonctionnelle avec les lambda expressions

• Déclaration, typage, implémentation et utilisation.
• L’intérêt d’auto avec les lambda-expressions.
• La gestion des fermetures (closures), avec capture par valeur ou par référence des variables liées au contexte.

Travaux pratiques
Exercices de programmation fonctionnelle.

La gestion mémoire et les conteneurs

• Les smart pointers : shared_ptr, weak_ptr, unique_ptr, auto_ptr. Usage conjoint avec la STL.

Travaux pratiques
Mise en œuvre de la gestion mémoire C++11.

Introduction

• Le développement natif, l’hétérogénéité et la fragmentation.
• Les principaux outils cross-platform.
• Positionnement de React Native par rapport aux solutions existantes.

React Native

• Rappels sur ES6/S201x. Notion de transpileur.
• React et le superset de JavaScript JSX.
• React Native : principes clés, fonctionnement général.
• Installation et configuration de React Native.
• Outils de développement et de debug.

Travaux pratiques
Installation et configuration de React Native. Maîtriser le debugger.

Architecture d’application

• Configurer un composant : state & props.
• React Native et MVC.
• Le pattern Flux, une alternative au MVC.
• L’arrivée de Redux : le store, le reducer, les actions.

Travaux pratiques
Initialisation d’un projet React Native. Configuration d’un composant.

Construire son interface

• Les composants de base (View, Text et Image) et leurs cycles de vie.
• Les événements Touch, la ListView et la ScrollView.
• Organiser le layout de l’application. Mise en page avec Flexbox.
• Styler les composants.
• Les différentes solutions de navigation entre les pages.
• Composants avancés.
• Utiliser des composants de la communauté.
• Ajouter des animations et des transitions.

Travaux pratiques
Développer une première application.

Les formulaires et la gestion des données

• Les principaux composants de formulaires.
• La validation de la saisie et la gestion des erreurs.
• Redux-form et alternatives.
• Récupération des données : xmlhttprequest et fetch.
• Le stockage local.
• La gestion offline.

Travaux pratiques
Développer un formulaire, valider les données et assurer la persistance des données.

Interagir avec le terminal

• Les principales API natives de React Native.
• Utiliser les plugins Cordova/PhoneGap.
• Développer un module natif.

Travaux pratiques
Implémentation des principales API natives.

Usages avancés

• Best Practices et erreurs fréquentes.
• Tests unitaires et fonctionnels.
• Publier l’application.
• Mises à jour Over The Air.
• Frameworks et outils complémentaires.

Travaux pratiques
Tester et déployer des applications React Native.

DevOps, enjeux, origine et fondamentaux

• Mutations engendrées par la (r)évolution digitale et les nouveaux challenges associés.
• Solutions : méthodes Agiles et DevOps.
• Différences avec les DSI traditionnelles.
• Généalogie de DevOps : Méthodes Agiles et Lean Manufacturing.
• Fondements du mouvement DevOps.

DevOps, de l’expression des besoins jusqu’à la production

• Fonctionnement et procédés clés de la DSI DevOps.
• Constituer des équipes pluridisciplinaires. L’apprentissage continu.
• Construire la chaîne de productions logicielles et pratiques associées.
• Sûreté de fonctionnement, feedbacks et amélioration continue.
• Adapter la gouvernance : passer à une structure innovante.
• Engagement de tous, le vrai défi pour les managers.
• Faire évoluer les postures.
• Management de la transformation DevOps : accompagner l’évolution.

Réflexion collective
Évolution culturelle de l’entreprise : freins et solutions.

Outils, positionnement, caractéristiques, risques et limites

• Gestion des exigences, Agile/DevOps (Trello, Wekan, Flowdock, Taiga…). Collaboration (Slack, Hipchat, Rocket.Chat…).
• Cloud (OpenStack, OpenShift Origin, Cloud Foundry…). Microservices et containers (Docker, Rkt, Kubernetes, Mesos…).
• Gestion de configuration (GLPI, Fusion Inventory, SpaceWalk…). Gestion de version (Git, Github, Gitlab, Bitbucket…).
• Intégration continue (Maven, Graddle, Jenkins, GitLab-CI, TeamCity, TravisCI, CircleCI, JUnit, PhPUnit, Mokito…).
• Gestion des dépôts et d\\\\’environnements (DockerHub/Registry, Artifactory, Infrastructure As Code/Configuration As Code).
• Automatisation des livraisons (Salstack, Vagrant, Terraform, CFEngine, Capistrano, Rundeck, Ansible, Chef, Puppet…).
• Automatisation des tests (Fitness, SOAPUI, LynIS, Snort, ZAP, Jasmine, Appium, Selenium, Cucumber, Gatling, JMeter…).
• Orchestration de release. Surveillance continue : monitoring/alerting et dashboard (ELK, Zabbix, Nagios…).

Etude de cas
Analyse des contextes technologiques et industriels variés.

Synthèse

• Importance de la veille technologique.
• Points à retenir.
• Conclusion.

Swift

• Pourquoi un nouveau langage ?
• Ses apports et nouveautés.
• Les playgrounds : terrains de jeu.
• Intégration aux outils existants.
• Swift système ouvert.

XCode l’environnement de développement

• Présentation de l’outil et ses addons.
• L’utilisation de XCode.
• Interface Builder et les divers outils disponibles.
• Le débogueur.
• Les outils de mesure : instruments.
• Les portail du développeur Apple.

Travaux pratiques
Mise en place de l’environnement de développement et premier exercice avec XCode et Swift. Utilisation du débogueur.

Les bases du langage Swift

• Les fonctionnements du compilateur et l’architecture.
• Les bases : variables, constantes et tuples, les chaînes de caractères.
• L’optional et sa gestion, l’unwrapped.
• Les opérateurs et la surcharge.
• Les structures de contrôle.
• Les closures et les fonctions.
• Classes, structures, énumérations, propriétés.
• L’héritage et les protocoles.

Travaux pratiques
Réalisation de plusieurs applications sur le langage et ses basiques.

La bibliothèque Swift

• Que contient la Swift Standard Library ?
• Gestion des tableaux, dictionnaires et Set.
• Les protocoles Equatable et Comparable : utilisation.
• Autres classes et structures disponibles.

Travaux pratiques
Mise en oeuvre des protocoles Comparable et Equatable.

Concepts avancés en Swift

• Les Subscripts : concept et implémentation.
• La gestion des erreurs et exceptions : try, catch, throw, throws, try, defer.
• La gestion de l’asynchronisme avec Grand Central Dispatch.
• La classe Thread, endormir un thread, annuler un thread, notification.
• Les références strong, weak et unowned.
• Le Lazy Loading.
• Créer des extensions en Swift.
• La généricité et les génériques.

Travaux pratiques
Mise en oeuvre de la généricité et des extensions.

Interaction Swift et Objective-C

• Comparaison des syntaxes entre Objective-C et Swift.
• Comparaison des types de données.
• Mixing and matching.
• Héritage entre Swift et Objective-C.
• Points particuliers et limitations.

Travaux pratiques
Mise en oeuvre du mix and matching avec XCode.

Introduction

• Enjeux de la programmation Multicore.
• Tableau des technologies utilisables : processus, thread et parallélisme.
• Description du fonctionnement d’un processeur.
• Architecture en “Hyperthreading”.
• Architectures des processeurs INTEL et AMD.
• Architectures NVidia et API.
• Architecture en mémoire partagée vs mémoire distribuée.

Modélisation des applications

• Importance des aspects modélisation.
• Patterns de mise en parallèle des traitements.
• Utilisation des mécanismes asynchrones.
• Développer une nouvelle application : précautions et modélisation. Eviter les “singletons”.
• Modifier une application existante en Multicore.
• Choix d’architecture : un compromis synchronisation et performance. Choix multiprocessus/multithreads.

Threads

• Apport des threads dans une application industrielle.
• Ordonnancement des threads.
• Gestion des stacks et “call stack” dans les threads.
• Débogueurs multithreads.
• Gestion des objets de synchronisation : sections critiques, Mutex et Sémaphores.
• Développer “thread safe”.
• API de threads TBB, Clik++, C++11, boost threads, pthreads.

Travaux pratiques
Threads et synchronisation en C/C++.

Processus

• Espaces d’adressage des processus, organisation.
• Critères de choix d’une approche multiprocessus.
• Techniques de communication interprocessus (IPC).
• Outils de debugging multiprocessus.
• Avantage et inconvénients des techniques multiprocessus.

Travaux pratiques
Gestion de traitements asynchrones avec l’API C/C++.

La programmation parallèle

• Apport et objectifs de la programmation parallèle.
• La librairie “OpenMP” C++ (programmation mémoire partagée).
• La librairie “OpenMPI” (programmation mémoire distribuée).
• Utiliser les GPU des cartes graphiques pour le calcul.
• Kits de NVidia (CUDA) et ATI.
• La librairie “OpenAcc” pour la programmation GPU.
• La librairie “OpenCL” pour la programmation parallèle CPU et GPU.

Travaux pratiques
Paralléliser des algorithmes avec “OpenMP” en C++. Utilisation de l’API OpenCL.

Synthèse et conclusion

• Conclusion des techniques étudiées.
• Avenir du C++ avec le multicore.

Swift

• Pourquoi un nouveau langage ?
• Ses apports et nouveautés.
• Les playgrounds : terrains de jeu.
• Intégration aux outils existants.
• Swift système ouvert.

XCode l’environnement de développement

• Présentation de l’outil et ses addons.
• L’utilisation de XCode.
• Interface Builder et les divers outils disponibles.
• Le débogueur.
• Les outils de mesure : instruments.
• Les portail du développeur Apple.

Travaux pratiques
Mise en place de l’environnement de développement et premier exercice avec XCode et Swift. Utilisation du débogueur.

Les bases du langage Swift

• Les fonctionnements du compilateur et l’architecture.
• Les bases : variables, constantes et tuples, les chaînes de caractères.
• L’optional et sa gestion, l’unwrapped.
• Les opérateurs et la surcharge.
• Les structures de contrôle.
• Les closures et les fonctions.
• Classes, structures, énumérations, propriétés.
• L’héritage et les protocoles.

Travaux pratiques
Réalisation de plusieurs applications sur le langage et ses basiques.

La bibliothèque Swift

• Que contient la Swift Standard Library ?
• Gestion des tableaux, dictionnaires et Set.
• Les protocoles Equatable et Comparable : utilisation.
• Autres classes et structures disponibles.

Travaux pratiques
Mise en oeuvre des protocoles Comparable et Equatable.

Concepts avancés en Swift

• Les Subscripts : concept et implémentation.
• La gestion des erreurs et exceptions : try, catch, throw, throws, try, defer.
• La gestion de l’asynchronisme avec Grand Central Dispatch.
• La classe Thread, endormir un thread, annuler un thread, notification.
• Les références strong, weak et unowned.
• Le Lazy Loading.
• Créer des extensions en Swift.
• La généricité et les génériques.

Travaux pratiques
Mise en oeuvre de la généricité et des extensions.

Interaction Swift et Objective-C

• Comparaison des syntaxes entre Objective-C et Swift.
• Comparaison des types de données.
• Mixing and matching.
• Héritage entre Swift et Objective-C.
• Points particuliers et limitations.

Travaux pratiques
Mise en oeuvre du mix and matching avec XCode.

Angular, mise en œuvre des bonnes pratiques

• Injection de dépendances.
• Types applicatifs partagés.
• PWA : les Services Workers.
• Requêtes HTTP avancées.
• Lazy Loading.

Travaux pratiques
Analyser et optimiser une application.

Fonctionnement interne d’Angular

• ZoneJS : le concept.
• Optimisation des cycles de rendu, exécution hors ZoneJS.
• Choisir RXJS.
• Utilisation des observables.
• Création, combinaison, opérateurs clés.
• Compilation Ahead Of Time.
• Webpack Bundle Analyzer.

Travaux pratiques
Créer une application utilisant RxJS.

Création de composants distribuables

• Les Web Components.
• Méthodologie : Interactive Component Sheet.
• Les décorateurs.
• Le Change Detection Mode.
• Composants neutres versus à état. Communication entre composants, optimisation ES6.
• Projection de contenu, pilotage de composants enfants.
• Préparer les composants pour la distribution.
• Documentation : génération dynamique.

Travaux pratiques
Développer et packager des composants distribuables.

Composants riches et librairies externes

• Découverte de l’écosystème Angular pour la gestion des données, AngularFire, NgRx.
• Les bibliothèques UI : Angular Material, Prime NG…
• Les animations.

Travaux pratiques
Réutilisation de composants, intégration de librairies externes.

Formulaire dynamique : le FormBuilder

• Création de formulaire dynamique : ReactiveFormsModule.
• FormControl et FormGroup, AbstractContrl, FormArray.
• Validation et gestion d’erreur personnalisée.
• Création de modèles de données.
• Utilisation du FormBuilder.
• Création dynamique de template.
• Abstraction de composant métier de formulaire.

Travaux pratiques
Mise en œuvre de la génération et les cycles de validation avancée de formulaire.

Tests unitaires. Bonnes pratiques et outils.

• Karma et Jasmine.
• Tests d’intégration avec Protractor.
• Le Code-Coverage.
• Behaviour Driven Development, Test Driven Development.
• Cas de test : Pipe, Component, Service, etc.

Travaux pratiques
TDD : développer une application à partir de tests unitaires.

La syntaxe du C++ (différences entre C et C++)

• Données : définition, initialisation, types de données.
• Expressions : notion de référence, mécanismes de cast.
• Opérateurs (: :, new, delete).
• Fonctions (passage de paramètres et valeur de retour par référence, valeurs par défaut, inlining, surcharge).
• Utilisation du code C dans un programme C++.
• Les références (arguments et valeurs de retour).
• Les types constants.
• Les espaces de nommage.
• Le typage “automatique” avec le mot-clé auto (C++ 11).

Travaux pratiques
Prise en main de l’environnement de développement et programmation d’un programme simple.

Approche Orientée Objet

• Les principes généraux des techniques Objet.
• C++ et la programmation Objet.
• Une introduction aux méthodologies orientées Objet.
• Une introduction aux modèles et à la notation UML (modèle statique, dynamique, modèle de coopération, scénario).

Travaux pratiques
Application des concepts à une étude de cas qui sera l’un des fils directeurs des exercices suivants.

Les classes et les objets C++

• Les aspects syntaxiques : les champs, les méthodes, les constructeurs.
• Le contrôle d’accès.
• L’autoréférence.
• Les champs et méthodes statiques.
• Les fonctions.
• Les méthodes et les classes Friend.
• La création dynamique des tableaux d’objets.
• Les aspects méthodologiques : la conception des classes.
• Les constructeurs de copie et de déplacement (C++11).
• La délégation de constructeurs (C++ 11).
• Introduction aux problématiques de gestion mémoire (pile, tas, ramasse-miettes…).

Travaux pratiques
La programmation de l’étude de cas. La conception et la construction d’une hiérarchie de classes et d’interfaces.

Dérivation et héritage

• Principe de la dérivation.
• Les aspects syntaxiques : la définition des classes dérivées, les constructeurs.
• Le contrôle d’accès.
• La mise en œuvre du polymorphisme : les fonctions virtuelles.
• La réutilisation de code : les classes abstraites.
• Les interfaces.
• La dérivation multiple.
• Les aspects sémantiques et méthodologiques : la factorisation du code.

Travaux pratiques
La mise en place du polymorphisme dans l’étude de cas.

Les exceptions

• Les aspects syntaxiques : les blocs de try, la génération des exceptions.
• Les aspects méthodologiques : la construction d’une hiérarchie d’exception, l’utilisation des exceptions.

Travaux pratiques
L’introduction des exceptions dans l’étude de cas.

La surcharge des opérateurs

• Principe de la surcharge.
• Surcharge des opérateurs binaires.
• Surcharge particulière : l’opérateur indice, fonction, conversion.
• Surcharge des opérateurs de gestion mémoire.
• Surcharge des opérateurs ‘<<‘ et ‘>>’.

Travaux pratiques
La surcharge de quelques opérateurs simples.

Les modèles

• Modèle de classe. Principes et mécanismes généraux. Surcharge des modèles et redéfinition de méthodes.
• Modèle de fonction. Principes et mécanismes généraux. Surcharge des modèles.
• Modèles et surcharge des opérateurs.
• Les modèles et les mécanismes de dérivation.
• Les améliorations proposées par C++ 11.

Travaux pratiques
Exercices sur les modèles.

Les I/O et aperçu sur la STL

• Les I/O.
• Le principe des streams et la hiérarchie des classes d’entrée/sortie.
• Description de quelques classes d’entrées/sorties.
• Aperçu sur la STL.
• Objectifs et principes.
• Descriptions de quelques modèles et classes.
• Les conteneurs, les itérateurs, la boucle basée sur un intervalle (C++ 11).

Conclusion

• Cycle de vie du logiciel : test, intégration, méthode de mise en production.
• Interaction avec les autres environnements.
• Analyse critique du C++.
• Evolution du C++.

Introduction

• Définition d’une démarche Projet. Cycle de vie d’un projet.
• Caractéristiques des projets informatiques. Les principaux livrables.
• Positionnement des travaux de planification et de suivi dans le processus Projet.

Processus de planification de base

• Décomposition du projet en tâches (WBS : Work Breakdown Structure).
• L’ordonnancement ou la mise en évidence des liaisons qui existent entre les différentes tâches d’un projet.
• Les types de liens, avance et retard, les dates au plus tôt et au plus tard, calcul des marges libres et totale.
• Représentation des contraintes d’ordonnancement des tâches : approches des méthodes PERT et Gantt.
• Optimisation de l’enchaînement des tâches pour minimiser le chemin critique.

Travaux pratiques
Lire un réseau de tâches PERT. Calculer les dates au plus tôt, les dates au plus tard, les marges. Mesurer les points d’attente et optimiser un réseau.

Introduction à MS-Project

• Initialisation d’un projet.
• Présentation de l’environnement de travail. Comment le personnaliser ?
• Les vues courantes.

Travaux pratiques
Initialisation d’un projet avec MS-Project.

Construction du diagramme de Gantt et affectation des ressources

• Comprendre l’équation Travail (Charge) – Unité (Nb ressources) – Durée.
• L’association des ressources aux tâches.
• Calendrier et disponibilité des ressources sur le projet.
• Les types de ressources (humaines, matérielles).

Travaux pratiques
Établir une planification et un diagramme de Gantt dans MS-Project. Créer, définir et affecter des ressources aux tâches dans MS-Project.

Optimisation de la planification et gestion des coûts

• Auditer les ressources.
• Le nivellement ou comment diminuer le nombre de chemins parallèles.
• Le lissage pour optimiser l’utilisation des ressources.
• Comprendre les types de tâches (capacité/durée/travail fixe) et les calculs de MS-Project.
• Le pilotage par les ressources ou par la durée dans MS-Project.
• Traduction des ressources en coûts.
• Définir et gérer les coûts : de l’offre au budget.

Travaux pratiques
Auditer l’utilisation des ressources, gérer des surcharges, appliquer un nivellement. Établir une planification initiale Gantt avec MS-Project.

Suivi et maîtrise de l’avancement du projet

• Les différents modes de pilotage de projet (par les délais, les charges et les coûts).
• Indicateurs d’avancement physique du projet : coefficient d’utilisation, vitesse et performance.
• L’avancement des lots, évolution des charges restantes.
• Les indicateurs économiques Projet : CBTP, CBTE, CRTE. Construction et interprétation d’une courbe en S.
• Comptes-rendus d’activité et d’avancement.
• Construction du tableau de bord du projet : choix des bons indicateurs.
• Comment mettre en évidence les données pertinentes du projet avec MS-Project ?
• Utiliser dans MS-Project les rapports d’avancement, voir l’utilisation des ressources et suivre les coûts du projet.
• Analyse des données et traitement des aléas en cours de projet. Le triangle projet.

Travaux pratiques
Établir un tableau de bord à partir de comptes-rendus d’activités. Construire un tableau de bord budgétaire avec MS-Project. Établir un tableau de bord projet à partir des résultats du précédent exercice.

Planification et suivi multiprojets

• La justification d’un découpage en sous-projets.
• Les axes de découpage projet : Produits (PBS), Activités (WBS), Ressources (RBS).
• Les contraintes de planification inter-projets, les ressources partagées.

Travaux pratiques
L’étude de cas précédemment traitée est décomposée en sous-projets.

Travail collaboratif et gestion multiprojets avec MS-Project

• La saisie des informations par les ressources, la consolidation dans MS-Project par le chef de projet.
• Comment effectuer les mises à jour. Les rôles du chef de projet et des sous-chefs de projets.
• La gestion multiprojets avec MS-Project, projet principal et sous-projets, les fichiers de ressources partagées.
• Les projets consolidés et les projets composants.
• Pourquoi et comment lier des projets ?
• Principe de fonctionnement de MS-Project Server : présentation des fonctionnalités majeures.

Travaux pratiques
Création de projet consolidé, utilisant des ressources partagées. Création de liaisons entre projets.

Cadrer un projet technique en milieu opérationnel

• Analyser les besoins.
• Réaliser un cahier des charges technique.
• Analyser les fonctionnalités et les contraintes du produit/service à développer.
• Établir le niveau de performance du produit/service.
• Organiser les tâches en workpackage.
• Établir les objectifs du projet, périmètre, livrables attendus, ressources nécessaires.
• Affecter les différentes responsabilités inhérentes aux activités : R. A. C. I.
• Stimuler la créativité des équipes internes et fournisseurs.
• Actionner les 4 leviers de conduite du changement.

Travaux pratiques
Analyse fonctionnelle complète jusqu’au cahier des charges. Tableau de bord du projet.

Bâtir son projet

• Planifier le projet en tâches avec des méthodes à capacités finies et non finies.
• Réaliser le phasage, le jalonnement du projet en collaboratif.
• Planifier les étapes, activités, tâches : en délais, charge, coût.
• Élaborer les différentes procédures : mesure de l’avancement, gestion des modifications…
• Établir les règles de fonctionnement du projet.