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
- —
- 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.
← → paso · R repetir · Espacio pausa
Aprenderás
- Reconocer un patrón aplicado donde no está su problema. (visto)
- Nombrar los 4 costos de construir por si acaso, según YAGNI. (visto)
- Cambiar un singleton que todos piden por dependencias declaradas. (visto)
- Cambiar una cadena de eventos en círculo por llamadas en orden. (visto)
- Saber cuándo una capa sí se paga y no quitarla. (visto)