Comment réussir un entretien Kotlin : les meilleures questions de niveau avancé

Comment réussir un entretien Kotlin : les meilleures questions de niveau avancé

Un entretien pour un poste de développeur Senior Kotlin ne se limite pas à une simple vérification de la syntaxe. Les recruteurs veulent voir une compréhension approfondie de l'architecture du langage, des spécificités de compilation et de la programmation multithread. Dans cet article, nous analysons les questions les plus difficiles et les plus fréquentes qui vous aideront à réussir votre entretien technique. Ce contenu est destiné aux développeurs ayant déjà une expérience avec Kotlin et Java.

1. Coroutines : Structured Concurrency et annulation de tâches

Les coroutines sont l'un des points forts de Kotlin. Une question avancée concerne souvent la Structured Concurrency. Le recruteur peut demander : « Que se passe-t-il si une coroutine enfant lève une exception et que la coroutine parent ne l'attrape pas ? »

La réponse réside dans la hiérarchie des Job. Si une coroutine enfant (lancée via coroutineScope ou à l'intérieur de launch) échoue avec une exception, celle-ci remonte vers le parent. La coroutine parent est annulée, et toutes ses tâches enfants le sont également. Cela rend le code prévisible et sûr.

Exemple à montrer lors de l'entretien :

import kotlinx.coroutines.*

fun main() = runBlocking {    try {        coroutineScope {            launch {                delay(100)                throw RuntimeException("Erreur dans la coroutine enfant")            }            launch {                delay(200)                println("Cette coroutine ne s'exécutera pas si la première échoue")            }        }    } catch (e: Exception) {        println("Exception attrapée : ${e.message}")    }    println("Le programme continue")}

Une autre question fréquente concerne l'annulation des coroutines. Comment annuler correctement une coroutine ? Utilisez Job.cancel() et vérifiez l'état via ensureActive() ou isActive dans les opérations longues.

2. Fonctions inline et types reified

Les développeurs avancés doivent comprendre pourquoi les fonctions inline sont nécessaires. La question peut être : « Pourquoi Kotlin ne permet-il pas d'utiliser les types reified sans inline ? »

Réponse : les types reified (matérialisés) ne fonctionnent qu'à l'intérieur des fonctions inline, car le code de ces fonctions est intégré directement à l'endroit de l'appel. Le compilateur substitue le type concret lors de la compilation, ce qui est impossible pour les fonctions génériques normales en raison de l'effacement des types dans la JVM.

Exemple démontrant la puissance de reified :

inline fun <reified T> isInstance(value: Any): Boolean {    return value is T}

fun main() {    println(isInstance<String>("Hello")) // true    println(isInstance<Int>("Hello"))    // false}

On vous demandera aussi noinline et crossinline. noinline interdit l'intégration d'un paramètre lambda spécifique, tandis que crossinline interdit l'utilisation de return à l'intérieur du lambda (retour non local).

3. Délégués : Delegates.observable, vetoable et délégués personnalisés

La question sur les délégués est un classique. Le niveau avancé implique non seulement la connaissance des délégués intégrés (lazy, observable), mais aussi la capacité d'écrire les vôtres.

Exemple : « Comment implémenter un délégué qui journalise chaque modification de propriété ? »

import kotlin.properties.ReadWritePropertyimport kotlin.reflect.KProperty

class LoggingDelegate<T>(private val initialValue: T) : ReadWriteProperty<Any?, T> {    private var value = initialValue

    override fun getValue(thisRef: Any?, property: KProperty<*>): T {        println("Lecture de ${property.name} : $value")        return value    }

    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {        println("Écriture de ${property.name} : $value")        this.value = value    }}

class User {    var