🌐 Inicio · 📚 Clases · 🧬 Atlas · 🧭 Rutas · 📝 Autoevaluación · 🔎 Buscar

📚 Índice completo de clases

⬅️ Volver al programa · 🗺️ Roadmap · 🌐 Atlas · 📅 Syllabus

Programa secuencial de 176 clases en 12 partes. La numeración es global (001→…) y el orden importa: cada clase asume la anterior.

Estado: 176 de 176 clases construidas · núcleo de 10 lenguajes. Programa completo ✅.

Este índice es el mapa: cada parte con su gancho y sus bloques temáticos. La explicación de qué se aprende en cada clase está en el README de cada parte, que es donde conviene entrar antes de abrir la primera clase.

🗂️ Las 12 partes de un vistazo

#	Parte	Clases	Rango	Tipo	Horas
0	Pensamiento computacional y el método políglota	14	001–014	método	~21 h
1	Atlas y genealogía de los lenguajes	14	015–028	método	~21 h
2	Herramientas, toolchains y anatomía de comandos	12	029–040	método	~18 h
3	Valores, tipos y variables	16	041–056	código	~40 h
4	Control del programa	16	057–072	código	~40 h
5	Funciones y modularidad	16	073–088	código	~40 h
6	Datos y estructuras	18	089–106	código	~45 h
7	Paradigmas	16	107–122	código	~40 h
8	Cómo funcionan los lenguajes	16	123–138	código	~40 h
9	Ingeniería de software políglota	16	139–154	código	~40 h
10	Interoperabilidad y fronteras entre lenguajes	10	155–164	código	~25 h
11	Proyecto integrador políglota	12	165–176	proyecto	~36 h

Parte 0 — Pensamiento computacional y el método políglota · clases 001–014

🧭 Aprender a pensar el problema antes de elegir con qué escribirlo.

📂 Abrir el README de la parte — de qué trata, qué necesitas traer, qué sabrás hacer al terminar y qué se aprende en cada clase.

La tesis y la brújula · 001–002

#	Clase
✅ 001	Qué es programar y por qué comparar lenguajes: la tesis políglota
✅ 002	Las tres clases de diferencia: sintáctica, semántica y paradigmática

Modelar el problema · 003–006

#	Clase
✅ 003	Problema, contexto, entradas, proceso y salidas
✅ 004	Descomposición y reconocimiento de patrones
✅ 005	Abstracción, restricciones y casos límite
✅ 006	Algoritmos: corrección y terminación

Del papel al algoritmo · 007–010

#	Clase
✅ 007	Pseudocódigo neutral: escribir sin lenguaje
✅ 008	Trazado manual y ejecución simbólica
✅ 009	Complejidad y eficiencia: intuición de coste
✅ 010	Legibilidad, estilo e idiomática

El método del curso en la práctica · 011–014

#	Clase
✅ 011	Anatomía de una ficha de transferencia y cómo estudiarla
✅ 012	casos.json y el verificador de equivalencia
✅ 013	El concepto en la familia: leer un lenguaje que no conoces
✅ 014	Cómo elegir lenguaje para un problema

Parte 1 — Atlas y genealogía de los lenguajes · clases 015–028

🧭 El árbol genealógico completo: por qué diez lenguajes bastan para leer decenas.

📂 Abrir el README de la parte — de qué trata, qué necesitas traer, qué sabrás hacer al terminar y qué se aprende en cada clase.

Cómo se lee el árbol · 015–016

#	Clase
✅ 015	El árbol genealógico de los lenguajes: mapa general
✅ 016	Cómo nace y evoluciona un lenguaje: estándares, versiones y ecosistemas

Las familias con representante en el núcleo · 017–021

#	Clase
✅ 017	Familia C y de las llaves: C, C++, Objective-C
✅ 018	Familia scripting dinámico: Python, Ruby, Perl, PHP, Lua
✅ 019	Familia JVM: Java, Kotlin, Scala, Groovy, Clojure
✅ 020	Familia .NET: C#, F#, VB.NET
✅ 021	Familia JavaScript y web: JS, TypeScript, Dart

Las familias que aportan ideas · 022–025

#	Clase
✅ 022	Familia funcional tipada (ML): Haskell, OCaml, F# y la influencia en Rust
✅ 023	Familia Lisp: Scheme, Racket, Clojure, Emacs Lisp
✅ 024	Familia lógica y declarativa: SQL, Prolog, Datalog
✅ 025	Familia concurrente/actor: Erlang, Elixir y el CSP de Go

Sistemas, cálculo y legado · 026–028

#	Clase
✅ 026	Familia de sistemas: C, C++, Rust, Zig
✅ 027	Familia array y científica: APL, R, Julia, Fortran, MATLAB
✅ 028	Lenguajes históricos y de nicho: COBOL, Fortran, Pascal, BASIC, Bash

Parte 2 — Herramientas, toolchains y anatomía de comandos · clases 029–040

🧭 Del archivo de texto al proceso que corre: el toolchain de cada lenguaje.

📂 Abrir el README de la parte — de qué trata, qué necesitas traer, qué sabrás hacer al terminar y qué se aprende en cada clase.

Qué hay entre tu texto y un proceso · 029–031

#	Clase
✅ 029	Qué es un toolchain: del código fuente al programa que corre
✅ 030	Compilado vs. interpretado vs. transpilado vs. bytecode/VM
✅ 031	Anatomía de un comando: nombre, subcomando, flags, argumentos y esquema

Instalar y ejecutar · 032–033

#	Clase
✅ 032	Instalación y gestión de versiones (pyenv, nvm, rustup, SDKMAN, phpenv)
✅ 033	Ejecutar: python, node, tsx, java, dotnet, go run, rustc, cc, php, sqlite3

Construir, depender y explorar · 034–036

#	Clase
✅ 034	Compilar y construir: gcc/clang, cargo, go build, javac, dotnet build
✅ 035	Paquetes y dependencias: pip, pnpm, cargo, maven/gradle, nuget, go mod, composer
✅ 036	REPL e intérpretes interactivos por lenguaje

Calidad, empaquetado y entorno · 037–040

#	Clase
✅ 037	Formateadores y linters: black, prettier, gofmt, rustfmt, clang-format, php-cs-fixer
✅ 038	Pruebas desde la terminal: pytest, node --test, go test, cargo test, dotnet test, phpunit
✅ 039	Empaquetado y distribución: wheels, jars, binarios, contenedores
✅ 040	Variables de entorno, rutas y el PATH en Windows y Unix

Parte 3 — Valores, tipos y variables · clases 041–056

🧭 La materia prima de todo programa: cómo cada lenguaje nombra, tipa, convierte y muta un valor.

📂 Abrir el README de la parte — de qué trata, qué necesitas traer, qué sabrás hacer al terminar y qué se aprende en cada clase.

Nombres y valores · 041–042

#	Clase
✅ 041	Literales, valores, variables y constantes
✅ 042	Declaración, asignación e inicialización

Los tipos primitivos, uno por uno · 043–048

#	Clase
✅ 043	Tipos primitivos: enteros, reales, booleanos, caracteres
✅ 044	Enteros: tamaño, signo, desbordamiento y bases
✅ 045	Números reales: punto flotante, precisión y decimales
✅ 046	Booleanos y valores de verdad
✅ 047	Caracteres, texto y Unicode
✅ 048	Cadenas: representación, inmutabilidad e interpolación

Los dos ejes del sistema de tipos · 049–052

#	Clase
✅ 049	Conversión de tipos: casting explícito vs. coerción implícita
✅ 050	Tipado estático vs. dinámico
✅ 051	Tipado fuerte vs. débil
✅ 052	Inferencia de tipos

Ausencia, mutación y expresión · 053–056

#	Clase
✅ 053	Nulabilidad: null, nil, None, Option y valores ausentes
✅ 054	Mutabilidad e inmutabilidad
✅ 055	Operadores y expresiones: aritméticos, lógicos, de comparación y bit a bit
✅ 056	Entrada y salida básica: leer y escribir

Parte 4 — Control del programa · clases 057–072

🧭 Decidir, repetir y fallar: el flujo del programa y sus formas en diez lenguajes.

📂 Abrir el README de la parte — de qué trata, qué necesitas traer, qué sabrás hacer al terminar y qué se aprende en cada clase.

Decidir · 057–062

#	Clase
✅ 057	Booleanos, condiciones y cortocircuito
✅ 058	Guardas y validación temprana
✅ 059	if / else y anidamiento
✅ 060	Expresiones condicionales: ternario e if como expresión
✅ 061	switch, case y fallthrough
✅ 062	Coincidencia de patrones: match / when

Repetir · 063–067

#	Clase
✅ 063	Iteración por condición: while y do-while
✅ 064	Iteración por rango: for clásico y for-range
✅ 065	Iteración por colección: for-each e iteradores
✅ 066	Iteradores y generadores perezosos (lazy)
✅ 067	Comprensiones de listas y colecciones

Repetir sin bucles · 068–069

#	Clase
✅ 068	Funciones de orden superior: map, filter, reduce
✅ 069	Recursión y recursión de cola

Salir del flujo y fallar bien · 070–072

#	Clase
✅ 070	Control de flujo: break, continue, return, goto
✅ 071	Manejo de errores I: excepciones (try/catch/finally)
✅ 072	Manejo de errores II: resultados y valores (Result/Either/error de Go)

Parte 5 — Funciones y modularidad · clases 073–088

🧭 La función como contrato: firma, paso de parámetros, cierres y fronteras de módulo.

📂 Abrir el README de la parte — de qué trata, qué necesitas traer, qué sabrás hacer al terminar y qué se aprende en cada clase.

La firma como contrato · 073–078

#	Clase
✅ 073	Firma, parámetros, argumentos y retorno
✅ 074	Parámetros por defecto y opcionales
✅ 075	Argumentos nombrados y de palabra clave
✅ 076	Parámetros variádicos
✅ 077	Múltiples retornos y desestructuración
✅ 078	Genéricos y polimorfismo paramétrico

Qué recibe realmente la función · 079–081

#	Clase
✅ 079	Paso por valor
✅ 080	Paso por referencia
✅ 081	Semántica de movimiento y préstamo (Rust)

Dónde viven los nombres · 082–085

#	Clase
✅ 082	Alcance (scope) y sombreado (shadowing)
✅ 083	Cierres (closures) y captura de variables
✅ 084	Funciones puras y efectos secundarios
✅ 085	Funciones de primera clase y como valores

De la función al proyecto · 086–088

#	Clase
✅ 086	Módulos, paquetes y espacios de nombres
✅ 087	Visibilidad, encapsulación y contratos (public/private)
✅ 088	Importar, exportar y organizar un proyecto

Parte 6 — Datos y estructuras · clases 089–106

🧭 Dónde se guardan los datos, qué cuesta cada operación y qué significa realmente copiar.

📂 Abrir el README de la parte — de qué trata, qué necesitas traer, qué sabrás hacer al terminar y qué se aprende en cada clase.

Secuencias · 089–093

#	Clase
✅ 089	Arreglos de tamaño fijo
✅ 090	Listas, vectores y arreglos dinámicos
✅ 091	Tuplas y registros posicionales
✅ 092	Rangos y secuencias
✅ 093	Cadenas como estructura de datos

Colecciones por clave y por disciplina · 094–096

#	Clase
✅ 094	Conjuntos (sets) y unicidad
✅ 095	Mapas / diccionarios / tablas hash
✅ 096	Pilas y colas

Estructuras enlazadas · 097–098

#	Clase
✅ 097	Árboles
✅ 098	Grafos

Modelar un dato propio · 099–100

#	Clase
✅ 099	Registros, structs y clases
✅ 100	Enumeraciones y tipos algebraicos (ADT / sum types)

Qué significa copiar · 101–103

#	Clase
✅ 101	Igualdad vs. identidad
✅ 102	Copia superficial vs. profunda; referencia vs. valor
✅ 103	Propiedad y ciclo de vida de los datos

Sacar los datos del proceso · 104–106

#	Clase
✅ 104	Archivos: leer y escribir texto y binario
✅ 105	JSON: serialización y deserialización
✅ 106	Otros formatos y persistencia: CSV, YAML, binarios, bases de datos

Parte 7 — Paradigmas · clases 107–122

🧭 Los ocho estilos de resolver: qué considera cada paradigma una pieza legítima de solución.

📂 Abrir el README de la parte — de qué trata, qué necesitas traer, qué sabrás hacer al terminar y qué se aprende en cada clase.

Qué es un paradigma · 107

#	Clase
✅ 107	Qué es un paradigma y por qué importa

Imperativo y sus herederos · 108–109

#	Clase
✅ 108	Imperativo y estructurado
✅ 109	Procedimental y modular

Orientación a objetos · 110–113

#	Clase
✅ 110	Orientado a objetos: clases, objetos y estado
✅ 111	Herencia, composición y polimorfismo
✅ 112	Interfaces, traits y clases abstractas
✅ 113	OO basado en prototipos (JavaScript)

Funcional · 114–116

#	Clase
✅ 114	Funcional I: inmutabilidad y funciones puras
✅ 115	Funcional II: composición, currying y aplicación parcial
✅ 116	Funcional III: functores, mónadas y efectos (visión práctica)

Declarativo y lógico · 117–118

#	Clase
✅ 117	Declarativo: consultas y transformación (SQL)
✅ 118	Lógico: reglas, hechos y unificación (Prolog)

Eventos, flujos y concurrencia · 119–122

#	Clase
✅ 119	Orientado a eventos y callbacks
✅ 120	Reactivo y flujos de datos (streams)
✅ 121	Concurrente: hilos, tareas y canales
✅ 122	Asíncrono: async/await y promesas

Parte 8 — Cómo funcionan los lenguajes · clases 123–138

🧭 Lo que ocurre bajo el código: compilación, memoria, concurrencia y por qué falla lo que falla.

📂 Abrir el README de la parte — de qué trata, qué necesitas traer, qué sabrás hacer al terminar y qué se aprende en cada clase.

Del texto a la acción · 123–126

#	Clase
✅ 123	Del código a la ejecución: fases de compilación
✅ 124	Compilador, intérprete y JIT
✅ 125	Bytecode y máquinas virtuales (JVM, CLR, V8)
✅ 126	AOT vs. JIT: costos y beneficios

Dónde viven los datos · 127–129

#	Clase
✅ 127	La pila (stack) y el marco de llamada
✅ 128	El heap y la asignación dinámica
✅ 129	Referencias, apuntadores y direcciones

Las tres respuestas a «quién libera» · 130–132

#	Clase
✅ 130	Gestión manual de memoria (C): malloc/free
✅ 131	Recolección de basura (GC)
✅ 132	RAII, propiedad y préstamos (Rust/C++)

Hacer varias cosas a la vez · 133–136

#	Clase
✅ 133	Concurrencia: procesos, hilos y memoria compartida
✅ 134	Tareas, corrutinas y canales
✅ 135	Actores y paso de mensajes (modelo BEAM)
✅ 136	El modelo de memoria y las condiciones de carrera

Cuando algo falla · 137–138

#	Clase
✅ 137	Errores: de sintaxis, de tipos, de enlace y de ejecución
✅ 138	Depuración: cómo se diagnostica en cada runtime

Parte 9 — Ingeniería de software políglota · clases 139–154

🧭 Que funcione, que se construya igual siempre, que llegue a producción y que se pueda cambiar.

📂 Abrir el README de la parte — de qué trata, qué necesitas traer, qué sabrás hacer al terminar y qué se aprende en cada clase.

Comprobar que funciona · 139–142

#	Clase
✅ 139	Pruebas unitarias por lenguaje
✅ 140	Pruebas de integración y el verificador de equivalencia
✅ 141	Depuradores: gdb, lldb, pdb y los de IDE
✅ 142	Registro (logging) y observabilidad

Que se construya igual siempre · 143–145

#	Clase
✅ 143	Dependencias, versiones y lockfiles
✅ 144	Compilación reproducible y empaquetado
✅ 145	Git y control de versiones para proyectos políglotas

Que llegue a producción · 146–148

#	Clase
✅ 146	Revisión de código y estándares
✅ 147	Integración continua (CI) multi-lenguaje
✅ 148	Entrega y despliegue

Que se pueda cambiar · 149–151

#	Clase
✅ 149	Diseño y arquitectura comparada
✅ 150	Refactorización segura
✅ 151	Patrones de diseño comparados entre lenguajes

Que aguante · 152–154

#	Clase
✅ 152	Rendimiento y perfilado (profiling)
✅ 153	Seguridad: entradas, memoria y dependencias
✅ 154	Mantenibilidad, documentación y deuda técnica

Parte 10 — Interoperabilidad y fronteras entre lenguajes · clases 155–164

🧭 Las fronteras entre lenguajes: FFI, ABI, serialización, contratos, Wasm e incrustación.

📂 Abrir el README de la parte — de qué trata, qué necesitas traer, qué sabrás hacer al terminar y qué se aprende en cada clase.

La frontera íntima: mismo proceso · 155–158

#	Clase
✅ 155	Por qué los sistemas reales son políglotas
✅ 156	La FFI (Foreign Function Interface): llamar a C desde todos
✅ 157	ABI, enlace y convenciones de llamada
✅ 158	Enlaces (bindings) y wrappers

La frontera por datos · 159–161

#	Clase
✅ 159	Serialización entre lenguajes: JSON, Protobuf, MessagePack
✅ 160	Contratos de API: REST, gRPC y esquemas
✅ 161	Procesos y comunicación: stdin/stdout, sockets, colas

Terrenos comunes · 162–163

#	Clase
✅ 162	WebAssembly como objetivo común
✅ 163	Incrustar un lenguaje en otro (Lua, Python embebido)

La decisión · 164

#	Clase
✅ 164	Elegir el lenguaje correcto para cada componente

Parte 11 — Proyecto integrador políglota · clases 165–176

🧭 Un sistema real con cinco componentes en cinco lenguajes, construido, probado, desplegado y defendido.

📂 Abrir el README de la parte — de qué trata, qué necesitas traer, qué sabrás hacer al terminar y qué se aprende en cada clase.

Diseño · 165–166

#	Clase
✅ 165	El proyecto: un sistema con componentes en varios lenguajes
✅ 166	Diseño: responsabilidades y contratos entre componentes

Los cinco componentes · 167–171

#	Clase
✅ 167	Componente CLI (lenguaje de sistemas)
✅ 168	Componente de API/servicio (backend)
✅ 169	Componente web/frontend (JS/TS)
✅ 170	Componente de datos y consultas (SQL)
✅ 171	Componente de automatización/scripting

Datos, pruebas y despliegue · 172–174

#	Clase
✅ 172	Persistencia y almacenamiento
✅ 173	Pruebas end-to-end del sistema completo
✅ 174	Empaquetado, contenedores y despliegue

Defender y transferir · 175–176

#	Clase
✅ 175	Documentación y defensa de las decisiones de lenguaje
✅ 176	Cierre: retrospectiva y transferencia a nuevos lenguajes