Kotlin Coroutines - Avancé

Maîtriser l’usage des coroutines
Comprendre le modèle de concurrence sous jacent
Comprendre la structured concurrency et son application
Maîtriser les CoroutineScope et leurs usages
Maîtriser les Job et leur application
Savoir faire communiquer des coroutines
Savoir interopérer les CoroutineContext et les Threads de la JVM
Comprendre et maîtriser la gestion des erreurs et leur propagation
Savoir traiter des flux de données asynchrones
Appréhender l’implémentation interne des coroutines et son implication

Attestation de fin de formation

Introduction
Coroutines Basics : introduction à l’utilisation des coroutines
Coroutine : définition et API de base
Appels non bloquants et mot clef suspend
Les bases de l’API Flow
Utilisation de l’API Job pour synchroniser des coroutines
Orchestration de coroutines Basics
Async / Await
Concurrence structurée avec coroutineScope
Modèle de concurrence
Quelles threads pour exécuter les coroutines ?
Quelles implications pour les coroutines ?
La notion de Dispatcher et son usage
Job : cancel et timeout
Comprendre le mécanisme d’annulation de coroutine
Modèle coopératif
Gestion du NonCancellable
Exécution avec timeout
CoroutineContext
Qu'est-ce qu’un CoroutineContext ?
Comment y accéder et s’en servir ?
Comment définir ses propres clés ?
Quelles informations y sont disponibles ?
Comment modifier le contexte d’une coroutine
Structured Concurrency
Qu'est-ce qu’un CoroutineScope ?
Lien avec un CoroutineContext et un Job
Différence entre coroutineScope, CoroutineScope et CoroutineScope()
Utilisation de GlobalScope
Propagation des erreurs et cancellation
Gestion de la concurrence
Approche par confinement de Thread ou de coroutine
Utilisation de Mutex
Utilisation de Channel : les bases
Les Flow
Comprendre la notion de cold Flow
Flow builders, opérations intermédiaires et terminales
Flow builder et suspend function, les recommandations
Invariants de Flow : context preservation et exception transparency
Les bases d’utilisation des buffers
Plus loin avec les Job
Maîtriser le cycle de vie
API Job() et CompletableJob
Les SupervisedJob et la gestion des erreurs associée
Plus loin avec les coroutines builders
Inventaire des coroutines builders et leurs différences
Gestion du démarrage des coroutines
Plus loin avec les context
Interopérabilité avec les Threads
Plus loin avec les Channels
Fan in / fan out
Gestion des buffers
Paramétrer le fonctionnement quand le buffer est plein
Initiation à l’utilisation du Select
Plus loin avec les Flow
Hot flows : SharedFlow
Hot flows : StateFlow
Gestion du replayable cache
Comprendre l’implémentation du shareIn
Les tests
Bien tester les coroutines
Gestion du temps et du delay
Fonctionnement interne des coroutines
Coroutine, continuation et state machine
Comprendre le fonctionnement des continuation par l’exemple
Les implications sur le quotidien : debug et profiling

Conditions d'accès réglementaires :
Cette formation informatique s’adresse à des développeurs Kotlin qui souhaitent parfaire leur maîtrise de l’API coroutine. Même si la majorité des concepts couverts est multi plateforme, certains exemples et cas d’usages s’adressent particulièrement à la cible JVM.

Conditions d'accés pédagogiques :
Maîtriser les bases de la programmation objet
Maîtriser les bases de la programmation concurrente (notion de Thread et d’accès concurrent à la mémoire)
Maîtriser le langage Kotlin

Critères d'admission :
Inscription directe ou par un conseiller en insertion professionnelle

Modalités d'enseignement :
Sans objet

Rythme :
Temps plein