Acoplamiento y cohesión
- Lección 2 de 32
- 10 min
- Inicial
- 12 pasos
Cambias el nombre de un campo y se rompen cuatro archivos en dos módulos. Ese dolor tiene nombre: acoplamiento alto y cohesión baja. Aquí aprendes a verlos en el código y a corregirlos sin llenarlo todo de capas.
- Clases que toca el cambio
- —
- Módulos que toca
- —
- Motivos para cambiar Utils
- —
- petición
- respuesta
- petición fallida
Paso 1 de 12
Problema
Una factura que recorre medio sistema
Una tienda en línea tiene dos módulos: Pedidos (Order, Customer, Address) y Facturación (Invoice y compañía). Para calcular el impuesto, Invoice necesita el país del cliente.
Para llegar a él, escribe this.order.customer.address.country: pasa por Order, entra a Customer y de ahí a Address. Funciona, pero Invoice acaba de aprender cómo está armado por dentro el módulo de Pedidos.
Paso 2 de 12
Concepto
Acoplamiento: cuánto necesitas saber del otro
El acoplamiento mide cuánto tiene que saber un módulo de otro para funcionar. Invoice no solo sabe que existe un pedido: sabe que el pedido tiene un customer, que el cliente tiene un address y que la dirección tiene un country.
Cada cosa que sabe es un punto por donde un cambio ajeno lo puede romper. La idea no es nueva: el término se popularizó en el artículo «Structured Design» de Stevens, Myers y Constantine (IBM Systems Journal, 1974), y Constantine ya trabajaba estas ideas en los años 60.
Paso 3 de 12
Problema
Renombras un campo y se rompen cuatro clases
Alguien renombra country a countryCode en Address. Un cambio chico, en un solo módulo. Pero Invoice, Report (ventas por país) y Utils (que recibe un Customer entero para calcular la tasa) también recorrían la cadena hasta country.
Resultado: 4 clases que tocar en 2 módulos, y dos equipos que coordinar por un nombre de campo.
Qué cambió
- country → countryCode en Address
- Invoice, Report y Utils dejan de compilar
Paso 4 de 12
Solución
Pide lo que necesitas, no el objeto entero
Order ofrece un método country() que le pregunta a Customer, y solo Customer lee Address. Invoice y Report llaman a this.order.country(), y la tasa se calcula con taxRate(country: string): recibe un texto, no un Customer.
Ahora el mismo renombre toca 2 clases (Address y Customer) de 1 módulo. Lo que hay detrás de Order puede cambiar sin que Facturación se entere.
Qué cambió
- Order.country() y Customer.country()
- taxRate recibe un string
- Utils ya no conoce Customer
Paso 5 de 12
Concepto
Cohesión: lo de adentro, ¿va junto?
La cohesión mide cuánto tienen que ver entre sí las cosas que viven en un mismo módulo. Mira Utils: formatea fechas, calcula impuestos y convierte títulos en URLs.
Son 3 motivos para cambiar que no tienen nada que ver: un cambio de formato de fecha, una ley de impuestos nueva o una regla de URLs te hacen abrir el mismo archivo, y todo el que importa Utils queda atado a los tres.
Paso 6 de 12
Solución
Junta lo que cambia junto
Deja en el módulo solo lo que cambia por el mismo motivo. taxRate se queda y el módulo pasa a llamarse TaxRates; formatDate se va con Report, que es quien la usa, y slugify con el código que arma las URLs.
Ahora una ley de impuestos nueva cambia un solo archivo, y quien solo necesita impuestos ya no arrastra fechas ni URLs.
Qué cambió
- Utils pasa a ser TaxRates
- formatDate y slugify salen del módulo
Paso 7 de 12
Técnica
Caso real: depender de una interfaz
En Java, SLF4J es una fachada de logs: tu código escribe contra su interfaz Logger y no sabe qué biblioteca hay detrás. Según su documentación, eliges el backend (Logback, Log4j o java.util.logging) al desplegar.
En el diagrama, Invoice solo ve Logger, el bloque punteado: una interfaz. Logback la implementa, pero Invoice nunca lo nombra.
Paso 8 de 12
Solución
Cambias el backend sin tocar tu código
El equipo decide pasar de Logback a Log4j. Cambia la dependencia que va en el despliegue y listo: 0 clases de la aplicación cambian, porque ninguna nombraba a Logback.
Compara con el principio de la lección: allí un renombre tocaba 4 clases. La diferencia no es la cantidad de código, sino cuánto sabe cada parte de la otra.
Qué cambió
- Logback → Log4j
- Invoice: 0 líneas cambiadas
Paso 9 de 12
Problema
Acoplamiento oculto: un módulo con estado
En Node.js, require guarda en caché cada módulo: todas las llamadas que apuntan al mismo archivo reciben exactamente el mismo objeto. Si ese objeto se puede modificar, cada archivo que lo importa queda atado a lo que hagan los demás.
Aquí Report cambia currency a "USD" para un informe, y Invoice empieza a facturar en dólares. No hay ninguna flecha entre Report e Invoice, pero están acopladas a través de config.js.
Paso 10 de 12
Compromiso
Lo que no significan
Acoplamiento cero no existe: un programa es código que habla con otro código. El objetivo es que cada módulo sepa lo mínimo de los demás, como Invoice que solo conoce Order.
Cohesión no es tener archivos chicos, y no repetir código (DRY) no siempre ayuda: si dos funciones que no tienen nada que ver comparten un helper, ahora cualquier cambio en una puede romper la otra.
Paso 11 de 12
Compromiso
Cuándo no vale la pena
Desacoplar agrega interfaces, parámetros y saltos entre archivos. En un prototipo o un script de un solo uso, ese costo no se recupera: escríbelo directo y, si sobrevive, refactoriza.
Tampoco partas un módulo que ya es cohesivo: dividir uno de 200 líneas que cambia junto en 10 archivos (tamaños de ejemplo) solo te hace saltar más entre pestañas, sin bajar el acoplamiento.
Paso 12 de 12
Resumen
Resumen
Acoplamiento: cuánto sabe un módulo de otro. Cada cosa que sabe es un punto por donde lo rompen.
Mide un diseño con una pregunta: si cambio esto, ¿cuántas clases y módulos toco?
Pide lo que necesitas (country(), un string), no el objeto entero.
Cohesión: junta lo que cambia por el mismo motivo y separa lo que no.
Depende de interfaces donde el otro lado puede cambiar, como SLF4J, y no desacoples prototipos ni partas módulos cohesivos.
← → paso · R repetir · Espacio pausa
Aprenderás
- Reconocer cuánto sabe un módulo de otro (acoplamiento) (visto)
- Medir un cambio en clases y módulos que toca (visto)
- Bajar el acoplamiento pidiendo solo lo que necesitas (visto)
- Juntar lo que cambia junto (cohesión) (visto)
- Depender de una interfaz, como hace SLF4J (visto)
- Saber cuándo no vale la pena desacoplar (visto)