Illustration stages Nous recrutons
Develop

Formation Kotlin Coroutines - Avancé

Maîtrisez les fonctionnalités avancées des Kotlin Coroutines pour écrire un code asynchrone performant et maintenable.
3 jours (21h00)
1 à 8 personnes
0 participant·e·s
de janvier 2023 à ce jour.
Théorie - 60%
Pratique - 40%
Formation Kotlin Coroutines présentiel ou à distance avec 4SH
Prix de la formation 2100 € HT Niveaux disponibles Prochaine(s) session(s)
Du 16/06/2025 au 18/06/2025
Prendre rendez-vous
Toutes nos formations sont disponibles en présentiel ou à distance.
Pré-inscription
Niveau :
Icône avance Avancé
En soumettant ce formulaire, vous  acceptez que 4SH mémorise et utilise vos données personnelles dans les conditions décrites dans la Notice d'informations RGPD.
Merci de cocher l'acceptation de la notice d'informations RGPD.
Prix de la formation
2100 € HT

Description formation Kotlin Avancé

Kotlin est un langage de programmation moderne développé par JetBrains. Ce langage statiquement typé peut être exécuté sur la JVM et est complètement interopérable avec Java. Il offre une syntaxe concise et des fonctionnalités modernes qui facilitent le développement d'applications, comme une meilleure gestion de la nullité, des capacités d’extensions et une API très riche sur les collections...

La formation Kotlin Coroutines Avancé est conçue pour les personnes maîtrisant déjà le langage Kotlin, mais n’ayant que des connaissances superficielles des coroutines et souhaitant approfondir leurs compétences. Elle couvre une variété de sujets sur l’utilisation des coroutines allant de la maîtrise des concepts au coeur de l’API (CoroutineScope, CoroutineContext, Job, Dispatcher, coroutines builders, …) jusqu’à leur fonctionnement interne et leur implémentation sous forme de continuation.

La formation s’appuie sur des éléments théoriques mais également des démonstrations et des travaux pratiques pour assurer une maîtrise complète des concepts avancés de cette API.


Pour qui ?

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.

Prérequis

  • 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

Objectifs pédagogiques

  • 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

Programme formation Kotlin Coroutines

  1. Introduction
  2. 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
  3. Orchestration de coroutines Basics
    • Async / Await
    • Concurrence structurée avec coroutineScope
  4. Modèle de concurrence
    • Quelles threads pour exécuter les coroutines ?
    • Quelles implications pour les coroutines ?
    • La notion de Dispatcher et son usage
  5. Job : cancel et timeout
    • Comprendre le mécanisme d’annulation de coroutine
    • Modèle coopératif
    • Gestion du NonCancellable
    • Exécution avec timeout
  6. 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
  7. 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
  8. Gestion de la concurrence
    • Approche par confinement de Thread ou de coroutine
    • Utilisation de Mutex
    • Utilisation de Channel : les bases
  1. 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
  2. Plus loin avec les Job
    • Maîtriser le cycle de vie
    • API Job() et CompletableJob
    • Les SupervisedJob et la gestion des erreurs associée
  3. Plus loin avec les coroutines builders
    • Inventaire des coroutines builders et leurs différences
    • Gestion du démarrage des coroutines
  4. Plus loin avec les context
    • Interopérabilité avec les Threads
  5. 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
  6. Plus loin avec les Flow
    • Hot flows : SharedFlow
    • Hot flows : StateFlow
    • Gestion du replayable cache
    • Comprendre l’implémentation du shareIn
  7. Les tests
    • Bien tester les coroutines
    • Gestion du temps et du delay
  8. 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

Modalités d'accueil

Café offert
Repas du déjeuner inclus dans le tarif de la formation
Parking


Formation(s) liée(s)

Java
à partir de
1800 €
(7)

Java

Develop

Tout savoir sur ce langage de programmation multiplateforme orienté objet.