# Criterio

> Aprende a programar en Python desde Hola mundo viendo, paso a paso, qué se ejecuta primero y dónde vive cada variable en memoria (marcos en la pila, objetos en el montón). 16 lecciones hasta un agregado de Domain Driven Design con Test Driven Development, cada una trabajada con metodologías de aprendizaje medidas en el tiempo: antes (t<0), en (t=0) y después (t>0).

## Ruta de lecciones
- [1. Hola mundo](https://criterio.benjacode.com/aprende/hola-mundo): Ver que Python compila todo antes de ejecutar, y que evalúa los argumentos antes de llamar a una función.
- [2. Variables: nombres que apuntan](https://criterio.benjacode.com/aprende/variables): Entender que una variable no es una caja: es un nombre que apunta a un objeto.
- [3. Reasignar no es modificar](https://criterio.benjacode.com/aprende/reasignacion): Ver que y = x comparte el objeto, y que x = x + 1 crea un objeto nuevo sin tocar el anterior.
- [4. Qué se calcula primero](https://criterio.benjacode.com/aprende/expresiones): Seguir el orden exacto en que Python evalúa una expresión antes de asignar.
- [5. Decidir: if y else](https://criterio.benjacode.com/aprende/condicionales): Ver que la condición se evalúa a True o False y que el bloque que no corresponde se salta.
- [6. Repetir: for](https://criterio.benjacode.com/aprende/bucles): Ver que el for vuelve a la misma línea y que total apunta a un objeto nuevo en cada vuelta.
- [7. Funciones y su marco](https://criterio.benjacode.com/aprende/funciones): Ver que def no ejecuta el cuerpo, que cada llamada crea un marco y que las variables locales mueren al volver.
- [8. Llamadas dentro de llamadas](https://criterio.benjacode.com/aprende/pila): Ver que cada llamada tiene su propio x aunque se llamen igual, y que la pila crece y decrece.
- [9. Listas: dos nombres, un objeto](https://criterio.benjacode.com/aprende/listas-alias): Ver que b = a no copia una lista, y que list(a) sí crea otra.
- [10. La trampa del valor por defecto](https://criterio.benjacode.com/aprende/defecto-mutable): Ver que el valor por defecto se crea una sola vez, al ejecutar def, y vive pegado a la función.
- [11. Diccionarios: claves que apuntan](https://criterio.benjacode.com/aprende/diccionarios): Ver que un dict guarda referencias y que asignar una clave modifica el mismo objeto.
- [12. Clases y objetos: qué es self](https://criterio.benjacode.com/aprende/clases): Ver que los atributos viven dentro del objeto en el montón y que self es una referencia más a ese objeto.
- [13. Excepciones: saltar en el tiempo](https://criterio.benjacode.com/aprende/excepciones): Ver que raise abandona la función, destruye su marco y salta al except, saltándose líneas.
- [14. Value Object: valores que no cambian](https://criterio.benjacode.com/aprende/value-object): Ver que a + b llama a un método, que el Value Object crea objetos nuevos y que == compara por valor.
- [15. Pruebas: assert y TDD](https://criterio.benjacode.com/aprende/pruebas-tdd): Ver que una prueba es una función que llama a tu código y que assert lanza un error si algo es falso.
- [16. Agregado: un objeto que se protege](https://criterio.benjacode.com/aprende/agregado): Ver que el agregado verifica su regla antes de modificar su estado, así un error no lo deja a medias.

## Páginas
- [Ruta](https://criterio.benjacode.com/aprende): las lecciones por unidad, con tu avance.
- [Metodologías](https://criterio.benjacode.com/metodologias): catálogo filtrable por familia y evidencia.
- [Comparar](https://criterio.benjacode.com/comparar): curvas de retención, comprensión, transferencia y criterio a 30 días.
- [Mi metodología](https://criterio.benjacode.com/mi-metodologia): combina las metodologías elegidas en un solo plan.
- [Fundamentos](https://criterio.benjacode.com/fundamentos): arquitectura DDD, pruebas que codifican la evidencia y supuestos del modelo.

## Metodologías
### Memoria
- [Releer y subrayar](https://criterio.benjacode.com/metodos/relectura): El método de control: lo que casi todos hacemos por defecto. Evidencia baja. Fuente: Dunlosky et al. (2013), Improving Students' Learning With Effective Learning Techniques.
- [Práctica de recuperación](https://criterio.benjacode.com/metodos/recuperacion): Ponerte a prueba sin mirar, en vez de volver a leer. Evidencia alta. Fuente: Roediger y Karpicke (2006), Test-Enhanced Learning; Dunlosky et al. (2013).
- [Repetición espaciada](https://criterio.benjacode.com/metodos/espaciada): Recuperar en intervalos crecientes: 1, 3, 7, 14 y 28 días. Evidencia alta. Fuente: Cepeda et al. (2006), Distributed Practice in Verbal Recall Tasks; Leitner (1972).

### Comprensión
- [Fracaso productivo](https://criterio.benjacode.com/metodos/fracaso-productivo): Intentar resolver antes de que te enseñen. Fallar primero, entender después. Evidencia moderada. Fuente: Kapur (2008), Productive Failure; Sinha y Kapur (2021), metaanálisis en Review of Educational Research.
- [Ejemplos resueltos que se desvanecen](https://criterio.benjacode.com/metodos/ejemplos-resueltos): Ver la solución completa, luego completar huecos cada vez más grandes. Evidencia alta. Fuente: Sweller y Cooper (1985); Renkl y Atkinson (2003), Structuring the Transition From Example Study to Problem Solving.
- [PRIMM: predecir, ejecutar, investigar, modificar, crear](https://criterio.benjacode.com/metodos/primm): Lees código y predices qué hará antes de ejecutarlo. Evidencia moderada. Fuente: Sentance, Waite y Kallia (2019), Teaching Computer Programming With PRIMM.
- [Técnica Feynman (autoexplicación)](https://criterio.benjacode.com/metodos/feynman): Explica el concepto con palabras simples. Donde usas jerga, no entendiste. Evidencia moderada. Fuente: Chi et al. (1994), Eliciting Self-Explanations; Dunlosky et al. (2013).

### Práctica
- [Práctica intercalada](https://criterio.benjacode.com/metodos/intercalado): Mezcla problemas de distintos patrones en vez de practicar uno a la vez. Evidencia moderada. Fuente: Rohrer y Taylor (2007), The Shuffling of Mathematics Problems Improves Learning; Dunlosky et al. (2013).
- [Ejemplos con errores (caza del bug)](https://criterio.benjacode.com/metodos/ejemplos-con-errores): Te dan código con un error de diseño; tú lo encuentras y explicas. Evidencia moderada. Fuente: Große y Renkl (2007), Finding and Fixing Errors in Worked Examples; McLaren et al. (2016).
- [Problemas de Parsons](https://criterio.benjacode.com/metodos/parsons): Ordena líneas de código desordenadas hasta formar la solución. Evidencia moderada. Fuente: Parsons y Haden (2006); Ericson, Margulieux y Rick (2017), Solving Parsons Problems Versus Fixing and Writing Code.
- [Aprender con TDD (cada prueba es una hipótesis)](https://criterio.benjacode.com/metodos/tdd): Escribe la prueba de lo que crees que hará el código antes de escribirlo. Evidencia práctica profesional. Fuente: Beck (2002), Test-Driven Development: By Example. Los estudios sobre productividad son mixtos (Fucci et al., 2017)..
- [Kata y práctica deliberada](https://criterio.benjacode.com/metodos/kata): Repite un ejercicio corto, con una meta concreta y medición, varias veces. Evidencia moderada. Fuente: Ericsson, Krampe y Tesch-Römer (1993); con matices en Macnamara, Hambrick y Oswald (2014).
- [Aprendizaje para el dominio (mastery learning)](https://criterio.benjacode.com/metodos/maestria): No avanzas al siguiente tema hasta dominar el actual (80% o más). Evidencia alta. Fuente: Bloom (1984), The 2 Sigma Problem; Kulik, Kulik y Bangert-Drowns (1990), metaanálisis.

### Criterio
- [Interrogación elaborativa (los cinco porqués)](https://criterio.benjacode.com/metodos/cinco-porques): Ante cada afirmación pregunta por qué, hasta llegar a una fuerza del negocio. Evidencia moderada. Fuente: Pressley et al. (1987), Elaborative Interrogation; Dunlosky et al. (2013).
- [Pre-mortem y post-mortem (contrafactual)](https://criterio.benjacode.com/metodos/premortem): Antes de decidir, imagina que ya fracasó. Después, pregunta qué habría pasado con la otra opción. Evidencia moderada. Fuente: Mitchell, Russo y Pennington (1989), Back to the Future; Klein (2007), Performing a Project Premortem.
- [Casos con protagonista](https://criterio.benjacode.com/metodos/casos): Sigues a una persona en un proyecto real a lo largo del tiempo y decides con ella. Evidencia práctica profesional. Fuente: Kolodner (1993), Case-Based Reasoning; método del caso de Harvard. Evidencia variable según diseño..
- [Diario de decisiones (ADR) y ciclo de Kolb](https://criterio.benjacode.com/metodos/adr): Escribe cada decisión con contexto, alternativas y consecuencias esperadas; revísala después. Evidencia moderada. Fuente: Kolb (1984), Experiential Learning; Di Stefano et al. (2014), Making Experience Count; Nygard (2011), ADR.

### Con otros
- [Enseñar: pato de goma y diálogo socrático](https://criterio.benjacode.com/metodos/ensenar): Explica tu código línea por línea a alguien (o algo) que solo hace preguntas. Evidencia moderada. Fuente: Fiorella y Mayer (2013), The Relative Benefits of Learning by Teaching; Hunt y Thomas (1999), The Pragmatic Programmer.
- [Programación en pareja](https://criterio.benjacode.com/metodos/pareja): Dos personas, un teclado: una escribe, la otra navega y pregunta. Cambian de rol. Evidencia moderada. Fuente: McDowell et al. (2006); Hannay et al. (2009), The Effectiveness of Pair Programming: A Meta-Analysis.

## Cómo funciona el paso a paso
Un motor en Python ejecuta el código real con sys.settrace y registra en cada paso la pila de marcos, los objetos con su dirección, la salida y el orden de evaluación de la línea siguiente. El mismo motor corre en el navegador con Pyodide para ejecutar el código que escribas.

## Nota sobre el modelo de aprendizaje
Las trayectorias de las metodologías vienen de un modelo ilustrativo en Python, calibrado para respetar hallazgos de la investigación. Sirve para comparar metodologías, no para predecir resultados individuales.

## Código
- https://github.com/BenjaminGhiggo/criterio-de-desarrollo