🧭 Estado del programa. Las 176 clases en 12 partes están construidas. Las clases de código (Partes 3–11) traen sus 10 implementaciones del núcleo con el código a la vista y verificadas en CI contra su casos.json; las de método (Partes 0–2) son las clases conceptuales de pensamiento, familias de lenguajes y toolchains.

Qué verifica una máquina y qué no, para que sepas de qué te fías: el verificador de equivalencia ejecuta en CI las implementaciones de cada clase de código contra su casos.json y comprueba que todas producen la misma salida. El texto de las clases y el Atlas son material de lectura escrito a mano, apoyado en los libros de referencia: no se ejecutan en CI. Si el badge de CI está verde, garantiza que las implementaciones equivalentes lo son de verdad.

🎯 Qué es esto

Un currículo modular y secuencial que enseña los conocimientos transferibles de la programación: no diez cursos aislados, sino cada concepto (una variable, un bucle, una función, un tipo) mostrado una vez y luego comparado entre lenguajes. La pregunta que responde cada clase no es "¿cómo se escribe en X?", sino "¿qué permanece y qué cambia —y por qué— al pasar de un lenguaje a otro?".

Cada clase es una carpeta con un README.md completo que incluye:

• 🎯 Objetivo y resultados de aprendizaje verificables.
• 🗺️ Temas con el porqué de cada uno · 📖 Definiciones de los términos.
• 🧮 Modelo (entradas/salidas/reglas) y 📐 algoritmo en pseudocódigo neutral.
• 🌐 Implementaciones idiomáticas con el código a la vista en los 10 lenguajes del núcleo.
• 🔬 Comparación (sintáctica · semántica · paradigmática) y 🧬 el concepto en la familia.
• ✅ Prueba común (casos.json) · 🧪 reto de transferencia · ⚠️ errores comunes · ❓ FAQ.
• 🔗 Referencias a los libros del área y de cada lenguaje.

📚 Pauta derivada de los mejores libros

El contenido no sale de una plantilla: cada parte sigue la literatura de referencia de su tema. Estos son los libros que sostienen el programa (las referencias apuntan a las obras; no se reproduce su contenido, la redacción es original).

Cada clase cita, en su sección de 🔗 Referencias, los libros de su parte y el libro del lenguaje.

🧩 Núcleo y Atlas: dos capas

La idea: aprende el representante, reconoce la familia entera. Si dominas C, ya lees el 80 % de la sintaxis de Java, C#, JS, Go y PHP. El Atlas cubre esa amplitud sin multiplicar el mantenimiento.

🗂️ Las 12 partes

➡️ Ver el índice completo de las 176 clases

📕 Manual completo (todo el curso en un documento)

¿Prefieres el curso entero en un solo sitio, para leer de corrido o estudiar sin conexión? El manual consolida las 176 clases en orden, con portada e índice enlazado, y con el código de los 10 lenguajes a la vista, que es lo que hace que valga la pena en papel: se comparan sin saltar entre archivos.

• 📥 Descargar el manual en PDF — listo para imprimir o leer offline.

Se genera con python scripts/generar_manual.py a partir de las clases, así que siempre refleja el contenido actual del repositorio. Para guías sueltas por clase: python scripts/generar_material.py --parte 3 deja los PDF en material/ (no se versionan).

🧬 Los primos: el mismo programa en toda la familia

Cada muestra de código del núcleo enlaza, justo debajo, a las versiones del mismo programa en los lenguajes primos de su familia. Si lees el bloque de Python, ves de inmediato cómo lo escribirían Ruby, Perl, Lua, Tcl o R:

🧬 El mismo programa en la familia Scripting dinámico: Ruby · Perl · Lua · Tcl · R

Son 2722 programas repartidos en las 7 familias del Atlas, y lo que da valor a cada página no es el código sino el párrafo «Qué reconocer» que la cierra: que 0 es verdadero en Lua y Clojure, que Lua hace herencia por __index —el mismo modelo de prototipos de JavaScript—, o que el name mangling de C++ no está estandarizado entre compiladores.

Ruby, Perl y Lua se ejecutan en CI contra el mismo casos.json que el núcleo (workflow Labs); los otros 17 primos son material de lectura y así se declara en cada página.

🧪 El verificador de equivalencia

El diferenciador de este programa: cada clase de código define un casos.json (entradas y salidas comunes), y el verificador ejecuta todas las implementaciones alimentándolas por stdin para comprobar que coinciden. No es teoría: es equivalencia demostrada por máquina, en paralelo por lenguaje en CI.

python scripts/verificar_equivalencia.py 041            # una clase
python scripts/verificar_equivalencia.py --all          # todas las clases
python scripts/verificar_equivalencia.py --all --lang go  # solo un lenguaje

Los lenguajes cuyo toolchain no esté instalado se omiten e informan (degradación silenciosa); SQL, al ser declarativo, se marca como ilustrativo.

🧭 Portal

• 🧭 Rutas por perfil — "vengo de Python", "quiero sistemas (C/Rust)", "web (JS/TS)", "backend (Java/C#/Go)", "datos (SQL)".
• 🌐 Atlas de lenguajes — genealogía, historia, características y toolchain de cada familia.
• 📝 Autoevaluaciones — una batería de preguntas por parte.
• 📖 Glosario — términos enlazados a la clase donde se explican.
• 🧪 Laboratorios — la equivalencia demostrada: el verificador sobre las implementaciones.

🌐 Todo navegable en el sitio del curso (GitHub Pages).

🗂️ Estructura del repositorio

classes/
  _manifest.json          # fuente de verdad (176 clases)
  README.md               # índice completo
  parte-N-.../
    README.md             # README de la parte (con sus libros de referencia)
    NNN-.../
      README.md           # la clase, con el código a la vista
      concepto.md comparacion.md reto.md casos.json
      implementaciones/<lenguaje>/...
atlas/  rutas/  autoevaluaciones/  glosario/  labs/
scripts/  docs/  .github/workflows/

👩‍🏫 Para instructores

• 📅 Syllabus y cronograma — horas por parte, dependencias y un plan de ~41 semanas.
• 📊 Rúbrica de evaluación — cómo puntuar retos de transferencia, laboratorios y el proyecto integrador.
• 🎓 Examen final por perfil — teoría + transferencia verificada + explicación, para cada ruta.
• 🧱 Currículo · Metodología · Ampliar lenguajes.

🚀 Cómo estudiar

problema → concepto → pseudocódigo → implementaciones → comparación → transferencia

1. Sigue el orden. La numeración es global y secuencial por diseño: cada clase asume la anterior. Empieza por la Parte 0, que fija el método de comparación.
2. Lee las 10 implementaciones, no solo la de tu lenguaje. El valor de cada clase está en el contraste: ahí se ve qué es esencial y qué es accidente de la sintaxis.
3. Ejecuta el verificador. Comprueba tú mismo que las implementaciones son equivalentes, y observa en qué se diferencian sus salidas cuando fuerzas un caso límite.
4. Haz el reto de transferencia. Portar el concepto a un lenguaje que no dominas es donde se fija el aprendizaje.
5. Usa los libros de referencia de cada parte para profundizar en lo que más te interese.

Principios

• Comparar conceptos, no solo sintaxis.
• Anclar el contenido en los libros de referencia de cada área.
• Mantener el mismo problema, datos de prueba y resultado esperado en todos los lenguajes.
• Explicar diferencias reales sin declarar que todos los lenguajes son iguales.
• Distinguir siempre lo que verifica la máquina de lo que es material de lectura.
• Crecer por conceptos, no por cursos aislados.
• Usar pnpm en todo componente JavaScript/TypeScript que requiera paquetes.

🤝 Contribuir y seguridad

Lee la guía de contribución y la política de seguridad. El repositorio escanea secretos con gitleaks y el tooling con bandit en cada push.

Licencia

MIT. Consulta LICENSE.