Java avanzado: testing, concurrencia y la JVM
Cómo se prueba código de verdad, cómo corren varios hilos a la vez, y qué hace la JVM entre javac y que el programa ande.
12 aulas · 8 horas de práctica · en el navegador, sin instalar nada
Temario
- Por qué testear — Un test manual con if y println encuentra bugs reales, pero no escala. Arrange-Act-Assert es el patrón que vas a repetir en todo el curso.
- JUnit real y el framework casero — Cómo se ve un test con JUnit de verdad —anotaciones, ciclo de vida, aserciones— y un framework de aserciones propio que sí corre en este motor.
- Test doubles: stub, fake, mock, spy — Aislar una clase de sus dependencias reales para testearla. Mockito real como referencia, y un fake escrito a mano que sí corre en este motor.
- Cobertura y buenos tests — Qué mide la cobertura y por qué el 100% no garantiza nada. Tests frágiles vs. robustos, testear comportamiento y no implementación, y por qué los casos borde importan más que los casos fáciles.
- Taller — Validador de pedidos — Un validador de pedidos chico, construido guiado por tests: primero la regla de validez, después el descuento por volumen, y por último aislar la consulta de stock con un fake — sin tocar nada real.
- La JVM por dentro I: class loading, bytecode y JIT — Qué pasa entre que javac compila tu archivo y que el programa corre: bytecode, el classloader, y por qué la JVM empieza interpretando y termina compilando a código nativo.
- La JVM por dentro II: memoria — Stack vs. heap: dónde vive cada cosa. El garbage collector, conceptual. El string pool, ejecutable: por qué a veces == miente y equals dice la verdad.
- Concurrencia I: threads y el modelo mental — Qué es un thread, Thread vs. Runnable, start() vs. run(), y por qué en este motor no se puede ejecutar un hilo real — de referencia, y una simulación de planificador que sí corre.
- Concurrencia II: condiciones de carrera y synchronized — Qué es una condición de carrera —conceptual, con un ejemplo comentado— y cómo synchronized la evita dejando pasar un hilo a la vez por una sección crítica.
- Concurrencia III: volatile y atómicos — volatile garantiza visibilidad, no atomicidad. AtomicInteger/AtomicLong dan operaciones realmente atómicas sin un synchronized manual — y por qué conviene preferirlas cuando alcanzan.
- Cierre: testing, concurrencia y la JVM — Un checklist de qué testear (y qué no) antes de un commit, y un repaso final que junta el framework de aserciones con un tipo atómico.
- Taller — Contador seguro — Cierre del curso: una clase respaldada por AtomicInteger, probada con el framework de aserciones casero, y ejercitada con el mismo planificador cooperativo de un solo hilo de las aulas de concurrencia — testing y concurrencia, atados.