YAGNI, KISS y DRY: 3 principios que deberías aplicar siempre

KISS, DRY y YAGNI son tres principios aplicables al diseño y desarrollo de software. Aunque los tratemos juntos en esta entrada, no están relacionados entre sí, más allá de la claridad y simplicidad que transmiten sus mensajes.

YAGNI - You Aren’t Gonna Need It

Este principio se resume en:

No implementes hoy algo que no necesitas hoy.

Es muy común intentar dejar el código “preparado para el futuro”, pero en la práctica ese futuro casi nunca llega o, cuando llega, los requisitos han cambiado.

Sin aplicar YAGNI

class NotificationService {
  sendNotification(
    userId: string,
    options?: {
      byEmail?: boolean;
      bySMS?: boolean;
      byPush?: boolean;
    },
  ) {
    if (options?.byEmail) {
      this.sendEmail(userId);
    }
    if (options?.bySMS) {
      this.sendSMS(userId);
    }
    if (options?.byPush) {
      this.sendPush(userId);
    }
  }
}

Aquí estamos desarrollando tres posibles canales de notificación que nadie ha pedido todavía.

Aplicando YAGNI

class NotificationService {
  sendEmailNotification(userId: string) {
    this.sendEmail(userId);
  }
}

Cuando realmente necesites SMS o Push, los implementas en ese momento.

KISS - Keep It Simple

KISS trata de evitar soluciones innecesariamente complejas.

Cuanto más complejo es el código, más difícil es:

• Entenderlo.
• Testearlo.
• Modificarlo.
• Detectar errores.

Sin KISS

function getFullName(user: { name?: string; surname?: string }): string {
  if (
    user.name !== undefined &&
    user.name !== null &&
    user.surname !== undefined &&
    user.surname !== null
  ) {
    return `${user.name} ${user.surname}`;
  }

  return "";
}

Aplicando KISS

function getFullName(user: { name?: string; surname?: string }): string {
  return `${user.name ?? ""} ${user.surname ?? ""}`.trim();
}

Mismo resultado, menos ruido mental.

DRY - Don’t Repeat Yourself

DRY busca evitar duplicar lógica en distintas partes del sistema.

Cuando repites código:

• Aumentas el riesgo de errores.
• Haces más difícil el mantenimiento.
• Complicas cambios futuros.

Sin aplicar DRY

function calculatePriceWithVAT(price: number): number {
  return price + price * 0.21;
}

function calculateDiscountedPriceWithVAT(price: number): number {
  const discounted = price - 10;
  return discounted + discounted * 0.21;
}

function calculateShippingCostWithVAT(cost: number): number {
  return cost + cost * 0.21;
}

El cálculo del IVA está repetido en varios sitios.

Aplicando DRY

const VAT = 0.21;

function addVAT(amount: number): number {
  return amount * VAT;
}

function calculatePriceWithVAT(price: number): number {
  return price + addVAT(price);
}

function calculateDiscountedPriceWithVAT(price: number): number {
  const discounted = price - 10;
  return discounted + addVAT(discounted);
}

function calculateShippingCostWithVAT(cost: number): number {
  return cost + addVAT(cost);
}

Si mañana el IVA cambia, solo tendrás que modificar un único lugar.

Estos principios son especialmente útiles en proyectos de software a medida, donde cada decisión técnica debe aportar valor real al negocio.