[!IMPORTANT] Este repositorio no reemplaza los cursos de cada lenguaje. Es el mapa de lo que permanece al cambiar de lenguaje. Fluent Python, Effective Java, The Rust Programming Language y compañía aparecen como referencias de profundización en cada clase, sin copiar ni falsear su contenido: la redacción aquí es original. Cada obra citada está en el registro de fuentes con su ISBN-13 o su DOI, para que cualquiera pueda ir a comprobarla.

✅ Estado verificable

🌟 Qué hace diferente a este programa

• Enseña el concepto una vez y luego lo compara: la pregunta no es "¿cómo se escribe en X?", sino "¿qué permanece y qué cambia —y por qué— al pasar de un lenguaje a otro?".
• La equivalencia entre lenguajes la demuestra una máquina, no una promesa del texto: mismo casos.json, mismas salidas, en CI.
• Distingue siempre las tres clases de diferencia: sintáctica, semántica y paradigmática — la mayoría de los cursos mezclan las tres.
• Separa el núcleo (se implementa y se verifica) del Atlas (se comprende por características), y no vende lo segundo como lo primero.
• Ancla cada parte en la literatura de referencia de su área, con la cita en la clase.
• Declara sin adornos qué verifica la máquina y qué es material de lectura.

🧬 El mapa del programa

flowchart LR
    A["🧠 00 Pensamiento<br/>computacional"] --> B["🌳 01 Atlas y<br/>genealogía"]
    A --> C["🛠️ 02 Toolchains<br/>y comandos"]
    B --> D["🔤 03 Valores, tipos<br/>y variables"]
    C --> D
    D --> E["🔀 04 Control del<br/>programa"]
    E --> F["🧩 05 Funciones y<br/>modularidad"]
    F --> G["🗃️ 06 Datos y<br/>estructuras"]
    G --> H["🎭 07 Paradigmas"]
    G --> I["⚙️ 08 Cómo funcionan<br/>los lenguajes"]
    H --> J["🏗️ 09 Ingeniería de<br/>software políglota"]
    I --> J
    I --> K["🔌 10 Interoperabilidad<br/>y fronteras"]
    J --> K
    K --> L["🎓 11 Proyecto<br/>integrador"]

🗂️ Las 12 partes, en 5 etapas

Cada parte tiene su propio README docente, y no un índice de enlaces: de qué trata, qué necesitas traer, qué sabrás hacer al terminar, qué se aprende en cada una de sus clases agrupadas por bloques, los malentendidos que corrige y los libros que la sostienen. La numeración es global y secuencial por diseño: lo que enseña cada parte es el prerrequisito real de la siguiente.

🟢 Etapa 1 — Método y mapa (clases de método)

Cómo se compara un lenguaje con otro, de dónde vienen todos y con qué se ejecutan. Salida: leer código de un lenguaje que no conoces.

🔵 Etapa 2 — El programa elemental

Los tres ladrillos que todo lenguaje tiene: qué es un valor, cómo se decide y cómo se nombra un bloque de trabajo. Salida: escribir el mismo programa correcto en diez lenguajes.

🟣 Etapa 3 — Datos y paradigmas

De guardar un dato a elegir un estilo de resolver: OO, funcional, declarativo, concurrente. Salida: reconocer el paradigma detrás de una API y su coste.

🟠 Etapa 4 — Máquina e ingeniería

Qué ocurre bajo el código (memoria, GC, propiedad, compilación) y cómo se construye software que otros mantienen. Salida: explicar el porqué, no solo el cómo.

🔴 Etapa 5 — Fronteras y proyecto

Dónde se tocan dos lenguajes distintos y el trabajo que junta las once partes anteriores. Salida: montar un sistema real con más de un lenguaje y defenderlo.

➡️ Ver el índice completo de las 176 clases · 📅 Cronograma de ~406 h / ~41 semanas

🚀 Inicio rápido

git clone https://github.com/vladimiracunadev-create/polyglot-programming-labs.git
cd polyglot-programming-labs

python scripts/validar_estructura.py            # el repo cuadra con el manifest
python scripts/verificar_equivalencia.py 041    # una clase, en todos los lenguajes instalados
python scripts/verificar_equivalencia.py --all --lang go   # solo un lenguaje, todas las clases

No hace falta instalar nada más para leer: cada clase muestra el código de los diez lenguajes a la vista, en su README.md.

Sitio local:

python scripts/generar_sitio.py && python -m http.server 8080

Abre http://localhost:8080/site/.

🧪 El verificador de equivalencia

El diferenciador del 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_primos.py --all --lang ruby    # los primos del Atlas que sí se ejecutan

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

📥 El curso en cinco formatos

El mismo contenido, generado siempre desde las mismas clases. Todo en el último release.

🔍 Las apps se verifican por dentro. Un APK sin curso compila igual y un .exe sin datos arranca igual: todas las señales de build quedan verdes. Por eso android.yml descomprime el APK y desktop.yml lee el índice del ejecutable, y cuentan las 176 páginas de clase y los 136 anexos antes de publicar nada.

Regenerar cualquiera de ellos desde el repositorio:

python scripts/generar_sitio.py                # el portal HTML (site/), base de las apps
python scripts/generar_manual.py               # manual/MANUAL.pdf
python scripts/generar_manual.py --atlas       # manual/ATLAS.pdf, las 60 fichas
python scripts/generar_manual.py --con-vivos --con-primos --salida manual/MANUAL-COMPLETO.pdf
python scripts/generar_material.py --parte 3   # guías sueltas por clase en material/

📦 Contrato de una clase

classes/parte-N-slug/NNN-topic/
├── README.md            ← la clase completa, con el código de los 10 lenguajes a la vista
├── concepto.md
├── comparacion.md       ← sintáctica · semántica · paradigmática
├── reto.md              ← reto de transferencia
├── primos.md            ← el mismo programa en los lenguajes primos de cada familia
├── vivos.md             ← el mismo programa en los 12 lenguajes que siguen en producción
├── casos.json           ← la prueba común que ejecuta el verificador
└── implementaciones/<lenguaje>/...

Dentro del README.md de cada clase: 🎯 objetivo y resultados verificables · 🗺️ temas con su porqué · 📖 definiciones · 🧮 modelo (entradas/salidas/reglas) · 📐 pseudocódigo neutral · 🌐 las 10 implementaciones · 🔬 comparación · 🧬 el concepto en la familia · ✅ prueba común · 🧪 reto · ⚠️ errores comunes · ❓ FAQ · 🔗 referencias a los libros del área y del lenguaje.

📚 Las fuentes: qué se ha leído para escribir esto

El contenido no sale de una plantilla: cada parte sigue la literatura de referencia de su tema. No se reproduce el contenido de ninguna obra: la redacción es original, cada clase cita el libro que corresponde y declara para qué lo usa —no basta con nombrarlo—.

Aquí están todas las obras, una por una, con su edición y su localizador, para que cualquiera pueda ir a comprobarlas. El registro completo, con la lista de clases que citan cada obra, está en sources/bibliography.json.

La obra rectora de cada lenguaje del núcleo

Las obras de área, y en qué partes se usan

Los artículos fundacionales que se citan

Estas tablas no se teclean: las escribe scripts/verificar_fuentes.py leyendo el registro y las 176 clases. En cada cambio, el CI comprueba que las 41 obras citadas están todas en el registro y que ninguna entrada sobra, y que cada una de las 1922 citas dice para qué sirve.

🧩 Núcleo, Atlas y lenguajes vivos: tres 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.

🗂️ Cada lenguaje del repositorio tiene ficha propia. Las 60 fichas —los 10 del núcleo incluidos— siguen la misma anatomía: historia, dónde vive hoy, lo que enseña y no enseña ningún otro, lo que se ha modernizado, cómo se ejecuta con órdenes reales, el programa de la clase 041 explicado línea a línea y bibliografía.

🧟 Por qué hay una capa de lenguajes vivos

No es nostalgia: es profundidad. Cada uno de esos dieciocho se incluye por dos motivos verificables — que se ejecuta hoy en producción (banca, sanidad, aviónica, diseño de chips, ERP, CAD, hojas de cálculo) y que deja a la vista un concepto que el núcleo esconde: la aritmética decimal exacta en COBOL, el tipo que lleva una regla de negocio en Ada, la base de datos que es el lenguaje en MUMPS, el if que resulta ser un mensaje en Smalltalk, el código que es un dato en Lisp, el bucle principal que escribe el runtime en RPG.

Y muchos se han actualizado para resolver problemas actuales: COBOL genera JSON con sentencias del lenguaje, Fortran descarga bucles a la GPU, RPG consume APIs REST, Ada 2022 comprueba contratos, Perl 5.40 tiene try/catch, Delphi compila para iOS y Android. Cada ficha lo detalla en su sección 🔄 Lo que se ha modernizado.

Donde un lenguaje no puede expresar el problema de una clase —JCL no calcula, VBA vive dentro de Excel, AutoLISP dentro de AutoCAD— el contrato se adapta y la adaptación se declara, en lugar de inventar un programa falso.

👉 Índice de lenguajes que siguen vivos

🧬 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 en 20 lenguajes, 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. Verificar tres de veinte no es verificarlos todos.

🧭 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.
• 🧟 Lenguajes que siguen vivos — 18 fichas de lenguajes antiguos en producción hoy: dónde se usan, qué han modernizado y qué concepto enseñan.
• 📝 Autoevaluaciones — 90 preguntas, una batería por parte, con quiz y progreso local.
• 📖 Glosario — 424 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), y el mismo portal completo dentro de la app de Android y del ejecutable de escritorio, sin conexión.

👩‍🏫 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.

🗂️ Estructura del repositorio

classes/
  _manifest.json          # fuente de verdad (176 clases)
  README.md               # índice completo
  parte-N-.../
    README.md             # README docente de la parte (generado desde scripts/guias.py)
    NNN-.../              # la clase (ver «Contrato de una clase»)
atlas/  rutas/  autoevaluaciones/  glosario/  labs/   # portal
apps/android/  apps/desktop/                          # el curso empaquetado
manual/  material/  docs/  site/                      # PDF, guías y portal HTML
scripts/  .github/workflows/

Todo deriva de classes/_manifest.json, producido por scripts/build.py a partir de scripts/curriculo.py y scripts/guias.py. Re-ejecutar python scripts/build.py actualiza índice y README de parte sin tocar las clases, que se escriben a mano. Qué se edita y qué se genera está en la guía de contribución.

🚀 Cómo estudiar

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

1. Sigue el orden. 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 está en el contraste: ahí se ve qué es esencial y qué es accidente de la sintaxis.
3. Ejecuta el verificador. Comprueba tú mismo la equivalencia, y observa en qué se diferencian las 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.

🔗 Programas conectados

⚖️ Qué es y qué no es este programa

💡 Idea fuerza

El valor de este programa no está en acumular lenguajes, sino en separar lo que se transfiere de lo que es accidente de sintaxis: cada clase produce el mismo resultado en diez lenguajes, demuestra por máquina que son equivalentes, y luego explica en qué se diferencian de verdad. Aprender el undécimo lenguaje deja de ser empezar de cero.

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.

🧪 Calidad

python scripts/validar_estructura.py
python scripts/build.py --stats
python scripts/verificar_equivalencia.py --all
npx --yes markdownlint-cli2 "**/*.md"

🤝 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

Código y documentación original bajo MIT. Los libros, lenguajes, toolchains y servicios externos citados conservan sus propias licencias y términos.