28 temas · 5074 lecciones · 1503 h de estudio
Guías interactivas y profundas para dominar tecnología de cero a experto. Elige un tema y recorre el camino, nivel a nivel.
La matemática, la ciencia y las herramientas que sostienen todo lo demás. Es cierto independientemente de la tecnología que uses.
La base combinatoria del razonamiento sobre programas: conjuntos, relaciones, grafos, recurrencias e inducción.
Lógica proposicional y de primer orden, sistemas de deducción, y la correspondencia entre demostraciones y programas.
Espacios vectoriales, matrices, autovalores y descomposiciones: la matemática que hay bajo los gráficos y el aprendizaje automático.
Probabilidad, variables aleatorias, distribuciones e inferencia, con el análisis de algoritmos aleatorizados como motivación.
Divisibilidad, aritmética modular, primalidad y logaritmo discreto: los cimientos de la criptografía moderna.
Divide y vencerás, programación dinámica, voraces, grafos y flujos, con el análisis de coste como hilo conductor.
Listas, pilas, tablas hash, árboles equilibrados, montículos y estructuras persistentes, con sus costes amortizados.
P, NP, reducciones, completitud y jerarquías: qué se puede resolver de forma eficiente y qué no.
Autómatas, lenguajes formales, máquinas de Turing, indecidibilidad y el problema de la parada.
Cálculo lambda, sistemas de tipos, inferencia, polimorfismo y tipos dependientes, y por qué un tipo es una demostración.
Memoria compartida frente a paso de mensajes, exclusión mutua, modelos de memoria, y los teoremas de imposibilidad.
Relojes lógicos, consenso, replicación, tolerancia a fallos, CAP y los CRDT como teoría antes que como librería.
El modelo de propagación: grafos de dependencias, tracking, consistencia glitch-free, y qué distingue push de pull.
Gramáticas, análisis léxico y sintáctico, semántica, representaciones intermedias, optimización y generación de código.
Procesos e hilos, cambio de contexto, planificadores, prioridades y el coste real de la concurrencia en el sistema.
Paginación, la TLB, el fallo de página, la asignación de memoria y por qué tu puntero no apunta a la RAM.
Inodos, journaling, cachés, sincronización a disco y las garantías reales que ofrece cada sistema de ficheros.
La interfaz entre el espacio de usuario y el núcleo: syscalls, interrupciones, copias de memoria y el coste del cruce.
Monolítico frente a microkernel, exokernels, unikernels y qué se gana y se pierde en cada reparto de responsabilidades.
El modelo de dispositivos, DMA, interrupciones, buses y cómo un driver expone hardware como una abstracción del sistema.
El monolito modular, los límites internos, cuándo la modularidad basta y qué problema resuelve de verdad partir un sistema.
Descomposición por dominio, comunicación entre servicios, transacciones distribuidas, y el coste operativo que se compra.
Colas, log de eventos, event sourcing, CQRS, entrega al menos una vez y el diseño para el reprocesado.
Cuándo tiene sentido invertir el modelo cliente-servidor, qué garantías cambia y qué problemas nuevos crea.
Modelos de consistencia, particionado, replicación y las decisiones que impone el teorema CAP en un sistema real.
Recursos, versionado, paginación, idempotencia, errores y evolución de un contrato con clientes que no controlas.
El shell como lenguaje: expansión, redirección, procesos, señales, y scripts que no se rompen con un espacio.
De cero a nivel dios: modelo modal, tu propia config en Lua, un IDE para C/Rust/Swift/Frontend, terminal, automatización e IA.
El modelo de objetos, el grafo de commits, rebase, reflog y resolver cualquier situación entendiendo qué hay debajo.
Búsqueda difusa, expresiones regulares a escala, y componer herramientas para encontrar cualquier cosa en segundos.
Sesiones persistentes, paneles, sesionizadores y un flujo de trabajo que sobrevive a cerrar el portátil.
Versionar la configuración, gestionarla entre máquinas, y el arranque de un equipo nuevo en minutos.
Dónde se implementa el núcleo. Un mismo concepto reaparece aquí con la forma que le da cada plataforma.
Cómo funciona un motor de reactividad por dentro: el grafo de dependencias, tracking automático, push-pull, glitches, el árbol de dueños y los motores comparados.
Los cimientos de la reactividad: signals y observables, derivación, inmutabilidad, sincronización, el estado del servidor, la URL, formularios y local-first.
Modelar el estado como una máquina: autómatas, statecharts de Harel, XState v5 a fondo, el actor model, testing basado en modelos y patrones reales.
De Flux a Redux Toolkit y la ola ligera: store, reducers, middleware, selectores, RTK Query, DevTools, y Zustand/Jotai/Valtio a fondo.
Elm y TEA: el lenguaje funcional puro sin errores en runtime, Model/update/view, los efectos como datos, y el legado que sembró en Redux, TCA y MVI.
The Composable Architecture de Point-Free: State, Action, Reducer, Effect y Store; composición, @Dependency, navegación como dato y testing exhaustivo.
Model-View-Intent en el mundo Android: Orbit, coroutines y Flow, estado inmutable en Compose, side effects de una sola vez y Kotlin Multiplatform.
CSS de verdad: cascada y capas, :has, nesting, @scope, grid y subgrid, container queries, OKLCH, anchor positioning, arquitectura y rendimiento.
El movimiento en la web: el pipeline del navegador, transitions y keyframes, WAAPI, scroll-driven, view transitions y GSAP a fondo.
Gráficos 3D en la web: el pipeline, geometría e instancing, PBR y texturas, glTF, shaders GLSL, TSL con WebGPURenderer y producción.
La API gráfica moderna de la web: adaptador y dispositivo, buffers y bind groups, WGSL a fondo, compute shaders, GPGPU y arquitecturas de render.
Los dos modelos del gráfico 2D: el contexto de canvas, píxeles y composición, SVG a fondo, filtros, y la visualización de datos.
Hacer que vaya rápido de verdad: LCP, INP y CLS, la red y la caché, el coste del JavaScript, el pipeline de render, memoria y estrategias de carga.
Las herramientas por dentro: Elements y la cascada real, breakpoints que no son de línea, el waterfall, el flame chart, cazar fugas y automatizar.
De islands architecture a producción: componentes, content collections, SSR/SSG, actions, view transitions, el compilador en Rust y desplegar en el edge.
Reactividad de grano fino: signals, efectos, memos, stores, control flow, createResource, Solid 2.0 (async first-class) y SolidStart.
El camino a producción: pnpm, módulos, Vite y Rolldown, bundling, code splitting, lazy loading, monorepos y remote caching (Turborepo/Nx).
Swift 6 a fondo: el modelo de tipos y valores, protocolos y genéricos, macros y result builders, memoria y ownership, concurrencia estricta, y Swift fuera de Apple.
Kotlin como lenguaje: nulabilidad en el sistema de tipos, sealed y exhaustividad, genéricos y varianza, DSLs, corrutinas y Flow por dentro, el compilador K2 y los cuatro backends.
Lua a fondo: tablas y metatablas, closures y upvalues, corrutinas, el recolector y la máquina virtual de registros, la API C, embeber el lenguaje y LuaJIT.
De la sintaxis de C23 al nivel PhD: punteros, memoria, Meson, sanitizers, ABI, libc/musl, freestanding, concurrencia y tu propia libc.
Ownership, traits, lifetimes, async (edición 2024), unsafe/FFI, no_std, embebido, debugging y programación a nivel de tipos.
Desarrollo Android completo: Jetpack Compose y UI adaptativa, las librerías de Jetpack (Room, WorkManager, Paging), capacidades del sistema, rendimiento y Google Play.
Desarrollo iOS completo: SwiftUI y su modelo declarativo, SwiftData y persistencia, arquitectura, capacidades del sistema, rendimiento y publicar en la App Store.