Nivel inicial13 min de lectura · Publicado el 25 de mayo de 2018

Koan y kata: qué son y qué significan (zen y programación)

Un músico no aprende a tocar en mitad del concierto: ensaya escalas en casa. En programación, en cambio, solemos practicar directamente en el proyecto, con prisas y con código que va a producción. Las katas y los koans son el «ensayo en casa» del programador.

Las dos palabras vienen de Japón y de tradiciones distintas. Primero veremos qué significan en su origen y después cómo las usamos al programar.

Qué es un koan (significado en el zen)

Un koan es una pregunta, un diálogo o una historia corta que un maestro zen plantea a su alumno. A primera vista parece absurdo o no tiene respuesta lógica. No está pensado para resolverse razonando, sino para que el alumno deje de lado sus suposiciones y lo vea de otra manera.

El maestro comprueba si el alumno lo ha entendido en una entrevista privada entre los dos. Lo que cuenta no es dar con una frase correcta, sino lo que esa respuesta muestra de su comprensión.

Algunos datos para situarlo:

• De dónde viene la palabra: del chino gōng’àn, que significa «caso público», como el expediente de un juicio que sirve de precedente. Las colecciones de koans recogen dichos de maestros antiguos para que otros los estudien.
• Quién los usa: sobre todo la escuela Rinzai del zen japonés. La escuela Sōtō los estudia menos.
• Colecciones clásicas: El paso sin puerta (Mumonkan, 1228), con 48 koans, y El registro del acantilado azul (Hekiganroku, 1125), con 100.

Ejemplos de koan

• El sonido de una sola mano. Del maestro japonés Hakuin (siglo XVIII): dos manos que dan una palmada suenan; ¿cuál es el sonido de una sola mano? Es el koan más conocido en Occidente.
• El perro de Zhaozhou (o Joshu, en japonés). Un monje pregunta al maestro Zhaozhou si un perro tiene naturaleza de Buda, y él responde solo «Mu», que significa «no». Es el primer caso de El paso sin puerta.

Si intentas responderlos como un acertijo, te atascas. Esa es la idea.

Qué es una kata (significado en las artes marciales)

Kata es una palabra japonesa que significa «forma» o «patrón». En el kárate es una secuencia fija de movimientos básicos (golpes, bloqueos, desplazamientos) encadenados con sentido. Se practica en solitario o en pareja, una y otra vez.

Nadie te va a atacar justo en el orden de la kata. No se trata de memorizar una pelea, sino de que los movimientos te salgan solos cuando los necesites.

Qué es una kata de programación

Una kata de programación (o code kata) es un problema pequeño que resuelves para practicar, no para entregar. Lo que importa es cómo lo resuelves: los pasos, las pruebas, el diseño. Y como en el kárate, se repite: la misma kata hecha varias veces enseña cosas distintas cada vez.

El término lo popularizó Dave Thomas, coautor de The Pragmatic Programmer, en su serie CodeKata. Según cuenta en cómo empezó, se dio cuenta de que un rato de 45 minutos jugando con código desechable, sin presión, era una sesión de práctica parecida a las de las artes marciales. Él describe cada kata como un ejercicio corto, de unos 30 minutos a una hora, y deja claro que el objetivo es practicar, no llegar a la solución.

Algunas características:

• Son cortas. Caben en una sesión.
• No dependen del lenguaje. El mismo enunciado sirve en Java, Python o JavaScript, así que también sirven para practicar un lenguaje nuevo.
• Se comparten. Después de resolverla, comparar tu solución con la de otras personas es parte del aprendizaje.
• Se pueden hacer en pareja. Programar en pareja (pair programming) es una de las prácticas de Extreme Programming, y las katas son una buena forma de entrenarla. Cuando un grupo se junta para hacerlas se llama coding dojo (el dojo es la sala donde se entrena en las artes marciales). En español lo explican bien en Genbeta.

El objetivo es practicar, no la solución.

Qué es un koan de programación

Un koan de programación es un ejercicio para aprender un lenguaje paso a paso. Te descargas un conjunto de tests que fallan y tienes que completar el código para que pasen. Cada uno enseña una sola idea, y lo que aprendes en uno te sirve para el siguiente.

La idea se hizo popular con los Ruby Koans de EdgeCase, escritos por Jim Weirich y Joe O’Brien. Su página explica que los basaron en tests para enseñar también la cultura del testing, y que sigues el ciclo de TDD: ver el koan fallar (rojo), hacerlo pasar (verde) y pararte a pensar qué te enseña. Después vinieron versiones para otros lenguajes, como los Python Koans o los Kotlin Koans oficiales de JetBrains.

Así es un koan mínimo en JavaScript. Tienes que cambiar __ por el valor correcto:

// koan.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';

const __ = 'RELLÉNAME';

test('toUpperCase no cambia el texto original', () => {
  const saludo = 'hola';
  saludo.toUpperCase();
  assert.equal(saludo, __); // ¿qué vale saludo ahora?
});

Al ejecutarlo con node --test koan.test.js, falla y te enseña lo que esperaba frente a lo que hay. Si pones 'hola', pasa, y has aprendido que en JavaScript los textos no se modifican: toUpperCase() devuelve uno nuevo.

¿Por qué se llaman koans? Porque cada ejercicio es una pequeña pregunta que te obliga a pararte a pensar. Es un guiño al zen; el parecido es lejano, porque un koan de programación sí tiene una respuesta correcta.

Cómo practicar una kata con TDD, paso a paso

TDD (test-driven development, desarrollo guiado por tests) consiste en escribir primero una prueba pequeña y después el código justo para que pase. Una kata es el sitio ideal para practicarlo, porque no hay prisa ni código heredado.

1. Elige una kata sencilla y lee el enunciado entero, pero no lo resuelvas de cabeza.
2. Escribe el test más simple que se te ocurra y comprueba que falla (rojo).
3. Escribe el mínimo código para que pase (verde), aunque parezca una trampa.
4. Mejora el código sin cambiar lo que hace (refactoring), con los tests en verde.
5. Repite con el siguiente caso, siempre en pasos pequeños.
6. Al terminar, bórralo y repítela otro día. Prueba otro lenguaje, otro orden de tests o una restricción nueva.

Los pasos de TDD los tienes explicados con más calma en Pasos para aplicar TDD.

Ejemplo: la kata FizzBuzz resuelta con TDD

FizzBuzz es la kata clásica para empezar. Dado un número, devuelve:

• "Fizz" si es múltiplo de 3.
• "Buzz" si es múltiplo de 5.
• "FizzBuzz" si es múltiplo de los dos.
• El propio número, como texto, en cualquier otro caso.

Usamos el ejecutor de tests que trae Node, así que no hay que instalar nada. Crea una carpeta con un package.json que solo contenga {"type": "module"}.

Rojo. El primer test, el más simple:

// fizzbuzz.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { fizzbuzz } from './fizzbuzz.js';

test('un número normal se dice tal cual', () => {
  assert.equal(fizzbuzz(1), '1');
});

Con una función vacía, node --test falla: esperaba '1' y recibió undefined.

Verde. El mínimo para que pase, aunque parezca hacer trampa:

// fizzbuzz.js
export function fizzbuzz(n) {
  return '1';
}

Ese «truco» obliga a escribir el siguiente test para avanzar. Vas añadiendo casos (el 2, el 3, el 5, el 15…), uno cada vez, y en cada uno haces solo lo necesario para que pase. Al final los tests quedan así:

test('un número normal se dice tal cual', () => {
  assert.equal(fizzbuzz(1), '1');
  assert.equal(fizzbuzz(2), '2');
});

test('los múltiplos de 3 dicen Fizz', () => {
  assert.equal(fizzbuzz(3), 'Fizz');
  assert.equal(fizzbuzz(6), 'Fizz');
});

test('los múltiplos de 5 dicen Buzz', () => {
  assert.equal(fizzbuzz(5), 'Buzz');
  assert.equal(fizzbuzz(10), 'Buzz');
});

test('los múltiplos de 3 y de 5 dicen FizzBuzz', () => {
  assert.equal(fizzbuzz(15), 'FizzBuzz');
  assert.equal(fizzbuzz(30), 'FizzBuzz');
});

Refactor. Con todo en verde, ordenamos el código para que se lea mejor. Damos nombre a la idea de «ser múltiplo»:

// fizzbuzz.js
const esMultiplo = (n, divisor) => n % divisor === 0;

export function fizzbuzz(n) {
  if (esMultiplo(n, 15)) return 'FizzBuzz';
  if (esMultiplo(n, 3)) return 'Fizz';
  if (esMultiplo(n, 5)) return 'Buzz';
  return String(n);
}

$ node --test
✔ un número normal se dice tal cual
✔ los múltiplos de 3 dicen Fizz
✔ los múltiplos de 5 dicen Buzz
✔ los múltiplos de 3 y de 5 dicen FizzBuzz
ℹ pass 4
ℹ fail 0

La segunda vez que la hagas, ponte un reto: sin if, en otro lenguaje o con un compañero que escriba los tests mientras tú escribes el código.

Katas clásicas para empezar

De menos a más difícil:

Tienes muchas más en el catálogo de Coding Dojo y en las 21 katas de CodeKata. Plataformas como Codewars o Exercism también las llaman katas o ejercicios y corrigen tu solución con tests.

En este blog tienes algunas resueltas: números romanos en JavaScript, el Juego de la Vida de Conway con TDD y una selección de katas para pruebas. Y si lo que buscas son koans, los Kotlin Koans y los koans de ES6.

Cómo practicar katas con un asistente de IA sin que te las resuelva

Un asistente de IA resuelve FizzBuzz en un segundo. Precisamente por eso puede arruinar la práctica: si te da la solución, te saltas lo único que importa, que es el camino. Es como ir al gimnasio y pedirle a otro que levante las pesas por ti.

Esto es criterio propio, no una regla oficial de ninguna herramienta:

• Apaga el autocompletado con IA durante la kata. Si el editor te sugiere la función entera, ya no estás practicando.
• Pídele que no escriba código. Por ejemplo: «Estoy haciendo la kata FizzBuzz con TDD para practicar. No escribas código ni me des la solución. Solo dime si mi siguiente test es el paso más pequeño posible y, si no, por qué».
• Úsalo como compañero de pareja, no como piloto. Que te proponga el siguiente caso de prueba y tú escribes el test y el código.
• Úsalo al final, para comparar. Cuando termines, pídele otra solución y fíjate en qué decisiones tomó distinto. Es el «ver cómo lo resuelve otra gente» de siempre.
• Practica también revisar. Pídele una solución a una kata que ya domines y búscale los fallos. Leer código ajeno con ojo crítico es la habilidad que más vas a necesitar cuando trabajes con agentes.

Para leer más (en español)

• Qué es un coding dojo, en Genbeta.
• Ejercicios (katas) para mejorar habilidades de programación, en Blog Bitix.
• Koans, katas y études, en Altenwald.

Fuentes

Comprobado en noviembre de 2026:

• Kata de programación: CodeKata, CodeKata: How It Started y Kata, Kumite, Koan, and Dreyfus, de Dave Thomas (textos de 2003, republicados en codekata.com en 2013). De ahí salen la definición de kata («forma o patrón» en japonés), la duración de 30 minutos a una hora y la idea de que el objetivo es practicar.
• Koan de programación: README de los Ruby Koans (EdgeCase; autores, inspiración en los «Meta Koans» de Ara Howard y el ciclo rojo, verde, refactor), Python Koans y la documentación de Kotlin Koans (actualizada el 23 de marzo de 2026).
• Koan en el zen: solo se ha consultado una fuente secundaria, el artículo Kōan de la Wikipedia en inglés, que remite a Hori (2000), Foulk (2000) y Aitken (1991), y el de Mu para el caso del perro de Zhaozhou. Los koans se citan parafraseados, no como cita literal. Falta contrastarlos con una traducción publicada del Mumonkan.
• Katas clásicas: enunciados en Coding Dojo, Roy Osherove, Robert C. Martin y los repositorios de Emily Bache.
• Código ejecutado: la kata FizzBuzz (cada paso: rojo, verde y refactor) y el koan de JavaScript se han ejecutado con Node.js 24.21.0 y su ejecutor de tests integrado node:test (estable en Node 24) en Ubuntu 26.04.