Retos concretos (Mundo 0, JS, PHP)

Mundo 0 (Fundamentos)

0-1 — Variables y tipos

id: 0-1
tipo: MCQ
dificultad: 1
baseXp: 10
tags: [fundamentals, types, variables]
enunciado: |
	¿Qué salida produce el siguiente fragmento en JavaScript?
	let a = '5';
	let b = 2;
	console.log(a + b);
opciones:
	- 7
	- 52 # correcta
	- TypeError
	- undefined
correcta: 2
explicacion: en JS la + con string concatena → '5' + 2 = '52'.
hints:
	- id: h1
		text: "¿Qué ocurre si uno de los operandos es string? Pista: operador + se sobrecarga."
		penalty_percent: 0.10

0-2 — Condicionales & estructuras de control

id: 0-2
tipo: MCQ
dificultad: 1
baseXp: 10
tags: [control-flow, if, loops]
enunciado: |
	Indica cuál es la salida del siguiente pseudocódigo:
	x = 0
	for i in 1..3:
		if i % 2 == 0:
			x = x + 10
		else:
			x = x + 1
	print(x)
opciones:
	- 12 # correcta
	- 6
	- 11
	- 10
hints:
	- id: h1
		text: "Recorre i = 1,2,3; qué suma en cada paso?"
		penalty_percent: 0.10

0-3 — Funciones y modularidad

id: 0-3
tipo: Coding
dificultad: 2
baseXp: 12
tags: [functions, basics]
enunciado: |
	Implementa una función isPalindrome(s) que reciba una cadena s y devuelva true si es palíndromo (ignorando mayúsculas y espacios), false en caso contrario.
tests:
	- input: "ana"
		output: true
	- input: "An a"
		output: true
	- input: "test"
		output: false
	- input: ""
		output: true
hints:
	- id: h1
		text: "Convierte a minúsculas y elimina espacios antes de comprobar."
		penalty_percent: 0.15

0-4 — Arrays / listas y operaciones comunes

id: 0-4
tipo: Coding
dificultad: 2
baseXp: 12
tags: [arrays, map_filter_reduce]
enunciado: |
	Escribe una función unique(arr) que reciba un array y devuelva un array con los elementos únicos (sin alterar el orden).
tests:
	- input: [1,2,2,3]
		output: [1,2,3]
	- input: ['a','b','a']
		output: ['a','b']
	- input: []
		output: []
hints:
	- id: h1
		text: "Usa un set para comprobar qué ya apareció."
		penalty_percent: 0.10

0-5 — Recursividad básica

id: 0-5
tipo: Coding
dificultad: 3
baseXp: 15
tags: [recursion, algorithms]
enunciado: |
	Implementa sumList(arr) que calcule la suma de elementos de una lista de forma recursiva. Evita soluciones iterativas.
tests:
	- input: [1,2,3,4]
		output: 10
	- input: []
		output: 0
	- input: [5]
		output: 5
hints:
	- id: h1
		text: "Caso base: lista vacía."
		penalty_percent: 0.15

0-6 — Complejidad (Big O)

id: 0-6
tipo: MCQ
dificultad: 3
baseXp: 12
tags: [complexity, analysis]
enunciado: |
	¿Cuál es la complejidad temporal (Big-O) del siguiente código en términos de n?
	for i from 1 to n:
		for j from 1 to n:
			print(i,j)
opciones:
	- O(n)
	- O(n log n)
	- O(n^2) # correcta
	- O(2^n)
hints:
	- id: h1
		text: "Dos bucles anidados de 1..n ⇒ n * n."
		penalty_percent: 0.10

Ruta JavaScript

1-js-1 — JS: ES6 y sintaxis moderna

id: 1-js-1
tipo: MCQ + Coding
dificultad: 2
baseXp: 15
tags: [javascript, es6]
enunciado: |
	(MCQ) ¿Cuál es la diferencia entre var, let y const en alcance y mutabilidad?
	(Coding) Implementa flatten(arr) que "aplane" un array de profundidad 1 (ej: [1,[2,3],4] -> [1,2,3,4]).
tests:
	- input: [1,[2,3],4]
		output: [1,2,3,4]
	- input: []
		output: []
hints:
	- id: h1
		text: "Para el coding, usa Array.prototype.concat o spread operator."
		penalty_percent: 0.10

1-js-2 — Asíncrono: Promesas y async/await

id: 1-js-2
tipo: Coding / MCQ
dificultad: 3
baseXp: 20
tags: [javascript, async, node]
enunciado: |
	Implementa una función fetchAll(urls) que recibe un array de URLs y devuelve un Promise que resuelve con un array de respuestas (usar fetch o simular). Si alguna URL falla, la función debe rechazar con el error.
tests:
	- input: ['ok','ok']
		output: ['resp1','resp2']
	- input: ['ok','fail']
		output: error
hints:
	- id: h1
		text: "Piensa en Promise.all y manejo de excepciones."
		penalty_percent: 0.15

1-js-3 — DOM y eventos (mini-proyecto)

id: 1-js-3
tipo: Mini-project
dificultad: 3
baseXp: 20
tags: [frontend, dom, events]
enunciado: |
	Crea una pequeña página con: un input de texto, un botón “Añadir” y una lista. Al clicar “Añadir” el texto del input debe agregarse como un <li> a la lista. Borrar el input tras añadir. (Requiere manipulación DOM y eventos).
criterios_evaluacion:
	- funcionamiento básico
	- validación (no añadir strings vacíos)
hints:
	- id: h1
		text: "Usa document.createElement, appendChild y addEventListener."
		penalty_percent: 0.10

Ruta PHP

1-php-1 — PHP moderno (8+) — sintaxis y tipado

id: 1-php-1
tipo: MCQ / Coding
dificultad: 2
baseXp: 12
tags: [php, basics]
enunciado: |
	(MCQ) En PHP 8, ¿qué ventaja trae la declaración de tipos escalares (type hints) en funciones?
	opciones: a) rendimiento garantizado, b) validación temprana y documentación, c) elimina necesidad de excepciones, d) nada
	correcta: b
	(Coding) Escribe una función sumArray(array $arr): int que sume enteros en el array y devuelva 0 si está vacío.
tests:
	- input: [1,2,3]
		output: 6
	- input: []
		output: 0
hints:
	- id: h1
		text: "Usa array_sum o un loop; respeta las firmas de tipo."
		penalty_percent: 0.10

1-php-2 — POO en PHP (clases y namespaces)

id: 1-php-2
tipo: Coding
dificultad: 3
baseXp: 18
tags: [php, oop]
enunciado: |
	Implementa una clase User con propiedades id, name (privadas) y métodos __construct($id,$name), getId(), getName() y setName($name). Asegura encapsulación.
tests:
	- crear instancia new User(1,'Ana'), getName() devuelve 'Ana'
	- setName('Luis') luego devuelve 'Luis'
hints:
	- id: h1
		text: "Usa private y métodos públicos para acceso."
		penalty_percent: 0.10

1-php-3 — Laravel CRUD básico (mini-proyecto)

id: 1-php-3
tipo: Project
dificultad: 4
baseXp: 25
tags: [php, laravel, crud]
enunciado: |
	Crea un CRUD mínimo para Product (id, name, price) usando Laravel: rutas, controlador ProductController con index, show, store, update, destroy y migración. Incluye validación básica en store (name requerido, price numérico > 0).
criterios_evaluacion:
	- rutas respondan
	- validación funcione
	- migración crea tabla con columnas correctas
hints:
	- id: h1
		text: "Usa php artisan make:model -m, make:controller --resource."
		penalty_percent: 0.15

---

Rúbrica mínima de evaluación

• MCQ: respuesta correcta → correctness=1; incorrecta → 0. Si hay explicación pedida, se evalúa manualmente.
• Coding: correctness = testsPassed / totalTests.
• Tiempo: si timeLimit existe y timeTaken < timeLimit se aplica timeBonus según la fórmula acordada.
• Hints: penalización según penalty_percent de cada hint usado.
• XP final: aplicar fórmula xpAwarded = round((base * correctness + timeBonus) * streakMultiplier - hintPenalty - retryPenalty)

Gamified Learning App: Resumen y Alcance

Plan Modular del Proyecto

1. Currículum & Contenido (Autoría)

Propósito: Definir qué enseñar — skills, misiones, bosses, rubric. Salida: Catálogo de misiones (JSON/YAML), guías para autores, banco de tests. Prioridad: Alta (sin contenido no hay aprendizaje). Dependencias: Ninguna (puede diseñarse en paralelo al infra). Criterio de éxito: Al menos 1 mundo completo (misiones + boss) listo para publicar.

2. Motor pedagógico & adaptativo

Propósito: Adaptar la secuencia a cada usuario (mastery, spaced repetition, selección de retos). Salida: Algoritmo de selección (pseudocódigo), parámetros, API para recomendar. Prioridad: Alta. Dependencias: Catálogo de retos + telemetría (historial de intentos).

3. Catálogo de retos y formatos

Propósito: Estandarizar MCQ, coding, debug, drag&drop, simulation, project. Salida: Esquema de reto (YAML/JSON), templates de tests, política de hints. Prioridad: Alta. Dependencias: Currículum.

4. Runner / Sandbox de ejecución

Propósito: Evaluar retos de código de forma segura (tests automatizados). Salida: Servicio containerizado (Judge0 o Docker runner), API de ejecución. Prioridad: Media-alta. Dependencias: Esquema de retos (tests), infra (colas/microservicios).

5. Backend (API autoritativa)

Propósito: Almacenar usuarios, intentos, calcular XP, aplicar reglas anti-cheat. Salida: Endpoints REST, lógica de evaluación server-side, DB schema. Prioridad: Alta. Dependencias: Catálogo, runner.

6. Cliente (Frontend / App)

Propósito: UI práctica para ejecutar retos, ver progreso, editar código. Salida: Prototipo web (React) y app Flutter mínima (runner MCQ + coding editor). Prioridad: Alta. Dependencias: Backend + runner.

7. Gamificación & Economy

Propósito: Definir XP, niveles, rewards, skill points, perks. Salida: Reglas de gamificación, tablas de xp, inventario. Prioridad: Media. Dependencias: Backend, curriculum.

8. Analíticas / Telemetría

Propósito: Medir eficacia del contenido y ajuste de dificultad. Salida: Dashboards (pass rate, hint usage, mastery per skill). Prioridad: Media. Dependencias: Backend + instrumentation del cliente.

9. Seguridad & Anti-cheat

Propósito: Evitar farming de XP, cheating en submissions. Salida: Reglas rate-limit, hashing tests, similarity checks, logs. Prioridad: Alta. Dependencias: Backend, runner.

10. DevOps / Infra y despliegue

Propósito: Infra reproducible, CI/CD, despliegue del runner y backend. Salida: Dockerfiles, pipelines, Terraform/Ansible (si aplica). Prioridad: Media. Dependencias: Todos los servicios.

11. QA / Playtesting y comunidad

Propósito: Iterar contenido, pulir UX, obtener feedback. Salida: Lista de pruebas, beta testers, correcciones. Prioridad: Continua. Dependencias: Prototipo funcional.

12. Integración IA (opcional pero estratégico)

Propósito: Generar variantes de retos, feedback automático, explicaciones. Salida: Módulo generador de enunciados y explicaciones. Prioridad: Baja-media. Dependencias: Catálogo y métricas.

---

Currículum & Misiones (Parte 1)

Mundo 0 — Fundamentos (obligatorio)

• 0-1 Variables y tipos — MCQ / ejercicio corto — tipos, coerción, scope. — dif 1 — baseXp 10
• 0-2 Condicionales & Estructuras de control — MCQ / puzzle — if/switch/loops — dif 1 — baseXp 10
• 0-3 Funciones y modularidad — Coding (snippet) — funciones, parámetros, retorno — dif 2 — baseXp 12
• 0-4 Arrays / Listas y operaciones comunes — Coding — map/filter/reduce basics — dif 2 — baseXp 12
• 0-5 Recursividad básica — Coding — factorial, sumList — dif 3 — baseXp 15
• 0-6 Complejidad (Big O) — MCQ / explicación breve — analizar snippets — dif 3 — baseXp 12
• 0-boss Boss: Retos algorítmicos — Coding set — 8 problems fáciles-medios — dif 4 — baseXp 60

Mundo 1 — Ruta (elige una)

Ruta JavaScript

• 1-js-1 JS: ES6 & sintaxis moderna — MCQ — let/const/arrow/templ — dif 2 — baseXp 12
• 1-js-2 Asíncrono: Promesas & async/await — Coding/MCQ — fetch, promesas — dif 3 — baseXp 20
• 1-js-3 DOM & eventos — Mini-proyecto — manipulación DOM, eventos — dif 3 — baseXp 20
• 1-js-4 Node.js básico — Coding — servidor Express simple — dif 3 — baseXp 20
• 1-js-5 Testing con Jest — Coding — escribir tests unitarios — dif 3 — baseXp 18
• 1-js-boss Boss: Mini-app React/Next — Project — CRUD + routing + fetch — dif 5 — baseXp 80

Ruta PHP

• 1-php-1 PHP moderno (8+) — MCQ/Coding — tipado, namespaces — dif 2 — baseXp 12
• 1-php-2 POO en PHP — Coding — clases, interfaces — dif 3 — baseXp 18
• 1-php-3 Composer & ecosistema — MCQ — paquetes, autoload — dif 2 — baseXp 12
• 1-php-4 Laravel CRUD básico — Coding/Project — rutas, controllers, Eloquent — dif 4 — baseXp 25
• 1-php-5 Auth & security (Sanctum/JWT) — MCQ/Project — auth flows — dif 4 — baseXp 25
• 1-php-boss Boss: Mini-app Laravel — Project — auth + CRUD + tests — dif 5 — baseXp 80

Mundo 2 — Ingeniería de Software

• 2-1 SOLID & principios (KISS/DRY/YAGNI) — MCQ / refactor exercise — dif 3 — baseXp 20
• 2-2 Patrones de diseño (creacionales) — MCQ / diagram — Singleton, Factory — dif 3 — baseXp 18
• 2-3 Patrones (estructurales/comportamentales) — MCQ / dragdrop — Observer, Strategy — dif 4 — baseXp 22
• 2-4 Clean Code & refactorización — Coding — refactor module — dif 4 — baseXp 30
• 2-boss Boss: Refactor legacy — Project — convertir spaghetti a módulo — dif 6 — baseXp 120

Mundo 3 — Bases de Datos

• 3-1 SQL básico / JOINs — MCQ / queries — dif 3 — baseXp 18
• 3-2 Modelado ER & normalización — Drag&Drop / design — dif 4 — baseXp 22
• 3-3 Transacciones & concurrencia — Simulation — dif 4 — baseXp 24
• 3-4 ORM (Prisma/Eloquent) — Coding — migraciones, relaciones — dif 4 — baseXp 25
• 3-boss Boss: BD e-commerce + reportes — Project — dif 6 — baseXp 130

Mundo 4 — Inteligencia Artificial (integrado con Python)

• 4-1 Math básico para ML — MCQ / short tasks — álgebra linear básica — dif 4 — baseXp 25
• 4-2 ML clásico (scikit-learn) — Coding — regresión/clasificación — dif 5 — baseXp 40
• 4-3 Redes neuronales intro — Coding — TF/PyTorch simple — dif 5 — baseXp 45
• 4-boss Boss: Recomendador y API — Project — modelo + endpoint — dif 6 — baseXp 150

Mundo 5 — Arquitectura Avanzada

• 5-1 Monolito vs Microservicios — MCQ / scenario — dif 4 — baseXp 25
• 5-2 Event-driven (colasmanga) — Drag/Simulation — dif 5 — baseXp 30
• 5-3 API design (REST/GraphQL) — Coding/Design — dif 4 — baseXp 25
• 5-boss Boss: Diseña sistema distribuido — Project + defense — dif 7 — baseXp 200

Mundo 6 — DevOps & Cloud

• 6-1 Docker & contenedores — Hands-on — dockerize a service — dif 4 — baseXp 25
• 6-2 CI/CD pipelines — Simulation / yml — GitHub Actions basic — dif 4 — baseXp 25
• 6-3 Infra as code (Terraform) — MCQ/Project — dif 5 — baseXp 40
• 6-boss Boss: Despliegue completo multi-env — Project — dif 7 — baseXp 180

Mundo Final — Misión Final

• F-1 AgroConecta 2.0 (integral) — Project + Defensa — full stack + IA + deploy — dif 9 — baseXp 300

Ejemplo de misión en formato JSON

{
	"id":"0-5",
	"title":"Recursividad básica",
	"type":"coding",
	"tags":["recursion","algorithms","fundamentals"],
	"difficulty":3,
	"baseXp":15,
	"statement":"Escribe una función sumList(arr) que retorne la suma de los elementos.",
	"tests":[ {"input":[1,2,3], "output":6}, {"input":[], "output":0} ],
	"hints":[ {"id":"h1","text":"Define el caso base: lista vacía.","penalty_percent":0.15} ]
}

---

Objetivo

Construir una app gamificada para enseñar programación e ingeniería de software de forma secuencial, medible, personalizada y práctica. El usuario elige una ruta principal (JS o PHP) y la app cubre desde fundamentos hasta DevOps e IA, adaptándose al nivel del jugador para maximizar el aprendizaje (spaced repetition, práctica deliberada, feedback inmediato).

Principios pedagógicos

• Mastery learning: No se avanza hasta dominar cada unidad.
• Práctica deliberada + feedback inmediato: Cada reto da feedback detallado y micro-lección.
• Spaced repetition: Repaso de temas débiles.
• Interleaving: Mezcla de problemas de varias áreas.
• Progresión por habilidades: El foco es la habilidad, no el lenguaje.
• Evaluación formativa y sumativa: Mini-retos + bosses/proyectos.

Arquitectura técnica

• Cliente móvil: Flutter (Android/iOS)
• Cliente web (opcional): React + TypeScript
• Backend: Laravel (PHP) recomendado, o Node+TS
• Runner/Judge: Servicio independiente (Judge0 o propio, containerizado)
• DB: PostgreSQL + Redis
• Colas: RabbitMQ / Redis Streams
• Storage: S3 compatible
• IA: Servicio separado para generación de retos/explicaciones
• Autenticación: JWT/OAuth
• Observabilidad: Logging, métricas, tracing

Modelos de datos esenciales

• User: id, nombre, email, nivel, xp, skillMastery, streak, ruta, artefactos
• Challenge: id, título, tipo, tags, dificultad, baseXp, tests, hints
• Attempt: id, userId, challengeId, tiempo, hints usados, score, xpAwarded, resultado
• Mission/World: id, misiones

Formato de autoría

• Cada reto en YAML/JSON: id, título, tipo, tags, dificultad, baseXp, enunciado, tests, hints, rubrica
• Flujo: IA genera → humano revisa → publicar

Tipos de retos y evaluación

• MCQ, multi-select, coding, debugging, drag&drop, simulation, project/boss
• Fórmulas de XP: baseXp, correctness, timeBonus, streakMultiplier, hintPenalty, retryPenalty
• Proyectos: rubrica con criterios y pesos

Personalización y adaptación

• Mastery por skill (EMA)
• Algoritmo adaptativo de dificultad
• Selección de siguiente reto según debilidades y spaced repetition

Anti-cheat y seguridad

• Evaluación y XP solo en backend
• Sandbox de ejecución
• Rate limit, detección de patrones sospechosos, plagio, logs

Gamificación

• Skill points, streaks, daily quests, bosses, side quests, respec, peer review, modo práctica, coleccionables

UI/UX esenciales

• Dashboard, mapa de mundos, runner de retos, feedback panel, perfil/skill tree, project review, analytics, leaderboard
• Explicaciones claras, transparencia en XP, hints progresivos

MVP (prioridad)

1. Auth + perfil
2. Catálogo de mundos/misiones (MCQ)
3. MCQ runner con scoring y feedback
4. XP/leveling y skillMastery
5. Selección de ruta (JS/PHP)
6. Persistencia offline mínima
7. Backend autoritativo
8. Servicio de ejecución para retos de código

API mínima

• POST /api/auth/login
• GET /api/user/me
• GET /api/worlds
• GET /api/challenges/:id
• POST /api/attempts
• POST /api/projects
• GET /api/leaderboard
• POST /api/runner/execute

Fases de implementación

• Fase 0: Diseño, taxonomía, wireframes
• Fase 1: MVP funcional
• Fase 2: Coding runner, más misiones, rutas completas
• Fase 3: Skill tree, bosses, peer review
• Fase 4: IA para retos y adaptación
• Fase 5: DevOps, analytics, anti-cheat, bosses finales

---

Este README resume la visión, arquitectura, modelos y prioridades para la app gamificada de aprendizaje de programación. Se puede expandir cada sección según se avance en el desarrollo.