JAFSJosé Antonio Fuentes Santiago

DDD en un apocalipsis zombi. Parte 1

22-02-2026

Imaginemos que estamos en pleno apocalipsis zombi. Tu grupo de supervivientes ha encontrado refugio en una vieja central eléctrica abandonada, pero la situación es crítica: hay que gestionar refugios, coordinar reabastecimientos, controlar infecciones y tomar decisiones que pueden significar vida o muerte. Decides crear un sistema para ayudar a gestionar todo esto.

Meses después, el sistema funciona, pero hay un problema: cada vez que el líder del grupo (nuestro "experto de negocio") pide un cambio, tú y tu equipo os perdéis en traducciones. Él habla de "supervivientes en cuarentena", tú piensas en user.status = 3. Él menciona "refugio en capacidad crítica", tú ves shelter.count >= shelter.max. El código funciona, pero nadie entiende realmente qué hace sin abrir cada archivo y desentrañar la lógica. Y en un apocalipsis zombi, perder tiempo tratando de entender el código puede costarte la vida.

Este es exactamente el tipo de problema que Domain-Driven Design vino a resolver. Y no, DDD no es una arquitectura ni un framework mágico que instalas con npm. Es una filosofía de desarrollo que propone algo radical y a la vez obvio: el código debe ser un espejo fiel de cómo funcionan las cosas en el mundo real del negocio (o en nuestro caso, del apocalipsis).

La idea la plasmó Eric Evans en 2003 en su libro Domain-Driven Design: Tackling Complexity in the Heart of Software, y aunque ya han pasado más de dos décadas, la premisa sigue siendo igual de potente: si el líder de supervivientes y el desarrollador miran el modelo del sistema, ambos deberían ver lo mismo. Mismos conceptos, mismas palabras, mismas reglas.

¿Suena simple? Lo es. ¿Es fácil de implementar? Para nada. Pero cuando funciona, la diferencia es brutal: el código deja de ser una caja negra incomprensible y se convierte en una representación viva del dominio.

¿Por qué DDD en un apocalipsis zombi?

Nuestro dominio de supervivencia tiene todo lo que necesita un buen modelo de DDD:

  • Actores claros: Supervivientes, Refugios, Suministros, Infectados
  • Reglas firmes: capacidad máxima de refugio, riesgo de contagio por proximidad, prioridad de evacuación
  • Eventos que importan: SupervivienteInfectado, RefugioReabastecido, CuarentenaActivada
  • Consecuencias inmediatas: un error en la lógica de cuarentena puede significar un brote masivo

Si el código habla ese mismo idioma del apocalipsis, las decisiones serán más rápidas y menos peligrosas. Si en cambio tenemos un User.status = 2 en lugar de un Superviviente.infectar(), alguien va a acabar mordido porque no entendió qué hacía ese "2".

Ahora que entendemos el problema, veamos cómo DDD nos da las herramientas para solucionarlo.

Ciudad post-apocalíptica

1. Lenguaje ubicuo (Ubiquitous Language)

El primer pilar de DDD es establecer un lenguaje común entre todos los que participan en el proyecto. Y cuando digo común, me refiero a que las mismas palabras que usa el líder de supervivientes cuando describe cómo funciona la gestión del refugio, deben ser exactamente las mismas que aparecen en el código, en los tests, en la documentación y en las reuniones de equipo.

¿Por qué es esto tan importante? Pensemos en un ejemplo concreto del apocalipsis:

Imagina que el líder del grupo dice: "Cuando un superviviente muestra síntomas de infección, debe entrar inmediatamente en cuarentena hasta que un médico lo evalúe". Si tú como desarrollador traduces esto internamente a user.status = 2 y user.quarantine = true, ¿qué pasa cuando dentro de tres meses otro desarrollador tenga que modificar esa lógica? Va a tener que hacer arqueología de código para descifrar qué significa status = 2.

El lenguaje ubicuo elimina esa traducción mental. En nuestro refugio:

  • No decimos Usuario, decimos Superviviente. Porque en un apocalipsis zombi no hay "usuarios", hay personas luchando por sobrevivir.
  • No tenemos un método setSalud(valor), tenemos sufrirHerida(), curar() o aplicarVendaje(). Son acciones que cualquiera entiende sin necesidad de abrir la documentación.
  • No hay un status = 5, hay un método ponerEnCuarentena() que hace exactamente lo que dice.

¿Qué pasa si no usamos lenguaje ubicuo?

La consecuencia directa es la pérdida de conocimiento del dominio. El código se vuelve críptico, lleno de abreviaciones y abstracciones que solo el desarrollador original entiende. Cuando esa persona se va (o peor, se convierta en zombi), su conocimiento desaparecerá con ella.

Además, cada conversación con el equipo de negocio se convierte en un ejercicio de traducción simultánea: ellos hablan de "reabastecimiento de urgencia", tú piensas en supply.priority = 1. Ellos dicen "ruta segura", tú ves route.safe = true. Es agotador y, lo peor de todo, propenso a errores de comunicación.

En la práctica

Si en una especificación la líder del grupo menciona "cuarentena", en el código tendremos una clase o concepto llamado Cuarentena, no IsolationZone ni StatusType2. Si hablan de "suministros críticos", el código tendrá SuministrosCriticos, no ImportantSupplies.

Este lenguaje compartido se convierte en el diccionario viviente del proyecto. Y debe estar documentado: un simple glosario donde se definan los términos clave del dominio puede salvar a tu equipo de horas de confusión.

La líder y el desarrollador hablan el mismo idioma

En la imagen superior podemos ver cómo el desarrollador tiene que dejar de pensar en tecnicismos para comenzar a hablar con la líder el mismo idioma.

La diferencia entre el código de la izquierda y el de la derecha parece cosmética, pero en la práctica es enorme:

// ❌ Sin lenguaje ubicuo
user.status = 2;
user.quarantine = true;

// ✅ Con lenguaje ubicuo
superviviente.ponerEnCuarentena();

En el primer caso, ¿qué significa status = 2? ¿Hay un status = 1? ¿Y un status = 3? ¿Quién sabe qué implica cada número? En el segundo caso, la intención es cristalina. Y si en el futuro la cuarentena implica también bloquear el acceso al comedor o notificar al médico, ¿dónde pones esa lógica? En el método ponerEnCuarentena(), claro. El código se organiza solo cuando el lenguaje es el correcto.

2. Bounded Contexts (Contextos delimitados)

Aquí viene uno de los conceptos más potentes de DDD y, a la vez, uno de los más malinterpretados. Un Bounded Context (Contexto Delimitado) es básicamente una frontera donde un modelo específico tiene sentido y es coherente.

¿Por qué necesitamos esto? Porque en sistemas grandes, la misma palabra puede significar cosas completamente diferentes dependiendo de quién la use. Y esto no es un error, es natural.

Pongamos un ejemplo del apocalipsis: la palabra "Superviviente".

  • Para el equipo de Logística, es alguien que consume recursos, tiene una ubicación y puede transportar suministros. Les interesa su capacidad de carga y su ruta.
  • Para el equipo de Sanidad, es un o una paciente potencial con un historial médico, un nivel de salud y un riesgo de infección. Les importa su temperatura corporal y si se ha expuesto a mordeduras.
  • Para el equipo de Comando, es una unidad con habilidades específicas que puede asignarse a refugios o misiones. Les interesa su experiencia en combate o sus conocimientos técnicos.

¿Ves el problema? Si intentamos meter todo esto en una única clase Superviviente, acabaremos con un monstruo de 50 propiedades donde la mitad no tienen sentido en cada contexto. Y peor aún, cuando Logística quiera cambiar cómo se calcula la capacidad de carga, podría romper accidentalmente algo en Sanidad.

Dividir para reinar

La solución es dividir nuestro sistema en contextos delimitados, cada uno con su propio modelo:

Contexto de Logística

  • Gestiona rutas de reabastecimiento entre refugios
  • Controla niveles de stock y consumo estimado
  • Calcula costes de transporte y riesgos de las rutas
  • Su Superviviente tiene: ubicación, capacidad de carga, estado de movilidad

Contexto de Sanidad

  • Rastrea infecciones y posibles brotes
  • Gestiona vacunas y tratamientos médicos
  • Monitoriza el estado de salud general
  • Su Superviviente tiene: historial médico, síntomas, nivel de inmunidad

Contexto de Comando

  • Asigna supervivientes a refugios
  • Decide evacuaciones y redistribuciones
  • Planifica misiones y estrategias
  • Su Superviviente tiene: habilidades, experiencia, refugio asignado

Dentro de cada contexto, el modelo y el lenguaje son coherentes y enfocados. No hay propiedades "de más" ni responsabilidades que no correspondan.

Los tres contextos delimitados de nuestro apocalipsis

En la imagen superior podemos ver los tres contextos delimitados de nuestro apocalipsis: logística, sanidad y comando.

Comunicación entre contextos

Pero claro, estos contextos no viven aislados. Cuando Sanidad detecta un brote de infección, Comando necesita saberlo para activar una evacuación. Cuando Logística actualiza el stock de un refugio, Comando debe conocer si hay escasez crítica.

La comunicación entre contextos se hace mediante contratos bien definidos:

  • APIs: interfaces claras que exponen solo lo necesario
  • Eventos de dominio: "Ha ocurrido X" (por ejemplo, SupervivienteInfectado, RefugioReabastecido)
  • Anti-corruption layers: capas que traducen entre los modelos de diferentes contextos, protegiendo a cada uno de los cambios del otro

Por ejemplo, cuando Sanidad emite el evento BroteDetectado, Comando no necesita conocer los detalles médicos internos. Solo recibe la información que le importa: qué refugio está afectado y cuántas personas están en riesgo.

Diagrama de comunicación entre Sanidad, Logística y Comando

Diagrama de comunicación entre Sanidad, Logística y Comando

3. Entidades y Objetos de Valor

Una de las distinciones más importantes en DDD es entender la diferencia entre algo que "es" y algo que "tiene". Suena filosófico, pero tiene implicaciones muy prácticas en cómo diseñamos nuestro código.

Entidad (Entity): lo que importa es quién ES

Una Entidad es algo que tiene una identidad única y continuada en el tiempo, independientemente de cómo cambien sus atributos.

Pensemos en una superviviente llamada Gema. Cuando Gema entra al refugio, tiene 100 puntos de salud y no está infectada. A lo largo de los días, Gema sufre una herida (ahora tiene 80 de salud), luego le curan (recupera a 95), después contrae una leve infección... su estado cambia constantemente. Pero en todo momento seguimos hablando de Gema, la misma superviviente. Su identidad no cambia aunque sus atributos sí lo hagan.

Eso es una Entidad. Lo que importa es quién es, no cómo está.

Características de las Entidades:

  • Tienen un identificador único (ID) que las distingue
  • Su identidad persiste a lo largo del tiempo
  • Pueden cambiar de estado sin dejar de ser ellas mismas
  • Dos entidades con los mismos atributos pero diferente ID son diferentes
    • Gema con 100 de salud ≠ Pedro con 100 de salud (son personas distintas)
// Entidad - Tiene identidad propia a través del ID
class Survivor {
  constructor(
    public readonly id: string, // El ID nunca cambia
    public name: string,
    public health: number
  ) {}

  sufrirHerida(puntos: number): void {
    this.health = Math.max(0, this.health - puntos);
  }

  curar(puntos: number): void {
    this.health = Math.min(100, this.health + puntos);
  }

  // La igualdad se determina por ID, no por atributos
  equals(other: Survivor): boolean {
    return this.id === other.id;
  }
}

const gema = new Survivor("survivor-1", "Gema", 100);
gema.sufrirHerida(20); // salud: 80 → sigue siendo Gema
gema.curar(15);        // salud: 95 → sigue siendo Gema

const otraPersona = new Survivor("survivor-2", "Gema", 95);

// Aunque tengan el mismo nombre y la misma salud, NO son la misma persona
console.log(gema.equals(otraPersona)); // false → diferente ID

Objeto de Valor (Value Object): lo que importa es QUÉ es

Un Objeto de Valor es algo que se define completamente por sus atributos. No tiene identidad propia, simplemente representa un valor.

Pensemos en las coordenadas de un punto de suministro: { lat: 40.4168, lon: -3.7038 }. Estas coordenadas no "son" nadie ni nada. Son simplemente un valor que describe una ubicación. Si mañana tienes otra posición con exactamente la misma latitud y longitud, es la misma coordenada, no importa quién la use o cuándo se creó.

Características de los Objetos de Valor:

  • No tienen identidad propia
  • Se definen completamente por sus atributos
  • Son inmutables: si necesitas cambiarlos, creas uno nuevo
  • Dos objetos de valor con los mismos atributos son idénticos
    • Coordenadas(40.4168, -3.7038) === Coordenadas(40.4168, -3.7038)

Otros ejemplos en nuestro apocalipsis:

  • Suministro: un pack de vendas es idéntico a otro pack de vendas del mismo tipo
  • FechaEvacuacion: el 25 de diciembre de 2026 es el mismo día para todo el mundo
  • CantidadMunicion: 50 balas son 50 balas, no importa quién las cuente
// Value Object - Inmutable
class Coordinates {
  constructor(
    public readonly lat: number,
    public readonly lon: number
  ) {}

  // Comparación por valor, no por referencia
  equals(other: Coordinates): boolean {
    return this.lat === other.lat && this.lon === other.lon;
  }
}

// Si necesitas cambiar las coordenadas, creas unas nuevas
const punto1 = new Coordinates(40.4168, -3.7038);
const punto2 = new Coordinates(41.3851, 2.1734); // Nuevo objeto

// Comparación
console.log(punto1.equals(punto2)); // false
console.log(punto1.equals(new Coordinates(40.4168, -3.7038))); // true

¿Por qué importa esta distinción?

Si confundes Entidades con Objetos de Valor, puedes cometer errores críticos:

  • Tratar una Entidad como Value Object: Si comparas dos supervivientes solo por su salud actual, podrías pensar que son la misma persona. Catastrófico.
  • Tratar un Value Object como Entidad: Si das un ID único a cada conjunto de coordenadas, acabarás con miles de objetos "diferentes" que en realidad representan la misma posición. Desperdicio de memoria y lógica innecesariamente compleja.

La regla simple: si la pregunta "¿es el mismo?" se responde con un ID, es una Entidad. Si se responde comparando valores, es un Value Object.

Entidad vs Value Object

4. Agregados: el guardián de las reglas

Ahora entramos en uno de los conceptos más poderosos de DDD: los Agregados. Si has llegado hasta aquí pensando "vale, ya tengo Entidades y Value Objects, ¿qué más necesito?", prepárate porque los Agregados son lo que realmente mantiene la integridad de tu dominio.

¿Qué es un Agregado?

Un Agregado es un grupo de Entidades y Objetos de Valor que se tratan como una unidad a la hora de aplicar cambios. Dentro de este grupo hay una raíz del agregado (Aggregate Root), que es la única puerta de entrada permitida para modificar cualquier cosa dentro del agregado.

Piénsalo como un refugio con una sola puerta de acceso vigilada. Nadie puede entrar ni salir sin pasar por esa puerta. Nadie puede modificar nada dentro sin que el guardián lo autorice. Ese guardián es la raíz del agregado.

¿Por qué necesitamos esto?

En nuestro apocalipsis zombi, imagina que tenemos un refugio con estas reglas críticas:

  1. Capacidad máxima: Un refugio solo puede albergar un número limitado de supervivientes (si no, se agota el oxígeno, la comida, o simplemente no caben).
  2. Cuarentena obligatoria: Si hay infectados sin cuarentena, no se puede admitir más gente (riesgo de contagio masivo).
  3. Gestión de suministros: Los suministros del refugio deben ser controlados y contabilizados.

Si permitimos que cualquier parte del código pueda modificar directamente la lista de supervivientes o los suministros, ¿quién garantiza que se cumplan estas reglas? La respuesta: nadie. Y en cuanto alguien añade un superviviente sin verificar la capacidad, o asigna suministros sin control, el caos es inevitable.

El Refugio como Agregado

Vamos a modelar Shelter (Refugio) como la raíz del agregado. Todo lo que ocurre con los supervivientes y suministros de ese refugio debe pasar por él:

  • ✅ La raíz (Shelter) expone métodos que verifican las invariantes antes de realizar cambios
  • ✅ Los supervivientes y suministros son privados, nadie puede tocarlos directamente desde fuera
  • ✅ Cada operación (admit(), addSupply()) protege las reglas del negocio
  • ❌ No hay setters públicos ni acceso directo al estado interno
// Value Object - Representa un suministro genérico
// Como es un Value Object, es inmutable (readonly)
class Supply {
  constructor(
    public readonly name: string,
    public readonly amount: number
  ) {}
}

// Entity - Representa un superviviente individual
// Tiene identidad única (id) y puede cambiar de estado
class Survivor {
  constructor(
    public readonly id: string,
    public name: string,
    public health: number
  ) {}
}

// Aggregate Root - La "puerta de entrada" a nuestro agregado
// Es la ÚNICA forma de modificar supervivientes y suministros
export class Shelter {
  // CRÍTICO: Estos arrays son PRIVADOS
  // Nadie fuera de esta clase puede modificarlos directamente
  private survivors: Survivor[] = [];
  private supplies: Supply[] = [];
  private currentCount = 0;

  constructor(
    public readonly id: string,
    public readonly capacity: number  // Invariante: no podemos superarla
  ) {}

  // Método público para admitir supervivientes
  // Aquí es donde protegemos nuestras reglas de negocio
  public admit(s: Survivor): void {
    // INVARIANTE 1: Verificar capacidad ANTES de admitir
    // Esta es la regla que no puede romperse NUNCA
    if (this.currentCount + 1 > this.capacity) {
      throw new Error("Refugio lleno: no podemos admitir más supervivientes");
    }

    // Solo si pasa la verificación, modificamos el estado
    this.survivors.push(s);
    this.currentCount++;

    // Aquí podríamos emitir un evento: SupervivienteAdmitido
  }

  // Método para añadir suministros
  // La lógica de negocio: si ya existe el suministro, sumamos cantidades
  public addSupply(supply: Supply): void {
    const existing = this.supplies.find(x => x.name === supply.name);

    if (existing) {
      // Los Value Objects son inmutables, así que creamos uno nuevo
      const merged = new Supply(existing.name, existing.amount + supply.amount);
      // Reemplazamos el antiguo por el nuevo
      this.supplies = this.supplies.map(x => x === existing ? merged : x);
    } else {
      // Si no existe, lo añadimos directamente
      this.supplies.push(supply);
    }
  }

  // Métodos de consulta: devolvemos COPIAS, no las referencias originales
  // Esto evita que alguien pueda modificar el estado desde fuera
  public getSurvivors(): Survivor[] {
    return [...this.survivors];
  }

  public getSupplies(): Supply[] {
    return [...this.supplies];
  }
}

Veamos cómo funciona esto en la práctica:

// Creamos un refugio con capacidad para 3 supervivientes
const electricShelter = new Shelter("Central Eléctrica Abandonada", 3);

// Admitimos a tres supervivientes sin problema
electricShelter.admit(new Survivor("1", "Pepe", 10));
electricShelter.admit(new Survivor("2", "Juana", 8));
electricShelter.admit(new Survivor("3", "Atolón", 9));

console.log(electricShelter.getSurvivors());
// [
//   Survivor: { "id": "1", "name": "Pepe", "health": 10 },
//   Survivor: { "id": "2", "name": "Juana", "health": 8},
//   Survivor: { "id": "3", "name": "Atolón", "health": 9 }
// ]

// Si intentamos admitir un cuarto superviviente...
// electricShelter.admit(new Survivor("4", "Ariel", 7));
// ❌ Error: "Refugio lleno: no podemos admitir más supervivientes"
// La invariante nos protege de romper la regla

// Añadimos suministros
electricShelter.addSupply(new Supply("vendas", 10));
console.log(electricShelter.getSupplies());
// [Supply: { "name": "vendas", "amount": 10 }]

// Si añadimos más vendas, se suman automáticamente
electricShelter.addSupply(new Supply("vendas", 7));
console.log(electricShelter.getSupplies());
// [Supply: { "name": "vendas", "amount": 17 }]
// Observa que no hay dos entradas de "vendas", se han consolidado

Puntos clave del agregado

Fijémonos en lo que hace que este código sea un buen agregado:

  1. Estado privado: Los arrays survivors y supplies son privados. Imposible modificarlos desde fuera sin pasar por los métodos de la raíz.

  2. Invariantes protegidas: Antes de modificar cualquier estado, verificamos que no rompemos las reglas (capacity). Si la regla se viola, lanzamos un error y el estado permanece intacto.

  3. Métodos con sentido de negocio: No tenemos setSurvivors() ni addSurvivorToArray(). Tenemos admit(), que tiene significado en el lenguaje del dominio.

  4. Copias defensivas: Los getters devuelven copias ([...this.survivors]), no las referencias originales. Esto evita que alguien haga shelter.getSurvivors().push(...) y modifique el estado sin pasar por las validaciones.

  5. Consistencia transaccional: Cuando modificas un agregado, todos los cambios se hacen juntos. O se admite completamente al superviviente (con todas las verificaciones), o no se admite. No hay estados intermedios inválidos.

La siguiente imagen resume la estructura del agregado: Shelter es la raíz, los supervivientes y suministros son internos, y el acceso siempre pasa por los métodos públicos de la raíz:

Diagrama de clases del agregado

Diagrama de clases del agregado: Shelter como raíz, Survivor como Entidad y Supply como Value Object.

Y si lo llevamos al mundo físico del apocalipsis, la analogía es perfecta:

El Refugio como Agregado: el guardián controla quién entra

El combatiente en la puerta es la raíz del agregado. No importa quién intente entrar ni cómo de urgente sea la situación, si el refugio está lleno, nadie entra. Las invariantes se respetan siempre. Y si el camión llega con suministros, también pasa por él antes de que las cajas entren al refugio.

Continuará

En esta primera parte hemos sentado las bases de DDD: el lenguaje ubicuo que elimina traducciones mentales, los Bounded Contexts que dividen el sistema de forma coherente, las Entidades y Value Objects que modelan la identidad y el valor, y los Agregados que protegen las invariantes del dominio.

En la segunda parte veremos cómo conectar todo esto con el exterior: Servicios de Dominio, Eventos, Repositorios y la capa de Aplicación. Además, veremos los antipatterns más comunes y cuándo tiene sentido (y cuándo no) aplicar DDD.

Otros artículos de la serie

  • Parte 2: Servicios de dominio, repositorios, capa de aplicación y eventos de dominio.
  • Parte 3: Sagas, antipatrones y pruebas.
  • Parte 4: Patrón Outbox, consistencia eventual entre agregados, el patrón Snapshot.
  • F.A.Q.: Preguntas frecuentes.
ESTO SIGUE EN EL REFUGIO

Si te has quedado con ganas de más arquitectura, en Domain-Driven Design en un Apocalipsis Zombi lo cuento entero: entidades, agregados, contextos delimitados y un refugio que aguanta cuando el proyecto crece. En tapa blanda y Kindle, y gratis si tienes Kindle Unlimited.

Si quieres seguir por donde lo deja este artículo, en el libro tienes:

  • Capítulo 3, «Mapa de contextos»: quién va aguas arriba y quién aguas abajo, las formas de relacionarse y el mapa completo del refugio.
  • Capítulo 5, «Agregados»: factorías para las construcciones complejas, dónde vive la lógica y cuándo basta una entidad con una lista.