Cómo aprobar una entrevista de Kotlin: principales preguntas de nivel avanzado

Cómo aprobar una entrevista de Kotlin: principales preguntas de nivel avanzado

Una entrevista para un puesto de desarrollador Senior de Kotlin no es solo una verificación de sintaxis. Los entrevistadores quieren ver una comprensión profunda de la arquitectura del lenguaje, las particularidades de la compilación y la concurrencia. En este artículo, analizaremos las preguntas más difíciles y frecuentes que te ayudarán a superar con confianza una entrevista técnica. El material está dirigido a desarrolladores que ya tienen experiencia con Kotlin y Java.

1. Corrutinas: Structured Concurrency y cancelación de tareas

Las corrutinas son uno de los puntos fuertes de Kotlin. Una pregunta avanzada a menudo se refiere a Structured Concurrency. El entrevistador puede preguntar: «¿Qué sucede si una corrutina hija lanza una excepción y la corrutina padre no la captura?»

La respuesta está en la jerarquía de Job. Si una corrutina hija (iniciada mediante coroutineScope o dentro de launch) falla con una excepción, esta asciende al padre. La corrutina padre se cancela, y todas sus tareas hijas también. Esto hace que el código sea predecible y seguro.

Ejemplo que vale la pena mostrar en la entrevista:

import kotlinx.coroutines.*

fun main() = runBlocking {    try {        coroutineScope {            launch {                delay(100)                throw RuntimeException("Error en la corrutina hija")            }            launch {                delay(200)                println("Esta corrutina no se ejecutará si la primera falla")            }        }    } catch (e: Exception) {        println("Excepción capturada: ${e.message}")    }    println("El programa continúa su ejecución")}

Otra pregunta frecuente es la cancelación de corrutinas. ¿Cómo cancelar correctamente una corrutina? Usa Job.cancel() y verifica el estado mediante ensureActive() o isActive dentro de operaciones largas.

2. Funciones inline y tipos reified

Los desarrolladores avanzados deben entender para qué sirven las funciones inline. La pregunta podría ser: «¿Por qué Kotlin no permite usar tipos reified sin inline?»

Respuesta: los tipos reified (reificados) solo funcionan dentro de funciones inline, porque el código de dicha función se inserta directamente en el lugar de la llamada. El compilador sustituye el tipo concreto durante la compilación, lo cual es imposible para funciones genéricas normales debido al borrado de tipos en la JVM.

Ejemplo que demuestra el poder 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}

También preguntarán sobre noinline y crossinline. noinline prohíbe la inserción de un parámetro lambda específico, mientras que crossinline prohíbe usar return dentro de la lambda (retorno no local).

3. Delegados: Delegates.observable, vetoable y delegados personalizados

La pregunta sobre delegados es un clásico. El nivel avanzado implica no solo conocer los delegados incorporados (lazy, observable), sino también saber escribir los propios.

Ejemplo: «¿Cómo implementar un delegado que registre cada cambio de propiedad?»

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("Lectura de ${property.name}: $value")        return value    }

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

class User {    var