Ingeniería de Sistemas · Semestre IV · 2026-2 · Clase 4 de 16

Soluciones que
ya funcionan

Los patrones de diseño: el catálogo de respuestas probadas que un arquitecto no reinventa, sino que elige. — Elkin Rodríguez E.

Ruta de hoy · 3 horas

Cómo va a fluir la clase

01
Consejo de Arquitectura Sustentan los ADR pendientes. 15 min.
02
Qué es un patrón Desde cero, y dónde encaja en el curso.
03
Cinco patrones y dos principios Siete casos reales de cada uno: contexto, código y comparación.
04
Taller individual Seis casos nuevos, cuatro versiones distintas. 45 min.
Pendiente de la clase pasada · 15 minutos exactos

Consejo de Arquitectura · sustentación

Ya escribieron su ADR. Hoy lo defienden. Tres grupos, cuatro minutos cada uno — sorteo de quiénes.

  1. 2 min · La decisión. Qué driver mandaba, qué separaron y qué dejaron junto.
  2. 1 min · La factura. Qué están pagando por esa decisión.
  3. 1 min · Un grupo responde. Complementa, refuta o señala lo que faltó.
Tarea · tres voluntarios

Un acoplamiento de la vida real

Tres personas, 60 segundos cada una. Tres cosas y se sientan:

1

Qué está pegado con qué.

2

Qué síntoma lo delata.

3

Qué driver se incumple por eso.

Reconexión

Dónde quedamos

Clase 2

Los drivers: qué exige el negocio.

→

Clase 3

El estilo: qué va junto y qué separado.

→

Hoy

Los patrones: con qué se construye por dentro.

Capa 1 · por qué hoy toca esto

El hilo del curso, en una frase

Todo el semestre responde una sola pregunta, bajando de nivel cada semana.

Clases 1 a 3

¿Qué es arquitectura? ¿Qué exige el negocio? ¿Qué forma tiene el sistema?

Clase 4 · hoy

¿Con qué construyo cada parte? El catálogo de soluciones probadas.

Clase 5 en adelante

¿Cómo lo comunico? ¿Cómo lo evalúo? Y los estilos en profundidad.

La pregunta que alguno se está haciendo

"¿Y los estilos no eran lo importante?"

Sí, y por eso vuelven tres veces más: microservicios, arquitecturas basadas en eventos y CQRS tienen clase propia más adelante.

Los patrones de diseño, en cambio, pasan una sola vez por este curso. Por eso hoy nos detenemos aquí.
La razón de fondo

Un estilo se construye con patrones

Cuando lleguemos a…Van a necesitar…
Arquitecturas basadas en eventosObserver / publicador-suscriptor
Microservicios en profundidadAdapter, para las fronteras
CQRSSeparación de responsabilidades
Implementar cualquier estiloStrategy e inyección de dependencias
En una fraseSin las piezas de hoy, los estilos de más adelante serían diagramas bonitos que ustedes no sabrían construir.
Capa 1 · desde cero

¿Qué es un patrón de diseño?

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.

La analogíaEn cocina nadie inventa cómo hacer un sofrito. Existe, tiene nombre, y decir "sofrito" ahorra explicar cinco pasos. Un patrón es eso para el código.
Lo que NO es

Tres malentendidos comunes

1
No es código para copiar Es una idea de estructura. Se implementa distinto en cada lenguaje.
2
No es una regla obligatoria Un patrón mal traído complica más de lo que resuelve.
3
No es sinónimo de "bien hecho" Usar cinco patrones no mejora un programa. Usar el que corresponde, sí.
De dónde salen

El catálogo que usa toda la industria

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.
.

Creacionales

Cómo se crean los objetos.
Factory · Singleton

Estructurales

Cómo se conectan las piezas.
Adapter · Decorator

Comportamiento

Cómo colaboran entre sí.
Strategy · Observer

El mapa de hoy

Cinco patrones y dos principios

PatrónFamiliaQué resuelve
StrategyComportamientoVarias formas de hacer lo mismo
ObserverComportamientoAvisarle a varios interesados
AdapterEstructuralUsar algo que no controlamos
Factory y SingletonCreacionalesCómo se crean los objetos
Y dos cosas que NO son patrones

Patrón no es lo mismo que principio

Lo que vemos¿Patrón GoF?Qué resuelve
Inyección de dependenciasNo. Es un principioQue el código se pueda probar
Separar responsabilidadesNo. Es un principioUna pieza, una razón de cambio
La diferenciaUn patrón trae una estructura fija con roles. Un principio es una idea general que se aplica en muchas situaciones — y suele ser la razón por la que el patrón funciona. Decirlo bien en una entrevista los distingue.
Comportamiento · GoF

Strategy

La señal: Una cadena de if / elif que crece cada vez que aparece una variante nueva.

Qué hace: Cada variante pasa a ser su propia clase con el mismo método.
Strategy · caso 1 de 7 · el contexto

Tarifas de envío

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.

Por qué Strategy y no otroHay varias formas de calcular lo mismo y la lista crece. Nadie decide una vez: se decide en cada llamada.
Strategy · caso 1 · antes

Tarifas de envío

Cópienlo y ejecútenlo · da 15800
def tarifa(tipo, peso):
    if tipo == "estandar":
        return peso * 3000
    elif tipo == "express":
        return peso * 5400 + 5000
    return 0

print(tarifa("express", 2))
Strategy · caso 1 · después

Tarifas de envío

Con Strategy aplicado
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))
Strategy · caso 1 · la línea que cambió

Una línea contra una línea

Antes · decide adentroLa fórmula de express vive en una rama del if
Después · delegaVive en su propia clase Express

Qué hace el patrón

Saca 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.

Por qué sirve aquí

Cuando entra la modalidad 'programado', se agrega sin abrir lo que ya funcionaba.

Qué se paga

Pasa de 1 función a varias clases. Hay que saber dónde vive cada variante. Con dos casos fijos, sobra.

Strategy · caso 1 · el impacto

Qué cuesta el cambio, antes y después

Si mañana entra la modalidad 'programado'…AntesDespués
Archivos que hay que abrir1 · el que ya funcionaba1 · uno nuevo
Código existente que se tocaSíNinguno
Variantes que se pueden romperTodas0
¿Se prueba una variante sola?NoSí
Piezas totales1 funciónVarias clases
Strategy · caso 1 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
estandar · express

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Envio
↓
Estandar
Express

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen 15800
Strategy · caso 2 de 7 · el contexto

Intereses por tipo de crédito

Un 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.

Por qué Strategy y no otroEl cálculo cambia por producto, pero la operación es la misma: pasar capital y recibir interés.
Strategy · caso 2 · antes

Intereses por tipo de crédito

Cópienlo y ejecútenlo · da 899999.9999999999
def interes(tipo, capital):
    if tipo == "libre":
        return capital * 0.022
    elif tipo == "vivienda":
        return capital * 0.009
    return 0

print(interes("vivienda", 100000000))
Strategy · caso 2 · después

Intereses por tipo de crédito

Con Strategy aplicado
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))
Strategy · caso 2 · la línea que cambió

Una línea contra una línea

Antes · decide adentroCada producto es una rama del if
Después · delegaCada producto es una clase con calcular

Qué hace el patrón

Saca 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.

Por qué sirve aquí

Cuando entra el crédito educativo, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Pasa de 1 función a varias clases. Hay que saber dónde vive cada variante. Con dos casos fijos, sobra.

Strategy · caso 2 · el impacto

Qué cuesta el cambio, antes y después

Si mañana entra el crédito educativo…AntesDespués
Archivos que hay que abrir1 · el que ya funcionaba1 · uno nuevo
Código existente que se tocaSíNinguno
Variantes que se pueden romperTodas0
¿Se prueba una variante sola?NoSí
Piezas totales1 funciónVarias clases
Strategy · caso 2 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
libre · vivienda

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Credito
↓
Libre
Vivienda

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen 899999.9999999999
Strategy · caso 3 de 7 · el contexto

Recargo por medio de pago

Un 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.

Por qué Strategy y no otroLo que cambia es solo la fórmula; quien la usa siempre hace lo mismo.
Strategy · caso 3 · antes

Recargo por medio de pago

Cópienlo y ejecútenlo · da 6000.0
def recargo(medio, monto):
    if medio == "tarjeta":
        return monto * 0.03
    elif medio == "pse":
        return 1500
    return 0

print(recargo("tarjeta", 200000))
Strategy · caso 3 · después

Recargo por medio de pago

Con Strategy aplicado
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))
Strategy · caso 3 · la línea que cambió

Una línea contra una línea

Antes · decide adentroCambiar el recargo obliga a editar la función
Después · delegaCambiar el recargo toca una sola clase

Qué hace el patrón

Saca 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.

Por qué sirve aquí

Cuando entra el recargo de Nequi, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Pasa de 1 función a varias clases. Hay que saber dónde vive cada variante. Con dos casos fijos, sobra.

Strategy · caso 3 · el impacto

Qué cuesta el cambio, antes y después

Si mañana entra el recargo de Nequi…AntesDespués
Archivos que hay que abrir1 · el que ya funcionaba1 · uno nuevo
Código existente que se tocaSíNinguno
Variantes que se pueden romperTodas0
¿Se prueba una variante sola?NoSí
Piezas totales1 funciónVarias clases
Strategy · caso 3 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
tarjeta · pse

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Pago
↓
Tarjeta
Pse

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen 6000.0
Strategy · caso 4 de 7 · el contexto

Formato de exportación

Un 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.

Por qué Strategy y no otroCada formato arma el texto distinto, pero todos reciben los mismos datos.
Strategy · caso 4 · antes

Formato de exportación

Cópienlo y ejecútenlo · da ana,luis
def exportar(formato, datos):
    if formato == "csv":
        return ",".join(datos)
    elif formato == "texto":
        return " | ".join(datos)
    return ""

print(exportar("csv", ["ana", "luis"]))
Strategy · caso 4 · después

Formato de exportación

Con Strategy aplicado
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"]))
Strategy · caso 4 · la línea que cambió

Una línea contra una línea

Antes · decide adentroAgregar JSON = otra rama del if
Después · delegaAgregar JSON = una clase nueva, sin tocar nada

Qué hace el patrón

Saca 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.

Por qué sirve aquí

Cuando piden exportar a JSON, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Pasa de 1 función a varias clases. Hay que saber dónde vive cada variante. Con dos casos fijos, sobra.

Strategy · caso 4 · el impacto

Qué cuesta el cambio, antes y después

Si mañana piden exportar a JSON…AntesDespués
Archivos que hay que abrir1 · el que ya funcionaba1 · uno nuevo
Código existente que se tocaSíNinguno
Variantes que se pueden romperTodas0
¿Se prueba una variante sola?NoSí
Piezas totales1 funciónVarias clases
Strategy · caso 4 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
csv · texto

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Exportador
↓
Csv
Texto

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen ana,luis
Strategy · caso 5 de 7 · el contexto

Nota final del curso

Cada 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.

Por qué Strategy y no otroMisma entrada, misma salida, distinta fórmula según una regla externa.
Strategy · caso 5 · antes

Nota final del curso

Cópienlo y ejecútenlo · da 3.9
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))
Strategy · caso 5 · después

Nota final del curso

Con Strategy aplicado
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))
Strategy · caso 5 · la línea que cambió

Una línea contra una línea

Antes · decide adentroLa ponderación está mezclada con la lógica
Después · delegaCada esquema de ponderación es una clase

Qué hace el patrón

Saca 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.

Por qué sirve aquí

Cuando una facultad cambia su ponderación, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Pasa de 1 función a varias clases. Hay que saber dónde vive cada variante. Con dos casos fijos, sobra.

Strategy · caso 5 · el impacto

Qué cuesta el cambio, antes y después

Si mañana una facultad cambia su ponderación…AntesDespués
Archivos que hay que abrir1 · el que ya funcionaba1 · uno nuevo
Código existente que se tocaSíNinguno
Variantes que se pueden romperTodas0
¿Se prueba una variante sola?NoSí
Piezas totales1 funciónVarias clases
Strategy · caso 5 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
practico · teorico

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Curso
↓
Practico
Teorico

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen 3.9
Strategy · caso 6 de 7 · el contexto

Validación de documento

Colombia 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.

Por qué Strategy y no otroLa pregunta es siempre ¿es válido?, pero la regla depende del tipo.
Strategy · caso 6 · antes

Validación de documento

Cópienlo y ejecútenlo · da True
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"))
Strategy · caso 6 · después

Validación de documento

Con Strategy aplicado
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"))
Strategy · caso 6 · la línea que cambió

Una línea contra una línea

Antes · decide adentroTodas las reglas en la misma función
Después · delegaUna clase por tipo de documento

Qué hace el patrón

Saca 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.

Por qué sirve aquí

Cuando hay que validar pasaporte, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Pasa de 1 función a varias clases. Hay que saber dónde vive cada variante. Con dos casos fijos, sobra.

Strategy · caso 6 · el impacto

Qué cuesta el cambio, antes y después

Si mañana hay que validar pasaporte…AntesDespués
Archivos que hay que abrir1 · el que ya funcionaba1 · uno nuevo
Código existente que se tocaSíNinguno
Variantes que se pueden romperTodas0
¿Se prueba una variante sola?NoSí
Piezas totales1 funciónVarias clases
Strategy · caso 6 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
cc · nit

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Documento
↓
Cedula
Nit

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen True
Strategy · caso 7 de 7 · el contexto

Orden de los productos

El 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.

Por qué Strategy y no otroEl qué es fijo (ordenar productos); el cómo cambia.
Strategy · caso 7 · antes

Orden de los productos

Cópienlo y ejecútenlo · da [('agua', 1500), ('pan', 3000)]
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)]))
Strategy · caso 7 · después

Orden de los productos

Con Strategy aplicado
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)]))
Strategy · caso 7 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl criterio está escrito adentro
Después · delegaEl criterio se pasa desde afuera

Qué hace el patrón

Saca 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.

Por qué sirve aquí

Cuando quieren ordenar por popularidad, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Pasa de 1 función a varias clases. Hay que saber dónde vive cada variante. Con dos casos fijos, sobra.

Strategy · caso 7 · el impacto

Qué cuesta el cambio, antes y después

Si mañana quieren ordenar por popularidad…AntesDespués
Archivos que hay que abrir1 · el que ya funcionaba1 · uno nuevo
Código existente que se tocaSíNinguno
Variantes que se pueden romperTodas0
¿Se prueba una variante sola?NoSí
Piezas totales1 funciónVarias clases
Strategy · caso 7 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
precio · nombre

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Catalogo
↓
PorPrecio
PorNombre

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen [('agua', 1500), ('pan', 3000)]
Comportamiento · GoF

Observer

La señal: Un método que llama uno por uno a varios módulos que no le importan.

Qué hace: El emisor guarda una lista y avisa a todos, sin saber quiénes son.
Observer · caso 1 de 7 · el contexto

Un termostato

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.

Por qué Observer y no otroUno cambia, varios reaccionan — y la lista de interesados va a crecer.
Observer · caso 1 · antes

Un termostato

Cópienlo y ejecútenlo · da ['pantalla:22', 'registro:22']
class Termostato:
    def cambiar(self, grados):
        return [f"pantalla:{grados}", f"registro:{grados}"]

print(Termostato().cambiar(22))
Observer · caso 1 · después

Un termostato

Con Observer aplicado
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))
Observer · caso 1 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl termostato tiene los nombres escritos
Después · delegaEl termostato solo recorre una lista

Qué hace el patrón

Reemplaza los nombres fijos por una lista. El emisor ya no sabe a quién le avisa, solo recorre a los que se registraron.

Por qué sirve aquí

Cuando hay que avisar también al celular del técnico, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Leyendo el emisor ya no se sabe qué pasa. Depurar cuesta más y el orden no está garantizado.

Observer · caso 1 · el impacto

Qué cuesta el cambio, antes y después

Si mañana hay que avisar también al celular del técnico…AntesDespués
Archivos que hay que abrir1 · el emisor1 · uno nuevo
Código existente que se tocaSíNinguno
Si un interesado falla…Puede tumbar el métodoLos demás siguen
¿Se prueba un interesado solo?NoSí
¿Se sabe qué pasa leyendo el emisor?SíNo · ese es el costo
Observer · caso 1 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
pantalla · registro

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Termostato
↓
Pantalla
Registro

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen ['pantalla:22', 'registro:22']
Observer · caso 2 de 7 · el contexto

Marcador de un partido

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.

Por qué Observer y no otroUn solo hecho debe propagarse a varios lugares que no se conocen entre sí.
Observer · caso 2 · antes

Marcador de un partido

Cópienlo y ejecútenlo · da ['tablero:local', 'sonido:local']
class Marcador:
    def gol(self, equipo):
        return [f"tablero:{equipo}", f"sonido:{equipo}"]

print(Marcador().gol("local"))
Observer · caso 2 · después

Marcador de un partido

Con Observer aplicado
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"))
Observer · caso 2 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl marcador conoce tablero y sonido
Después · delegaEl marcador no sabe quién escucha

Qué hace el patrón

Reemplaza los nombres fijos por una lista. El emisor ya no sabe a quién le avisa, solo recorre a los que se registraron.

Por qué sirve aquí

Cuando piden publicar el gol en redes, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Leyendo el emisor ya no se sabe qué pasa. Depurar cuesta más y el orden no está garantizado.

Observer · caso 2 · el impacto

Qué cuesta el cambio, antes y después

Si mañana piden publicar el gol en redes…AntesDespués
Archivos que hay que abrir1 · el emisor1 · uno nuevo
Código existente que se tocaSíNinguno
Si un interesado falla…Puede tumbar el métodoLos demás siguen
¿Se prueba un interesado solo?NoSí
¿Se sabe qué pasa leyendo el emisor?SíNo · ese es el costo
Observer · caso 2 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
tablero · sonido

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Marcador
↓
Tablero
Sonido

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen ['tablero:local', 'sonido:local']
Observer · caso 3 de 7 · el contexto

Carrito de compras

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.

Por qué Observer y no otroEl carrito no debería saber qué partes de la pantalla existen.
Observer · caso 3 · antes

Carrito de compras

Cópienlo y ejecútenlo · da ['total:5000', 'contador:1']
class Carrito:
    def agregar(self, precio):
        return [f"total:{precio}", f"contador:1"]

print(Carrito().agregar(5000))
Observer · caso 3 · después

Carrito de compras

Con Observer aplicado
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))
Observer · caso 3 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl carrito llama a total y contador
Después · delegaEl carrito publica y sigue su vida

Qué hace el patrón

Reemplaza los nombres fijos por una lista. El emisor ya no sabe a quién le avisa, solo recorre a los que se registraron.

Por qué sirve aquí

Cuando agregan un banner de envío gratis, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Leyendo el emisor ya no se sabe qué pasa. Depurar cuesta más y el orden no está garantizado.

Observer · caso 3 · el impacto

Qué cuesta el cambio, antes y después

Si mañana agregan un banner de envío gratis…AntesDespués
Archivos que hay que abrir1 · el emisor1 · uno nuevo
Código existente que se tocaSíNinguno
Si un interesado falla…Puede tumbar el métodoLos demás siguen
¿Se prueba un interesado solo?NoSí
¿Se sabe qué pasa leyendo el emisor?SíNo · ese es el costo
Observer · caso 3 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
total · contador

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Carrito
↓
Total
Contador

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen ['total:5000', 'contador:1']
Observer · caso 4 de 7 · el contexto

Sensor de puerta

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.

Por qué Observer y no otroSeguridad va a pedir más avisos el próximo mes: cámara, WhatsApp, celaduría.
Observer · caso 4 · antes

Sensor de puerta

Cópienlo y ejecútenlo · da ['alarma:23:40', 'bitacora:23:40']
class Puerta:
    def abrir(self, hora):
        return [f"alarma:{hora}", f"bitacora:{hora}"]

print(Puerta().abrir("23:40"))
Observer · caso 4 · después

Sensor de puerta

Con Observer aplicado
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"))
Observer · caso 4 · la línea que cambió

Una línea contra una línea

Antes · decide adentroAgregar un aviso obliga a tocar el sensor
Después · delegaAgregar un aviso no toca el sensor

Qué hace el patrón

Reemplaza los nombres fijos por una lista. El emisor ya no sabe a quién le avisa, solo recorre a los que se registraron.

Por qué sirve aquí

Cuando piden avisar por WhatsApp a celaduría, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Leyendo el emisor ya no se sabe qué pasa. Depurar cuesta más y el orden no está garantizado.

Observer · caso 4 · el impacto

Qué cuesta el cambio, antes y después

Si mañana piden avisar por WhatsApp a celaduría…AntesDespués
Archivos que hay que abrir1 · el emisor1 · uno nuevo
Código existente que se tocaSíNinguno
Si un interesado falla…Puede tumbar el métodoLos demás siguen
¿Se prueba un interesado solo?NoSí
¿Se sabe qué pasa leyendo el emisor?SíNo · ese es el costo
Observer · caso 4 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
alarma · bitacora

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Puerta
↓
Alarma
Bitacora

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen ['alarma:23:40', 'bitacora:23:40']
Observer · caso 5 de 7 · el contexto

Cambio de precio

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.

Por qué Observer y no otroUn cambio dispara efectos en módulos que evolucionan por separado.
Observer · caso 5 · antes

Cambio de precio

Cópienlo y ejecútenlo · da ['etiqueta:12000', 'historial:12000']
class Producto:
    def cambiar_precio(self, nuevo):
        return [f"etiqueta:{nuevo}", f"historial:{nuevo}"]

print(Producto().cambiar_precio(12000))
Observer · caso 5 · después

Cambio de precio

Con Observer aplicado
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))
Observer · caso 5 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl producto conoce etiqueta e historial
Después · delegaEl producto solo anuncia el cambio

Qué hace el patrón

Reemplaza los nombres fijos por una lista. El emisor ya no sabe a quién le avisa, solo recorre a los que se registraron.

Por qué sirve aquí

Cuando piden avisar al comparador de precios, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Leyendo el emisor ya no se sabe qué pasa. Depurar cuesta más y el orden no está garantizado.

Observer · caso 5 · el impacto

Qué cuesta el cambio, antes y después

Si mañana piden avisar al comparador de precios…AntesDespués
Archivos que hay que abrir1 · el emisor1 · uno nuevo
Código existente que se tocaSíNinguno
Si un interesado falla…Puede tumbar el métodoLos demás siguen
¿Se prueba un interesado solo?NoSí
¿Se sabe qué pasa leyendo el emisor?SíNo · ese es el costo
Observer · caso 5 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
etiqueta · historial

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Producto
↓
Etiqueta
Historial

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen ['etiqueta:12000', 'historial:12000']
Observer · caso 6 de 7 · el contexto

Nivel de un tanque

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.

Por qué Observer y no otroUn mismo evento tiene varios interesados, y mañana habrá uno más.
Observer · caso 6 · antes

Nivel de un tanque

Cópienlo y ejecútenlo · da ['bomba:15', 'indicador:15']
class Tanque:
    def medir(self, nivel):
        return [f"bomba:{nivel}", f"indicador:{nivel}"]

print(Tanque().medir(15))
Observer · caso 6 · después

Nivel de un tanque

Con Observer aplicado
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))
Observer · caso 6 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl tanque llama a bomba e indicador
Después · delegaEl tanque notifica a su lista

Qué hace el patrón

Reemplaza los nombres fijos por una lista. El emisor ya no sabe a quién le avisa, solo recorre a los que se registraron.

Por qué sirve aquí

Cuando piden registrar el evento en la nube, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Leyendo el emisor ya no se sabe qué pasa. Depurar cuesta más y el orden no está garantizado.

Observer · caso 6 · el impacto

Qué cuesta el cambio, antes y después

Si mañana piden registrar el evento en la nube…AntesDespués
Archivos que hay que abrir1 · el emisor1 · uno nuevo
Código existente que se tocaSíNinguno
Si un interesado falla…Puede tumbar el métodoLos demás siguen
¿Se prueba un interesado solo?NoSí
¿Se sabe qué pasa leyendo el emisor?SíNo · ese es el costo
Observer · caso 6 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
bomba · indicador

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Tanque
↓
Bomba
Indicador

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen ['bomba:15', 'indicador:15']
Observer · caso 7 de 7 · el contexto

Campana de la universidad

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.

Por qué Observer y no otroEl emisor no debe depender de cuántos receptores haya.
Observer · caso 7 · antes

Campana de la universidad

Cópienlo y ejecútenlo · da ['salones:10:00', 'tableros:10:00']
class Campana:
    def sonar(self, hora):
        return [f"salones:{hora}", f"tableros:{hora}"]

print(Campana().sonar("10:00"))
Observer · caso 7 · después

Campana de la universidad

Con Observer aplicado
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"))
Observer · caso 7 · la línea que cambió

Una línea contra una línea

Antes · decide adentroLa campana conoce a cada receptor
Después · delegaLa campana recorre observadores

Qué hace el patrón

Reemplaza los nombres fijos por una lista. El emisor ya no sabe a quién le avisa, solo recorre a los que se registraron.

Por qué sirve aquí

Cuando piden avisar a la app de estudiantes, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Leyendo el emisor ya no se sabe qué pasa. Depurar cuesta más y el orden no está garantizado.

Observer · caso 7 · el impacto

Qué cuesta el cambio, antes y después

Si mañana piden avisar a la app de estudiantes…AntesDespués
Archivos que hay que abrir1 · el emisor1 · uno nuevo
Código existente que se tocaSíNinguno
Si un interesado falla…Puede tumbar el métodoLos demás siguen
¿Se prueba un interesado solo?NoSí
¿Se sabe qué pasa leyendo el emisor?SíNo · ese es el costo
Observer · caso 7 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
salones · tableros

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Campana
↓
Salones
Tableros

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen ['salones:10:00', 'tableros:10:00']
Estructural · GoF

Adapter

La señal: El nombre de un proveedor externo aparece regado por todo el sistema.

Qué hace: Una clase traduce: por fuera nuestro idioma, por dentro el del proveedor.
Adapter · caso 1 de 7 · el contexto

Proveedor de SMS

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.

Por qué Adapter y no otroDependemos de algo que no controlamos y cuyo formato no es el nuestro.
Adapter · caso 1 · antes

Proveedor de SMS

Cópienlo y ejecútenlo · da True
class ProveedorSMS:
    def send_text(self, phone, body):
        return {"code": 200, "to": phone}

print(ProveedorSMS().send_text("+57300111", "hola")["code"] == 200)
Adapter · caso 1 · después

Proveedor de SMS

Con Adapter aplicado
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"))
Adapter · caso 1 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl sistema conoce send_text y códigos
Después · delegaEl sistema solo conoce enviar

Qué hace el patrón

Pone una frontera. Solo el adaptador habla el idioma del proveedor; el resto del sistema habla el del negocio.

Por qué sirve aquí

Cuando la empresa cambia de proveedor de SMS, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Una clase más de intermediación. Si el proveedor ofrece algo que la interfaz no expone, hay que ampliarla.

Adapter · caso 1 · el impacto

Qué cuesta el cambio, antes y después

Si mañana la empresa cambia de proveedor de SMS…AntesDespués
Archivos que hay que abrirTodos los que lo usan1 · el adaptador
¿En qué idioma piensa el sistema?El del proveedorEl del negocio
Riesgo de equivocarse al convertirEn cada lugarEn uno solo
¿Se prueba sin llamar al proveedor?NoSí
Piezas totalesLas que ya habíaUna clase más
Adapter · caso 1 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
ProveedorSMS

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Mensajeria
↓
ProveedorSMS

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen True
Adapter · caso 2 de 7 · el contexto

Servicio de clima

Un 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.

Por qué Adapter y no otroLa conversión está regada en cada lugar que consulta el clima.
Adapter · caso 2 · antes

Servicio de clima

Cópienlo y ejecútenlo · da 20.0
class ApiClima:
    def get_temp(self, city): return 68.0

print(round((ApiClima().get_temp("Bogota") - 32) * 5 / 9, 1))
Adapter · caso 2 · después

Servicio de clima

Con Adapter aplicado
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"))
Adapter · caso 2 · la línea que cambió

Una línea contra una línea

Antes · decide adentroLa fórmula de conversión, repetida
Después · delegaLa conversión vive en un solo sitio

Qué hace el patrón

Pone una frontera. Solo el adaptador habla el idioma del proveedor; el resto del sistema habla el del negocio.

Por qué sirve aquí

Cuando el servicio empieza a devolver Celsius, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Una clase más de intermediación. Si el proveedor ofrece algo que la interfaz no expone, hay que ampliarla.

Adapter · caso 2 · el impacto

Qué cuesta el cambio, antes y después

Si mañana el servicio empieza a devolver Celsius…AntesDespués
Archivos que hay que abrirTodos los que lo usan1 · el adaptador
¿En qué idioma piensa el sistema?El del proveedorEl del negocio
Riesgo de equivocarse al convertirEn cada lugarEn uno solo
¿Se prueba sin llamar al proveedor?NoSí
Piezas totalesLas que ya habíaUna clase más
Adapter · caso 2 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
ApiClima

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Clima
↓
ApiClima

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen 20.0
Adapter · caso 3 de 7 · el contexto

Servicio de mapas

Una 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.

Por qué Adapter y no otroEl idioma del proveedor se filtró al vocabulario del negocio.
Adapter · caso 3 · antes

Servicio de mapas

Cópienlo y ejecútenlo · da 15.4
class ApiMapas:
    def distance(self, a, b): return 15400

print(round(ApiMapas().distance("A", "B") / 1000, 2))
Adapter · caso 3 · después

Servicio de mapas

Con Adapter aplicado
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"))
Adapter · caso 3 · la línea que cambió

Una línea contra una línea

Antes · decide adentroCada llamada divide entre 1000
Después · delegaEl adaptador entrega kilómetros

Qué hace el patrón

Pone una frontera. Solo el adaptador habla el idioma del proveedor; el resto del sistema habla el del negocio.

Por qué sirve aquí

Cuando se cambia de proveedor de mapas, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Una clase más de intermediación. Si el proveedor ofrece algo que la interfaz no expone, hay que ampliarla.

Adapter · caso 3 · el impacto

Qué cuesta el cambio, antes y después

Si mañana se cambia de proveedor de mapas…AntesDespués
Archivos que hay que abrirTodos los que lo usan1 · el adaptador
¿En qué idioma piensa el sistema?El del proveedorEl del negocio
Riesgo de equivocarse al convertirEn cada lugarEn uno solo
¿Se prueba sin llamar al proveedor?NoSí
Piezas totalesLas que ya habíaUna clase más
Adapter · caso 3 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
ApiMapas

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Mapas
↓
ApiMapas

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen 15.4
Adapter · caso 4 de 7 · el contexto

Reloj del sistema

El 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.

Por qué Adapter y no otroHay que traducir entre dos representaciones del mismo dato.
Adapter · caso 4 · antes

Reloj del sistema

Cópienlo y ejecútenlo · da 2026-02-0
class RelojSO:
    def epoch(self): return 1770000000

print("2026-02-" + str(1770000000 % 100))
Adapter · caso 4 · después

Reloj del sistema

Con Adapter aplicado
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())
Adapter · caso 4 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl cálculo de fecha, repetido
Después · delegaUna sola clase traduce

Qué hace el patrón

Pone una frontera. Solo el adaptador habla el idioma del proveedor; el resto del sistema habla el del negocio.

Por qué sirve aquí

Cuando cambia la forma de leer la hora, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Una clase más de intermediación. Si el proveedor ofrece algo que la interfaz no expone, hay que ampliarla.

Adapter · caso 4 · el impacto

Qué cuesta el cambio, antes y después

Si mañana cambia la forma de leer la hora…AntesDespués
Archivos que hay que abrirTodos los que lo usan1 · el adaptador
¿En qué idioma piensa el sistema?El del proveedorEl del negocio
Riesgo de equivocarse al convertirEn cada lugarEn uno solo
¿Se prueba sin llamar al proveedor?NoSí
Piezas totalesLas que ya habíaUna clase más
Adapter · caso 4 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
RelojSO

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Reloj
↓
RelojSO

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen 2026-02-0
Adapter · caso 5 de 7 · el contexto

Lector de archivos viejo

Un 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.

Por qué Adapter y no otroNo se puede modificar el sistema viejo, pero sí envolverlo.
Adapter · caso 5 · antes

Lector de archivos viejo

Cópienlo y ejecútenlo · da ['ana', 'luis', 'pedro']
class LectorLegado:
    def read_line(self): return "ana;luis;pedro"

print(LectorLegado().read_line().split(";"))
Adapter · caso 5 · después

Lector de archivos viejo

Con Adapter aplicado
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())
Adapter · caso 5 · la línea que cambió

Una línea contra una línea

Antes · decide adentroTodos parsean el texto crudo
Después · delegaSolo el adaptador conoce el formato

Qué hace el patrón

Pone una frontera. Solo el adaptador habla el idioma del proveedor; el resto del sistema habla el del negocio.

Por qué sirve aquí

Cuando el sistema viejo cambia el separador, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Una clase más de intermediación. Si el proveedor ofrece algo que la interfaz no expone, hay que ampliarla.

Adapter · caso 5 · el impacto

Qué cuesta el cambio, antes y después

Si mañana el sistema viejo cambia el separador…AntesDespués
Archivos que hay que abrirTodos los que lo usan1 · el adaptador
¿En qué idioma piensa el sistema?El del proveedorEl del negocio
Riesgo de equivocarse al convertirEn cada lugarEn uno solo
¿Se prueba sin llamar al proveedor?NoSí
Piezas totalesLas que ya habíaUna clase más
Adapter · caso 5 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
LectorLegado

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Lector
↓
LectorLegado

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen ['ana', 'luis', 'pedro']
Adapter · caso 6 de 7 · el contexto

Pasarela de pagos

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.

Por qué Adapter y no otroEl error de multiplicar por 100 puede ocurrir en cualquiera de los once sitios.
Adapter · caso 6 · antes

Pasarela de pagos

Cópienlo y ejecútenlo · da True
class Pasarela:
    def do_charge(self, cents, token):
        return {"status": "OK"}

print(Pasarela().do_charge(50000 * 100, "tok")["status"] == "OK")
Adapter · caso 6 · después

Pasarela de pagos

Con Adapter aplicado
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"))
Adapter · caso 6 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl * 100 está en once lugares
Después · delegaEl * 100 está en uno solo

Qué hace el patrón

Pone una frontera. Solo el adaptador habla el idioma del proveedor; el resto del sistema habla el del negocio.

Por qué sirve aquí

Cuando la empresa cambia de pasarela, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Una clase más de intermediación. Si el proveedor ofrece algo que la interfaz no expone, hay que ampliarla.

Adapter · caso 6 · el impacto

Qué cuesta el cambio, antes y después

Si mañana la empresa cambia de pasarela…AntesDespués
Archivos que hay que abrirTodos los que lo usan1 · el adaptador
¿En qué idioma piensa el sistema?El del proveedorEl del negocio
Riesgo de equivocarse al convertirEn cada lugarEn uno solo
¿Se prueba sin llamar al proveedor?NoSí
Piezas totalesLas que ya habíaUna clase más
Adapter · caso 6 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
OK

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Pagos
↓
Pasarela

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen True
Adapter · caso 7 de 7 · el contexto

Impresora antigua

Una impresora antigua solo entiende comandos crudos de dos letras.

Cada módulo arma los comandos a mano y ya hubo recibos impresos con basura.

Por qué Adapter y no otroQueremos pedirle un recibo, no armar comandos a mano.
Adapter · caso 7 · antes

Impresora antigua

Cópienlo y ejecútenlo · da PRN:recibo 001
class ImpresoraVieja:
    def cmd(self, code, data): return f"{code}:{data}"

print(ImpresoraVieja().cmd("PRN", "recibo 001"))
Adapter · caso 7 · después

Impresora antigua

Con Adapter aplicado
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"))
Adapter · caso 7 · la línea que cambió

Una línea contra una línea

Antes · decide adentroCada módulo arma comandos
Después · delegaEl adaptador arma el comando

Qué hace el patrón

Pone una frontera. Solo el adaptador habla el idioma del proveedor; el resto del sistema habla el del negocio.

Por qué sirve aquí

Cuando llega una impresora nueva, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Una clase más de intermediación. Si el proveedor ofrece algo que la interfaz no expone, hay que ampliarla.

Adapter · caso 7 · el impacto

Qué cuesta el cambio, antes y después

Si mañana llega una impresora nueva…AntesDespués
Archivos que hay que abrirTodos los que lo usan1 · el adaptador
¿En qué idioma piensa el sistema?El del proveedorEl del negocio
Riesgo de equivocarse al convertirEn cada lugarEn uno solo
¿Se prueba sin llamar al proveedor?NoSí
Piezas totalesLas que ya habíaUna clase más
Adapter · caso 7 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
ImpresoraVieja

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Impresora
↓
ImpresoraVieja

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen PRN:recibo 001
Creacional · GoF

Factory

La señal: El mismo if de creación aparece copiado en varios archivos.

Qué hace: Un solo lugar decide qué crear. El resto pide y recibe.
Factory · caso 1 de 7 · el contexto

Crear reportes

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.

Por qué Factory y no otroEl mismo if de creación aparece copiado en muchos sitios.
Factory · caso 1 · antes

Crear reportes

Cópienlo y ejecútenlo · da PDF listo
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())
Factory · caso 1 · después

Crear reportes

Con Factory aplicado
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())
Factory · caso 1 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl if de creación, repetido
Después · delegaUn solo lugar decide qué crear

Qué hace el patrón

Concentra la decisión. Quien usa el objeto ya no decide cuál crear: lo pide y lo recibe.

Por qué sirve aquí

Cuando agregan el reporte en CSV, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Una clase más y un salto de lectura. Si solo hay una cosa que crear, la fábrica sobra.

Factory · caso 1 · el impacto

Qué cuesta el cambio, antes y después

Si mañana agregan el reporte en CSV…AntesDespués
Lugares donde se decide qué crearVarios · copiados1
Riesgo de que queden desalineadosAltoNinguno
Código existente que se tocaTodos los sitiosSolo la fábrica
¿Quien lo usa sabe cómo se crea?Sí · y no deberíaNo
Piezas totalesLas que ya habíaUna clase más
Factory · caso 1 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
pdf

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
FabricaReportes
↓
ReportePDF
ReporteExcel

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen PDF listo
Factory · caso 2 de 7 · el contexto

Crear notificadores

Se 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.

Por qué Factory y no otroQuien envía no debería saber cómo se construye el notificador.
Factory · caso 2 · antes

Crear notificadores

Cópienlo y ejecútenlo · da sms enviado
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())
Factory · caso 2 · después

Crear notificadores

Con Factory aplicado
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())
Factory · caso 2 · la línea que cambió

Una línea contra una línea

Antes · decide adentroCada módulo elige el canal
Después · delegaLa fábrica elige el canal

Qué hace el patrón

Concentra la decisión. Quien usa el objeto ya no decide cuál crear: lo pide y lo recibe.

Por qué sirve aquí

Cuando agregan notificación push, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Una clase más y un salto de lectura. Si solo hay una cosa que crear, la fábrica sobra.

Factory · caso 2 · el impacto

Qué cuesta el cambio, antes y después

Si mañana agregan notificación push…AntesDespués
Lugares donde se decide qué crearVarios · copiados1
Riesgo de que queden desalineadosAltoNinguno
Código existente que se tocaTodos los sitiosSolo la fábrica
¿Quien lo usa sabe cómo se crea?Sí · y no deberíaNo
Piezas totalesLas que ya habíaUna clase más
Factory · caso 2 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
correo

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
FabricaNotificador
↓
PorCorreo
PorSMS

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen sms enviado
Factory · caso 3 de 7 · el contexto

Vehículo de domicilio

Un 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í.

Por qué Factory y no otroLa regla de asignación es una sola, pero está copiada.
Factory · caso 3 · antes

Vehículo de domicilio

Cópienlo y ejecútenlo · da moto
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())
Factory · caso 3 · después

Vehículo de domicilio

Con Factory aplicado
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())
Factory · caso 3 · la línea que cambió

Una línea contra una línea

Antes · decide adentroLa regla de km, repetida
Después · delegaLa regla vive en la fábrica

Qué hace el patrón

Concentra la decisión. Quien usa el objeto ya no decide cuál crear: lo pide y lo recibe.

Por qué sirve aquí

Cuando agregan domicilio en camioneta, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Una clase más y un salto de lectura. Si solo hay una cosa que crear, la fábrica sobra.

Factory · caso 3 · el impacto

Qué cuesta el cambio, antes y después

Si mañana agregan domicilio en camioneta…AntesDespués
Lugares donde se decide qué crearVarios · copiados1
Riesgo de que queden desalineadosAltoNinguno
Código existente que se tocaTodos los sitiosSolo la fábrica
¿Quien lo usa sabe cómo se crea?Sí · y no deberíaNo
Piezas totalesLas que ya habíaUna clase más
Factory · caso 3 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Moto · Bici

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
FabricaVehiculo
↓
Moto
Bici

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen moto
Factory · caso 4 de 7 · el contexto

Conexión a base de datos

Distintos 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.

Por qué Factory y no otroQuien consulta no necesita saber qué motor hay debajo.
Factory · caso 4 · antes

Conexión a base de datos

Cópienlo y ejecútenlo · da postgres ok
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())
Factory · caso 4 · después

Conexión a base de datos

Con Factory aplicado
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())
Factory · caso 4 · la línea que cambió

Una línea contra una línea

Antes · decide adentroCada capa decide el motor
Después · delegaLa fábrica decide el motor

Qué hace el patrón

Concentra la decisión. Quien usa el objeto ya no decide cuál crear: lo pide y lo recibe.

Por qué sirve aquí

Cuando se migra a otro motor, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Una clase más y un salto de lectura. Si solo hay una cosa que crear, la fábrica sobra.

Factory · caso 4 · el impacto

Qué cuesta el cambio, antes y después

Si mañana se migra a otro motor…AntesDespués
Lugares donde se decide qué crearVarios · copiados1
Riesgo de que queden desalineadosAltoNinguno
Código existente que se tocaTodos los sitiosSolo la fábrica
¿Quien lo usa sabe cómo se crea?Sí · y no deberíaNo
Piezas totalesLas que ya habíaUna clase más
Factory · caso 4 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
postgres

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
FabricaConexion
↓
Postgres
SqlServer

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen postgres ok
Factory · caso 5 de 7 · el contexto

Tipo de usuario

Cada 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.

Por qué Factory y no otroLa creación tiene lógica propia que merece un solo dueño.
Factory · caso 5 · antes

Tipo de usuario

Cópienlo y ejecútenlo · da lectura
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())
Factory · caso 5 · después

Tipo de usuario

Con Factory aplicado
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())
Factory · caso 5 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl rol se decide en cada pantalla
Después · delegaEl rol se decide en la fábrica

Qué hace el patrón

Concentra la decisión. Quien usa el objeto ya no decide cuál crear: lo pide y lo recibe.

Por qué sirve aquí

Cuando agregan el rol de auditor, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Una clase más y un salto de lectura. Si solo hay una cosa que crear, la fábrica sobra.

Factory · caso 5 · el impacto

Qué cuesta el cambio, antes y después

Si mañana agregan el rol de auditor…AntesDespués
Lugares donde se decide qué crearVarios · copiados1
Riesgo de que queden desalineadosAltoNinguno
Código existente que se tocaTodos los sitiosSolo la fábrica
¿Quien lo usa sabe cómo se crea?Sí · y no deberíaNo
Piezas totalesLas que ya habíaUna clase más
Factory · caso 5 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
admin

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
FabricaUsuario
↓
Admin
Invitado

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen lectura
Factory · caso 6 de 7 · el contexto

Empaque por tamaño

La 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.

Por qué Factory y no otroUna regla de negocio metida en la creación del objeto.
Factory · caso 6 · antes

Empaque por tamaño

Cópienlo y ejecútenlo · da sobre
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())
Factory · caso 6 · después

Empaque por tamaño

Con Factory aplicado
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())
Factory · caso 6 · la línea que cambió

Una línea contra una línea

Antes · decide adentroLa regla de peso, en cada módulo
Después · delegaLa regla de peso, en la fábrica

Qué hace el patrón

Concentra la decisión. Quien usa el objeto ya no decide cuál crear: lo pide y lo recibe.

Por qué sirve aquí

Cuando agregan empaque refrigerado, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Una clase más y un salto de lectura. Si solo hay una cosa que crear, la fábrica sobra.

Factory · caso 6 · el impacto

Qué cuesta el cambio, antes y después

Si mañana agregan empaque refrigerado…AntesDespués
Lugares donde se decide qué crearVarios · copiados1
Riesgo de que queden desalineadosAltoNinguno
Código existente que se tocaTodos los sitiosSolo la fábrica
¿Quien lo usa sabe cómo se crea?Sí · y no deberíaNo
Piezas totalesLas que ya habíaUna clase más
Factory · caso 6 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Caja · Sobre

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
FabricaEmpaque
↓
Caja
Sobre

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen sobre
Factory · caso 7 de 7 · el contexto

Documento tributario

Se 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.

Por qué Factory y no otroEs una decisión tributaria que no debería estar dispersa.
Factory · caso 7 · antes

Documento tributario

Cópienlo y ejecútenlo · da cuenta de cobro emitida
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())
Factory · caso 7 · después

Documento tributario

Con Factory aplicado
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())
Factory · caso 7 · la línea que cambió

Una línea contra una línea

Antes · decide adentroLa decisión, repetida en el código
Después · delegaLa decisión, en un solo lugar

Qué hace el patrón

Concentra la decisión. Quien usa el objeto ya no decide cuál crear: lo pide y lo recibe.

Por qué sirve aquí

Cuando la DIAN agrega un documento, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Una clase más y un salto de lectura. Si solo hay una cosa que crear, la fábrica sobra.

Factory · caso 7 · el impacto

Qué cuesta el cambio, antes y después

Si mañana la DIAN agrega un documento…AntesDespués
Lugares donde se decide qué crearVarios · copiados1
Riesgo de que queden desalineadosAltoNinguno
Código existente que se tocaTodos los sitiosSolo la fábrica
¿Quien lo usa sabe cómo se crea?Sí · y no deberíaNo
Piezas totalesLas que ya habíaUna clase más
Factory · caso 7 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
juridica

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
FabricaDocumento
↓
Factura
CuentaCobro

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen cuenta de cobro emitida
Creacional · GoF · el más polémico

Singleton

La señal: Se crean varias instancias de algo que debería ser único.

Qué hace: Un método get() devuelve siempre el mismo objeto.
Singleton · caso 1 de 7 · el contexto

Configuración

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.

Por qué Singleton y no otroDebe existir una sola instancia compartida por todo el programa.
Singleton · caso 1 · antes

Configuración

Cópienlo y ejecútenlo · da 1.19 False
class Config:
    def __init__(self): self.iva = 1.19

a = Config()
b = Config()
print(a.iva, a is b)
Singleton · caso 1 · después

Configuración

Con Singleton aplicado
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)
Singleton · caso 1 · la línea que cambió

Una línea contra una línea

Antes · decide adentroCada llamada crea una configuración
Después · delegaTodos reciben el mismo objeto

Qué hace el patrón

Controla la creación. Todos reciben el mismo objeto en vez de crear el suyo.

Por qué sirve aquí

Cuando se agrega un módulo que lee la configuración, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Es una variable global disfrazada: la dependencia queda invisible y no se puede reemplazar en una prueba.

Singleton · caso 1 · el impacto

Qué cuesta el cambio, antes y después

Si mañana se agrega un módulo que lee la configuración…AntesDespués
Instancias que existenTantas como llamadasSiempre una
¿El estado queda sincronizado?NoSí
Recursos que se desperdicianUno por llamadaNinguno
¿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
Singleton · caso 1 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Config

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Config
↓
cada pieza

No conoce a ninguna: solo pide lo que necesita.

La salida cambia a propósito: 1.19 False pasa a 1.19 True
Singleton · caso 2 de 7 · el contexto

Contador de visitas

Cada 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.

Por qué Singleton y no otroEl estado tiene que ser compartido, no copiado.
Singleton · caso 2 · antes

Contador de visitas

Cópienlo y ejecútenlo · da 2 False
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)
Singleton · caso 2 · después

Contador de visitas

Con Singleton aplicado
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)
Singleton · caso 2 · la línea que cambió

Una línea contra una línea

Antes · decide adentroDos contadores independientes
Después · delegaUn contador único

Qué hace el patrón

Controla la creación. Todos reciben el mismo objeto en vez de crear el suyo.

Por qué sirve aquí

Cuando se agrega una pantalla que cuenta visitas, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Es una variable global disfrazada: la dependencia queda invisible y no se puede reemplazar en una prueba.

Singleton · caso 2 · el impacto

Qué cuesta el cambio, antes y después

Si mañana se agrega una pantalla que cuenta visitas…AntesDespués
Instancias que existenTantas como llamadasSiempre una
¿El estado queda sincronizado?NoSí
Recursos que se desperdicianUno por llamadaNinguno
¿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
Singleton · caso 2 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Contador

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Contador
↓
cada pieza

No conoce a ninguna: solo pide lo que necesita.

La salida cambia a propósito: 2 False pasa a 2 True
Singleton · caso 3 de 7 · el contexto

Registro de eventos

Se 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.

Por qué Singleton y no otroUn recurso único por naturaleza: el archivo de registro.
Singleton · caso 3 · antes

Registro de eventos

Cópienlo y ejecútenlo · da 2 False
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)
Singleton · caso 3 · después

Registro de eventos

Con Singleton aplicado
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)
Singleton · caso 3 · la línea que cambió

Una línea contra una línea

Antes · decide adentroCada parte abre su propio log
Después · delegaUn solo log para todos

Qué hace el patrón

Controla la creación. Todos reciben el mismo objeto en vez de crear el suyo.

Por qué sirve aquí

Cuando se agrega un módulo que registra, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Es una variable global disfrazada: la dependencia queda invisible y no se puede reemplazar en una prueba.

Singleton · caso 3 · el impacto

Qué cuesta el cambio, antes y después

Si mañana se agrega un módulo que registra…AntesDespués
Instancias que existenTantas como llamadasSiempre una
¿El estado queda sincronizado?NoSí
Recursos que se desperdicianUno por llamadaNinguno
¿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
Singleton · caso 3 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Log

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Log
↓
cada pieza

No conoce a ninguna: solo pide lo que necesita.

La salida cambia a propósito: 2 False pasa a 2 True
Singleton · caso 4 de 7 · el contexto

Conexión a base de datos

Abrir 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.

Por qué Singleton y no otroUn recurso caro que conviene crear una vez.
Singleton · caso 4 · antes

Conexión a base de datos

Cópienlo y ejecútenlo · da True False
class Conexion:
    def __init__(self): self.abierta = True

a = Conexion()
b = Conexion()
print(a.abierta, a is b)
Singleton · caso 4 · después

Conexión a base de datos

Con Singleton aplicado
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)
Singleton · caso 4 · la línea que cambió

Una línea contra una línea

Antes · decide adentroUna conexión por consulta
Después · delegaUna conexión reutilizada

Qué hace el patrón

Controla la creación. Todos reciben el mismo objeto en vez de crear el suyo.

Por qué sirve aquí

Cuando sube el número de consultas, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Es una variable global disfrazada: la dependencia queda invisible y no se puede reemplazar en una prueba.

Singleton · caso 4 · el impacto

Qué cuesta el cambio, antes y después

Si mañana sube el número de consultas…AntesDespués
Instancias que existenTantas como llamadasSiempre una
¿El estado queda sincronizado?NoSí
Recursos que se desperdicianUno por llamadaNinguno
¿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
Singleton · caso 4 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Conexion

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Conexion
↓
cada pieza

No conoce a ninguna: solo pide lo que necesita.

La salida cambia a propósito: True False pasa a True True
Singleton · caso 5 de 7 · el contexto

Caché de precios

Cada 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.

Por qué Singleton y no otroEl caché pierde el sentido si hay varios.
Singleton · caso 5 · antes

Caché de precios

Cópienlo y ejecútenlo · da None False
class Cache:
    def __init__(self): self.datos = {}

a = Cache(); a.datos["pan"] = 3000
b = Cache()
print(b.datos.get("pan"), a is b)
Singleton · caso 5 · después

Caché de precios

Con Singleton aplicado
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)
Singleton · caso 5 · la línea que cambió

Una línea contra una línea

Antes · decide adentroVarios cachés desincronizados
Después · delegaUn caché compartido

Qué hace el patrón

Controla la creación. Todos reciben el mismo objeto en vez de crear el suyo.

Por qué sirve aquí

Cuando se agrega otra pantalla con precios, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Es una variable global disfrazada: la dependencia queda invisible y no se puede reemplazar en una prueba.

Singleton · caso 5 · el impacto

Qué cuesta el cambio, antes y después

Si mañana se agrega otra pantalla con precios…AntesDespués
Instancias que existenTantas como llamadasSiempre una
¿El estado queda sincronizado?NoSí
Recursos que se desperdicianUno por llamadaNinguno
¿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
Singleton · caso 5 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Cache

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Cache
↓
cada pieza

No conoce a ninguna: solo pide lo que necesita.

La salida cambia a propósito: None False pasa a 3000 True
Singleton · caso 6 de 7 · el contexto

Cola de impresión

Dos colas de impresión distintas peleaban por la misma impresora.

Dos colas mandaban a la vez y los recibos salían intercalados entre sí.

Por qué Singleton y no otroUn dispositivo físico único exige una cola única.
Singleton · caso 6 · antes

Cola de impresión

Cópienlo y ejecútenlo · da 0 False
class Cola:
    def __init__(self): self.items = []

a = Cola(); a.items.append("doc1")
b = Cola()
print(len(b.items), a is b)
Singleton · caso 6 · después

Cola de impresión

Con Singleton aplicado
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)
Singleton · caso 6 · la línea que cambió

Una línea contra una línea

Antes · decide adentroDos colas para una impresora
Después · delegaUna sola cola

Qué hace el patrón

Controla la creación. Todos reciben el mismo objeto en vez de crear el suyo.

Por qué sirve aquí

Cuando se agrega otro punto de impresión, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Es una variable global disfrazada: la dependencia queda invisible y no se puede reemplazar en una prueba.

Singleton · caso 6 · el impacto

Qué cuesta el cambio, antes y después

Si mañana se agrega otro punto de impresión…AntesDespués
Instancias que existenTantas como llamadasSiempre una
¿El estado queda sincronizado?NoSí
Recursos que se desperdicianUno por llamadaNinguno
¿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
Singleton · caso 6 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Cola

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Cola
↓
cada pieza

No conoce a ninguna: solo pide lo que necesita.

La salida cambia a propósito: 0 False pasa a 1 True
Singleton · caso 7 de 7 · el contexto

Sesión del usuario

El 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.

Por qué Singleton y no otroLa sesión es una sola por definición.
Singleton · caso 7 · antes

Sesión del usuario

Cópienlo y ejecútenlo · da None False
class Sesion:
    def __init__(self): self.usuario = None

a = Sesion(); a.usuario = "ana"
b = Sesion()
print(b.usuario, a is b)
Singleton · caso 7 · después

Sesión del usuario

Con Singleton aplicado
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)
Singleton · caso 7 · la línea que cambió

Una línea contra una línea

Antes · decide adentroCada pantalla con su sesión
Después · delegaUna sesión compartida

Qué hace el patrón

Controla la creación. Todos reciben el mismo objeto en vez de crear el suyo.

Por qué sirve aquí

Cuando se agrega una sección nueva, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Es una variable global disfrazada: la dependencia queda invisible y no se puede reemplazar en una prueba.

Singleton · caso 7 · el impacto

Qué cuesta el cambio, antes y después

Si mañana se agrega una sección nueva…AntesDespués
Instancias que existenTantas como llamadasSiempre una
¿El estado queda sincronizado?NoSí
Recursos que se desperdicianUno por llamadaNinguno
¿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
Singleton · caso 7 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Sesion

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Sesion
↓
cada pieza

No conoce a ninguna: solo pide lo que necesita.

La salida cambia a propósito: None False pasa a ana True
Principio · NO es patrón GoF

Inyección de dependencias

La señal: Una clase va a buscar lo que necesita en vez de recibirlo.

Qué hace: Lo que necesita le llega por el constructor.
Inyección de dependencias · caso 1 de 7 · el contexto

Servicio de correo

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.

Por qué Inyección de dependencias y no otroLa clase va y busca lo que necesita en vez de recibirlo.
Inyección de dependencias · caso 1 · antes

Servicio de correo

Cópienlo y ejecútenlo · da real para ana
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"))
Inyección de dependencias · caso 1 · después

Servicio de correo

Con Inyección de dependencias aplicado
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"))
Inyección de dependencias · caso 1 · la línea que cambió

Una línea contra una línea

Antes · decide adentroCorreo() creado adentro
Después · delegaEl correo llega por el constructor

Qué hace el patrón

Invierte quién consigue qué. La clase deja de buscar y pasa a recibir, así que la dependencia se puede cambiar.

Por qué sirve aquí

Cuando hay que probar el flujo sin enviar correos, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Alguien tiene que armar y pasar las dependencias. En proyectos grandes suele hacer falta un contenedor.

Inyección de dependencias · caso 1 · el impacto

Qué cuesta el cambio, antes y después

Si mañana hay que probar el flujo sin enviar correos…AntesDespués
¿Se puede probar sin el servicio real?NoSí
¿La firma dice de qué depende?NoSí
Efectos secundarios en pruebasSí · realesNinguno
Código existente que se tocaEl de la claseSolo el constructor
Piezas totalesLas que ya habíaUna más al armar
Inyección de dependencias · caso 1 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Correo · Bienvenida

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Bienvenida
↓
Correo

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen real para ana
Inyección de dependencias · caso 2 de 7 · el contexto

El reloj

Un 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.

Por qué Inyección de dependencias y no otroDepende del reloj real, que no se puede controlar en una prueba.
Inyección de dependencias · caso 2 · antes

El reloj

Cópienlo y ejecútenlo · da recibo 2026-08-11
class Reloj:
    def hoy(self): return "2026-08-11"

class Recibo:
    def emitir(self): return "recibo " + Reloj().hoy()

print(Recibo().emitir())
Inyección de dependencias · caso 2 · después

El reloj

Con Inyección de dependencias aplicado
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())
Inyección de dependencias · caso 2 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl reloj se consulta adentro
Después · delegaEl reloj se recibe y se puede falsear

Qué hace el patrón

Invierte quién consigue qué. La clase deja de buscar y pasa a recibir, así que la dependencia se puede cambiar.

Por qué sirve aquí

Cuando hay que probar con una fecha fija, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Alguien tiene que armar y pasar las dependencias. En proyectos grandes suele hacer falta un contenedor.

Inyección de dependencias · caso 2 · el impacto

Qué cuesta el cambio, antes y después

Si mañana hay que probar con una fecha fija…AntesDespués
¿Se puede probar sin el servicio real?NoSí
¿La firma dice de qué depende?NoSí
Efectos secundarios en pruebasSí · realesNinguno
Código existente que se tocaEl de la claseSolo el constructor
Piezas totalesLas que ya habíaUna más al armar
Inyección de dependencias · caso 2 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Reloj · Recibo

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Recibo
↓
Reloj

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen recibo 2026-08-11
Inyección de dependencias · caso 3 de 7 · el contexto

Números aleatorios

Un 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.

Por qué Inyección de dependencias y no otroLo impredecible tiene que poder reemplazarse.
Inyección de dependencias · caso 3 · antes

Números aleatorios

Cópienlo y ejecútenlo · da sacaste 4
class Dado:
    def tirar(self): return 4

class Juego:
    def turno(self): return "sacaste " + str(Dado().tirar())

print(Juego().turno())
Inyección de dependencias · caso 3 · después

Números aleatorios

Con Inyección de dependencias aplicado
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())
Inyección de dependencias · caso 3 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl dado se crea adentro
Después · delegaEl dado se inyecta

Qué hace el patrón

Invierte quién consigue qué. La clase deja de buscar y pasa a recibir, así que la dependencia se puede cambiar.

Por qué sirve aquí

Cuando hay que probar con un valor fijo, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Alguien tiene que armar y pasar las dependencias. En proyectos grandes suele hacer falta un contenedor.

Inyección de dependencias · caso 3 · el impacto

Qué cuesta el cambio, antes y después

Si mañana hay que probar con un valor fijo…AntesDespués
¿Se puede probar sin el servicio real?NoSí
¿La firma dice de qué depende?NoSí
Efectos secundarios en pruebasSí · realesNinguno
Código existente que se tocaEl de la claseSolo el constructor
Piezas totalesLas que ya habíaUna más al armar
Inyección de dependencias · caso 3 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Dado · Juego

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Juego
↓
Dado

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen sacaste 4
Inyección de dependencias · caso 4 de 7 · el contexto

Repositorio de datos

Un 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.

Por qué Inyección de dependencias y no otroLa lógica no debería depender de la infraestructura.
Inyección de dependencias · caso 4 · antes

Repositorio de datos

Cópienlo y ejecútenlo · da 2
class Repo:
    def clientes(self): return ["ana", "luis"]

class Informe:
    def total(self): return len(Repo().clientes())

print(Informe().total())
Inyección de dependencias · caso 4 · después

Repositorio de datos

Con Inyección de dependencias aplicado
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())
Inyección de dependencias · caso 4 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl repositorio se crea adentro
Después · delegaEl repositorio se recibe

Qué hace el patrón

Invierte quién consigue qué. La clase deja de buscar y pasa a recibir, así que la dependencia se puede cambiar.

Por qué sirve aquí

Cuando hay que probar sin base de datos, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Alguien tiene que armar y pasar las dependencias. En proyectos grandes suele hacer falta un contenedor.

Inyección de dependencias · caso 4 · el impacto

Qué cuesta el cambio, antes y después

Si mañana hay que probar sin base de datos…AntesDespués
¿Se puede probar sin el servicio real?NoSí
¿La firma dice de qué depende?NoSí
Efectos secundarios en pruebasSí · realesNinguno
Código existente que se tocaEl de la claseSolo el constructor
Piezas totalesLas que ya habíaUna más al armar
Inyección de dependencias · caso 4 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Repo · Informe

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Informe
↓
Repo

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen 2
Inyección de dependencias · caso 5 de 7 · el contexto

Tasa de cambio

Un 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.

Por qué Inyección de dependencias y no otroUn dato externo y volátil metido en la lógica.
Inyección de dependencias · caso 5 · antes

Tasa de cambio

Cópienlo y ejecútenlo · da 40000
class Tasa:
    def usd(self): return 4000

class Precio:
    def en_pesos(self, dolares): return dolares * Tasa().usd()

print(Precio().en_pesos(10))
Inyección de dependencias · caso 5 · después

Tasa de cambio

Con Inyección de dependencias aplicado
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))
Inyección de dependencias · caso 5 · la línea que cambió

Una línea contra una línea

Antes · decide adentroLa tasa se consulta adentro
Después · delegaLa tasa se pasa como dependencia

Qué hace el patrón

Invierte quién consigue qué. La clase deja de buscar y pasa a recibir, así que la dependencia se puede cambiar.

Por qué sirve aquí

Cuando hay que probar con una tasa fija, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Alguien tiene que armar y pasar las dependencias. En proyectos grandes suele hacer falta un contenedor.

Inyección de dependencias · caso 5 · el impacto

Qué cuesta el cambio, antes y después

Si mañana hay que probar con una tasa fija…AntesDespués
¿Se puede probar sin el servicio real?NoSí
¿La firma dice de qué depende?NoSí
Efectos secundarios en pruebasSí · realesNinguno
Código existente que se tocaEl de la claseSolo el constructor
Piezas totalesLas que ya habíaUna más al armar
Inyección de dependencias · caso 5 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Tasa · Precio

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Precio
↓
Tasa

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen 40000
Inyección de dependencias · caso 6 de 7 · el contexto

Registro de auditoría

Cada 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.

Por qué Inyección de dependencias y no otroUn efecto secundario que conviene poder apagar.
Inyección de dependencias · caso 6 · antes

Registro de auditoría

Cópienlo y ejecútenlo · da log:50000
class Logger:
    def escribir(self, m): return "log:" + m

class Transferencia:
    def hacer(self, monto): return Logger().escribir(str(monto))

print(Transferencia().hacer(50000))
Inyección de dependencias · caso 6 · después

Registro de auditoría

Con Inyección de dependencias aplicado
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))
Inyección de dependencias · caso 6 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl logger se crea adentro
Después · delegaEl logger se inyecta

Qué hace el patrón

Invierte quién consigue qué. La clase deja de buscar y pasa a recibir, así que la dependencia se puede cambiar.

Por qué sirve aquí

Cuando hay que probar sin escribir en auditoría, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Alguien tiene que armar y pasar las dependencias. En proyectos grandes suele hacer falta un contenedor.

Inyección de dependencias · caso 6 · el impacto

Qué cuesta el cambio, antes y después

Si mañana hay que probar sin escribir en auditoría…AntesDespués
¿Se puede probar sin el servicio real?NoSí
¿La firma dice de qué depende?NoSí
Efectos secundarios en pruebasSí · realesNinguno
Código existente que se tocaEl de la claseSolo el constructor
Piezas totalesLas que ya habíaUna más al armar
Inyección de dependencias · caso 6 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
Logger · Transferencia

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Transferencia
↓
Logger

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen log:50000
Inyección de dependencias · caso 7 de 7 · el contexto

Validador externo

Aprobar 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.

Por qué Inyección de dependencias y no otroDepender de un servicio ajeno hace la prueba lenta y frágil.
Inyección de dependencias · caso 7 · antes

Validador externo

Cópienlo y ejecútenlo · da True
class ValidadorNit:
    def existe(self, nit): return True

class Registro:
    def aprobar(self, nit): return ValidadorNit().existe(nit)

print(Registro().aprobar("900123456"))
Inyección de dependencias · caso 7 · después

Validador externo

Con Inyección de dependencias aplicado
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"))
Inyección de dependencias · caso 7 · la línea que cambió

Una línea contra una línea

Antes · decide adentroEl validador se crea adentro
Después · delegaEl validador se recibe

Qué hace el patrón

Invierte quién consigue qué. La clase deja de buscar y pasa a recibir, así que la dependencia se puede cambiar.

Por qué sirve aquí

Cuando hay que probar sin llamar al servicio, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Alguien tiene que armar y pasar las dependencias. En proyectos grandes suele hacer falta un contenedor.

Inyección de dependencias · caso 7 · el impacto

Qué cuesta el cambio, antes y después

Si mañana hay que probar sin llamar al servicio…AntesDespués
¿Se puede probar sin el servicio real?NoSí
¿La firma dice de qué depende?NoSí
Efectos secundarios en pruebasSí · realesNinguno
Código existente que se tocaEl de la claseSolo el constructor
Piezas totalesLas que ya habíaUna más al armar
Inyección de dependencias · caso 7 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
ValidadorNit · Registro

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
Registro
↓
ValidadorNit

No conoce a ninguna: solo pide lo que necesita.

Ambos imprimen True
Principio · NO es patrón GoF

Separar responsabilidades

La señal: Para describir la función hace falta la palabra "y".

Qué hace: Cada pieza tiene una sola razón de existir.
Separar responsabilidades · caso 1 de 7 · el contexto

Una factura

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.

Por qué Separar responsabilidades y no otroPara describirla hay que decir calcula y formatea.
Separar responsabilidades · caso 1 · antes

Una factura

Cópienlo y ejecútenlo · da FACTURA total=7500
ITEMS = [("pan", 3000), ("leche", 4500)]

def facturar(items):
    total = sum(p for _, p in items)
    return f"FACTURA total={total}"

print(facturar(ITEMS))
Separar responsabilidades · caso 1 · después

Una factura

Con Separar responsabilidades aplicado
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)))
Separar responsabilidades · caso 1 · la línea que cambió

Una línea contra una línea

Antes · decide adentroCálculo y formato mezclados
Después · delegaDos funciones, una por responsabilidad

Qué hace el patrón

Parte por responsabilidad. Cada pieza tiene una sola razón de cambiar, así que un cambio no arrastra a los otros.

Por qué sirve aquí

Cuando cambian el formato de la factura, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Más funciones que leer y nombrar. Partir de más fragmenta la lógica sin ganancia.

Separar responsabilidades · caso 1 · el impacto

Qué cuesta el cambio, antes y después

Si mañana cambian el formato de la factura…AntesDespués
Razones de cambio de cada piezaVariasUna
¿Se prueba una parte sola?NoSí
Cambiar el formato obliga a…Tocar el cálculoNada más
Riesgo al modificarAltoAcotado
Piezas totales1 funciónVarias funciones
Separar responsabilidades · caso 1 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
facturar

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
cada función
↓
sumar
imprimir

Cada pieza se usa y se prueba sola.

Ambos imprimen FACTURA total=7500
Separar responsabilidades · caso 2 de 7 · el contexto

Registro de un usuario

Registrar 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.

Por qué Separar responsabilidades y no otroTres razones de cambio distintas en la misma función.
Separar responsabilidades · caso 2 · antes

Registro de un usuario

Cópienlo y ejecútenlo · da guardado:ana|aviso enviado
def registrar(nombre):
    ok = len(nombre) > 2
    guardado = "guardado:" + nombre if ok else "rechazado"
    return guardado + "|aviso enviado"

print(registrar("ana"))
Separar responsabilidades · caso 2 · después

Registro de un usuario

Con Separar responsabilidades aplicado
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())
Separar responsabilidades · caso 2 · la línea que cambió

Una línea contra una línea

Antes · decide adentroValidar, guardar y avisar juntos
Después · delegaTres funciones separadas

Qué hace el patrón

Parte por responsabilidad. Cada pieza tiene una sola razón de cambiar, así que un cambio no arrastra a los otros.

Por qué sirve aquí

Cuando cambia la regla de validación, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Más funciones que leer y nombrar. Partir de más fragmenta la lógica sin ganancia.

Separar responsabilidades · caso 2 · el impacto

Qué cuesta el cambio, antes y después

Si mañana cambia la regla de validación…AntesDespués
Razones de cambio de cada piezaVariasUna
¿Se prueba una parte sola?NoSí
Cambiar el formato obliga a…Tocar el cálculoNada más
Riesgo al modificarAltoAcotado
Piezas totales1 funciónVarias funciones
Separar responsabilidades · caso 2 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
registrar

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
cada función
↓
validar
guardar
avisar

Cada pieza se usa y se prueba sola.

Ambos imprimen guardado:ana|aviso enviado
Separar responsabilidades · caso 3 de 7 · el contexto

Reporte de ventas

Un 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.

Por qué Separar responsabilidades y no otroNo se puede probar solo el cálculo sin tocar los datos.
Separar responsabilidades · caso 3 · antes

Reporte de ventas

Cópienlo y ejecútenlo · da TOTAL:350
VENTAS = [("norte", 100), ("sur", 250)]

def reporte():
    total = sum(v for _, v in VENTAS)
    return f"TOTAL:{total}"

print(reporte())
Separar responsabilidades · caso 3 · después

Reporte de ventas

Con Separar responsabilidades aplicado
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())))
Separar responsabilidades · caso 3 · la línea que cambió

Una línea contra una línea

Antes · decide adentroConsulta, cálculo y formato juntos
Después · delegaCada paso por separado

Qué hace el patrón

Parte por responsabilidad. Cada pieza tiene una sola razón de cambiar, así que un cambio no arrastra a los otros.

Por qué sirve aquí

Cuando piden el reporte en otro formato, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Más funciones que leer y nombrar. Partir de más fragmenta la lógica sin ganancia.

Separar responsabilidades · caso 3 · el impacto

Qué cuesta el cambio, antes y después

Si mañana piden el reporte en otro formato…AntesDespués
Razones de cambio de cada piezaVariasUna
¿Se prueba una parte sola?NoSí
Cambiar el formato obliga a…Tocar el cálculoNada más
Riesgo al modificarAltoAcotado
Piezas totales1 funciónVarias funciones
Separar responsabilidades · caso 3 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
TOTAL

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
cada función
↓
consultar
calcular
formatear

Cada pieza se usa y se prueba sola.

Ambos imprimen TOTAL:350
Separar responsabilidades · caso 4 de 7 · el contexto

Procesar un pedido

Procesar 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.

Por qué Separar responsabilidades y no otroSi cambia la forma de cobrar, hay que tocar la verificación.
Separar responsabilidades · caso 4 · antes

Procesar un pedido

Cópienlo y ejecútenlo · da cobrado:15000
def procesar(cantidad):
    hay = cantidad <= 10
    cobro = cantidad * 5000 if hay else 0
    return f"cobrado:{cobro}"

print(procesar(3))
Separar responsabilidades · caso 4 · después

Procesar un pedido

Con Separar responsabilidades aplicado
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))))
Separar responsabilidades · caso 4 · la línea que cambió

Una línea contra una línea

Antes · decide adentroTres reglas de negocio mezcladas
Después · delegaTres funciones independientes

Qué hace el patrón

Parte por responsabilidad. Cada pieza tiene una sola razón de cambiar, así que un cambio no arrastra a los otros.

Por qué sirve aquí

Cuando cambia la forma de cobrar, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Más funciones que leer y nombrar. Partir de más fragmenta la lógica sin ganancia.

Separar responsabilidades · caso 4 · el impacto

Qué cuesta el cambio, antes y después

Si mañana cambia la forma de cobrar…AntesDespués
Razones de cambio de cada piezaVariasUna
¿Se prueba una parte sola?NoSí
Cambiar el formato obliga a…Tocar el cálculoNada más
Riesgo al modificarAltoAcotado
Piezas totales1 funciónVarias funciones
Separar responsabilidades · caso 4 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
cobrado

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
cada función
↓
hay_stock
cobrar
recibo

Cada pieza se usa y se prueba sola.

Ambos imprimen cobrado:15000
Separar responsabilidades · caso 5 de 7 · el contexto

Importar un archivo

Importar 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.

Por qué Separar responsabilidades y no otroCada paso puede fallar por razones distintas.
Separar responsabilidades · caso 5 · antes

Importar un archivo

Cópienlo y ejecútenlo · da guardados:2
LINEA = " ana , luis "

def importar(linea):
    partes = [p.strip() for p in linea.split(",")]
    return "guardados:" + str(len(partes))

print(importar(LINEA))
Separar responsabilidades · caso 5 · después

Importar un archivo

Con Separar responsabilidades aplicado
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 responsabilidades · caso 5 · la línea que cambió

Una línea contra una línea

Antes · decide adentroSeparar, limpiar y guardar juntos
Después · delegaUn paso, una función

Qué hace el patrón

Parte por responsabilidad. Cada pieza tiene una sola razón de cambiar, así que un cambio no arrastra a los otros.

Por qué sirve aquí

Cuando cambia el separador del archivo, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Más funciones que leer y nombrar. Partir de más fragmenta la lógica sin ganancia.

Separar responsabilidades · caso 5 · el impacto

Qué cuesta el cambio, antes y después

Si mañana cambia el separador del archivo…AntesDespués
Razones de cambio de cada piezaVariasUna
¿Se prueba una parte sola?NoSí
Cambiar el formato obliga a…Tocar el cálculoNada más
Riesgo al modificarAltoAcotado
Piezas totales1 funciónVarias funciones
Separar responsabilidades · caso 5 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
importar

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
cada función
↓
separar
limpiar
guardar

Cada pieza se usa y se prueba sola.

Ambos imprimen guardados:2
Separar responsabilidades · caso 6 de 7 · el contexto

Calcular la nómina

Calcular 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.

Por qué Separar responsabilidades y no otroLos descuentos cambian por ley; el formato, por diseño. No cambian juntos.
Separar responsabilidades · caso 6 · antes

Calcular la nómina

Cópienlo y ejecútenlo · da neto:1766400.0
def nomina(horas):
    bruto = horas * 12000
    neto = bruto - bruto * 0.08
    return f"neto:{neto}"

print(nomina(160))
Separar responsabilidades · caso 6 · después

Calcular la nómina

Con Separar responsabilidades aplicado
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))))
Separar responsabilidades · caso 6 · la línea que cambió

Una línea contra una línea

Antes · decide adentroBruto, descuentos y formato juntos
Después · delegaCada cálculo por su lado

Qué hace el patrón

Parte por responsabilidad. Cada pieza tiene una sola razón de cambiar, así que un cambio no arrastra a los otros.

Por qué sirve aquí

Cuando cambia el descuento por ley, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Más funciones que leer y nombrar. Partir de más fragmenta la lógica sin ganancia.

Separar responsabilidades · caso 6 · el impacto

Qué cuesta el cambio, antes y después

Si mañana cambia el descuento por ley…AntesDespués
Razones de cambio de cada piezaVariasUna
¿Se prueba una parte sola?NoSí
Cambiar el formato obliga a…Tocar el cálculoNada más
Riesgo al modificarAltoAcotado
Piezas totales1 funciónVarias funciones
Separar responsabilidades · caso 6 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
neto

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
cada función
↓
bruto
descuentos
desprendible

Cada pieza se usa y se prueba sola.

Ambos imprimen neto:1766400.0
Separar responsabilidades · caso 7 de 7 · el contexto

Publicar un artículo

Publicar 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.

Por qué Separar responsabilidades y no otroTres cosas distintas que evolucionan a ritmos distintos.
Separar responsabilidades · caso 7 · antes

Publicar un artículo

Cópienlo y ejecútenlo · da publicado:ARQUITECTURA
def publicar(titulo):
    ok = len(titulo) > 0
    texto = titulo.upper() if ok else ""
    return "publicado:" + texto

print(publicar("arquitectura"))
Separar responsabilidades · caso 7 · después

Publicar un artículo

Con Separar responsabilidades aplicado
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"))))
Separar responsabilidades · caso 7 · la línea que cambió

Una línea contra una línea

Antes · decide adentroValidar, formatear y publicar juntos
Después · delegaTres funciones encadenadas

Qué hace el patrón

Parte por responsabilidad. Cada pieza tiene una sola razón de cambiar, así que un cambio no arrastra a los otros.

Por qué sirve aquí

Cuando cambia la regla de publicación, se agrega sin abrir lo que ya funcionaba.

Qué se paga

Más funciones que leer y nombrar. Partir de más fragmenta la lógica sin ganancia.

Separar responsabilidades · caso 7 · el impacto

Qué cuesta el cambio, antes y después

Si mañana cambia la regla de publicación…AntesDespués
Razones de cambio de cada piezaVariasUna
¿Se prueba una parte sola?NoSí
Cambiar el formato obliga a…Tocar el cálculoNada más
Riesgo al modificarAltoAcotado
Piezas totales1 funciónVarias funciones
Separar responsabilidades · caso 7 · las dependencias

Quién conoce a quién

Antes · una pieza lo sabe todo
publicar

Cambiar una cosa obliga a entrar donde viven las demás.

Después · cada quien lo suyo
cada función
↓
valido
formatear
publicar

Cada pieza se usa y se prueba sola.

Ambos imprimen publicado:ARQUITECTURA
Taller individual · evaluado

Diagnóstico
de patrones

Ya vieron 49 casos resueltos. Ahora les toca a ustedes: seis casos nuevos, sin la respuesta, y trabajo individual.

Lo primero · esto es individual

Cada uno tiene un taller distinto

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.

Por qué asíNo es desconfianza: es que pensar solo es la única forma de aprender esto. En una entrevista técnica tampoco van a poder mirar al lado.
Cómo funciona · 45 min

Los cuatro pasos

  1. Abran su PDF y creen un cuaderno .ipynb en Colab o VS Code. 5 min
  2. Por cada caso: ejecuten el código y peguen la salida real que obtuvieron. 15 min
  3. Elijan el patrón que lo resuelve y escriban por qué, citando la señal. 15 min
  4. Respondan la pregunta de cierre de su versión. 10 min
El entregable

Un archivo .ipynb

Un cuaderno de Jupyter, hecho en Google Colab o en VS Code. No se recibe un .py, ni un Word, ni una foto.

Cómo se nombraNombreApellido_VersionA.ipynb — con la letra de su versión. Se entrega el archivo o el enlace de Colab con permiso de lectura.
La estructura del cuaderno

Dos celdas por cada caso

  1. Celda de código — el caso tal como viene en el PDF, ejecutado, con su salida visible debajo.
  2. Celda de texto — las cinco respuestas: salida obtenida, señal, patrón, por qué ese, y qué se paga.
  3. Al final, una celda de texto con la respuesta a la pregunta de cierre.
El código ya se los damos hecho. Lo que se califica es la sustentación escrita.
La plantilla de la celda de texto

Qué escriben por cada caso

Cópienla en cada celda Markdown de su cuaderno
## 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:           ...
Ojo con esto

Uno de los seis casos es una trampa

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.

Cómo se reconoceCuando hay más código de estructura que de negocio, o cuando la variación que el patrón resolvería no existe. Si contestan un patrón en los seis, ya sé que no lo pensaron.
La parte que decide la nota

Defensa oral · 90 segundos

Al final, llamo al azar a varios de ustedes y les pido explicar uno de sus casos, elegido por mí. Sin notas, sin pantalla.

Sobre la inteligencia artificial

Se los digo de frente

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.

Por qué no alcanzaUna IA les dará el nombre del patrón. No les dará la salida real de su ejecución, no sabrá cuál de los seis es la trampa en su versión, y no va a estar con ustedes en los 90 segundos de defensa oral.
Cómo se evalúa · cuenta en el 50% de dinámicas

Qué estoy calificando

CriterioPesoQué observo
Defensa oral40%Explica su caso sin notas. Es el criterio que más pesa.
Señal identificada20%Nombra qué en el código lo delata, no solo el patrón.
Salida real pegada20%Ejecutó de verdad. La salida coincide con la del código.
El caso trampa20%Lo detectó, o al menos dudó y lo justificó.
Antes de entregar

Chequeo rápido

EntregaEl archivo .ipynb o el enlace de Colab con permiso de lectura, por el canal del curso al terminar la clase.
Cierre

Se llevan tres ideas

La próxima clase: si ya sabemos diseñar, toca comunicarlo — documentación de arquitectura y vistas.
Tarea · próxima clase

Cacen un patrón en la naturaleza

Busquen en un proyecto real —de otra materia, de un trabajo o de un repositorio público— un patrón aplicado, bien o mal.

← Portal
← → o el apuntador para avanzar · F pantalla completa · clic en los términos azules
1 / 329