Antipatrones: cuando el patrón hace daño

  • Lección 32 de 32
  • 10 min
  • Intermedio
  • 11 pasos

Los patrones del curso también hacen daño cuando llegan antes que su problema. Vas a reconocer cuatro formas comunes de exceso, cambiarlas por la versión simple y saber cuándo una capa sí vale lo que cuesta.

Tipos para un saludo
—
Dependencias ocultas en place()
—
Orden de los pasos
—
main.tsGreeterFactoryinterfazGreeterFactoryDefaultGreeterFactoryDefaultGreeterFactoryGreeterinterfazMailerinterfazGreeterDefaultGreeterSmtpMailerDefaultGreeterFakeMailerFakeMailergreet()greet()OrdersOrdersAppContextsingletonAppContextPaymentsPaymentsmain.tsCarritoCarritoStockStockCorreoCorreogreeter.greet("Ana")4 tipos para un textomain.ts: un saludo en dos saltosconst factory: GreeterFactory =new DefaultGreeterFactory();const greeter = factory.create();greeter.greet("Ana"); // "Hola, Ana"1 implementación1 implementaciónsiempre DefaultGreeterQué decide cada piezaGreeterinterfaz con 1 implementaciónGreeterFactoryinterfaz con 1 implementaciónDefaultGreeterFactorysiempre crea DefaultGreeterDefaultGreeterarma el textouna funciónLo mismo, con una función+const greet = (name: string) =>+`Hola, ${name}`;+greet("Ana"); // "Hola, Ana"la carga: cada vez que lo lees1 pieza bastabaLos 4 costos de construir por si acaso (Fowler)construiranalizar, programar y probarretrasolo que no entregaste a tiempocargacomplejidad en cada cambioreparaciónarreglar lo que se pensó malAppContext.get() en todos ladosplace(): 0 parámetros, 4 dependenciasOrders depende de un singletonclass Orders {place() {▸const ctx = AppContext.get();ctx.db.save(ctx.cart);ctx.mailer.send(ctx.user);}}crea cada pieza una vezplace(cart, user)Orders declara lo que usaclass Orders {+constructor(private db: Db,+private mailer: Mailer) {}+place(cart: Cart, user: User) {this.db.save(cart);this.mailer.send(user);}}cart.changed otra vezstock.reservedmail.sentTres suscripciones, tres archivos// cart.tsbus.on("mail.sent", refreshCart);// stock.tsbus.on("cart.changed", reserve);// mail.tsbus.on("stock.reserved", sendMail);1. reserva, 2. correoEl orden, en una funciónfunction checkout(cart: Cart) {+reserve(cart);+sendMail(cart);}2 implementaciones realesguarda los correos en los testsUna interfaz que se paga▸interface Mailer { send(to: User): void; }class SmtpMailer implements Mailer { /* SMTP */ }class FakeMailer implements Mailer {sent: User[] = [];send(to: User) { this.sent.push(to); }}Señales de que sobra un patróninterfaz con 1 implementaciónusa la clasefábrica que crea siempre lo mismollama a newsingleton que todos pidenpasa dependenciaseventos que dan la vueltallama en ordenel lenguaje ya lo traeusa una funciónprimero el problemaEl curso en una tablaun patrónuna solución con nombrecreacionalesquién crea los objetosestructuralescómo encajan las piezasde comportamientocómo se reparten el trabajoantipatrónun patrón sin su problemaprimeroel problema, después el patrón
  • petición
  • respuesta
  • evento

Paso 1 de 11

Problema

Cuatro tipos para decir hola

Abres un proyecto y encuentras esto para saludar a un usuario: una interfaz Greeter, una interfaz GreeterFactory, una clase DefaultGreeter y una clase DefaultGreeterFactory. Para obtener «Hola, Ana», main.ts pide una fábrica, la fábrica crea el saludador y recién ahí se saluda.

Son 4 tipos y dos saltos para devolver un texto. Cada pieza es un patrón que viste en el curso, y está bien escrita. El problema no es cómo están hechas: es que ninguna resuelve un problema que exista aquí.

Qué cambió

  • 4 tipos para un saludo

Paso 2 de 11

Concepto

Un patrón sin su problema

Mira qué decide cada pieza. Greeter tiene una sola implementación, y GreeterFactory también. La fábrica siempre devuelve un DefaultGreeter: no elige nada. Factory sirve para decidir qué clase crear; si siempre es la misma, solo agrega un salto.

A esto se le llama antipatrón: una solución que se repite, parece buena y cuesta más de lo que da. Muchas veces no es un mal patrón, sino un buen patrón aplicado donde no está su problema.

Qué cambió

  • las mismas 4 piezas, con lo que decide cada una

Paso 3 de 11

Solución

La versión que hace lo mismo

Todo eso se reemplaza por una función: greet(name) devuelve «Hola, » seguido del nombre. Mismo resultado, 1 pieza en vez de 4, y quien la lee entiende lo que hace sin abrir otros archivos.

Si mañana aparece un segundo saludo de verdad, con otro idioma u otro canal, ahí sí puedes sacar un contrato. Conocer un patrón para cuando haga falta no te obliga a usarlo antes.

Qué cambió

  • GreeterFactory, Greeter y sus clases
  • greet(name)

Paso 4 de 11

Compromiso

Lo que cuesta construir por si acaso

Martin Fowler lo resume con YAGNI («You Aren't Gonna Need It»: no lo vas a necesitar), un lema de Extreme Programming. En su artículo de 2015 separa 4 costos de algo hecho antes de necesitarlo: construirlo, el retraso de lo que no entregaste mientras tanto, la carga de su complejidad sobre cada cambio y la reparación si resulta mal pensado.

Las 4 piezas del saludo cobran la carga cada vez que alguien las lee o las cambia. Ojo con el matiz: Fowler aclara que YAGNI no aplica al trabajo de hacer el código fácil de cambiar, como refactorizar o escribir tests. Eso es justo lo que te permite esperar.

Paso 5 de 11

Problema

El objeto que todos piden

Otro clásico: un singleton AppContext que guarda la base de datos, el carrito, el usuario y el servicio de correo. Orders y Payments lo piden con AppContext.get() desde cualquier método.

place() no recibe nada, pero por dentro usa 4 dependencias del contexto: db, cart, mailer y user. Su firma no lo dice, y para probarla tienes que llenar el singleton entero. Miško Hevery lo puso en el título de un artículo de 2008 del Google Testing Blog: «Singletons are Pathological Liars».

Qué cambió

  • AppContext.get() dentro de cada método

Paso 6 de 11

Solución

Pide lo que usas

Orders recibe db y mailer en su constructor, y place() recibe el carrito y el usuario. main.ts crea cada pieza una vez al arrancar y se la pasa a quien la necesita.

Las dependencias ocultas de place() bajan de 4 a 0: todas están en la firma. En un test pasas un db y un mailer falsos y listo. Es lo que viste en las lecciones de Singleton y de inyección de dependencias, aplicado para desarmar un singleton que creció de más.

Qué cambió

  • AppContext
  • constructor(db, mailer)
  • place(cart, user)

Paso 7 de 11

Problema

Una cadena de eventos que nadie ve entera

Ahora la tienda usa eventos para todo. El carrito emite cart.changed; el stock lo escucha, reserva y emite stock.reserved; el correo lo escucha, envía y emite mail.sent; y el carrito escucha mail.sent para refrescarse… y vuelve a emitir cart.changed.

Cada bus.on(...) vive en un archivo distinto y parece razonable por separado. Juntos forman un ciclo que no termina, y nadie lo ve leyendo un solo archivo. Observer desacopla a quien emite de quien escucha; cuando necesitas un orden fijo de pasos, ese desacople esconde el orden.

Qué cambió

  • 3 suscripciones en 3 archivos

Paso 8 de 11

Solución

Si el orden importa, llama en orden

checkout(cart) llama a reserve(cart) y después a sendMail(cart). El orden ya no está repartido entre suscripciones: se lee de arriba abajo en una función, y si reserve() lanza un error, el correo no sale.

Los eventos siguen siendo útiles cuando a quien emite de verdad no le importa quién escucha, como viste en la lección de Observer. Si un paso depende del anterior, es una llamada, no un evento.

Qué cambió

  • la cadena de eventos
  • checkout(): reserve y luego sendMail

Paso 9 de 11

Compromiso

Cuando la capa sí se paga

No todo contrato con pocas implementaciones sobra. Mailer tiene 2 implementaciones que se usan: SmtpMailer en producción y FakeMailer en los tests, que guarda los correos en una lista en vez de enviarlos.

Esa interfaz se paga sola: sin ella, cada test enviaría correos de verdad. Así que quitar patrones tampoco es siempre bueno. Antes de borrar una capa, busca evidencia: una segunda implementación real, un test que la sustituye o un historial de cambios que pasó por ahí.

Qué cambió

  • Mailer con 2 implementaciones

Paso 10 de 11

Técnica

Señales de que sobra un patrón

Ninguna señal es una regla, pero todas merecen una pregunta: una interfaz con 1 implementación y ningún test que la sustituya, una fábrica que siempre crea la misma clase, un singleton que todos piden y eventos que dan la vuelta hasta su origen.

Otra señal: escribir con clases lo que tu lenguaje ya trae, como viste en «Patrones que tu lenguaje ya trae». Quítalos en pasos pequeños y con los tests en verde, igual que en «Refactorizar hacia un patrón», pero en sentido contrario.

Qué cambió

  • las tres versiones simples, juntas

Paso 11 de 11

Resumen

Primero el problema, después el patrón

Un antipatrón suele ser un buen patrón sin su problema: fábricas que no eligen, interfaces con una sola implementación, singletons que todos piden y eventos que esconden el orden. La versión simple hace lo mismo con menos piezas, y YAGNI te recuerda lo que cuesta cargar las demás.

Con esto cierras el curso. Recorriste los 23 patrones del libro de 1994 y algunos más, con sus casos reales y cuándo no usarlos. Lo que te llevas no es un catálogo para aplicar: es el problema que resuelve cada uno. Cuando lo veas en tu código, ya sabes cómo se llama; cuando no esté, una función basta.

Aprenderás

  • Reconocer un patrón aplicado donde no está su problema.
  • Nombrar los 4 costos de construir por si acaso, según YAGNI.
  • Cambiar un singleton que todos piden por dependencias declaradas.
  • Cambiar una cadena de eventos en círculo por llamadas en orden.
  • Saber cuándo una capa sí se paga y no quitarla.