JavaScript y TypeScript

1. Introducción
   1. Historia y Evolución de JavaScript y TypeScript
      1. Origen de JavaScript en el navegador (Brendan Eich, 1995)
      2. Estándar ECMAScript y rol de ECMA International
      3. Comité TC39 y proceso de propuestas
      4. Evolución de ECMAScript (ES3, ES5, ES2015+)
      5. Aparición de TypeScript como superconjunto tipado de JavaScript
      6. Filosofía de TypeScript: tipado estático opcional y verificación en tiempo de compilación
      7. Compatibilidad progresiva con JavaScript existente
      8. Influencia de C#, Java y lenguajes estáticos en el diseño de TypeScript
      9. Adopción en backend, frontend y full-stack
      10. Impacto de Node.js en el uso de JavaScript fuera del navegador
      11. Expansión del ecosistema: Deno, Bun y runtimes alternativos
      12. Evolución del tooling: bundlers, transpiladores, linters
      13. Uso de TypeScript en grandes bases de código y monorepos
      14. Transición de JavaScript clásico basado en funciones a clases, módulos y async/await
      15. “Any valid JavaScript is valid TypeScript” como principio de diseño
   2. Versiones y Compatibilidad
      1. Versionado semántico de TypeScript
      2. Versionado de Node.js y compatibilidad con ECMAScript
      3. target y lib en tsconfig.json
      4. Downleveling y transpilación (ESNext → ES5)
      5. Compatibilidad con navegadores y entornos legacy
      6. Polyfills y core-js
      7. Características propuestas (stage 0–4) y su adopción en TypeScript
      8. Estabilidad de sintaxis frente a features experimentales
      9. Tipos DOM según versión de @types/web
      10. Estrategias de upgrade mayor de TypeScript en proyectos grandes
      11. Compatibilidad entre módulos ES (import/export) y CommonJS (require/module.exports)
      12. Detección de versión en runtime (process.versions, navigator.userAgent)
      13. Dependencia en especificación del Event Loop del host (browser vs Node)
      14. Compatibilidad entre distintos bundlers y empaquetadores
      15. Compatibilidad entre ts-node, tsx, babel, esbuild
   3. Instalación del Entorno
      1. Instalación de Node.js (instalador oficial)
      2. Instalación con nvm / fnm / asdf
      3. Instalación de Deno
      4. Instalación de Bun
      5. npm como package manager por defecto
      6. yarn clásico y yarn modern
      7. pnpm y almacenamiento global basado en content-addressable store
      8. Instalación global de typescript (npm install -g typescript)
      9. Instalación local de typescript como dependencia de desarrollo
      10. Verificación de node, npm, tsc en PATH
      11. Configuración inicial de proyecto (npm init, pnpm init, yarn init)
      12. Inicialización de TypeScript (tsc --init)
      13. Estructura de carpetas recomendada (src, dist, test)
      14. Soporte multiplataforma (Windows, macOS, Linux)
      15. Contenedores y devcontainers (Dockerfile, devcontainer.json)
   4. Ejecución de Código y REPL
      1. Ejecución directa de JavaScript con node archivo.js
      2. REPL interactivo de Node.js
      3. Ejecución directa de TypeScript con ts-node
      4. Ejecución directa de TypeScript con tsx
      5. Ejecución TypeScript nativa en Deno
      6. Ejecución TypeScript nativa en Bun
      7. Compilación explícita con tsc y luego ejecución con Node.js
      8. Flags comunes de Node (--inspect, --require, --experimental-*)
      9. Flags comunes de ts-node / tsx
      10. Uso de importaciones ES en Node ("type": "module")
      11. Uso de la consola del navegador como entorno interactivo
      12. Ejecución en entornos sandbox (CodeSandbox, StackBlitz)
      13. I/O estándar (stdin, stdout, stderr) en Node
      14. Pipes y redirección de salida en CLI de Node
      15. Hot reload durante desarrollo con nodemon, ts-node-dev
   5. IDEs y Editores
      1. Visual Studio Code y el Language Service de TypeScript
      2. WebStorm / IntelliJ IDEA con soporte TypeScript integrado
      3. Neovim con LSP (typescript-language-server)
      4. Vim con coc.nvim y extensiones TS
      5. Emacs con lsp-mode y tide
      6. Autocompletado, IntelliSense y sugerencias de tipo
      7. Navegación de código (Go to Definition, Find References)
      8. Refactorizaciones automáticas (renombrar símbolos, extraer funciones)
      9. Soporte de linters (ESLint) integrado en el editor
      10. Formato automático con Prettier
      11. Integración de debuggers (Chrome DevTools, Node Inspector)
      12. Integración con Git y control de versiones
      13. Snippets y plantillas de código repetitivo
      14. Diagnóstico en tiempo real del compilador de TypeScript
      15. Entornos de notebooks JS/TS (Quokka, Jupyter con kernels JS)
   6. Entornos de Proyecto y Aislamiento
      1. node_modules como entorno aislado por proyecto
      2. package.json como descriptor de entorno
      3. package-lock.json, yarn.lock, pnpm-lock.yaml
      4. Resolución determinista de dependencias
      5. Workspaces (yarn workspaces, pnpm workspaces, npm workspaces)
      6. Monorepos y herramientas (turbo, nx, lage)
      7. Separación entre dependencias de runtime (dependencies) y de build (devDependencies)
      8. Scripts de proyecto (npm run, pnpm run)
      9. Estrategias de versionado interno en monorepos
      10. Aislamiento por versión de Node usando nvm dentro del proyecto
      11. Contenedores reproducibles para desarrollo (Docker Compose)
      12. Variables de entorno (.env, dotenv, process.env)
      13. Reproducibilidad de builds en CI
      14. Caché incremental de transpilación y bundling
      15. Estándares de estructura de carpetas (src, lib, dist, scripts)
   7. Gestión de Paquetes y Dependencias
      1. npm install, npm update, npm uninstall
      2. yarn add, yarn remove, yarn upgrade
      3. pnpm add, pnpm remove, pnpm update
      4. Versiones fijas vs rangos (^, ~, *)
      5. Dependencias opcionales y peer dependencies
      6. Resolución de conflictos de versiones
      7. Auditoría de dependencias (npm audit, pnpm audit)
      8. Firma y verificación de integridad (shasum)
      9. Repositorios privados (Artifactory, Verdaccio)
      10. Instalaciones link/workspace locales
      11. Publicación de paquetes internos
      12. Tipos externos (@types/*) para librerías JS puras
      13. Mantenimiento de typesVersions en librerías TypeScript
      14. Dependencias transpiladas vs dependencias puras ESM
      15. Gestión de binarios nativos precompilados
   8. Herramientas del Ecosistema Web
      1. Bundlers (webpack, esbuild, rollup, vite)
      2. Compilación incremental y HMR (Hot Module Replacement)
      3. Transformación con Babel
      4. Minificación y tree-shaking
      5. Code splitting y lazy loading
      6. Sourcemaps y depuración en el navegador
      7. Polyfills automáticos según destino
      8. Linter y formateador integrados en pipeline de build
      9. Pruebas unitarias integradas en bundlers (vitest)
      10. Empaquetado para navegadores antiguos
      11. Empaquetado para runtimes edge
      12. Bundles isomórficos (SSR + CSR)
      13. Configuración multi-target (web, node, worker)
      14. Generación de tipos .d.ts
      15. Publicación de librerías como ESM y CJS
2. Fundamentos
   1. Tipos Básicos y el Sistema de Tipos de TypeScript
      1. Declaración de variables con let, const, var
      2. Inferencia de tipos
      3. Anotaciones de tipo explícitas
      4. Tipos primitivos (string, number, boolean)
      5. Tipos null, undefined, void
      6. Tipos bigint y symbol
      7. Tipos literales ("ok", 42, true)
      8. Tipos unión (|)
      9. Tipos intersección (&)
      10. Tipos any, unknown, never
      11. Alias de tipo (type)
      12. Interfaces (interface)
      13. Tuplas ([T, U])
      14. Enums (enum, const enum)
      15. Objetos con propiedades opcionales y readonly
   2. Operadores
      1. Operadores aritméticos (+, -, *, /, %, **)
      2. Operadores de asignación compuesta (+=, -=, *=, etc.)
      3. Operadores de comparación (===, !==, <, >, <=, >=)
      4. Operadores lógicos (&&, ||, !)
      5. Operador de fusión nula (??)
      6. Operador de encadenamiento opcional (?.)
      7. Operadores bitwise (&, |, ^, ~, <<, >>, >>>)
      8. Operador ternario (cond ? A : B)
      9. Operadores de propagación (...spread)
      10. Destructuración de arrays y objetos
      11. Precedencia y asociatividad de operadores
      12. Cortocircuito en ||, && y ??
      13. Coerción implícita con == vs comparación estricta ===
      14. delete para eliminar propiedades de objetos
      15. in y instanceof para verificación de pertenencia y tipo
   3. Control de Flujo
      1. if, else if, else
      2. switch y case
      3. for, for...of, for...in
      4. while y do...while
      5. break y continue
      6. Etiquetas de bucle (label:)
      7. Bloques con {} y alcance léxico
      8. Guard clauses y retornos tempranos
      9. throw para interrupción de flujo
      10. Narrowing de tipos dentro de condiciones
      11. Type guards personalizados con predicados (param is Tipo)
      12. Flujo de control basado en in, typeof, instanceof
      13. Exhaustividad en switch con never
      14. Assertions de no-nulo (!)
      15. Patrones de control de flujo funcional (array.filter, array.map)
   4. Funciones
      1. Declaraciones de función (function foo() {})
      2. Funciones flecha (const f = () => {})
      3. Parámetros tipados
      4. Parámetros opcionales (param?: T)
      5. Parámetros con valor por defecto
      6. Parámetros rest (...args: T[])
      7. Tipado de retorno explícito
      8. Funciones que retornan void
      9. Funciones que nunca retornan (never)
      10. Sobrecarga de funciones (signaturas múltiples)
      11. Funciones genéricas (<T>)
      12. Clausuras y entorno léxico
      13. this y binding explícito
      14. call, apply, bind
      15. Funciones async (async function)
   5. Errores y Excepciones
      1. try, catch, finally
      2. Lanzar errores (throw new Error())
      3. Tipado del valor capturado en catch
      4. Errores síncronos vs rechazos de Promesas
      5. Errores personalizados (class MiError extends Error)
      6. Rechazo de Promesas sin catch
      7. Manejo de errores en funciones async/await
      8. Promise.catch y try/catch async
      9. Errores de tipo (TypeError, RangeError, etc.)
      10. Assertions de tipo mal usadas y errores en runtime
      11. Enmascaramiento de errores con any
      12. Estrategias de logging de errores
      13. Errores fatales en Node (process.exit)
      14. Manejo centralizado de errores en aplicaciones web
      15. Errores recuperables vs no recuperables
   6. Entorno Global y Builtins
      1. Objeto global (globalThis)
      2. Objetos estándar (Object, Array, Map, Set)
      3. Math y operaciones numéricas
      4. Date y tiempo en milisegundos
      5. JSON (parse/stringify)
      6. console para salida estándar
      7. Promise como primitiva de async
      8. Symbol como clave única
      9. BigInt para enteros grandes
      10. RegExp para expresiones regulares
      11. Error y subclases integradas
      12. URL y URLSearchParams
      13. Intl e internacionalización
      14. TextEncoder / TextDecoder
      15. AbortController y cancelación
   7. Módulos e Imports
      1. Módulos ES (import, export)
      2. Importaciones por nombre y por defecto
      3. Reexportaciones (export * from)
      4. Import dinámico (import())
      5. Namespaces internos en TypeScript (namespace, legado)
      6. CommonJS (require, module.exports)
      7. Uso de "type": "module" en Node
      8. Resolución de rutas relativas y absolutas
      9. Alias de paths en tsconfig.json (paths, baseUrl)
      10. Barrel files (index.ts)
      11. Separación de tipos y valores en imports (import type)
      12. export type para exponer sólo tipos
      13. Árbol de dependencias y ciclos
      14. Side effects de módulos
      15. División lógica por capas (domain, infra, ui)
   8. Plataforma y Entorno de Ejecución
      1. DOM y APIs del navegador
      2. Node.js y APIs del sistema de archivos
      3. Web Workers y aislamiento de hilos en navegador
      4. Service Workers y ciclo offline
      5. APIs WebCrypto
      6. fetch y red HTTP
      7. Web Storage (localStorage, sessionStorage)
      8. IndexedDB
      9. Streams en navegador
      10. Streams en Node (fs.createReadStream)
      11. Timers (setTimeout, setInterval)
      12. Event Loop (cola de tareas y microtareas)
      13. APIs de proceso en Node (process, os)
      14. Variables de entorno y configuración
      15. Interoperabilidad entre frontend y backend con el mismo lenguaje
3. Estructuras y Manipulación de Datos
   1. Estructuras de Datos Fundamentales
      1. Arrays dinámicos (Array<T>)
      2. Tuplas tipadas en TypeScript
      3. Objetos literales como mapas clave-valor
      4. Map y WeakMap
      5. Set y WeakSet
      6. Pilas (stack) basadas en arrays
      7. Colas (queue) basadas en arrays
      8. Colas dobles (deque) con estructuras circulares
      9. Árboles y tries implementados en objetos/Map
      10. Grafos representados con listas de adyacencia
      11. Tablas hash y colisiones (visión conceptual)
      12. Inmutabilidad estructural con readonly
      13. Clonado superficial vs profundo (structuredClone)
      14. Comparación por referencia vs comparación por valor
      15. Uso de Object.freeze
   2. Iteradores y Generadores
      1. Protocolo iterable ([Symbol.iterator])
      2. Protocolo async iterable ([Symbol.asyncIterator])
      3. for...of para recorrer iterables
      4. Generadores (function*)
      5. Generadores async (async function*)
      6. yield y comunicación bidireccional
      7. Iteradores personalizados en clases
      8. Consumo manual de iteradores (next())
      9. Generadores como reemplazo de estados internos complejos
      10. Streams de datos perezosos
      11. Composición de generadores
      12. Uso de generadores para testing y mocking
      13. Adaptación de callbacks a iterables async
      14. Backpressure conceptual en flujos iterables
      15. Comparación entre for...of y métodos de array
   3. Arrays y Métodos Funcionales
      1. push, pop, shift, unshift
      2. slice y splice
      3. map para transformación
      4. filter para selección
      5. reduce para acumulación
      6. some y every
      7. find y findIndex
      8. flat y flatMap
      9. Ordenamiento con sort
      10. Comparadores personalizados en sort
      11. Copia inmutable con el spread [...arr]
      12. Particionamiento y groupBy (patrones comunes)
      13. Deduplicación usando Set
      14. Zipping y combinaciones de arrays
      15. Arrays tipados (Uint8Array, Float32Array, etc.)
   4. Manipulación de Strings y Texto
      1. Literales de string simples y template strings
      2. Concatenación y +
      3. Substrings y slice
      4. Búsqueda (indexOf, includes, startsWith, endsWith)
      5. Reemplazo (replace, replaceAll)
      6. División (split)
      7. Unión (join) desde arrays
      8. Normalización Unicode (normalize)
      9. Interpolación con template literals
      10. Construcción incremental de strings (buffers de strings)
      11. Codificación y decodificación (TextEncoder, TextDecoder)
      12. Serialización y deserialización JSON (JSON.stringify, JSON.parse)
      13. Escapado seguro para HTML (patrones)
      14. Plantillas etiquetadas (tagged templates)
      15. Internacionalización de texto con Intl.MessageFormat (visión general)
   5. Expresiones Regulares
      1. Literales /patrón/flags
      2. Constructor new RegExp()
      3. Flags comunes (g, i, m, s, u, y)
      4. Grupos de captura
      5. Grupos con nombre ((?<name>...))
      6. Lookahead y lookbehind
      7. Cuantificadores (+, *, {m,n})
      8. Límites de palabra y línea (\b, ^, $)
      9. Métodos test, exec
      10. Métodos de string que aceptan regex (match, matchAll, replace, split)
      11. Rendimiento y backtracking excesivo
      12. Sanitización de entradas dinámicas en regex
      13. Comparación regex vs parseadores dedicados
      14. Construcción dinámica de patrones seguros
      15. Patrones comunes para validación de datos
   6. Archivos, Streams y Datos Binarios
      1. Sistema de archivos en Node (fs.readFile, fs.writeFile)
      2. Streams legibles y escribibles en Node (fs.createReadStream)
      3. Pipes (readable.pipe(writable))
      4. Buffers (Buffer)
      5. Lectura de binarios (Buffer, Uint8Array)
      6. Escritura incremental de logs y datos
      7. Manejo de archivos grandes sin cargar todo a memoria
      8. Blob y File en el navegador
      9. Descarga de archivos en navegador (creación de enlaces dinámicos)
      10. Subida de archivos con FormData
      11. fetch con ReadableStream
      12. Streams web (ReadableStream, WritableStream, TransformStream)
      13. Compresión y descompresión en Node (módulo zlib)
      14. Archivos temporales y directorios temporales
      15. Permisos y rutas en distintos sistemas operativos
   7. Datos Especializados y Formatos
      1. CSV (parseo manual y librerías)
      2. JSON estructurado
      3. YAML y TOML en configuración
      4. XML y DOMParser
      5. HTML como árbol DOM
      6. Markdown como formato de contenido
      7. Binary blobs (imágenes, audio)
      8. ArrayBuffer y DataView
      9. Estructuras binarias con offsets fijos
      10. WebSockets como canal binario o texto
      11. IndexedDB como base de datos del navegador
      12. LocalStorage / SessionStorage como key-value store
      13. Cache Storage en Service Workers
      14. Serialización estructurada (structuredClone)
      15. Mensajería entre hilos (postMessage)
   8. Tiempo y Fechas
      1. Objeto Date
      2. Timestamp en milisegundos desde Epoch
      3. Date.now() y mediciones rápidas
      4. Formateo manual de fechas
      5. Librerías de fechas (luxon, date-fns)
      6. Zonas horarias e Intl.DateTimeFormat
      7. Parseo de cadenas de fecha
      8. Medición de rendimiento con performance.now()
      9. setTimeout y temporizadores
      10. setInterval y loops periódicos
      11. Cancelación de temporizadores (clearTimeout, clearInterval)
      12. Animaciones ligadas a requestAnimationFrame
      13. Sincronización de relojes entre cliente y servidor
      14. Cuestiones de DST y horario de verano
      15. Desfase entre reloj del sistema y reloj del servidor
4. Programación Estructurada y Modular
   1. Programación Orientada a Objetos (POO) en TypeScript/JavaScript
      1. Clases (class)
      2. Constructores (constructor)
      3. Propiedades de instancia
      4. Propiedades estáticas
      5. Métodos de instancia y estáticos
      6. Herencia con extends
      7. super y sobreescritura de métodos
      8. Modificadores de acceso (public, private, protected)
      9. Campos readonly
      10. Campos opcionales en clases
      11. Clases abstractas (abstract class)
      12. Métodos abstractos
      13. Interfaces como contratos de clases
      14. Implementación múltiple de interfaces
      15. Mixins y composición en lugar de herencia múltiple
   2. Decoradores y Metadatos
      1. Decoradores de clase
      2. Decoradores de método
      3. Decoradores de propiedad
      4. Decoradores de parámetro
      5. Metadata Reflection (reflect-metadata)
      6. Patrones de inyección de dependencias con decoradores
      7. Decoradores para validación
      8. Decoradores para logging y trazas
      9. Decoradores para binding automático de this
      10. Decoradores en frameworks (Angular, NestJS)
      11. Estado de estandarización de decoradores TC39
      12. Implicancias en tree-shaking y minificación
      13. Uso de decoradores en tests y mocks
      14. Decoradores y compatibilidad con emitDecoratorMetadata
      15. Consideraciones de rendimiento y orden de evaluación
   3. Módulos, Capas y Arquitectura
      1. Patrones de organización por dominio
      2. Patrones de organización por tipo (controllers, services, utils)
      3. Capas de infraestructura, dominio y aplicación
      4. Capas de UI, lógica y acceso a datos
      5. Módulos ES y carga estática
      6. Carga dinámica con import()
      7. CommonJS en entornos legacy
      8. Barrel modules (index.ts)
      9. Separación entre tipos y valores (import type)
      10. Evitar dependencias circulares
      11. Namespaces internos (histórico en TS)
      12. API pública vs detalles internos
      13. Versionado semántico de módulos internos
      14. Gestión de rutas absolutas con paths en tsconfig.json
      15. Monorepos con múltiples paquetes versionados
   4. Logging y Observabilidad
      1. console.log, console.warn, console.error
      2. Loggers estructurados (pino, winston)
      3. Niveles de log (debug, info, warn, error)
      4. Serialización segura de objetos en logs
      5. Formato JSON para logs machine-readable
      6. Logging en el navegador vs logging en Node
      7. Redacción de datos sensibles en logs
      8. Logs de rendimiento y tiempos de respuesta
      9. Integración con sistemas externos (APM)
      10. Trazas distribuidas (traceId, spanId)
      11. Métricas y contadores personalizados
      12. Alertas basadas en logs
      13. Integración con console.group y console.table
      14. Uso de debug namespaced en Node
      15. Logging condicional según NODE_ENV
   5. Documentación y Comentarios de Tipo
      1. Comentarios JSDoc
      2. Etiquetas @param, @returns, @deprecated
      3. Comentarios de tipo en JavaScript con // @ts-check
      4. Inferencia de tipos a partir de JSDoc
      5. TSDoc y convenciones para librerías públicas
      6. Generación automática de documentación de API
      7. Documentación en línea para funciones públicas
      8. Documentación para consumidores externos vs internos
      9. Comentarios de intención vs comentarios obvios
      10. Contratos de interfaz y documentación de invariantes
      11. Versionado de la documentación junto al código
      12. README técnicos por paquete
      13. Diagramas de arquitectura en monorepos
      14. Uso de /** @internal */ y visibilidad interna
      15. Control de documentación para clientes externos en SDKs
   6. Testing
      1. jest como framework de pruebas
      2. vitest y entornos ESM
      3. mocha + chai
      4. uvu, tape y frameworks minimalistas
      5. Pruebas unitarias
      6. Pruebas de integración
      7. Pruebas de extremo a extremo (E2E)
      8. Pruebas en navegador con Playwright
      9. Pruebas de API con Supertest / fetch mockeado
      10. Snapshots de UI
      11. Cobertura de código (coverage, istanbul, c8)
      12. Mocks y espías (jest.fn)
      13. Fixtures reutilizables
      14. Tests async/await y control de timers falsos
      15. Ejecución de tests en CI/CD
   7. Depuración
      1. Debugger en Chrome DevTools
      2. Debugger en VS Code (launch.json)
      3. node --inspect y el inspector de Node
      4. Breakpoints condicionales
      5. debugger; en el código
      6. Sourcemaps para mapear TypeScript → JavaScript
      7. Inspección de pila de llamadas (stack trace)
      8. Inspección de variables locales en tiempo real
      9. Watch expressions en el debugger
      10. Performance Profiler en navegador
      11. Heap snapshot para memoria
      12. Análisis de fugas de memoria en Node
      13. Depuración de Promesas rechazadas
      14. Seguimiento de eventos async en DevTools
      15. Depuración remota en contenedores y servidores
   8. Patrones de Diseño y Buenas Prácticas
      1. Programación funcional vs POO en JavaScript moderno
      2. Patrón módulo
      3. Patrón fábrica
      4. Patrón singleton
      5. Patrón estrategia
      6. Patrón adaptador
      7. Patrón fachada
      8. Patrón decorador (a nivel de objetos)
      9. Patrón observador (EventEmitter)
      10. Inyección de dependencias
      11. Patrón repositorio en capas de datos
      12. Patrón builder y objetos inmutables
      13. Patrón middleware (pipelines de funciones)
      14. Separación de concerns entre dominio y framework
      15. Diseño orientado a interfaces en TypeScript
5. Estructuras Avanzadas y Programación Funcional
   1. Programación Funcional
      1. Funciones puras
      2. Inmutabilidad de datos
      3. Evitar efectos secundarios
      4. map, filter, reduce como patrones
      5. Composición de funciones
      6. Currificación y partial application
      7. Funciones de orden superior
      8. Aplicaciones point-free
      9. Inmutabilidad estructural con readonly
      10. Patrones de actualización inmutable con spread
      11. Librerías de FP (Ramda)
      12. Monads y Either / Result (patrones funcionales)
      13. Option / Maybe como alternativa a null
      14. Validación funcional de datos
      15. Manejo funcional de errores en Promesas
   2. Iterables Avanzados y Generadores
      1. Iteración lazy para eficiencia
      2. Pipelines de datos con generadores
      3. Transformaciones paso a paso sin arrays intermedios
      4. Generadores async para streams remotos
      5. Consumo incremental de APIs paginadas
      6. Backpressure conceptual en streams async
      7. Coordinación de multitarea con generadores
      8. Implementación de Symbol.iterator
      9. Implementación de Symbol.asyncIterator
      10. Reintentos y recolección gradual de datos
      11. Iteradores infinitos controlados
      12. Conversión entre generadores y arrays
      13. Iteración sobre estructuras personalizadas
      14. for await...of en flujo async
      15. Patrones de pausar y reanudar ejecución
   3. Buffers Binarios y Vistas de Memoria
      1. ArrayBuffer
      2. DataView
      3. Typed arrays (Uint8Array, Float64Array)
      4. Interpretación de datos binarios crudos
      5. Endianness y lectura multibyte
      6. Construcción de protocolos binarios personalizados
      7. Conversión entre Buffer (Node) y typed arrays
      8. Serialización eficiente para red
      9. WebSockets binarios
      10. WebRTC DataChannels binarios
      11. Transferencia de memoria entre hilos (postMessage con transfer)
      12. Uso en criptografía y hashing
      13. Parsing de archivos multimedia
      14. Procesamiento de audio en tiempo real
      15. Integración con WebAssembly (memoria compartida)
   4. Rendimiento y Profiling
      1. Micro-optimizaciones vs optimización algorítmica
      2. Complejidad temporal y espacial en JS/TS
      3. Perfilador de rendimiento del navegador
      4. Perfilador de CPU en Node
      5. Perfilador de heap y memory leaks
      6. performance.now() y medición precisa
      7. console.time y console.timeEnd
      8. Optimización de loops
      9. Evitar trabajo innecesario en renders UI
      10. Evitar bloqueos del Event Loop
      11. Web Workers para tareas pesadas
      12. División de código (code splitting)
      13. Carga diferida (lazy loading)
      14. Caché de resultados (memoización)
      15. Optimización de serialización/deserialización JSON
   5. Calidad de Código y Estándares
      1. ESLint
      2. Reglas de estilo y convenciones del equipo
      3. Prettier como formateador de código
      4. Reglas específicas de TypeScript (@typescript-eslint)
      5. Reglas de seguridad (no eval, no Function dinámica insegura)
      6. Reglas de complejidad ciclomática
      7. Reglas de longitud de archivo y función
      8. Detección de dead code
      9. Análisis estático del flujo de null/undefined
      10. Revisiones de código (pull requests)
      11. Hooks de pre-commit (lint-staged, husky)
      12. Convenciones de nombres (camelCase, PascalCase, UPPER_CASE)
      13. Convenciones de carpetas (utils, services, components)
      14. Convenciones para manejo de errores
      15. Documentación de decisiones arquitectónicas
   6. Seguridad y Criptografía
      1. Modelos de amenaza en aplicaciones web
      2. XSS (Cross-Site Scripting)
      3. CSRF (Cross-Site Request Forgery)
      4. Inyección de código en templates
      5. Validación y sanitización de input
      6. DOMPurify y sanitización HTML
      7. CORS y restricciones de origen
      8. Content Security Policy (CSP)
      9. Gestión de tokens y cookies seguras
      10. Almacenamiento seguro en localStorage vs cookies
      11. crypto.subtle y WebCrypto API
      12. Hashing y firma digital en el navegador
      13. Seguridad en Node (fugas de secretos en logs)
      14. Dependencias vulnerables y npm audit
      15. Gestión de secretos en variables de entorno
   7. Tipado Avanzado en TypeScript
      1. Tipos genéricos (<T>)
      2. Restricciones de genéricos (<T extends U>)
      3. Tipos condicionales (T extends U ? X : Y)
      4. Tipos inferidos en condicionales (infer)
      5. Tipos mapeados ({[K in Keys]: ...})
      6. keyof y manipulación de llaves
      7. Index signatures ([key: string]: T)
      8. readonly en tipos
      9. Remapeo de modificadores (-readonly, ?)
      10. Utility types estándar (Partial, Required, Pick, Omit)
      11. Record<K,V> y diccionarios tipados
      12. ReturnType, Parameters, ConstructorParameters
      13. ThisType y tipado contextual de this
      14. Inferencia contextual en funciones flecha
      15. Branding y nominal typing (patrón type ID = string & {__brand: "ID"})
   8. Validación de Datos y Esquemas
      1. Validación en runtime vs chequeo estático
      2. Zod y esquemas tipados
      3. io-ts y decodificación segura
      4. Validación de requests HTTP
      5. Validación de respuestas de APIs externas
      6. Aserciones de tipo (asserts value is Tipo)
      7. Narrowing manual con validadores
      8. Serialización segura para persistencia
      9. Sanitización de datos antes de guardarlos
      10. Transformaciones de entrada (DTOs)
      11. Contratos entre capas frontend y backend
      12. Tipos compartidos entre cliente y servidor
      13. Versionado de esquemas de datos
      14. Compatibilidad hacia atrás en APIs
      15. Migraciones de estructura de datos en el tiempo
6. Concurrencia, Async y Bajo Nivel
   1. Async y Concurrencia en JavaScript
      1. Modelo single-threaded y Event Loop
      2. Promise como unidad básica de async
      3. async / await
      4. Estados de una Promesa (pending, fulfilled, rejected)
      5. Cadena de Promesas con .then
      6. Manejo de errores con .catch
      7. Ejecución paralela con Promise.all
      8. Ejecución competitiva con Promise.race
      9. Ejecución tolerante a fallas con Promise.allSettled
      10. Control de concurrencia con colas y semáforos userland
      11. Espera activa vs espera pasiva
      12. Bloqueos del Event Loop y CPU-bound
      13. Uso de Web Workers para CPU-bound en navegador
      14. Uso de worker_threads en Node
      15. Cancelación cooperativa con AbortController
   2. Networking y Comunicación
      1. fetch y solicitudes HTTP
      2. XMLHttpRequest (legado)
      3. WebSockets
      4. Server-Sent Events (SSE)
      5. gRPC-Web (patrones)
      6. Protocolos binarios sobre TCP en Node (net)
      7. HTTPS en Node (https)
      8. HTTP/2 y multiplexación
      9. Tiempo de espera y reintentos
      10. Política de mismo origen en navegador
      11. CORS y credenciales
      12. Serialización y deserialización JSON
      13. Streaming de respuesta con ReadableStream
      14. Subida de archivos en trozos (chunked upload)
      15. APIs en tiempo real y suscripción de eventos
   3. Multithreading, Workers y Paralelismo
      1. Web Workers en navegador
      2. Dedicated Workers vs Shared Workers
      3. Transferencia de buffers entre hilos
      4. SharedArrayBuffer
      5. Atomics y sincronización de memoria compartida
      6. worker_threads en Node
      7. Clustering de procesos en Node (cluster)
      8. Balanceo de carga en múltiples workers
      9. Comunicación entre workers con postMessage
      10. Aislamiento de estado y side effects
      11. Pools de workers
      12. Limitaciones de acceso al DOM en Web Workers
      13. Aceleración de tareas pesadas (compresión, hashing)
      14. Streams entre threads
      15. Diseño de pipelines paralelos
   4. Metaprogramación y Reflexión
      1. Proxy para interceptar acceso a objetos
      2. Reflect para operaciones de bajo nivel
      3. Definición de propiedades con Object.defineProperty
      4. Descriptores de propiedad (get, set, enumerable, configurable)
      5. Object.getPrototypeOf y Object.setPrototypeOf
      6. Object.freeze y Object.seal
      7. Patrón de interceptores y validación dinámica
      8. Generación dinámica de clases y funciones
      9. Evaluación dinámica de código (riesgos de eval)
      10. Serialización y reconstrucción dinámica de objetos
      11. Decoradores (propuesta TC39) como metaprogramación declarativa
      12. Metadatos de tipos en runtime (emulación con reflect-metadata)
      13. Inspección de stack trace y Error.captureStackTrace
      14. Patrones AOP (aspect-oriented programming) con Proxies
      15. Instrumentación dinámica para profiling
   5. Gestión de Recursos y Ciclo de Vida
      1. try/finally para liberar recursos
      2. Cancelación con AbortController
      3. Control manual de conexiones abiertas
      4. Streams y close/destroy
      5. Suscripciones a eventos y removeEventListener
      6. Limpieza de setInterval y setTimeout
      7. Manejadores de cierre de proceso en Node (process.on("exit"))
      8. Gestión de sockets abiertos
      9. Liberación de handles en tests
      10. Patrones de “destructor” manual en JS
      11. Patrones using y Symbol.dispose (propuesta)
      12. Control explícito de sesiones y tokens
      13. Recursos del DOM (observadores, listeners)
      14. Evitar fugas de listeners en SPAs
      15. Limpieza de workers inactivos
   6. Monitoreo, Métricas y Telemetría
      1. console.time y console.count
      2. Performance API en navegador
      3. Node perf_hooks para medición
      4. Recolección de métricas de latencia
      5. Recolección de métricas de throughput
      6. Métricas de uso de memoria
      7. Métricas de GC y pausas
      8. Logs estructurados con IDs de correlación
      9. Trazas distribuidas con headers de tracing
      10. Exportación de métricas a sistemas externos
      11. Alertas automáticas en producción
      12. Health checks y endpoints /health
      13. Rate limiting y mecanismos antiabuso
      14. Auditoría de acciones del usuario
      15. Observabilidad en entornos serverless / edge
   7. Recolección de Basura y Memoria
      1. Modelo de memoria administrada en JS
      2. Recolección de basura generacional
      3. Referencias fuertes vs débiles
      4. WeakMap y WeakSet
      5. WeakRef y FinalizationRegistry
      6. Fugas de memoria por referencias colgantes
      7. Fugas de memoria en closures
      8. Fugas de memoria en listeners no removidos
      9. Fragmentación de heap
      10. Trazas de heap en DevTools
      11. Monitoreo de uso de memoria en Node
      12. Límites de memoria en entornos serverless
      13. Impacto de objetos gigantes y arrays densos
      14. Uso de estructuras inmutables para evitar duplicados grandes
      15. Pausas de GC y rendimiento en tiempo real
   8. Interoperabilidad con Bajo Nivel y WebAssembly
      1. WebAssembly en el navegador
      2. Cargar módulos WebAssembly desde JavaScript
      3. Tipos numéricos de bajo nivel en WebAssembly
      4. Compartir memoria entre WebAssembly y JS
      5. Llamar funciones WebAssembly desde JS
      6. Llamar funciones JS desde WebAssembly
      7. Uso de WebAssembly para cómputo intensivo
      8. Integración con librerías compiladas (C/C++/Rust)
      9. WebAssembly en Node
      10. Conversión de buffers binarios para FFI
      11. Overhead de cruce de frontera JS ↔ WASM
      12. Control de tiempo real y latencia baja
      13. Seguridad y sandboxing de WebAssembly
      14. Reutilización de lógica en cliente y servidor vía WASM
      15. Limitaciones de WebAssembly frente a JS puro
7. Implementación y Distribución
   1. Herramientas de Entorno y Configuración
      1. tsconfig.json y opciones del compilador
      2. target y nivel de ECMAScript emitido
      3. module y formato de salida (ESNext, CommonJS)
      4. moduleResolution y resolución de paths
      5. strict y modo estricto
      6. noImplicitAny
      7. strictNullChecks
      8. esModuleInterop y compatibilidad con CommonJS
      9. skipLibCheck y rendimiento de compilación
      10. declaration y generación de .d.ts
      11. sourceMap para depuración
      12. outDir y rootDir
      13. Configuración por proyecto y references
      14. Proyectos incrementales (composite)
      15. paths y alias internos de importación
   2. Motores e Implementaciones de JavaScript
      1. V8 (Chrome, Node)
      2. SpiderMonkey (Firefox)
      3. JavaScriptCore (Safari)
      4. Chakra (histórico)
      5. Node.js como runtime en servidor
      6. Deno como runtime seguro y TS-first
      7. Bun como runtime y bundler integrado
      8. Cloudflare Workers / runtimes edge
      9. Service Workers y ejecución offline en navegador
      10. Motores en entornos embebidos (Electron)
      11. JS en entornos móviles híbridos
      12. Diferencias de API entre runtimes
      13. globalThis como abstracción común
      14. Límite de memoria y CPU en entornos edge/serverless
      15. Compatibilidad con módulos ES nativos
   3. Empaquetado, Build y Publicación
      1. webpack y empaquetado tradicional
      2. rollup para librerías
      3. esbuild y builds ultrarrápidos
      4. vite y desarrollo con HMR
      5. Transpilación con tsc
      6. Transpilación con Babel
      7. Tree-shaking y eliminación de código muerto
      8. Code splitting dinámico
      9. Generación de bundles múltiples (cjs, esm, iife)
      10. Minificación y ofuscación
      11. Generación de tipos .d.ts para consumidores TS
      12. Publicación en npm (npm publish)
      13. Versionado semántico (major.minor.patch)
      14. Changelogs y releases automatizados
      15. Publicación de paquetes privados internos
   4. Aplicaciones de Línea de Comando (CLI)
      1. Scripts ejecutables con Node (#!/usr/bin/env node)
      2. Commander.js para parseo de argumentos
      3. yargs para CLI declarativas
      4. process.argv y parseo manual
      5. Colores y formato en consola (chalk)
      6. Spinners y progreso visual en CLI
      7. Entrada interactiva (inquirer)
      8. Salida estructurada en JSON
      9. Logs y niveles verbosos (-v, --debug)
      10. Errores amigables en CLI
      11. Empaquetado de CLI en un solo archivo
      12. Distribución como paquete npm global
      13. Versionado y flags --version
      14. Comandos compuestos y subcomandos
      15. Autocompletado de shell (bash/zsh/fish)
   5. Aplicaciones Web y UI
      1. DOM y manipulación directa
      2. React y componentes funcionales
      3. JSX y TSX
      4. Hooks y estado local
      5. Estado global (Redux, Zustand)
      6. Context API
      7. Next.js y renderizado del lado del servidor (SSR)
      8. Vue con composición y tipado
      9. Svelte y bindings reactivos
      10. Web Components y customElements.define
      11. Shadow DOM y encapsulación de estilos
      12. CSS Modules / CSS-in-JS
      13. Accesibilidad (a11y)
      14. Persistencia de estado en localStorage
      15. Comunicación con APIs desde la UI
   6. Aplicaciones Móviles, Escritorio y Juegos
      1. React Native
      2. Expo y flujo móvil con TypeScript
      3. Capacitor / Ionic para apps híbridas
      4. Electron para escritorio
      5. Tauri y runtimes ligeros
      6. PWAs (Progressive Web Apps)
      7. Service Workers y caché offline
      8. Notificaciones push
      9. Acceso a hardware (sensores, cámara, micrófono)
      10. APIs de archivos locales en escritorio
      11. Motores gráficos 2D/3D (Pixi.js, Three.js)
      12. Animaciones con requestAnimationFrame
      13. Optimización de render en canvas/WebGL
      14. Sincronización de estado en tiempo real multijugador
      15. Distribución en tiendas (App Store / Play Store) vía wrappers
   7. Internacionalización (i18n) y Localización (l10n)
      1. API Intl
      2. Formato de números y monedas
      3. Formato de fechas y horarios
      4. Pluralización de mensajes
      5. Detección de locale del usuario
      6. Carga dinámica de mensajes traducidos
      7. Separación de traducciones por módulo
      8. Herramientas como i18next
      9. ICU MessageFormat
      10. Manejo de RTL (right-to-left)
      11. Zoned time y horario local
      12. Sensibilidad cultural en contenido
      13. Selección dinámica de fuentes y tipografías
      14. Traducción en build vs runtime
      15. Estrategias de fallback de idioma
   8. DevOps, Entrega y Despliegue
      1. Scripts de build en package.json
      2. Pipelines CI/CD
      3. Pruebas automáticas en cada commit
      4. Lint y type-check en CI
      5. Empaquetado para producción
      6. Despliegue en servidores Node tradicionales
      7. Despliegue serverless (AWS Lambda, Vercel Functions)
      8. Despliegue edge (Cloudflare Workers)
      9. Contenedores Docker para Node
      10. Health checks y monitoreo post-deploy
      11. Rollbacks y despliegues azules/verdes
      12. Feature flags y rollout gradual
      13. Versionado de APIs públicas
      14. Documentación de endpoints y contratos
      15. Observabilidad continua en producción
8. Internos
   1. Compilador de TypeScript y Proceso de Transpilación
      1. Análisis léxico y parser
      2. Creación del AST (árbol de sintaxis abstracta)
      3. Chequeo de tipos estático
      4. Inferencia de tipos
      5. Ampliación y reducción de uniones
      6. Emisión (emit) de JavaScript
      7. Generación de d.ts para tipos públicos
      8. Sourcemaps para depuración
      9. Proyectos incrementales y tsbuildinfo
      10. Referencias a proyectos (project references)
      11. Diferencias entre tsc y Babel para TS
      12. Limitaciones del chequeo de tipos en tiempo de compilación
      13. Eliminación de tipos y anotaciones en el JS emitido
      14. Transformaciones personalizadas del compilador
      15. Integración del Language Service en el editor
   2. Modelo de Ejecución de JavaScript
      1. Call stack
      2. Contextos de ejecución
      3. Ámbito léxico y closures
      4. Hoisting de variables y funciones
      5. Resolución de this
      6. Strict mode ("use strict")
      7. Event Loop y cola de tareas
      8. Microtareas (Promise.then)
      9. Macrotareas (setTimeout, I/O)
      10. Repaint / reflow del navegador
      11. Prioridades de tareas en el navegador
      12. Bloqueo del main thread
      13. Interacción entre JS y render de la UI
      14. Rechazos no manejados de Promesas
      15. Módulos ES y carga dinámica en runtime
   3. Modelo de Datos y Prototipos
      1. Objetos y prototipos
      2. [[Prototype]] y __proto__
      3. Cadena de prototipos
      4. Herencia basada en prototipos
      5. Clases como azúcar sintáctico sobre prototipos
      6. Descriptores de propiedad
      7. Enumerabilidad e iteración de llaves
      8. Object.keys, Object.values, Object.entries
      9. Object.assign y mezcla de objetos
      10. Sellado y congelamiento de objetos
      11. Inmutabilidad superficial vs profunda
      12. Comparación de objetos por referencia
      13. Serialización con JSON.stringify
      14. Limitaciones de JSON.stringify (funciones, undefined, Symbol)
      15. Clonación estructurada (structuredClone)
   4. Optimizaciones del Motor JavaScript
      1. JIT (Just-In-Time compilation)
      2. Inline caching
      3. Hidden classes
      4. Escape analysis
      5. Optimización de funciones calientes
      6. Deoptimización cuando cambian los tipos
      7. Representación interna de números (double, SMI)
      8. Recolección generacional de basura
      9. Inlining de funciones
      10. Eliminación de bounds checks en arrays
      11. Optimización de bucles apretados
      12. Penalización por megamorphic call sites
      13. Estructuras densas vs dispersas en arrays
      14. Impacto de delete en arrays
      15. Costo de capturar closures con muchas variables
   5. Interoperabilidad Nativa y FFI
      1. Addons nativos en Node (N-API)
      2. Interfaz C/C++ para módulos de alto rendimiento
      3. Compilación de addons para múltiples plataformas
      4. Gestión de memoria manual en addons
      5. Paso de buffers binarios entre JS y C++
      6. Seguridad y aislamiento al ejecutar código nativo
      7. Puentes con Rust (Neon, napi-rs)
      8. Puentes con Go (gobridge)
      9. Llamadas a librerías del sistema desde Node
      10. Consideraciones de portabilidad en binarios precompilados
      11. Versionado de ABI y compatibilidad
      12. Costos de cruce entre JS y nativo
      13. Exponer bindings tipados a TypeScript
      14. Depuración de código nativo integrado
      15. Distribución de módulos con binarios preconstruidos
   6. WebAssembly y Runtimes Aislados
      1. Compilación de código C/C++/Rust a WebAssembly
      2. Carga de módulos WASM en navegador
      3. Carga de módulos WASM en Node
      4. Memoria lineal compartida con WASM
      5. Paso de strings y arrays entre JS y WASM
      6. Ejecución de lógica crítica en WASM
      7. Aceleración de cómputo matemático
      8. WASM y sandboxing de seguridad
      9. Límites de llamadas frecuentes JS↔WASM
      10. Uso de WASI (interfaz de sistema para WASM)
      11. Ejecución en entornos serverless edge
      12. Reutilización de librerías nativas vía WASM
      13. Perfilado de rendimiento en WASM
      14. Integración con Web Workers para aislamiento
      15. Futuro de WASM en aplicaciones web complejas
   7. Estándares, Propuestas y Futuro del Lenguaje
      1. Proceso de propuesta TC39 (stages 0–4)
      2. Nuevas sintaxis del lenguaje
      3. Nuevas APIs estándar del runtime
      4. Decoradores estandarizados
      5. Records y Tuples inmutables (propuestas)
      6. Patrones de coincidencia estructural (pattern matching)
      7. Tipos sellados y exhaustividad
      8. Registros inmutables para datos seguros
      9. Tipos para excepciones y unknown seguro
      10. Campos privados # en clases
      11. Módulos nativos en el navegador sin bundler
      12. Evolución de import dinámico y lazy
      13. Nuevos primitivos de sincronización
      14. APIs criptográficas más ricas en WebCrypto
      15. Estandarización de APIs de streaming y backpressure
   8. Límites y Buenas Prácticas de Arquitectura
      1. Separación entre lógica de dominio y capas de infraestructura
      2. Evitar acoplamiento a frameworks
      3. Diseñar para testabilidad
      4. Manejo centralizado de configuración
      5. Manejo centralizado de errores
      6. Límite claro entre cliente y servidor
      7. Reutilización de tipos entre frontend y backend
      8. Versionado de contratos de API
      9. Estrategias de backward compatibility
      10. Limpieza de código muerto y flags experimentales
      11. Migraciones de datos controladas
      12. Monitoreo desde el inicio del proyecto
      13. Hardening de seguridad como requisito base
      14. Automatización de calidad en CI/CD
      15. Cultura de documentación viva y mantenible