Currículo — de Flutter a Kotlin de nivel alto

Este documento es la ruta completa. El kotlin-lab es el gimnasio; Kontor es el campo de juego; el audio es el repaso.

Principios

1. 20% teoría, 80% teclado. Cada concepto termina en un test, una pantalla o una explicación.

2. Una cosa nueva a la vez. No mezcles genéricos con coroutines en la misma sesión.

3. Primero funciona, luego es idiomático. No optimices antes de tener tests verdes.

4. Explica lo que aprendes. Si no puedes contarlo en 90 segundos, no lo dominas.

5. Vuelve atrás. La repetición espaciada vale más que avanzar rápido.

Mapa general

A una hora al día. Si tienes 30 minutos, duplica las semanas. Si tienes dos horas, comprime las fases 1–3, no las fases 4–5.

Fase 0 — Entorno (2 días)

Objetivo: que ejecutar tests sea tan fácil que no haya excusa.

• Instala JDK 21 si no lo tienes.

• Abre kotlin-lab en Android Studio (File → Open). Es el IDE del puesto: acostúmbrate a él desde el día 1.

• Ejecuta ./gradlew run y ./gradlew test --tests "lab.level01.*".

• Crea una carpeta notas/ para tus apuntes. No la subas a Git si no quieres.

• Crea un repositorio Git para el lab si vas a hacer commits. No es obligatorio.

Entregable: el nivel 1 falla, pero compila. Sabes ejecutar un test concreto.

Fase 1 — Sintaxis y dominio (semanas 1–3)

Semana 1 — Sintaxis, funciones y colecciones

• Lab: nivel 1 completo y nivel 2 completo.

• Lectura: docs/FLUTTER_TO_KOTLIN.md, secciones 1–5.

• Práctica extra: 10 katas de Kotlin Koans.

• Audio: lección 1 del curso (../../kontor/docs/kotlin/audio/01_val_var_tipos.mp3).

• Entregable: los 12 primeros ejercicios en verde.

Puente con Flutter: val/var, final/var, String?, ??, ?., map/where/fold.

Semana 2 — Clases y modelo de dominio

• Lab: nivel 3 completo.

• Lee core/domain de Kontor: Money, Account, Transfer, IbanValidator, TransferValidator.

• Escribe tu propia versión de Money y TransferValidator con tests.

• Entregable: una transferencia válida y una inválida con motivos claros.

Puente con Flutter: data class frente a clases con copyWith; sealed interface frente a estados con enum + campos opcionales.

Semana 3 — Genéricos y composición

• Lab: nivel 4 completo.

• Practica ApiResult<T>, Repository<T, ID>, Box<out T> y median<T>.

• Refactoriza tu dominio para usar Result/ApiResult en vez de excepciones para errores esperados.

• Entregable: repositorio en memoria con tests y un ApiResult que se compone con map.

Puente con Flutter: los genéricos de Dart existen, pero Kotlin añade variance (out/in) y sealed types. No los uses como decoración: úsalos para quitar Any y null.

Fase 2 — Kotlin avanzado (semanas 4–6)

Semana 4 — inline, reified, secuencias y DSLs

• Lab: nivel 5 completo.

• Estudia inline, reified, sequence, by y receptores de lambda.

• Escribe un DSL pequeño para construir un Account o un Transfer.

• Entregable: nivel 5 en verde y un DSL con un test legible.

Semana 5 — Idioms y refactor

• Repasa let, run, with, apply, also y decide cuándo no usarlos.

• Practica operator fun, delegación y buildList/buildString.

• Coge tus soluciones del nivel 1–4 y refactorízalas para que parezcan Kotlin, no Dart traducido.

• Entregable: un diff de refactor con tests verdes.

Semana 6 — Code review y lectura de código

• Lee un archivo de Kontor al día y escribe tres frases: datos, reglas, fallos posibles.

• Haz code review de tus propias soluciones: nombres, nulabilidad, API pública, tests.

• Empieza docs/ASSESSMENT.md y marca tus puntos débiles.

• Entregable: un documento notas/review-semana-6.md con 10 mejoras aplicadas.

Puente con Flutter: no traduzcas BuildContext a Kotlin. En Kotlin/Android el contexto se pasa como dependencia, no como árbol global.

Fase 3 — Coroutines y Flow (semanas 7–8)

Semana 7 — suspend, scopes y cancelación

• Lab: nivel 6, primeros ejercicios.

• Practica launch, async, withContext, coroutineScope, supervisorScope.

• Implementa timeout, retry y cancelación cooperativa.

• Entregable: una fake API con latencia y tests con runTest.

Puente con Flutter: Future se parece a suspend; async/await de Dart se parece a async/await de Kotlin, pero en Kotlin el scope y la cancelación son explícitos.

Semana 8 — Flow y estado reactivo

• Lab: nivel 6 completo, nivel 7 (idioms de mid Android) y nivel 8 (ViewModel de una transferencia, tras leer docs/ANDROID_BASICS.md).

• Practica map, filter, debounce, flatMapLatest, combine, stateIn.

• Distingue Flow, StateFlow y SharedFlow.

• Testea con Turbine.

• Entregable: buscador con debounce y estado de UI.

Puente con Flutter: Stream se parece a Flow; StreamController se parece a MutableStateFlow/SharedFlow, pero el ciclo de vida y el scope cambian.

Fase 4 — Compose y Android (semanas 9–11)

Semana 9 — Compose desde Flutter

• Lee docs/COMPOSE.md y feature/accounts/AccountsScreen.kt.

• Lee core/designsystem y entiende cómo se compone un tema.

• Porta una pantalla Flutter pequeña a Compose: lista, detalle y estado vacío.

• Aprende @Composable, remember, rememberSaveable, LaunchedEffect, collectAsStateWithLifecycle.

• Entregable: pantalla Compose con preview y estados loading/empty/error.

Semana 10 — Estado, navegación y accesibilidad

• Practica state hoisting, UiState inmutable y eventos.

• Añade navegación type-safe y un @Preview por estado.

• Revisa semántica, tamaños táctiles, contraste y contenido descriptivo.

• Entregable: pantalla con tres estados y tests de UI.

Semana 11 — Kontor tickets 1–6

• Haz los tickets de UI de docs/KONTOR_TICKETS.md: previews, composables, accesibilidad, skeleton y pull-to-refresh.

• Cada ticket: test primero, cambio pequeño, explicación en 90 segundos.

• Entregable: 6 tickets cerrados y una nota por ticket.

Fase 5 — Arquitectura, datos y calidad (semanas 12–14)

Semana 12 — MVVM y UDF

• Estudia AccountsViewModel, TransferViewModel y AppViewModel.

• Practica StateFlow<UiState>, eventos y SavedStateHandle.

• Haz los tickets 7–10: filtros persistentes, categoría, borrador y errores de red.

• Entregable: un ViewModel nuevo con tests de estado y 4 tickets cerrados.

Semana 13 — Room y fuente de verdad

• Estudia AccountDao, TransactionDao, TransferDao y KontorDatabase.

• Practica transacciones, migraciones y consultas reactivas con Flow.

• Haz los tickets 11–14: repositorio por cuenta, pantalla de detalle, fallos y refresh parcial.

• Entregable: una migración, un test de transacción atómica y 4 tickets cerrados.

Semana 14 — Retrofit, Hilt y CI

• Estudia BankApi, DemoApiInterceptor, NetworkModule, RepositoryModule.

• Practica errores de red, DTOs, mapeo y Hilt.

• Haz los tickets 15–20: idempotencia, UI test, debounce, animación, tema oscuro y Room.

• Añade un test de repositorio y revisa el CI.

• Entregable: 6 tickets cerrados y un pipeline verde.

Fase 6 — Nivel alto (semanas 15–16)

Semana 15 — KMP, Java interop y backend

• Crea un módulo Kotlin Multiplatform con Money e IbanValidator.

• Consume ese módulo desde JVM y, si quieres, desde Android.

• Opcional: una API Ktor con /accounts y /transfers.

• Entregable: módulo compartido con tests y README.

Semana 16 — Capstone y entrevista

• Elige un capstone de docs/PROJECTS.md.

• Haz un simulacro de 45 minutos: explica el proyecto, arquitectura, tests y límites.

• Repasa docs/ASSESSMENT.md.

• Entregable: repo, README, demo y explicación en inglés de 2 minutos.

Definición de “nivel alto” realista

Al terminar esta ruta deberías poder:

• leer y modificar cualquier archivo de Kontor sin miedo;

• escribir Kotlin idiomático, no Dart con sintaxis Kotlin;

• modelar dominio con tipos, no con String y Boolean;

• usar coroutines y Flow con criterio;

• construir una pantalla Compose con estados y tests;

• explicar decisiones y límites en una entrevista;

• aprender una librería nueva leyendo su API.

No te convierte en senior. Eso requiere producción, incidentes, code review de otros y años. Pero te deja en un nivel mid fuerte y con una base seria.

Qué hacer si te atascas

1. Reduce el problema a un test mínimo.

2. Escribe la firma y deja TODO().

3. Hazlo funcionar de la forma más simple.

4. Refactoriza.

5. Explica el cambio en voz alta.

6. Si sigues atascado, mira la solución y vuelve a escribirla desde cero al día siguiente.