Los patrones de diseño: el catálogo de respuestas probadas que un arquitecto no reinventa, sino que elige. — Elkin Rodríguez E.
Ya escribieron su ADR. Hoy lo defienden. Tres grupos, cuatro minutos cada uno — sorteo de quiénes.
Tres personas, 60 segundos cada una. Tres cosas y se sientan:
Qué está pegado con qué.
Qué síntoma lo delata.
Qué driver se incumple por eso.
Los drivers: qué exige el negocio.
El estilo: qué va junto y qué separado.
Los patrones: con qué se construye por dentro.
Todo el semestre responde una sola pregunta, bajando de nivel cada semana.
¿Qué es arquitectura? ¿Qué exige el negocio? ¿Qué forma tiene el sistema?
¿Con qué construyo cada parte? El catálogo de soluciones probadas.
¿Cómo lo comunico? ¿Cómo lo evalúo? Y los estilos en profundidad.
Sí, y por eso vuelven tres veces más: microservicios, arquitecturas basadas en eventos y CQRS tienen clase propia más adelante.
| Cuando lleguemos a… | Van a necesitar… |
|---|---|
| Arquitecturas basadas en eventos | Observer / publicador-suscriptor |
| Microservicios en profundidad | Adapter, para las fronteras |
| CQRS | Separación de responsabilidades |
| Implementar cualquier estilo | Strategy e inyección de dependencias |
Es una solución con nombre propio a un problema que aparece una y otra vez al escribir código. Alguien ya lo resolvió, alguien le puso nombre, y ahora todo el mundo lo reconoce.
En 1994, cuatro autores publicaron Design Patterns y catalogaron 23 patrones. Se les conoce como el GoF · Gang of Four
"La banda de los cuatro": apodo de Gamma, Helm, Johnson y Vlissides, autores del libro de 1994. Ese catálogo creó el vocabulario que todavía se usa en entrevistas técnicas y revisiones de código, treinta años después..
Cómo se crean los objetos.
Factory · Singleton
Cómo se conectan las piezas.
Adapter · Decorator
Cómo colaboran entre sí.
Strategy · Observer
| Patrón | Familia | Qué resuelve |
|---|---|---|
| Strategy | Comportamiento | Varias formas de hacer lo mismo |
| Observer | Comportamiento | Avisarle a varios interesados |
| Adapter | Estructural | Usar algo que no controlamos |
| Factory y Singleton | Creacionales | Cómo se crean los objetos |
| Lo que vemos | ¿Patrón GoF? | Qué resuelve |
|---|---|---|
| Inyección de dependencias | No. Es un principio | Que el código se pueda probar |
| Separar responsabilidades | No. Es un principio | Una pieza, una razón de cambio |
La señal: Una cadena de if / elif que crece cada vez que aparece una variante nueva.
Una transportadora cobra distinto según el tipo de envío. Cada temporada logística inventa una modalidad nueva.
Hoy el cálculo vive en una sola función que crece con cada modalidad. El equipo la abre varias veces al año, y cada vez que la abre puede romper una tarifa que ya funcionaba.
def tarifa(tipo, peso):
if tipo == "estandar":
return peso * 3000
elif tipo == "express":
return peso * 5400 + 5000
return 0
print(tarifa("express", 2))
class Estandar:
def calcular(self, peso): return peso * 3000
class Express:
def calcular(self, peso): return peso * 5400 + 5000
class Envio:
def __init__(self, tarifa): self.tarifa = tarifa
def calcular(self, peso): return self.tarifa.calcular(peso)
print(Envio(Express()).calcular(2))
La fórmula de express vive en una rama del ifVive en su propia clase ExpressSaca la decisión de adentro. La clase ya no sabe cuál variante es: solo sabe que lo que recibió tiene el método que necesita.
Cuando entra la modalidad 'programado', se agrega sin abrir lo que ya funcionaba.
Pasa de 1 función a varias clases. Hay que saber dónde vive cada variante. Con dos casos fijos, sobra.
| Si mañana entra la modalidad 'programado'… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | 1 · el que ya funcionaba | 1 · uno nuevo |
| Código existente que se toca | Sí | Ninguno |
| Variantes que se pueden romper | Todas | 0 |
| ¿Se prueba una variante sola? | No | Sí |
| Piezas totales | 1 función | Varias clases |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
15800Un banco calcula intereses distintos por producto. Cada semestre sale un crédito nuevo por resolución.
Hoy el cálculo vive en una sola función que crece con cada resolución. El equipo la abre cuatro veces al año, y cada vez que la abre puede romper un producto que ya funcionaba.
def interes(tipo, capital):
if tipo == "libre":
return capital * 0.022
elif tipo == "vivienda":
return capital * 0.009
return 0
print(interes("vivienda", 100000000))
class Libre:
def calcular(self, capital): return capital * 0.022
class Vivienda:
def calcular(self, capital): return capital * 0.009
class Credito:
def __init__(self, plan): self.plan = plan
def interes(self, capital): return self.plan.calcular(capital)
print(Credito(Vivienda()).interes(100000000))
Cada producto es una rama del ifCada producto es una clase con calcularSaca la decisión de adentro. La clase ya no sabe cuál variante es: solo sabe que lo que recibió tiene el método que necesita.
Cuando entra el crédito educativo, se agrega sin abrir lo que ya funcionaba.
Pasa de 1 función a varias clases. Hay que saber dónde vive cada variante. Con dos casos fijos, sobra.
| Si mañana entra el crédito educativo… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | 1 · el que ya funcionaba | 1 · uno nuevo |
| Código existente que se toca | Sí | Ninguno |
| Variantes que se pueden romper | Todas | 0 |
| ¿Se prueba una variante sola? | No | Sí |
| Piezas totales | 1 función | Varias clases |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
899999.9999999999Un comercio cobra recargo según el medio de pago. Marketing cambia los porcentajes cada temporada.
Cada temporada comercial obliga a entrar al mismo archivo. El código de pagos es el más delicado del sistema y nadie quiere tocarlo por un porcentaje.
def recargo(medio, monto):
if medio == "tarjeta":
return monto * 0.03
elif medio == "pse":
return 1500
return 0
print(recargo("tarjeta", 200000))
class Tarjeta:
def calcular(self, monto): return monto * 0.03
class Pse:
def calcular(self, monto): return 1500
class Pago:
def __init__(self, medio): self.medio = medio
def recargo(self, monto): return self.medio.calcular(monto)
print(Pago(Tarjeta()).recargo(200000))
Cambiar el recargo obliga a editar la funciónCambiar el recargo toca una sola claseSaca la decisión de adentro. La clase ya no sabe cuál variante es: solo sabe que lo que recibió tiene el método que necesita.
Cuando entra el recargo de Nequi, se agrega sin abrir lo que ya funcionaba.
Pasa de 1 función a varias clases. Hay que saber dónde vive cada variante. Con dos casos fijos, sobra.
| Si mañana entra el recargo de Nequi… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | 1 · el que ya funcionaba | 1 · uno nuevo |
| Código existente que se toca | Sí | Ninguno |
| Variantes que se pueden romper | Todas | 0 |
| ¿Se prueba una variante sola? | No | Sí |
| Piezas totales | 1 función | Varias clases |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
6000.0Un sistema exporta datos en varios formatos. Ya pidieron JSON y XML para el próximo trimestre.
Cada formato nuevo se mete en la misma función, que ya tiene cuatro ramas y nadie recuerda quién escribió la primera.
def exportar(formato, datos):
if formato == "csv":
return ",".join(datos)
elif formato == "texto":
return " | ".join(datos)
return ""
print(exportar("csv", ["ana", "luis"]))
class Csv:
def armar(self, datos): return ",".join(datos)
class Texto:
def armar(self, datos): return " | ".join(datos)
class Exportador:
def __init__(self, formato): self.formato = formato
def exportar(self, datos): return self.formato.armar(datos)
print(Exportador(Csv()).exportar(["ana", "luis"]))
Agregar JSON = otra rama del ifAgregar JSON = una clase nueva, sin tocar nadaSaca la decisión de adentro. La clase ya no sabe cuál variante es: solo sabe que lo que recibió tiene el método que necesita.
Cuando piden exportar a JSON, se agrega sin abrir lo que ya funcionaba.
Pasa de 1 función a varias clases. Hay que saber dónde vive cada variante. Con dos casos fijos, sobra.
| Si mañana piden exportar a JSON… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | 1 · el que ya funcionaba | 1 · uno nuevo |
| Código existente que se toca | Sí | Ninguno |
| Variantes que se pueden romper | Todas | 0 |
| ¿Se prueba una variante sola? | No | Sí |
| Piezas totales | 1 función | Varias clases |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
ana,luisCada facultad pondera parcial y taller distinto, y lo cambian por consejo académico.
Cada consejo académico cambia una ponderación, y el cambio obliga a tocar el archivo donde viven todas las demás.
def nota(esquema, parcial, taller):
if esquema == "practico":
return parcial * 0.4 + taller * 0.6
elif esquema == "teorico":
return parcial * 0.7 + taller * 0.3
return 0
print(nota("practico", 3.0, 4.5))
class Practico:
def calcular(self, p, t): return p * 0.4 + t * 0.6
class Teorico:
def calcular(self, p, t): return p * 0.7 + t * 0.3
class Curso:
def __init__(self, esquema): self.esquema = esquema
def nota(self, p, t): return self.esquema.calcular(p, t)
print(Curso(Practico()).nota(3.0, 4.5))
La ponderación está mezclada con la lógicaCada esquema de ponderación es una claseSaca la decisión de adentro. La clase ya no sabe cuál variante es: solo sabe que lo que recibió tiene el método que necesita.
Cuando una facultad cambia su ponderación, se agrega sin abrir lo que ya funcionaba.
Pasa de 1 función a varias clases. Hay que saber dónde vive cada variante. Con dos casos fijos, sobra.
| Si mañana una facultad cambia su ponderación… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | 1 · el que ya funcionaba | 1 · uno nuevo |
| Código existente que se toca | Sí | Ninguno |
| Variantes que se pueden romper | Todas | 0 |
| ¿Se prueba una variante sola? | No | Sí |
| Piezas totales | 1 función | Varias clases |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
3.9Colombia tiene cédula, NIT, cédula de extranjería y pasaporte. Cada uno valida distinto.
La función de validación creció con cada tipo de documento y hoy nadie se atreve a tocarla sin revisar los otros tres.
def valido(tipo, numero):
if tipo == "cc":
return numero.isdigit() and len(numero) >= 6
elif tipo == "nit":
return numero.isdigit() and len(numero) == 9
return False
print(valido("nit", "900123456"))
class Cedula:
def valido(self, n): return n.isdigit() and len(n) >= 6
class Nit:
def valido(self, n): return n.isdigit() and len(n) == 9
class Documento:
def __init__(self, regla): self.regla = regla
def valido(self, n): return self.regla.valido(n)
print(Documento(Nit()).valido("900123456"))
Todas las reglas en la misma funciónUna clase por tipo de documentoSaca la decisión de adentro. La clase ya no sabe cuál variante es: solo sabe que lo que recibió tiene el método que necesita.
Cuando hay que validar pasaporte, se agrega sin abrir lo que ya funcionaba.
Pasa de 1 función a varias clases. Hay que saber dónde vive cada variante. Con dos casos fijos, sobra.
| Si mañana hay que validar pasaporte… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | 1 · el que ya funcionaba | 1 · uno nuevo |
| Código existente que se toca | Sí | Ninguno |
| Variantes que se pueden romper | Todas | 0 |
| ¿Se prueba una variante sola? | No | Sí |
| Piezas totales | 1 función | Varias clases |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
TrueEl criterio para ordenar el catálogo cambia según la campaña comercial.
Mercadeo cambia el criterio en cada campaña y desarrollo termina editando la misma función una y otra vez.
def ordenar(criterio, items):
if criterio == "precio":
return sorted(items, key=lambda x: x[1])
elif criterio == "nombre":
return sorted(items, key=lambda x: x[0])
return items
print(ordenar("precio", [("pan", 3000), ("agua", 1500)]))
class PorPrecio:
def ordenar(self, items): return sorted(items, key=lambda x: x[1])
class PorNombre:
def ordenar(self, items): return sorted(items, key=lambda x: x[0])
class Catalogo:
def __init__(self, criterio): self.criterio = criterio
def listar(self, items): return self.criterio.ordenar(items)
print(Catalogo(PorPrecio()).listar([("pan", 3000), ("agua", 1500)]))
El criterio está escrito adentroEl criterio se pasa desde afueraSaca la decisión de adentro. La clase ya no sabe cuál variante es: solo sabe que lo que recibió tiene el método que necesita.
Cuando quieren ordenar por popularidad, se agrega sin abrir lo que ya funcionaba.
Pasa de 1 función a varias clases. Hay que saber dónde vive cada variante. Con dos casos fijos, sobra.
| Si mañana quieren ordenar por popularidad… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | 1 · el que ya funcionaba | 1 · uno nuevo |
| Código existente que se toca | Sí | Ninguno |
| Variantes que se pueden romper | Todas | 0 |
| ¿Se prueba una variante sola? | No | Sí |
| Piezas totales | 1 función | Varias clases |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
[('agua', 1500), ('pan', 3000)]La señal: Un método que llama uno por uno a varios módulos que no le importan.
Un termostato industrial. Cuando cambia la temperatura, la pantalla y el registro deben enterarse.
Cada vez que operaciones pide un aviso nuevo hay que entrar al código del termostato, que es lo más delicado del equipo.
class Termostato:
def cambiar(self, grados):
return [f"pantalla:{grados}", f"registro:{grados}"]
print(Termostato().cambiar(22))
class Pantalla:
def actualizar(self, g): return f"pantalla:{g}"
class Registro:
def actualizar(self, g): return f"registro:{g}"
class Termostato:
def __init__(self): self.obs = []
def registrar(self, o): self.obs.append(o)
def cambiar(self, g): return [o.actualizar(g) for o in self.obs]
t = Termostato(); t.registrar(Pantalla()); t.registrar(Registro())
print(t.cambiar(22))
El termostato tiene los nombres escritosEl termostato solo recorre una listaReemplaza los nombres fijos por una lista. El emisor ya no sabe a quién le avisa, solo recorre a los que se registraron.
Cuando hay que avisar también al celular del técnico, se agrega sin abrir lo que ya funcionaba.
Leyendo el emisor ya no se sabe qué pasa. Depurar cuesta más y el orden no está garantizado.
| Si mañana hay que avisar también al celular del técnico… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | 1 · el emisor | 1 · uno nuevo |
| Código existente que se toca | Sí | Ninguno |
| Si un interesado falla… | Puede tumbar el método | Los demás siguen |
| ¿Se prueba un interesado solo? | No | Sí |
| ¿Se sabe qué pasa leyendo el emisor? | Sí | No · ese es el costo |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
['pantalla:22', 'registro:22']Un marcador de estadio. Cada gol dispara tablero, sonido y estadísticas.
El marcador es el módulo que corre en vivo durante el partido. Tocarlo para agregar un aviso es riesgoso a esa hora.
class Marcador:
def gol(self, equipo):
return [f"tablero:{equipo}", f"sonido:{equipo}"]
print(Marcador().gol("local"))
class Tablero:
def actualizar(self, e): return f"tablero:{e}"
class Sonido:
def actualizar(self, e): return f"sonido:{e}"
class Marcador:
def __init__(self): self.obs = []
def registrar(self, o): self.obs.append(o)
def gol(self, e): return [o.actualizar(e) for o in self.obs]
m = Marcador(); m.registrar(Tablero()); m.registrar(Sonido())
print(m.gol("local"))
El marcador conoce tablero y sonidoEl marcador no sabe quién escuchaReemplaza los nombres fijos por una lista. El emisor ya no sabe a quién le avisa, solo recorre a los que se registraron.
Cuando piden publicar el gol en redes, se agrega sin abrir lo que ya funcionaba.
Leyendo el emisor ya no se sabe qué pasa. Depurar cuesta más y el orden no está garantizado.
| Si mañana piden publicar el gol en redes… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | 1 · el emisor | 1 · uno nuevo |
| Código existente que se toca | Sí | Ninguno |
| Si un interesado falla… | Puede tumbar el método | Los demás siguen |
| ¿Se prueba un interesado solo? | No | Sí |
| ¿Se sabe qué pasa leyendo el emisor? | Sí | No · ese es el costo |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
['tablero:local', 'sonido:local']Un carrito de compras. Al agregar un producto se actualizan el total y el contador del ícono.
El carrito es de los módulos más usados de la tienda. Cada cambio de interfaz obliga a modificarlo.
class Carrito:
def agregar(self, precio):
return [f"total:{precio}", f"contador:1"]
print(Carrito().agregar(5000))
class Total:
def actualizar(self, p): return f"total:{p}"
class Contador:
def actualizar(self, p): return "contador:1"
class Carrito:
def __init__(self): self.obs = []
def registrar(self, o): self.obs.append(o)
def agregar(self, p): return [o.actualizar(p) for o in self.obs]
c = Carrito(); c.registrar(Total()); c.registrar(Contador())
print(c.agregar(5000))
El carrito llama a total y contadorEl carrito publica y sigue su vidaReemplaza los nombres fijos por una lista. El emisor ya no sabe a quién le avisa, solo recorre a los que se registraron.
Cuando agregan un banner de envío gratis, se agrega sin abrir lo que ya funcionaba.
Leyendo el emisor ya no se sabe qué pasa. Depurar cuesta más y el orden no está garantizado.
| Si mañana agregan un banner de envío gratis… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | 1 · el emisor | 1 · uno nuevo |
| Código existente que se toca | Sí | Ninguno |
| Si un interesado falla… | Puede tumbar el método | Los demás siguen |
| ¿Se prueba un interesado solo? | No | Sí |
| ¿Se sabe qué pasa leyendo el emisor? | Sí | No · ese es el costo |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
['total:5000', 'contador:1']Un sensor de puerta en una bodega. Si se abre fuera de horario hay que avisar a varios sistemas.
Seguridad pide un aviso nuevo casi cada mes y desarrollo termina editando el sensor cada vez.
class Puerta:
def abrir(self, hora):
return [f"alarma:{hora}", f"bitacora:{hora}"]
print(Puerta().abrir("23:40"))
class Alarma:
def actualizar(self, h): return f"alarma:{h}"
class Bitacora:
def actualizar(self, h): return f"bitacora:{h}"
class Puerta:
def __init__(self): self.obs = []
def registrar(self, o): self.obs.append(o)
def abrir(self, h): return [o.actualizar(h) for o in self.obs]
p = Puerta(); p.registrar(Alarma()); p.registrar(Bitacora())
print(p.abrir("23:40"))
Agregar un aviso obliga a tocar el sensorAgregar un aviso no toca el sensorReemplaza los nombres fijos por una lista. El emisor ya no sabe a quién le avisa, solo recorre a los que se registraron.
Cuando piden avisar por WhatsApp a celaduría, se agrega sin abrir lo que ya funcionaba.
Leyendo el emisor ya no se sabe qué pasa. Depurar cuesta más y el orden no está garantizado.
| Si mañana piden avisar por WhatsApp a celaduría… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | 1 · el emisor | 1 · uno nuevo |
| Código existente que se toca | Sí | Ninguno |
| Si un interesado falla… | Puede tumbar el método | Los demás siguen |
| ¿Se prueba un interesado solo? | No | Sí |
| ¿Se sabe qué pasa leyendo el emisor? | Sí | No · ese es el costo |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
['alarma:23:40', 'bitacora:23:40']Cambiar el precio de un producto afecta la etiqueta en tienda y el historial de precios.
Comercial cambia los efectos de un cambio de precio con frecuencia, y todo desemboca en la misma clase.
class Producto:
def cambiar_precio(self, nuevo):
return [f"etiqueta:{nuevo}", f"historial:{nuevo}"]
print(Producto().cambiar_precio(12000))
class Etiqueta:
def actualizar(self, v): return f"etiqueta:{v}"
class Historial:
def actualizar(self, v): return f"historial:{v}"
class Producto:
def __init__(self): self.obs = []
def registrar(self, o): self.obs.append(o)
def cambiar_precio(self, v): return [o.actualizar(v) for o in self.obs]
p = Producto(); p.registrar(Etiqueta()); p.registrar(Historial())
print(p.cambiar_precio(12000))
El producto conoce etiqueta e historialEl producto solo anuncia el cambioReemplaza los nombres fijos por una lista. El emisor ya no sabe a quién le avisa, solo recorre a los que se registraron.
Cuando piden avisar al comparador de precios, se agrega sin abrir lo que ya funcionaba.
Leyendo el emisor ya no se sabe qué pasa. Depurar cuesta más y el orden no está garantizado.
| Si mañana piden avisar al comparador de precios… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | 1 · el emisor | 1 · uno nuevo |
| Código existente que se toca | Sí | Ninguno |
| Si un interesado falla… | Puede tumbar el método | Los demás siguen |
| ¿Se prueba un interesado solo? | No | Sí |
| ¿Se sabe qué pasa leyendo el emisor? | Sí | No · ese es el costo |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
['etiqueta:12000', 'historial:12000']Un tanque de agua. Al llegar al mínimo se prende la bomba y se enciende el indicador.
El tanque controla equipo físico. Cada modificación exige una parada de planta para probar.
class Tanque:
def medir(self, nivel):
return [f"bomba:{nivel}", f"indicador:{nivel}"]
print(Tanque().medir(15))
class Bomba:
def actualizar(self, n): return f"bomba:{n}"
class Indicador:
def actualizar(self, n): return f"indicador:{n}"
class Tanque:
def __init__(self): self.obs = []
def registrar(self, o): self.obs.append(o)
def medir(self, n): return [o.actualizar(n) for o in self.obs]
t = Tanque(); t.registrar(Bomba()); t.registrar(Indicador())
print(t.medir(15))
El tanque llama a bomba e indicadorEl tanque notifica a su listaReemplaza los nombres fijos por una lista. El emisor ya no sabe a quién le avisa, solo recorre a los que se registraron.
Cuando piden registrar el evento en la nube, se agrega sin abrir lo que ya funcionaba.
Leyendo el emisor ya no se sabe qué pasa. Depurar cuesta más y el orden no está garantizado.
| Si mañana piden registrar el evento en la nube… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | 1 · el emisor | 1 · uno nuevo |
| Código existente que se toca | Sí | Ninguno |
| Si un interesado falla… | Puede tumbar el método | Los demás siguen |
| ¿Se prueba un interesado solo? | No | Sí |
| ¿Se sabe qué pasa leyendo el emisor? | Sí | No · ese es el costo |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
['bomba:15', 'indicador:15']La campana de la universidad. Al terminar la hora hay que avisar a salones y tableros.
La campana es un servicio que corre todo el día. Cada cambio implica un despliegue en horario de clases.
class Campana:
def sonar(self, hora):
return [f"salones:{hora}", f"tableros:{hora}"]
print(Campana().sonar("10:00"))
class Salones:
def actualizar(self, h): return f"salones:{h}"
class Tableros:
def actualizar(self, h): return f"tableros:{h}"
class Campana:
def __init__(self): self.obs = []
def registrar(self, o): self.obs.append(o)
def sonar(self, h): return [o.actualizar(h) for o in self.obs]
c = Campana(); c.registrar(Salones()); c.registrar(Tableros())
print(c.sonar("10:00"))
La campana conoce a cada receptorLa campana recorre observadoresReemplaza los nombres fijos por una lista. El emisor ya no sabe a quién le avisa, solo recorre a los que se registraron.
Cuando piden avisar a la app de estudiantes, se agrega sin abrir lo que ya funcionaba.
Leyendo el emisor ya no se sabe qué pasa. Depurar cuesta más y el orden no está garantizado.
| Si mañana piden avisar a la app de estudiantes… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | 1 · el emisor | 1 · uno nuevo |
| Código existente que se toca | Sí | Ninguno |
| Si un interesado falla… | Puede tumbar el método | Los demás siguen |
| ¿Se prueba un interesado solo? | No | Sí |
| ¿Se sabe qué pasa leyendo el emisor? | Sí | No · ese es el costo |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
['salones:10:00', 'tableros:10:00']La señal: El nombre de un proveedor externo aparece regado por todo el sistema.
Se integra un proveedor de SMS. Su librería usa nombres en inglés y devuelve códigos HTTP.
El nombre del proveedor y su formato quedaron regados por el sistema. El contrato se renegocia cada dos años.
class ProveedorSMS:
def send_text(self, phone, body):
return {"code": 200, "to": phone}
print(ProveedorSMS().send_text("+57300111", "hola")["code"] == 200)
class ProveedorSMS:
def send_text(self, phone, body):
return {"code": 200, "to": phone}
class Mensajeria:
def __init__(self, prov): self.p = prov
def enviar(self, celular, texto):
return self.p.send_text(celular, texto)["code"] == 200
print(Mensajeria(ProveedorSMS()).enviar("+57300111", "hola"))
El sistema conoce send_text y códigosEl sistema solo conoce enviarPone una frontera. Solo el adaptador habla el idioma del proveedor; el resto del sistema habla el del negocio.
Cuando la empresa cambia de proveedor de SMS, se agrega sin abrir lo que ya funcionaba.
Una clase más de intermediación. Si el proveedor ofrece algo que la interfaz no expone, hay que ampliarla.
| Si mañana la empresa cambia de proveedor de SMS… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | Todos los que lo usan | 1 · el adaptador |
| ¿En qué idioma piensa el sistema? | El del proveedor | El del negocio |
| Riesgo de equivocarse al convertir | En cada lugar | En uno solo |
| ¿Se prueba sin llamar al proveedor? | No | Sí |
| Piezas totales | Las que ya había | Una clase más |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
TrueUn servicio de clima devuelve grados Fahrenheit. En Colombia se trabaja en Celsius.
La fórmula de conversión está copiada en cada pantalla que muestra clima, y ya hubo un error por copiarla mal.
class ApiClima:
def get_temp(self, city): return 68.0
print(round((ApiClima().get_temp("Bogota") - 32) * 5 / 9, 1))
class ApiClima:
def get_temp(self, city): return 68.0
class Clima:
def __init__(self, api): self.api = api
def temperatura(self, ciudad):
return round((self.api.get_temp(ciudad) - 32) * 5 / 9, 1)
print(Clima(ApiClima()).temperatura("Bogota"))
La fórmula de conversión, repetidaLa conversión vive en un solo sitioPone una frontera. Solo el adaptador habla el idioma del proveedor; el resto del sistema habla el del negocio.
Cuando el servicio empieza a devolver Celsius, se agrega sin abrir lo que ya funcionaba.
Una clase más de intermediación. Si el proveedor ofrece algo que la interfaz no expone, hay que ampliarla.
| Si mañana el servicio empieza a devolver Celsius… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | Todos los que lo usan | 1 · el adaptador |
| ¿En qué idioma piensa el sistema? | El del proveedor | El del negocio |
| Riesgo de equivocarse al convertir | En cada lugar | En uno solo |
| ¿Se prueba sin llamar al proveedor? | No | Sí |
| Piezas totales | Las que ya había | Una clase más |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
20.0Una API de mapas responde distancias en metros. El negocio habla en kilómetros.
La división entre mil aparece en cada módulo que muestra distancias, y en uno quedó mal.
class ApiMapas:
def distance(self, a, b): return 15400
print(round(ApiMapas().distance("A", "B") / 1000, 2))
class ApiMapas:
def distance(self, a, b): return 15400
class Mapas:
def __init__(self, api): self.api = api
def distancia_km(self, a, b):
return round(self.api.distance(a, b) / 1000, 2)
print(Mapas(ApiMapas()).distancia_km("A", "B"))
Cada llamada divide entre 1000El adaptador entrega kilómetrosPone una frontera. Solo el adaptador habla el idioma del proveedor; el resto del sistema habla el del negocio.
Cuando se cambia de proveedor de mapas, se agrega sin abrir lo que ya funcionaba.
Una clase más de intermediación. Si el proveedor ofrece algo que la interfaz no expone, hay que ampliarla.
| Si mañana se cambia de proveedor de mapas… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | Todos los que lo usan | 1 · el adaptador |
| ¿En qué idioma piensa el sistema? | El del proveedor | El del negocio |
| Riesgo de equivocarse al convertir | En cada lugar | En uno solo |
| ¿Se prueba sin llamar al proveedor? | No | Sí |
| Piezas totales | Las que ya había | Una clase más |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
15.4El sistema operativo entrega la hora como un número enorme. Queremos una fecha legible.
El cálculo de la fecha está repetido y en dos módulos da resultados distintos.
class RelojSO:
def epoch(self): return 1770000000
print("2026-02-" + str(1770000000 % 100))
class RelojSO:
def epoch(self): return 1770000000
class Reloj:
def __init__(self, so): self.so = so
def fecha(self):
return "2026-02-" + str(self.so.epoch() % 100)
print(Reloj(RelojSO()).fecha())
El cálculo de fecha, repetidoUna sola clase traducePone una frontera. Solo el adaptador habla el idioma del proveedor; el resto del sistema habla el del negocio.
Cuando cambia la forma de leer la hora, se agrega sin abrir lo que ya funcionaba.
Una clase más de intermediación. Si el proveedor ofrece algo que la interfaz no expone, hay que ampliarla.
| Si mañana cambia la forma de leer la hora… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | Todos los que lo usan | 1 · el adaptador |
| ¿En qué idioma piensa el sistema? | El del proveedor | El del negocio |
| Riesgo de equivocarse al convertir | En cada lugar | En uno solo |
| ¿Se prueba sin llamar al proveedor? | No | Sí |
| Piezas totales | Las que ya había | Una clase más |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
2026-02-0Un sistema heredado entrega los datos como texto separado por punto y coma.
Todos los módulos parsean el texto crudo del sistema viejo, y cada uno lo hace un poco distinto.
class LectorLegado:
def read_line(self): return "ana;luis;pedro"
print(LectorLegado().read_line().split(";"))
class LectorLegado:
def read_line(self): return "ana;luis;pedro"
class Lector:
def __init__(self, legado): self.l = legado
def nombres(self):
return self.l.read_line().split(";")
print(Lector(LectorLegado()).nombres())
Todos parsean el texto crudoSolo el adaptador conoce el formatoPone una frontera. Solo el adaptador habla el idioma del proveedor; el resto del sistema habla el del negocio.
Cuando el sistema viejo cambia el separador, se agrega sin abrir lo que ya funcionaba.
Una clase más de intermediación. Si el proveedor ofrece algo que la interfaz no expone, hay que ampliarla.
| Si mañana el sistema viejo cambia el separador… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | Todos los que lo usan | 1 · el adaptador |
| ¿En qué idioma piensa el sistema? | El del proveedor | El del negocio |
| Riesgo de equivocarse al convertir | En cada lugar | En uno solo |
| ¿Se prueba sin llamar al proveedor? | No | Sí |
| Piezas totales | Las que ya había | Una clase más |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
['ana', 'luis', 'pedro']Una pasarela de pagos cobra en centavos. El comercio piensa en pesos.
El multiplicar por cien aparece en once lugares. Un error ahí cobra cien veces de más.
class Pasarela:
def do_charge(self, cents, token):
return {"status": "OK"}
print(Pasarela().do_charge(50000 * 100, "tok")["status"] == "OK")
class Pasarela:
def do_charge(self, cents, token):
return {"status": "OK"}
class Pagos:
def __init__(self, pas): self.p = pas
def cobrar(self, pesos, tarjeta):
return self.p.do_charge(pesos * 100, tarjeta)["status"] == "OK"
print(Pagos(Pasarela()).cobrar(50000, "tok"))
El * 100 está en once lugaresEl * 100 está en uno soloPone una frontera. Solo el adaptador habla el idioma del proveedor; el resto del sistema habla el del negocio.
Cuando la empresa cambia de pasarela, se agrega sin abrir lo que ya funcionaba.
Una clase más de intermediación. Si el proveedor ofrece algo que la interfaz no expone, hay que ampliarla.
| Si mañana la empresa cambia de pasarela… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | Todos los que lo usan | 1 · el adaptador |
| ¿En qué idioma piensa el sistema? | El del proveedor | El del negocio |
| Riesgo de equivocarse al convertir | En cada lugar | En uno solo |
| ¿Se prueba sin llamar al proveedor? | No | Sí |
| Piezas totales | Las que ya había | Una clase más |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
TrueUna impresora antigua solo entiende comandos crudos de dos letras.
Cada módulo arma los comandos a mano y ya hubo recibos impresos con basura.
class ImpresoraVieja:
def cmd(self, code, data): return f"{code}:{data}"
print(ImpresoraVieja().cmd("PRN", "recibo 001"))
class ImpresoraVieja:
def cmd(self, code, data): return f"{code}:{data}"
class Impresora:
def __init__(self, vieja): self.v = vieja
def imprimir(self, texto):
return self.v.cmd("PRN", texto)
print(Impresora(ImpresoraVieja()).imprimir("recibo 001"))
Cada módulo arma comandosEl adaptador arma el comandoPone una frontera. Solo el adaptador habla el idioma del proveedor; el resto del sistema habla el del negocio.
Cuando llega una impresora nueva, se agrega sin abrir lo que ya funcionaba.
Una clase más de intermediación. Si el proveedor ofrece algo que la interfaz no expone, hay que ampliarla.
| Si mañana llega una impresora nueva… | Antes | Después |
|---|---|---|
| Archivos que hay que abrir | Todos los que lo usan | 1 · el adaptador |
| ¿En qué idioma piensa el sistema? | El del proveedor | El del negocio |
| Riesgo de equivocarse al convertir | En cada lugar | En uno solo |
| ¿Se prueba sin llamar al proveedor? | No | Sí |
| Piezas totales | Las que ya había | Una clase más |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
PRN:recibo 001La señal: El mismo if de creación aparece copiado en varios archivos.
Un sistema genera reportes en PDF o Excel. La decisión de cuál crear está repetida en varios archivos.
La misma decisión está copiada en cinco archivos. Cuando cambió la regla, dos quedaron desactualizados.
if de creación aparece copiado en muchos sitios.class ReportePDF:
def generar(self): return "PDF listo"
class ReporteExcel:
def generar(self): return "Excel listo"
tipo = "pdf"
r = ReportePDF() if tipo == "pdf" else ReporteExcel()
print(r.generar())
class ReportePDF:
def generar(self): return "PDF listo"
class ReporteExcel:
def generar(self): return "Excel listo"
class FabricaReportes:
def crear(self, tipo):
return ReportePDF() if tipo == "pdf" else ReporteExcel()
print(FabricaReportes().crear("pdf").generar())
El if de creación, repetidoUn solo lugar decide qué crearConcentra la decisión. Quien usa el objeto ya no decide cuál crear: lo pide y lo recibe.
Cuando agregan el reporte en CSV, se agrega sin abrir lo que ya funcionaba.
Una clase más y un salto de lectura. Si solo hay una cosa que crear, la fábrica sobra.
| Si mañana agregan el reporte en CSV… | Antes | Después |
|---|---|---|
| Lugares donde se decide qué crear | Varios · copiados | 1 |
| Riesgo de que queden desalineados | Alto | Ninguno |
| Código existente que se toca | Todos los sitios | Solo la fábrica |
| ¿Quien lo usa sabe cómo se crea? | Sí · y no debería | No |
| Piezas totales | Las que ya había | Una clase más |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
PDF listoSe notifica por correo o por SMS según la preferencia del usuario. Cada módulo repite la elección.
Cada módulo repite la elección del canal, y cuando se agregó WhatsApp hubo que buscarlos todos.
class PorCorreo:
def enviar(self): return "correo enviado"
class PorSMS:
def enviar(self): return "sms enviado"
canal = "sms"
n = PorCorreo() if canal == "correo" else PorSMS()
print(n.enviar())
class PorCorreo:
def enviar(self): return "correo enviado"
class PorSMS:
def enviar(self): return "sms enviado"
class FabricaNotificador:
def crear(self, canal):
return PorCorreo() if canal == "correo" else PorSMS()
print(FabricaNotificador().crear("sms").enviar())
Cada módulo elige el canalLa fábrica elige el canalConcentra la decisión. Quien usa el objeto ya no decide cuál crear: lo pide y lo recibe.
Cuando agregan notificación push, se agrega sin abrir lo que ya funcionaba.
Una clase más y un salto de lectura. Si solo hay una cosa que crear, la fábrica sobra.
| Si mañana agregan notificación push… | Antes | Después |
|---|---|---|
| Lugares donde se decide qué crear | Varios · copiados | 1 |
| Riesgo de que queden desalineados | Alto | Ninguno |
| Código existente que se toca | Todos los sitios | Solo la fábrica |
| ¿Quien lo usa sabe cómo se crea? | Sí · y no debería | No |
| Piezas totales | Las que ya había | Una clase más |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
sms enviadoUn domicilio se asigna a moto, bici o carro según la distancia. La regla se repite en tres pantallas.
La regla de kilómetros está copiada en tres pantallas y ya no coinciden entre sí.
class Moto:
def nombre(self): return "moto"
class Bici:
def nombre(self): return "bici"
km = 8
v = Bici() if km < 3 else Moto()
print(v.nombre())
class Moto:
def nombre(self): return "moto"
class Bici:
def nombre(self): return "bici"
class FabricaVehiculo:
def crear(self, km):
return Bici() if km < 3 else Moto()
print(FabricaVehiculo().crear(8).nombre())
La regla de km, repetidaLa regla vive en la fábricaConcentra la decisión. Quien usa el objeto ya no decide cuál crear: lo pide y lo recibe.
Cuando agregan domicilio en camioneta, se agrega sin abrir lo que ya funcionaba.
Una clase más y un salto de lectura. Si solo hay una cosa que crear, la fábrica sobra.
| Si mañana agregan domicilio en camioneta… | Antes | Después |
|---|---|---|
| Lugares donde se decide qué crear | Varios · copiados | 1 |
| Riesgo de que queden desalineados | Alto | Ninguno |
| Código existente que se toca | Todos los sitios | Solo la fábrica |
| ¿Quien lo usa sabe cómo se crea? | Sí · y no debería | No |
| Piezas totales | Las que ya había | Una clase más |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
motoDistintos ambientes usan motores de base de datos distintos.
Cada capa decide el motor por su cuenta, y en pruebas se conectan a la base equivocada.
class Postgres:
def conectar(self): return "postgres ok"
class SqlServer:
def conectar(self): return "sqlserver ok"
motor = "postgres"
c = Postgres() if motor == "postgres" else SqlServer()
print(c.conectar())
class Postgres:
def conectar(self): return "postgres ok"
class SqlServer:
def conectar(self): return "sqlserver ok"
class FabricaConexion:
def crear(self, motor):
return Postgres() if motor == "postgres" else SqlServer()
print(FabricaConexion().crear("postgres").conectar())
Cada capa decide el motorLa fábrica decide el motorConcentra la decisión. Quien usa el objeto ya no decide cuál crear: lo pide y lo recibe.
Cuando se migra a otro motor, se agrega sin abrir lo que ya funcionaba.
Una clase más y un salto de lectura. Si solo hay una cosa que crear, la fábrica sobra.
| Si mañana se migra a otro motor… | Antes | Después |
|---|---|---|
| Lugares donde se decide qué crear | Varios · copiados | 1 |
| Riesgo de que queden desalineados | Alto | Ninguno |
| Código existente que se toca | Todos los sitios | Solo la fábrica |
| ¿Quien lo usa sabe cómo se crea? | Sí · y no debería | No |
| Piezas totales | Las que ya había | Una clase más |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
postgres okCada rol de usuario tiene permisos distintos, y el objeto se crea en varios sitios.
El rol se decide en cada pantalla y ya hay dos pantallas con permisos distintos para el mismo usuario.
class Admin:
def permisos(self): return "todos"
class Invitado:
def permisos(self): return "lectura"
rol = "invitado"
u = Admin() if rol == "admin" else Invitado()
print(u.permisos())
class Admin:
def permisos(self): return "todos"
class Invitado:
def permisos(self): return "lectura"
class FabricaUsuario:
def crear(self, rol):
return Admin() if rol == "admin" else Invitado()
print(FabricaUsuario().crear("invitado").permisos())
El rol se decide en cada pantallaEl rol se decide en la fábricaConcentra la decisión. Quien usa el objeto ya no decide cuál crear: lo pide y lo recibe.
Cuando agregan el rol de auditor, se agrega sin abrir lo que ya funcionaba.
Una clase más y un salto de lectura. Si solo hay una cosa que crear, la fábrica sobra.
| Si mañana agregan el rol de auditor… | Antes | Después |
|---|---|---|
| Lugares donde se decide qué crear | Varios · copiados | 1 |
| Riesgo de que queden desalineados | Alto | Ninguno |
| Código existente que se toca | Todos los sitios | Solo la fábrica |
| ¿Quien lo usa sabe cómo se crea? | Sí · y no debería | No |
| Piezas totales | Las que ya había | Una clase más |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
lecturaLa bodega elige caja o sobre según el peso del pedido.
La regla de peso está copiada en la app y en el panel de bodega, y no coinciden.
class Caja:
def tipo(self): return "caja"
class Sobre:
def tipo(self): return "sobre"
peso = 0.3
e = Sobre() if peso < 0.5 else Caja()
print(e.tipo())
class Caja:
def tipo(self): return "caja"
class Sobre:
def tipo(self): return "sobre"
class FabricaEmpaque:
def crear(self, peso):
return Sobre() if peso < 0.5 else Caja()
print(FabricaEmpaque().crear(0.3).tipo())
La regla de peso, en cada móduloLa regla de peso, en la fábricaConcentra la decisión. Quien usa el objeto ya no decide cuál crear: lo pide y lo recibe.
Cuando agregan empaque refrigerado, se agrega sin abrir lo que ya funcionaba.
Una clase más y un salto de lectura. Si solo hay una cosa que crear, la fábrica sobra.
| Si mañana agregan empaque refrigerado… | Antes | Después |
|---|---|---|
| Lugares donde se decide qué crear | Varios · copiados | 1 |
| Riesgo de que queden desalineados | Alto | Ninguno |
| Código existente que se toca | Todos los sitios | Solo la fábrica |
| ¿Quien lo usa sabe cómo se crea? | Sí · y no debería | No |
| Piezas totales | Las que ya había | Una clase más |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
sobreSe emite factura o cuenta de cobro según el tipo de persona.
La decisión tributaria está dispersa y un cambio de la DIAN obligó a buscar en todo el código.
class Factura:
def emitir(self): return "factura emitida"
class CuentaCobro:
def emitir(self): return "cuenta de cobro emitida"
persona = "natural"
d = Factura() if persona == "juridica" else CuentaCobro()
print(d.emitir())
class Factura:
def emitir(self): return "factura emitida"
class CuentaCobro:
def emitir(self): return "cuenta de cobro emitida"
class FabricaDocumento:
def crear(self, persona):
return Factura() if persona == "juridica" else CuentaCobro()
print(FabricaDocumento().crear("natural").emitir())
La decisión, repetida en el códigoLa decisión, en un solo lugarConcentra la decisión. Quien usa el objeto ya no decide cuál crear: lo pide y lo recibe.
Cuando la DIAN agrega un documento, se agrega sin abrir lo que ya funcionaba.
Una clase más y un salto de lectura. Si solo hay una cosa que crear, la fábrica sobra.
| Si mañana la DIAN agrega un documento… | Antes | Después |
|---|---|---|
| Lugares donde se decide qué crear | Varios · copiados | 1 |
| Riesgo de que queden desalineados | Alto | Ninguno |
| Código existente que se toca | Todos los sitios | Solo la fábrica |
| ¿Quien lo usa sabe cómo se crea? | Sí · y no debería | No |
| Piezas totales | Las que ya había | Una clase más |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
cuenta de cobro emitidaLa señal: Se crean varias instancias de algo que debería ser único.
get() devuelve siempre el mismo objeto.La configuración se estaba creando de nuevo en cada llamada, y algunos módulos leían valores viejos.
Un módulo leía el IVA viejo y otro el nuevo, y las facturas del mismo día salieron con valores distintos.
class Config:
def __init__(self): self.iva = 1.19
a = Config()
b = Config()
print(a.iva, a is b)
class Config:
_i = None
def __init__(self): self.iva = 1.19
@classmethod
def get(cls):
if cls._i is None: cls._i = Config()
return cls._i
a = Config.get()
b = Config.get()
print(a.iva, a is b)
Cada llamada crea una configuraciónTodos reciben el mismo objetoControla la creación. Todos reciben el mismo objeto en vez de crear el suyo.
Cuando se agrega un módulo que lee la configuración, se agrega sin abrir lo que ya funcionaba.
Es una variable global disfrazada: la dependencia queda invisible y no se puede reemplazar en una prueba.
| Si mañana se agrega un módulo que lee la configuración… | Antes | Después |
|---|---|---|
| Instancias que existen | Tantas como llamadas | Siempre una |
| ¿El estado queda sincronizado? | No | Sí |
| Recursos que se desperdician | Uno por llamada | Ninguno |
| ¿Se puede reemplazar en una prueba? | Sí | No · ese es el costo |
| ¿La dependencia se ve en la firma? | Sí | No · ese es el costo |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
1.19 False pasa a 1.19 TrueCada módulo llevaba su propio contador de visitas y los números nunca cuadraban.
El informe de gerencia mostraba un número y el panel operativo otro, ambos supuestamente del mismo día.
class Contador:
def __init__(self): self.n = 0
a = Contador(); a.n += 1
b = Contador(); b.n += 1
print(a.n + b.n, a is b)
class Contador:
_i = None
def __init__(self): self.n = 0
@classmethod
def get(cls):
if cls._i is None: cls._i = Contador()
return cls._i
a = Contador.get(); a.n += 1
b = Contador.get(); b.n += 1
print(b.n, a is b)
Dos contadores independientesUn contador únicoControla la creación. Todos reciben el mismo objeto en vez de crear el suyo.
Cuando se agrega una pantalla que cuenta visitas, se agrega sin abrir lo que ya funcionaba.
Es una variable global disfrazada: la dependencia queda invisible y no se puede reemplazar en una prueba.
| Si mañana se agrega una pantalla que cuenta visitas… | Antes | Después |
|---|---|---|
| Instancias que existen | Tantas como llamadas | Siempre una |
| ¿El estado queda sincronizado? | No | Sí |
| Recursos que se desperdician | Uno por llamada | Ninguno |
| ¿Se puede reemplazar en una prueba? | Sí | No · ese es el costo |
| ¿La dependencia se ve en la firma? | Sí | No · ese es el costo |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
2 False pasa a 2 TrueSe abrían varios archivos de log a la vez y las líneas quedaban repartidas.
Las líneas del log quedaban repartidas en varios archivos y rastrear un incidente tomaba horas.
class Log:
def __init__(self): self.lineas = []
a = Log(); a.lineas.append("inicio")
b = Log(); b.lineas.append("fin")
print(len(a.lineas) + len(b.lineas), a is b)
class Log:
_i = None
def __init__(self): self.lineas = []
@classmethod
def get(cls):
if cls._i is None: cls._i = Log()
return cls._i
a = Log.get(); a.lineas.append("inicio")
b = Log.get(); b.lineas.append("fin")
print(len(b.lineas), a is b)
Cada parte abre su propio logUn solo log para todosControla la creación. Todos reciben el mismo objeto en vez de crear el suyo.
Cuando se agrega un módulo que registra, se agrega sin abrir lo que ya funcionaba.
Es una variable global disfrazada: la dependencia queda invisible y no se puede reemplazar en una prueba.
| Si mañana se agrega un módulo que registra… | Antes | Después |
|---|---|---|
| Instancias que existen | Tantas como llamadas | Siempre una |
| ¿El estado queda sincronizado? | No | Sí |
| Recursos que se desperdician | Uno por llamada | Ninguno |
| ¿Se puede reemplazar en una prueba? | Sí | No · ese es el costo |
| ¿La dependencia se ve en la firma? | Sí | No · ese es el costo |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
2 False pasa a 2 TrueAbrir una conexión a la base de datos por cada consulta agotaba el servidor.
Con cada consulta se abría una conexión nueva y el servidor empezó a rechazar peticiones en hora pico.
class Conexion:
def __init__(self): self.abierta = True
a = Conexion()
b = Conexion()
print(a.abierta, a is b)
class Conexion:
_i = None
def __init__(self): self.abierta = True
@classmethod
def get(cls):
if cls._i is None: cls._i = Conexion()
return cls._i
a = Conexion.get()
b = Conexion.get()
print(a.abierta, a is b)
Una conexión por consultaUna conexión reutilizadaControla la creación. Todos reciben el mismo objeto en vez de crear el suyo.
Cuando sube el número de consultas, se agrega sin abrir lo que ya funcionaba.
Es una variable global disfrazada: la dependencia queda invisible y no se puede reemplazar en una prueba.
| Si mañana sube el número de consultas… | Antes | Después |
|---|---|---|
| Instancias que existen | Tantas como llamadas | Siempre una |
| ¿El estado queda sincronizado? | No | Sí |
| Recursos que se desperdician | Uno por llamada | Ninguno |
| ¿Se puede reemplazar en una prueba? | Sí | No · ese es el costo |
| ¿La dependencia se ve en la firma? | Sí | No · ese es el costo |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
True False pasa a True TrueCada módulo tenía su copia del caché de precios y mostraban precios distintos.
Una pantalla mostraba el precio viejo y otra el actualizado, y un cliente reclamó por eso.
class Cache:
def __init__(self): self.datos = {}
a = Cache(); a.datos["pan"] = 3000
b = Cache()
print(b.datos.get("pan"), a is b)
class Cache:
_i = None
def __init__(self): self.datos = {}
@classmethod
def get(cls):
if cls._i is None: cls._i = Cache()
return cls._i
a = Cache.get(); a.datos["pan"] = 3000
b = Cache.get()
print(b.datos.get("pan"), a is b)
Varios cachés desincronizadosUn caché compartidoControla la creación. Todos reciben el mismo objeto en vez de crear el suyo.
Cuando se agrega otra pantalla con precios, se agrega sin abrir lo que ya funcionaba.
Es una variable global disfrazada: la dependencia queda invisible y no se puede reemplazar en una prueba.
| Si mañana se agrega otra pantalla con precios… | Antes | Después |
|---|---|---|
| Instancias que existen | Tantas como llamadas | Siempre una |
| ¿El estado queda sincronizado? | No | Sí |
| Recursos que se desperdician | Uno por llamada | Ninguno |
| ¿Se puede reemplazar en una prueba? | Sí | No · ese es el costo |
| ¿La dependencia se ve en la firma? | Sí | No · ese es el costo |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
None False pasa a 3000 TrueDos colas de impresión distintas peleaban por la misma impresora.
Dos colas mandaban a la vez y los recibos salían intercalados entre sí.
class Cola:
def __init__(self): self.items = []
a = Cola(); a.items.append("doc1")
b = Cola()
print(len(b.items), a is b)
class Cola:
_i = None
def __init__(self): self.items = []
@classmethod
def get(cls):
if cls._i is None: cls._i = Cola()
return cls._i
a = Cola.get(); a.items.append("doc1")
b = Cola.get()
print(len(b.items), a is b)
Dos colas para una impresoraUna sola colaControla la creación. Todos reciben el mismo objeto en vez de crear el suyo.
Cuando se agrega otro punto de impresión, se agrega sin abrir lo que ya funcionaba.
Es una variable global disfrazada: la dependencia queda invisible y no se puede reemplazar en una prueba.
| Si mañana se agrega otro punto de impresión… | Antes | Después |
|---|---|---|
| Instancias que existen | Tantas como llamadas | Siempre una |
| ¿El estado queda sincronizado? | No | Sí |
| Recursos que se desperdician | Uno por llamada | Ninguno |
| ¿Se puede reemplazar en una prueba? | Sí | No · ese es el costo |
| ¿La dependencia se ve en la firma? | Sí | No · ese es el costo |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
0 False pasa a 1 TrueEl usuario aparecía deslogueado en unas pantallas y logueado en otras.
El usuario aparecía deslogueado al cambiar de sección y tenía que entrar otra vez.
class Sesion:
def __init__(self): self.usuario = None
a = Sesion(); a.usuario = "ana"
b = Sesion()
print(b.usuario, a is b)
class Sesion:
_i = None
def __init__(self): self.usuario = None
@classmethod
def get(cls):
if cls._i is None: cls._i = Sesion()
return cls._i
a = Sesion.get(); a.usuario = "ana"
b = Sesion.get()
print(b.usuario, a is b)
Cada pantalla con su sesiónUna sesión compartidaControla la creación. Todos reciben el mismo objeto en vez de crear el suyo.
Cuando se agrega una sección nueva, se agrega sin abrir lo que ya funcionaba.
Es una variable global disfrazada: la dependencia queda invisible y no se puede reemplazar en una prueba.
| Si mañana se agrega una sección nueva… | Antes | Después |
|---|---|---|
| Instancias que existen | Tantas como llamadas | Siempre una |
| ¿El estado queda sincronizado? | No | Sí |
| Recursos que se desperdician | Uno por llamada | Ninguno |
| ¿Se puede reemplazar en una prueba? | Sí | No · ese es el costo |
| ¿La dependencia se ve en la firma? | Sí | No · ese es el costo |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
None False pasa a ana TrueLa señal: Una clase va a buscar lo que necesita en vez de recibirlo.
Una clase de bienvenida manda un correo. Para probarla había que enviar correos de verdad.
Cada corrida de pruebas mandaba correos reales a las cuentas de prueba, y el proveedor bloqueó la cuenta por spam.
class Correo:
def enviar(self, a): return f"real para {a}"
class Bienvenida:
def saludar(self, a): return Correo().enviar(a)
print(Bienvenida().saludar("ana"))
class Correo:
def enviar(self, a): return f"real para {a}"
class Bienvenida:
def __init__(self, correo): self.correo = correo
def saludar(self, a): return self.correo.enviar(a)
print(Bienvenida(Correo()).saludar("ana"))
Correo() creado adentroEl correo llega por el constructorInvierte quién consigue qué. La clase deja de buscar y pasa a recibir, así que la dependencia se puede cambiar.
Cuando hay que probar el flujo sin enviar correos, se agrega sin abrir lo que ya funcionaba.
Alguien tiene que armar y pasar las dependencias. En proyectos grandes suele hacer falta un contenedor.
| Si mañana hay que probar el flujo sin enviar correos… | Antes | Después |
|---|---|---|
| ¿Se puede probar sin el servicio real? | No | Sí |
| ¿La firma dice de qué depende? | No | Sí |
| Efectos secundarios en pruebas | Sí · reales | Ninguno |
| Código existente que se toca | El de la clase | Solo el constructor |
| Piezas totales | Las que ya había | Una más al armar |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
real para anaUn recibo estampa la fecha de hoy. La prueba pasaba ayer y falla hoy.
La prueba pasaba el día que se escribió y fallaba al siguiente. El equipo terminó desactivándola.
class Reloj:
def hoy(self): return "2026-08-11"
class Recibo:
def emitir(self): return "recibo " + Reloj().hoy()
print(Recibo().emitir())
class Reloj:
def hoy(self): return "2026-08-11"
class Recibo:
def __init__(self, reloj): self.reloj = reloj
def emitir(self): return "recibo " + self.reloj.hoy()
print(Recibo(Reloj()).emitir())
El reloj se consulta adentroEl reloj se recibe y se puede falsearInvierte quién consigue qué. La clase deja de buscar y pasa a recibir, así que la dependencia se puede cambiar.
Cuando hay que probar con una fecha fija, se agrega sin abrir lo que ya funcionaba.
Alguien tiene que armar y pasar las dependencias. En proyectos grandes suele hacer falta un contenedor.
| Si mañana hay que probar con una fecha fija… | Antes | Después |
|---|---|---|
| ¿Se puede probar sin el servicio real? | No | Sí |
| ¿La firma dice de qué depende? | No | Sí |
| Efectos secundarios en pruebas | Sí · reales | Ninguno |
| Código existente que se toca | El de la clase | Solo el constructor |
| Piezas totales | Las que ya había | Una más al armar |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
recibo 2026-08-11Un juego usa un dado. Con azar adentro, la prueba nunca da dos veces lo mismo.
La prueba daba resultados distintos en cada corrida y nadie confiaba en ella.
class Dado:
def tirar(self): return 4
class Juego:
def turno(self): return "sacaste " + str(Dado().tirar())
print(Juego().turno())
class Dado:
def tirar(self): return 4
class Juego:
def __init__(self, dado): self.dado = dado
def turno(self): return "sacaste " + str(self.dado.tirar())
print(Juego(Dado()).turno())
El dado se crea adentroEl dado se inyectaInvierte quién consigue qué. La clase deja de buscar y pasa a recibir, así que la dependencia se puede cambiar.
Cuando hay que probar con un valor fijo, se agrega sin abrir lo que ya funcionaba.
Alguien tiene que armar y pasar las dependencias. En proyectos grandes suele hacer falta un contenedor.
| Si mañana hay que probar con un valor fijo… | Antes | Después |
|---|---|---|
| ¿Se puede probar sin el servicio real? | No | Sí |
| ¿La firma dice de qué depende? | No | Sí |
| Efectos secundarios en pruebas | Sí · reales | Ninguno |
| Código existente que se toca | El de la clase | Solo el constructor |
| Piezas totales | Las que ya había | Una más al armar |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
sacaste 4Un informe cuenta clientes. Para probar la lógica había que tener la base de datos prendida.
Para correr las pruebas había que tener la base de datos prendida, así que nadie las corría en su portátil.
class Repo:
def clientes(self): return ["ana", "luis"]
class Informe:
def total(self): return len(Repo().clientes())
print(Informe().total())
class Repo:
def clientes(self): return ["ana", "luis"]
class Informe:
def __init__(self, repo): self.repo = repo
def total(self): return len(self.repo.clientes())
print(Informe(Repo()).total())
El repositorio se crea adentroEl repositorio se recibeInvierte quién consigue qué. La clase deja de buscar y pasa a recibir, así que la dependencia se puede cambiar.
Cuando hay que probar sin base de datos, se agrega sin abrir lo que ya funcionaba.
Alguien tiene que armar y pasar las dependencias. En proyectos grandes suele hacer falta un contenedor.
| Si mañana hay que probar sin base de datos… | Antes | Después |
|---|---|---|
| ¿Se puede probar sin el servicio real? | No | Sí |
| ¿La firma dice de qué depende? | No | Sí |
| Efectos secundarios en pruebas | Sí · reales | Ninguno |
| Código existente que se toca | El de la clase | Solo el constructor |
| Piezas totales | Las que ya había | Una más al armar |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
2Un precio se convierte usando la tasa del día, que cambia constantemente.
La tasa cambia todos los días y la prueba fallaba cada vez que se movía el dólar.
class Tasa:
def usd(self): return 4000
class Precio:
def en_pesos(self, dolares): return dolares * Tasa().usd()
print(Precio().en_pesos(10))
class Tasa:
def usd(self): return 4000
class Precio:
def __init__(self, tasa): self.tasa = tasa
def en_pesos(self, dolares): return dolares * self.tasa.usd()
print(Precio(Tasa()).en_pesos(10))
La tasa se consulta adentroLa tasa se pasa como dependenciaInvierte quién consigue qué. La clase deja de buscar y pasa a recibir, así que la dependencia se puede cambiar.
Cuando hay que probar con una tasa fija, se agrega sin abrir lo que ya funcionaba.
Alguien tiene que armar y pasar las dependencias. En proyectos grandes suele hacer falta un contenedor.
| Si mañana hay que probar con una tasa fija… | Antes | Después |
|---|---|---|
| ¿Se puede probar sin el servicio real? | No | Sí |
| ¿La firma dice de qué depende? | No | Sí |
| Efectos secundarios en pruebas | Sí · reales | Ninguno |
| Código existente que se toca | El de la clase | Solo el constructor |
| Piezas totales | Las que ya había | Una más al armar |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
40000Cada transferencia escribe en el log real, incluso durante las pruebas.
Las pruebas dejaban cientos de líneas basura en el archivo de auditoría real.
class Logger:
def escribir(self, m): return "log:" + m
class Transferencia:
def hacer(self, monto): return Logger().escribir(str(monto))
print(Transferencia().hacer(50000))
class Logger:
def escribir(self, m): return "log:" + m
class Transferencia:
def __init__(self, logger): self.logger = logger
def hacer(self, monto): return self.logger.escribir(str(monto))
print(Transferencia(Logger()).hacer(50000))
El logger se crea adentroEl logger se inyectaInvierte quién consigue qué. La clase deja de buscar y pasa a recibir, así que la dependencia se puede cambiar.
Cuando hay que probar sin escribir en auditoría, se agrega sin abrir lo que ya funcionaba.
Alguien tiene que armar y pasar las dependencias. En proyectos grandes suele hacer falta un contenedor.
| Si mañana hay que probar sin escribir en auditoría… | Antes | Después |
|---|---|---|
| ¿Se puede probar sin el servicio real? | No | Sí |
| ¿La firma dice de qué depende? | No | Sí |
| Efectos secundarios en pruebas | Sí · reales | Ninguno |
| Código existente que se toca | El de la clase | Solo el constructor |
| Piezas totales | Las que ya había | Una más al armar |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
log:50000Aprobar un registro consulta un servicio externo de validación en cada prueba.
Cada prueba consultaba el servicio externo y tardaba minutos; a veces el servicio estaba caído.
class ValidadorNit:
def existe(self, nit): return True
class Registro:
def aprobar(self, nit): return ValidadorNit().existe(nit)
print(Registro().aprobar("900123456"))
class ValidadorNit:
def existe(self, nit): return True
class Registro:
def __init__(self, validador): self.v = validador
def aprobar(self, nit): return self.v.existe(nit)
print(Registro(ValidadorNit()).aprobar("900123456"))
El validador se crea adentroEl validador se recibeInvierte quién consigue qué. La clase deja de buscar y pasa a recibir, así que la dependencia se puede cambiar.
Cuando hay que probar sin llamar al servicio, se agrega sin abrir lo que ya funcionaba.
Alguien tiene que armar y pasar las dependencias. En proyectos grandes suele hacer falta un contenedor.
| Si mañana hay que probar sin llamar al servicio… | Antes | Después |
|---|---|---|
| ¿Se puede probar sin el servicio real? | No | Sí |
| ¿La firma dice de qué depende? | No | Sí |
| Efectos secundarios en pruebas | Sí · reales | Ninguno |
| Código existente que se toca | El de la clase | Solo el constructor |
| Piezas totales | Las que ya había | Una más al armar |
Cambiar una cosa obliga a entrar donde viven las demás.
No conoce a ninguna: solo pide lo que necesita.
TrueLa señal: Para describir la función hace falta la palabra "y".
Una función de facturación calcula el total y arma el texto de la factura.
Cuando contabilidad pidió cambiar el formato de la factura, hubo que meterse en el código que calcula el total.
ITEMS = [("pan", 3000), ("leche", 4500)]
def facturar(items):
total = sum(p for _, p in items)
return f"FACTURA total={total}"
print(facturar(ITEMS))
ITEMS = [("pan", 3000), ("leche", 4500)]
def sumar(items): return sum(p for _, p in items)
def imprimir(total): return f"FACTURA total={total}"
print(imprimir(sumar(ITEMS)))
Cálculo y formato mezcladosDos funciones, una por responsabilidadParte por responsabilidad. Cada pieza tiene una sola razón de cambiar, así que un cambio no arrastra a los otros.
Cuando cambian el formato de la factura, se agrega sin abrir lo que ya funcionaba.
Más funciones que leer y nombrar. Partir de más fragmenta la lógica sin ganancia.
| Si mañana cambian el formato de la factura… | Antes | Después |
|---|---|---|
| Razones de cambio de cada pieza | Varias | Una |
| ¿Se prueba una parte sola? | No | Sí |
| Cambiar el formato obliga a… | Tocar el cálculo | Nada más |
| Riesgo al modificar | Alto | Acotado |
| Piezas totales | 1 función | Varias funciones |
Cambiar una cosa obliga a entrar donde viven las demás.
Cada pieza se usa y se prueba sola.
FACTURA total=7500Registrar un usuario valida el nombre, lo guarda y manda el aviso, todo junto.
Cambiar la regla de validación obligaba a revisar también el guardado y el envío del aviso.
def registrar(nombre):
ok = len(nombre) > 2
guardado = "guardado:" + nombre if ok else "rechazado"
return guardado + "|aviso enviado"
print(registrar("ana"))
def validar(nombre): return len(nombre) > 2
def guardar(nombre, ok): return "guardado:" + nombre if ok else "rechazado"
def avisar(): return "aviso enviado"
print(guardar("ana", validar("ana")) + "|" + avisar())
Validar, guardar y avisar juntosTres funciones separadasParte por responsabilidad. Cada pieza tiene una sola razón de cambiar, así que un cambio no arrastra a los otros.
Cuando cambia la regla de validación, se agrega sin abrir lo que ya funcionaba.
Más funciones que leer y nombrar. Partir de más fragmenta la lógica sin ganancia.
| Si mañana cambia la regla de validación… | Antes | Después |
|---|---|---|
| Razones de cambio de cada pieza | Varias | Una |
| ¿Se prueba una parte sola? | No | Sí |
| Cambiar el formato obliga a… | Tocar el cálculo | Nada más |
| Riesgo al modificar | Alto | Acotado |
| Piezas totales | 1 función | Varias funciones |
Cambiar una cosa obliga a entrar donde viven las demás.
Cada pieza se usa y se prueba sola.
guardado:ana|aviso enviadoUn reporte de ventas consulta, calcula el total y formatea la salida.
No se podía verificar el cálculo sin consultar la base de datos ni armar el texto completo.
VENTAS = [("norte", 100), ("sur", 250)]
def reporte():
total = sum(v for _, v in VENTAS)
return f"TOTAL:{total}"
print(reporte())
VENTAS = [("norte", 100), ("sur", 250)]
def consultar(): return VENTAS
def calcular(d): return sum(v for _, v in d)
def formatear(t): return f"TOTAL:{t}"
print(formatear(calcular(consultar())))
Consulta, cálculo y formato juntosCada paso por separadoParte por responsabilidad. Cada pieza tiene una sola razón de cambiar, así que un cambio no arrastra a los otros.
Cuando piden el reporte en otro formato, se agrega sin abrir lo que ya funcionaba.
Más funciones que leer y nombrar. Partir de más fragmenta la lógica sin ganancia.
| Si mañana piden el reporte en otro formato… | Antes | Después |
|---|---|---|
| Razones de cambio de cada pieza | Varias | Una |
| ¿Se prueba una parte sola? | No | Sí |
| Cambiar el formato obliga a… | Tocar el cálculo | Nada más |
| Riesgo al modificar | Alto | Acotado |
| Piezas totales | 1 función | Varias funciones |
Cambiar una cosa obliga a entrar donde viven las demás.
Cada pieza se usa y se prueba sola.
TOTAL:350Procesar un pedido verifica stock, cobra y arma el recibo en un solo método.
Cambiar la forma de cobrar obligaba a revisar también la verificación de stock.
def procesar(cantidad):
hay = cantidad <= 10
cobro = cantidad * 5000 if hay else 0
return f"cobrado:{cobro}"
print(procesar(3))
def hay_stock(cantidad): return cantidad <= 10
def cobrar(cantidad, hay): return cantidad * 5000 if hay else 0
def recibo(cobro): return f"cobrado:{cobro}"
print(recibo(cobrar(3, hay_stock(3))))
Tres reglas de negocio mezcladasTres funciones independientesParte por responsabilidad. Cada pieza tiene una sola razón de cambiar, así que un cambio no arrastra a los otros.
Cuando cambia la forma de cobrar, se agrega sin abrir lo que ya funcionaba.
Más funciones que leer y nombrar. Partir de más fragmenta la lógica sin ganancia.
| Si mañana cambia la forma de cobrar… | Antes | Después |
|---|---|---|
| Razones de cambio de cada pieza | Varias | Una |
| ¿Se prueba una parte sola? | No | Sí |
| Cambiar el formato obliga a… | Tocar el cálculo | Nada más |
| Riesgo al modificar | Alto | Acotado |
| Piezas totales | 1 función | Varias funciones |
Cambiar una cosa obliga a entrar donde viven las demás.
Cada pieza se usa y se prueba sola.
cobrado:15000Importar un archivo separa el texto, lo limpia y lo guarda sin distinción.
Un cambio en el formato del archivo obligó a revisar también el guardado.
LINEA = " ana , luis "
def importar(linea):
partes = [p.strip() for p in linea.split(",")]
return "guardados:" + str(len(partes))
print(importar(LINEA))
LINEA = " ana , luis "
def separar(linea): return linea.split(",")
def limpiar(partes): return [p.strip() for p in partes]
def guardar(partes): return "guardados:" + str(len(partes))
print(guardar(limpiar(separar(LINEA))))
Separar, limpiar y guardar juntosUn paso, una funciónParte por responsabilidad. Cada pieza tiene una sola razón de cambiar, así que un cambio no arrastra a los otros.
Cuando cambia el separador del archivo, se agrega sin abrir lo que ya funcionaba.
Más funciones que leer y nombrar. Partir de más fragmenta la lógica sin ganancia.
| Si mañana cambia el separador del archivo… | Antes | Después |
|---|---|---|
| Razones de cambio de cada pieza | Varias | Una |
| ¿Se prueba una parte sola? | No | Sí |
| Cambiar el formato obliga a… | Tocar el cálculo | Nada más |
| Riesgo al modificar | Alto | Acotado |
| Piezas totales | 1 función | Varias funciones |
Cambiar una cosa obliga a entrar donde viven las demás.
Cada pieza se usa y se prueba sola.
guardados:2Calcular la nómina suma horas, aplica descuentos y arma el desprendible.
Cuando cambió el porcentaje de descuento por ley, hubo que tocar el código que arma el desprendible.
def nomina(horas):
bruto = horas * 12000
neto = bruto - bruto * 0.08
return f"neto:{neto}"
print(nomina(160))
def bruto(horas): return horas * 12000
def descuentos(b): return b - b * 0.08
def desprendible(neto): return f"neto:{neto}"
print(desprendible(descuentos(bruto(160))))
Bruto, descuentos y formato juntosCada cálculo por su ladoParte por responsabilidad. Cada pieza tiene una sola razón de cambiar, así que un cambio no arrastra a los otros.
Cuando cambia el descuento por ley, se agrega sin abrir lo que ya funcionaba.
Más funciones que leer y nombrar. Partir de más fragmenta la lógica sin ganancia.
| Si mañana cambia el descuento por ley… | Antes | Después |
|---|---|---|
| Razones de cambio de cada pieza | Varias | Una |
| ¿Se prueba una parte sola? | No | Sí |
| Cambiar el formato obliga a… | Tocar el cálculo | Nada más |
| Riesgo al modificar | Alto | Acotado |
| Piezas totales | 1 función | Varias funciones |
Cambiar una cosa obliga a entrar donde viven las demás.
Cada pieza se usa y se prueba sola.
neto:1766400.0Publicar un artículo valida el título, lo formatea y lo publica.
Cambiar el formato del título obligaba a revisar también la validación y la publicación.
def publicar(titulo):
ok = len(titulo) > 0
texto = titulo.upper() if ok else ""
return "publicado:" + texto
print(publicar("arquitectura"))
def valido(t): return len(t) > 0
def formatear(t, ok): return t.upper() if ok else ""
def publicar(texto): return "publicado:" + texto
print(publicar(formatear("arquitectura", valido("arquitectura"))))
Validar, formatear y publicar juntosTres funciones encadenadasParte por responsabilidad. Cada pieza tiene una sola razón de cambiar, así que un cambio no arrastra a los otros.
Cuando cambia la regla de publicación, se agrega sin abrir lo que ya funcionaba.
Más funciones que leer y nombrar. Partir de más fragmenta la lógica sin ganancia.
| Si mañana cambia la regla de publicación… | Antes | Después |
|---|---|---|
| Razones de cambio de cada pieza | Varias | Una |
| ¿Se prueba una parte sola? | No | Sí |
| Cambiar el formato obliga a… | Tocar el cálculo | Nada más |
| Riesgo al modificar | Alto | Acotado |
| Piezas totales | 1 función | Varias funciones |
Cambiar una cosa obliga a entrar donde viven las demás.
Cada pieza se usa y se prueba sola.
publicado:ARQUITECTURAYa vieron 49 casos resueltos. Ahora les toca a ustedes: seis casos nuevos, sin la respuesta, y trabajo individual.
Hay cuatro versiones (A, B, C y D) repartidas de forma que quien tienen al lado no tiene la misma. Copiarse no ayuda: los casos son otros.
.ipynb en Colab o VS Code. 5 minUn cuaderno de Jupyter, hecho en Google Colab o en VS Code. No se recibe un .py, ni un Word, ni una foto.
NombreApellido_VersionA.ipynb — con la letra de su versión. Se entrega el archivo o el enlace de Colab con permiso de lectura.## Caso [numero] 1. Salida real que obtuve al ejecutar: ... 2. La senal que veo en el codigo: ... 3. Patron o principio que aplicaria: ... 4. Por que ese y no otro: ... 5. Que se paga al aplicarlo: ...
En cada versión hay un caso donde aplicar un patrón es la respuesta equivocada. Ahí lo correcto es simplificar o no tocar nada.
Al final, llamo al azar a varios de ustedes y les pido explicar uno de sus casos, elegido por mí. Sin notas, sin pantalla.
No puedo impedir que usen IA, y no voy a fingir que sí. Lo que hice fue diseñar el taller para que la IA no alcance.
| Criterio | Peso | Qué observo |
|---|---|---|
| Defensa oral | 40% | Explica su caso sin notas. Es el criterio que más pesa. |
| Señal identificada | 20% | Nombra qué en el código lo delata, no solo el patrón. |
| Salida real pegada | 20% | Ejecutó de verdad. La salida coincide con la del código. |
| El caso trampa | 20% | Lo detectó, o al menos dudó y lo justificó. |
.ipynb o el enlace de Colab con permiso de lectura, por el canal del curso al terminar la clase.Busquen en un proyecto real —de otra materia, de un trabajo o de un repositorio público— un patrón aplicado, bien o mal.