Tu zona de trabajo: estudia, abre materiales, practica y pregunta cuando te atasques.

Comprender qué es Vue.js y construir tu primera app reactiva desde cero.

• ¿Qué es un framework SPA progresivo? Vue en el ecosistema frontend
• Crear la instancia con createApp y montar en el DOM
• Reactividad: data(), ref(), reactive()
• Interpolación {{ }}, directivas v-bind, v-on, v-if, v-for
• Single File Component (SFC): <template>, <script>, <style scoped>
• CDN vs proyecto Vite: cuándo usar cada uno

Construir apps modulares con comunicación correcta entre componentes padre e hijo.

• Arquitectura de componentes y flujo unidireccional de datos
• Props: defineProps() con tipado, valores por defecto y required
• Eventos personalizados: defineEmits() y emit()
• Slots básicos para contenido flexible e inyectable
• Patrón completo: TarjetaRecurso (hijo) ↔ AppUt2 (padre)
• script setup vs Options API: ventajas de cada enfoque

Crear SPAs con navegación real entre vistas y estado global centralizado.

• Vue Router: createRouter, createWebHistory, rutas anidadas
• <RouterView /> y <RouterLink>: navegación sin recarga de página
• Rutas dinámicas con parámetros: /perfil/:id
• Pinia: defineStore, state, actions, getters
• Comparativa Pinia vs Vuex: por qué Pinia es el estándar en Vue 3
• Persistencia del store con localStorage

Escribir código Vue de calidad profesional y desplegar la SPA a producción.

• Arquitectura: components/, views/, composables/, stores/
• Patrón contenedor/presentacional: separar lógica de renderizado
• Testing con Vitest + Testing Library: render, fireEvent, emitted()
• Accesibilidad: aria-live, labels asociados, v-bind:key en listas
• Build con Vite: npm run build genera carpeta dist optimizada
• Despliegue en Netlify / Vercel: drag & drop o CI desde repositorio

Configurar el entorno completo y entender la estructura de un proyecto Android.

• Instalar Android Studio, SDK 34 y crear el primer emulador
• Entender la estructura de carpetas: manifest, res/, build.gradle.kts
• Gestionar dependencias con el Version Catalog (libs.versions.toml)
• Ejecutar comandos Gradle: assembleDebug, test, lint
• Variables, tipos, control de flujo y funciones en Kotlin desde VS Code

Dominar el Kotlin necesario para Android: null safety, colecciones y patrones funcionales.

• Null safety: ?., ?:, let — nunca más NPE
• Data classes con copy() y destructuring
• Colecciones: filter, map, groupBy, sortedBy
• Scope functions: apply, let, also, run, with
• Sealed classes para modelar estados (Loading, Success, Error)
• Extension functions y lambdas

Crear interfaces modernas con el paradigma declarativo de Jetpack Compose.

• Declarativo vs imperativo — por qué Compose reemplaza al XML
• @Composable, recomposición y jerarquía de UI
• Modifier: padding, fillMaxSize, clickable, clip... (el orden importa)
• Layouts: Column, Row, Box y sus Arrangements
• Material 3: Card, Button, TextField, Scaffold, TopAppBar
• Estado local con remember + mutableStateOf
• @Preview para ver la UI sin emulador

Implementar la arquitectura MVVM correctamente para separar UI de lógica de negocio.

• ViewModel: sobrevive a rotaciones, gestiona el estado
• MutableStateFlow / StateFlow + collectAsState()
• UiState sealed class: Loading, Success, Error, Empty — sin estados inválidos
• UiState data class: múltiples campos con propiedades derivadas
• Eventos one-shot con SharedFlow (navegación, Snackbar)
• viewModelScope.launch { } y update { }

Navegar entre pantallas de forma segura y gestionar el back stack correctamente.

• NavController + NavHost — el grafo de navegación
• Rutas con sealed class para evitar errores de tipeo
• Pasar argumentos entre pantallas (Int, String, opcionales)
• popBackStack(), launchSingleTop, limpiar el stack
• Bottom Navigation Bar con estado restaurado entre pestañas

Implementar listas eficientes que nunca se congelen, con todos sus estados.

• LazyColumn vs Column — por qué el parámetro key es crítico
• Estados de lista: Loading / Success / Error / Empty
• Sticky headers con stickyHeader
• Optimización con derivedStateOf y remember(input)
• LazyRow para listas horizontales

Conectar la app a APIs REST manejando todos los tipos de error posibles.

• Setup Retrofit + OkHttp + kotlinx.serialization
• Interface de API con @GET, @POST, @Path, @Query, @Body
• safeApiCall — wrapper que captura Success, Error HTTP y Exception de red
• Interceptor de logging para depuración
• API de práctica: jsonplaceholder.typicode.com

Programar de forma asíncrona sin bloquear el hilo principal ni crashear la app.

• suspend fun — se pausa sin bloquear el hilo
• Dispatchers.IO para red y BD · Main para UI
• launch vs async/await — paralelismo real
• Flow — streams de datos reactivos (emite múltiples valores)
• Operadores: map, filter, debounce, collectLatest
• StateFlow para estado UI · SharedFlow para eventos

Persistir datos localmente con SQLite a través de Room de forma reactiva.

• @Entity — la tabla · @Dao — las operaciones · @Database — la BD
• CRUD: @Upsert, @Delete, @Query
• Flow<List<T>> en el DAO — la UI se actualiza sola al cambiar datos
• Migraciones para actualizar el esquema sin perder datos del usuario
• Integración con ViewModel usando stateIn

Crear apps que funcionen sin conexión mostrando siempre datos locales.

• Room como Single Source of Truth — la UI nunca lee de la API directamente
• Patrón Repository — abstrae si los datos vienen de red o de la BD
• Mappers entre capas: modelo API → Entity → Dominio
• Estrategias: cache-first y network-first
• Detectar conectividad con callbackFlow + ConnectivityManager

Escribir tests unitarios de ViewModel que realmente protejan el código.

• JUnit 4 — @Test, @Before, @After · Patrón AAA
• Fakes — implementaciones de repositorio controladas para tests
• runTest + UnconfinedTestDispatcher para coroutines
• Turbine para testear secuencias de estados en StateFlow
• Tests obligatorios: estado inicial, validación, toggle, error, eliminar

Generar y firmar un APK de release listo para distribuir.

• debug vs release — diferencias de firma, ProGuard y rendimiento
• Keystore — clave privada de firma (nunca la pierdas)
• ProGuard/R8 — ofuscación, shrinking y eliminación de logs
• APK para distribución directa · AAB obligatorio en Play Store
• GitHub Actions CI/CD — tests + lint + build automático en cada PR
• Checklist de entrega completo

Gestionar el ciclo completo de permisos peligrosos sin frustrar al usuario.

• Permisos normales vs peligrosos — qué requiere solicitud en runtime
• ActivityResultContracts.RequestPermission() — el launcher moderno
• Flujo completo: pedir → concedido / denegado / denegado permanente
• shouldShowRequestPermissionRationale — cuándo explicar antes de pedir
• Abrir Ajustes del sistema si deniega permanentemente
• Permisos granulares en Android 13+: READ_MEDIA_IMAGES

Acceder a cámara, galería y audio — los recursos multimedia clave del BOE.

• CameraX — captura de fotos con gestión de ciclo de vida
• Photo Picker (PickVisualMedia) — galería moderna sin permisos en API 33+
• Coil (AsyncImage) — carga de imágenes eficiente con caché
• MediaPlayer — reproducción de audio con controles completos
• MediaRecorder — grabación de audio con permiso RECORD_AUDIO
• FileProvider para compartir ficheros de forma segura

Gestionar procesos del sistema operativo desde Java.

• Lanzar y controlar procesos con ProcessBuilder y Runtime.exec()
• Leer stdout/stderr y escribir en stdin del proceso hijo
• Obtener PID, estado y código de retorno
• Redirección de E/S y procesos en background

Crear y gestionar hilos con Thread y Runnable.

• Ciclo de vida: NEW, RUNNABLE, BLOCKED, TERMINATED
• Thread, Runnable y lambdas
• sleep(), join(), interrupt()
• Daemon threads y prioridades

Evitar condiciones de carrera y coordinar hilos de forma segura.

• synchronized, monitores y sección crítica
• wait() / notify() / notifyAll()
• Semáforos con Semaphore
• Variables atómicas: AtomicInteger, AtomicBoolean
• Problema productor-consumidor

Programar cliente-servidor con comunicación TCP fiable.

• ServerSocket + Socket: ciclo aceptar-leer-escribir
• Servidor multihilo: un hilo por cliente
• Serialización con ObjectInputStream / ObjectOutputStream
• Chat cliente-servidor completo

Comunicación sin conexión y comparar TCP vs UDP.

• DatagramSocket y DatagramPacket
• Envío y recepción de datagramas
• Diferencias TCP (fiable, conexión) vs UDP (rápido, sin garantías)
• Casos de uso: streaming, juegos, DNS

Crear un servidor HTTP/REST con Java estándar (sin frameworks).

• HttpServer de com.sun.net.httpserver
• Endpoints GET / POST / DELETE con rutas
• Serialización/deserialización JSON manual
• Códigos de estado HTTP y cabeceras CORS

Consumir APIs REST desde Java con HttpClient.

• HttpClient, HttpRequest, HttpResponse (Java 11+)
• Peticiones GET / POST con cuerpo JSON
• Autenticación con cabeceras (Bearer token)
• Consumir APIs públicas externas

Guardar y recuperar datos entre ejecuciones usando ficheros JSON.

• Guardar historial de mensajes en fichero NDJSON
• Lectura y escritura con BufferedReader / FileWriter
• Parseo JSON manual y con Gson
• Sincronización del acceso concurrente al fichero

Usar el framework de concurrencia de Java para gestionar pools de hilos.

• ExecutorService y Executors: pools fijos, cached y scheduled
• Callable y Future: tareas con retorno
• CompletableFuture para encadenar operaciones asíncronas
• BlockingQueue para comunicación entre hilos
• Monitoreo y depuración con VisualVM / jstack

Aplicar criptografía y comunicaciones seguras en Java.

• Hashing con SHA-256 y bcrypt
• Cifrado simétrico AES (CBC, GCM)
• Cifrado asimétrico RSA: par de claves, firma digital
• Comunicaciones SSL/TLS con SSLSocket
• Certificados y KeyStore

Preparar el entorno de desarrollo y ejecutar el primer programa Kotlin.

• Instalar JDK 17+, VS Code y extensiones necesarias
• Configurar Live Server para la plataforma
• Primer programa: fun main() y println()
• Ejecutar snippets en el playground online (OneCompiler)

Variables, tipos, funciones y strings en Kotlin.

• val (inmutable) vs var (mutable): tipado explícito e inferido
• Tipos básicos: Int, Double, Boolean, String
• Funciones: fun nombre(param: Tipo): Tipo, valores por defecto
• String templates: "Hola $nombre, tienes ${edad + 1} años"

Condicionales, bucles y rangos en Kotlin.

• if como expresión: val max = if (a > b) a else b
• when: el switch de Kotlin, potente y expresivo
• Bucles: for (i in 1..10), while, do-while
• Rangos con step: 1..100 step 5, downTo

Eliminar NullPointerException con el sistema de tipos nullable y dominar colecciones.

• Tipos nullable: String? vs String
• Operadores: ?. (safe call), ?: (Elvis), !! (not-null assert)
• Listas: listOf(), mutableListOf(), filter, map, find
• Sets y Mapas: mapOf(), mutableMapOf()

Dominar lambdas y operaciones funcionales sobre colecciones.

• Funciones de orden superior: pasar funciones como parámetros
• Lambdas: { x -> x * 2 } y sintaxis it
• Operaciones funcionales: filter, map, reduce, groupBy, sortedBy
• Encadenamiento fluido y legibilidad

Clases, data classes, enums y principios de POO en Kotlin.

• Clases: constructor primario, propiedades con val/var
• data class: equals, hashCode, copy, toString automáticos
• enum class con propiedades y métodos
• Herencia con open y override, clases selladas (sealed)
• Interfaces y companion object

Escribir y ejecutar tests automáticos con JUnit 5 en proyectos Gradle.

• Estructura de proyecto Gradle con src/test/kotlin
• Anotaciones JUnit 5: @Test, @BeforeEach, @AfterEach
• Assertions: assertEquals, assertNotNull, assertThrows
• Ejecutar con .\test.bat y ver informe de resultados

Guardar y recuperar datos entre ejecuciones con ficheros y JSON.

• Leer y escribir ficheros con File.readText() / File.writeText()
• Parseo CSV manual
• Serialización JSON con Gson: toJson() / fromJson()
• Gestión de errores al acceder a ficheros

Puente entre Kotlin de consola y el desarrollo Android nativo.

• Diferencias entre Kotlin JVM y Kotlin Android
• Concepto de Activity, ViewModel y ciclo de vida
• Primer vistazo a Jetpack Compose vs XML layouts
• Lo que ya sabes de Kotlin que aplica directamente en Android