Fan-in y fan-out

Actualizado el 15 de noviembre de 2026

Sigla sin sigla asentada; se escriben fan-in y fan-out
Aspecto «Acoplamiento»
Se mide en método (procedimiento o módulo, en la literatura original) y clase
Tipo de valor recuento (entero, mínimo 0)
Dirección fan-out: más alto es peor; fan-in: informativa (alto suele significar reutilización)
Umbrales de referencia fan-out: revisar por encima de 10 (Yourdon y Constantine); 20 por clase (valor por defecto de Checkstyle)
Origen diseño estructurado: Stevens, Myers y Constantine (1974); Yourdon y Constantine (1975, 1979)
Stau Metro no la calcula

En pocas palabras

Se fija en quién llama a quién. El fan-out de un método es cuántos métodos distintos llama; su fan-in, desde cuántos métodos lo llaman. Un método con mucho fan-out coordina demasiadas piezas y es difícil de entender; uno con mucho fan-in es una pieza muy reutilizada, y por eso conviene que sea pequeña, sencilla y estable.

Qué mide

El grado de cada nodo en un grafo de uso. Las dos direcciones dicen cosas distintas:

  • Fan-out (abanico de salida): de cuántas piezas depende un elemento. Cada una es algo que hay que conocer para entenderlo y algo que, si cambia, puede romperlo. Yourdon y Constantine lo llaman también span of control, por analogía con un jefe y sus subordinados directos.
  • Fan-in (abanico de entrada): cuántas piezas dependen del elemento. Para el diseño estructurado es la razón de ser de la modularidad: cada llamada adicional a un módulo común es código que no se ha duplicado. A cambio, cada usuario es un sitio que puede romperse si el elemento cambia.

El grafo de uso puede ser de varias clases, y el número cambia con él:

  • el grafo de llamadas entre métodos o procedimientos (la definición original);
  • el grafo de dependencias entre clases o paquetes, donde una arista es cualquier uso de un tipo;
  • el flujo de información, que añade a las llamadas los datos compartidos: es la variante de Henry y Kafura (ver la «complejidad de flujo de información»).

Para quien empieza. Fan es «abanico». Piensa en un método como un punto con flechas: las que salen hacia los métodos que llama forman el fan-out; las que llegan desde quienes lo llaman, el fan-in.

Cómo se calcula

En la forma estructural, sobre un grafo dirigido en el que una arista x→yx \to y significa «xx usa yy»:

fanout(x)=∣{ y:x→y }∣fanin(x)=∣{ y:y→x }∣\mathit{fanout}(x) = |\{\, y : x \to y \,\}| \qquad \mathit{fanin}(x) = |\{\, y : y \to x \,\}|

Se cuentan elementos distintos: llamar tres veces al mismo método suma 1. En un diagrama de estructura, Yourdon y Constantine definen el fan-out como el número de subordinados inmediatos de un módulo y el fan-in como el número de módulos superiores que lo llaman.

Hay que fijar tres decisiones antes de contar, y cada herramienta las toma a su manera:

  • Qué queda fuera. Lo habitual es no contar las llamadas a la biblioteca estándar ni a rutinas del sistema; Card y Agresti (1988) las excluyen del fan-out, pero sí cuentan las llamadas a código reutilizado de otras aplicaciones.
  • Qué es una arista. Solo llamadas, o cualquier referencia a un tipo (campo, parámetro, new, cast…).
  • Directo o transitivo. El fan-in y el fan-out clásicos son directos; los recuentos transitivos son otras métricas (ver «Relación con otras métricas»).

Ejemplo

import java.util.List;

record Item(String sku, long cents, int qty) {}

final class Checkout {
    String checkout(List<Item> items) {           // fan-out 3: validate, total, format
        validate(items);
        long sum = total(items);
        return format(sum);
    }

    void validate(List<Item> items) {             // fan-out 0: isEmpty es de la JDK
        if (items.isEmpty()) throw new IllegalArgumentException("empty");
    }

    long total(List<Item> items) {                // fan-out 1: lineTotal
        long sum = 0;
        for (Item item : items) sum += lineTotal(item);
        return sum;
    }

    long lineTotal(Item item) {                   // fan-out 2: Item.cents, Item.qty
        return item.cents() * item.qty();
    }

    String format(long cents) {                   // fan-out 0: String.format es de la JDK
        return String.format("%d.%02d", cents / 100, cents % 100);
    }
}

Contando solo llamadas a métodos del propio código:

Método Llama a Fan-out Lo llaman Fan-in
checkout validate, total, format 3 nadie en el ejemplo 0
validate nada propio 0 checkout 1
total lineTotal 1 checkout 1
lineTotal cents, qty 2 total 1
format nada propio 0 checkout 1

El bucle de total llama a lineTotal muchas veces al ejecutarse, pero en el código hay una sola llamada a un único método: fan-out 1. A nivel de clase, con aristas de dependencia entre tipos, Checkout tiene fan-out 1 (Item; List y String son de la JDK) e Item tiene fan-in 1.

Cómo interpretarla

Fan-out alto. Es la señal más clara de las dos. Yourdon y Constantine recuerdan que un jefe con más de 7 ± 2 subordinados directos tiene un trabajo demasiado complejo, y proponen revisar los módulos con un span of control por encima de 10 y también los de 1 o 2. Observan que un fan-out alto suele venir de no haber definido niveles intermedios, más que de haber partido un módulo en exceso. Checkstyle, a nivel de clase, avisa por encima de 20 tipos usados.

Qué hacer: agrupa las llamadas que forman una subtarea con sentido en un método o una clase intermedia; si el elemento coordina piezas que no tienen nada que ver entre sí, probablemente hace más de una cosa.

Fan-in alto. No es malo por sí mismo: en el diseño estructurado se busca maximizarlo, porque significa reutilización. Pero cambia lo que se le pide al elemento: debe ser pequeño, cohesivo y estable, porque un cambio en él llega a todos los que lo usan. Yourdon y Constantine advierten que no se consigue a cualquier precio: juntar funciones sin relación en un «supermódulo» para que muchos lo llamen sube el fan-in y destroza la cohesión.

Las dos a la vez. Un elemento con fan-in y fan-out altos está en mitad de muchos caminos: recibe de muchos sitios y reparte hacia muchos otros. Es el caso que Henry y Kafura penalizan con el producto de ambos al cuadrado.

Fan-in 0. En un método no público suele ser código muerto. En uno público puede ser un punto de entrada, un método que se llama por reflexión o una API que se usa desde fuera del código analizado.

Ojo. Fan-in y fan-out no son simétricos en lo que piden. Un fan-out alto pide simplificar el elemento; un fan-in alto pide protegerlo (tests, una interfaz estable), no reducirlo.

Para profundizar

Forma del sistema. Yourdon y Constantine describen los sistemas bien diseñados con fan-out alto en los módulos de arriba y fan-in alto en los de abajo; dan como típico un fan-out medio de tres o cuatro, y advierten que no es una regla que haya que seguir al pie de la letra.

Fan-out y complejidad estructural. Card y Agresti (1988) separan la complejidad de las conexiones entre procedimientos de la complejidad interna de cada uno. En los datos que analizaron, el fan-in múltiple se concentraba en rutinas matemáticas sencillas, así que lo descartaron como indicador de complejidad y se quedaron con el fan-out. Su complejidad estructural es la media del fan-out al cuadrado:

S=1n∑i=1nfi 2S = \frac{1}{n} \sum_{i=1}^{n} f_i^{\,2}

donde fif_i es el fan-out del procedimiento ii y nn el número de procedimientos. Elevar al cuadrado castiga más un método con fan-out 6 que dos con fan-out 3. Sobre los cinco métodos de Checkout: (9+0+1+4+0)/5=2,8(9 + 0 + 1 + 4 + 0) / 5 = 2{,}8.

Fan-in y fan-out informacionales. Henry y Kafura (1981) amplían las dos cuentas con los datos: el fan-in suma los flujos que llegan al procedimiento y las estructuras de datos globales que lee; el fan-out, los flujos que salen y las estructuras que modifica. Kitchenham, Pickard y Linkman (1990) probaron métricas derivadas de las suyas en un sistema de comunicaciones: el fan-out informacional identificaba programas propensos a cambios y a fallos, pero las métricas de código sencillas (líneas y número de ramas) lo hacían mejor.

Cómo se falsea. El fan-out baja metiendo las llamadas detrás de una fachada que no añade nada, o pasando de llamadas directas a eventos o reflexión, que el análisis estático no ve. El acoplamiento sigue ahí; solo deja de contarse.

Relación con otras métricas

En las herramientas

Stau Metro no tiene una métrica llamada fan-in o fan-out, pero calcula varias que lo son en la práctica:

  • A nivel de clase e interfaz, «Dcy» (NumDependenciesClass, NumDependenciesInterface) es un fan-out estructural: cuenta las clases distintas a las que el elemento se refiere por cualquier vía (herencia, tipos de campos, parámetros y variables, new, llamadas, anotaciones…); solo cuentan las clases con código fuente, no las de bibliotecas compiladas, incluida la estándar. «Dpt» (NumDependentsClass, NumDependentsInterface) es el fan-in correspondiente.
  • A nivel de método, «CALL» (NumMethodCalls) cuenta las expresiones de llamada y de creación de objetos del método, cada aparición por separado: no es un fan-out de métodos distintos. «CALLED» (NumTimesCalled) cuenta los puntos de llamada que resuelven al método, incluidos los que pasan por un supertipo del proyecto al que sobrescribe; se acerca al fan-in, pero contando sitios de llamada y no métodos llamantes distintos.
  • A nivel de paquete, «Ce» y «Ca», que cuentan clases y no paquetes: las del paquete que dependen de alguna de fuera, y las de fuera que dependen de alguna del paquete. Las clases de test no entran en ninguno de los dos recuentos.

Checkstyle (ClassFanOutComplexity). Cuenta cuántos otros tipos usa una clase, record, interfaz, enumerado o anotación. El máximo por defecto es 20. Excluye por defecto una lista de clases corrientes (envoltorios, colecciones, String, Object, excepciones habituales) y todo el paquete java.lang; las listas se pueden cambiar con excludedClasses, excludedPackages y excludeClassesRegexps. Su documentación añade que el cuadrado de este valor se ha relacionado con el esfuerzo de mantenimiento en programas funcionales, por fichero.

Referencias

  • Stevens, W. P., Myers, G. J. y Constantine, L. L. (1974). «Structured Design». IBM Systems Journal, 13(2), 115-139.
  • Yourdon, E. y Constantine, L. L. (1979). Structured Design: Fundamentals of a Discipline of Computer Program and Systems Design. Prentice-Hall (1.ª ed., Yourdon Press, 1975). Capítulo 8 (forma del sistema) y capítulo 9 (span of control y fan-in).
  • Card, D. N. y Agresti, W. W. (1988). «Measuring Software Design Complexity». Journal of Systems and Software, 8(3), 185-197. https://doi.org/10.1016/0164-1212(88)90021-0
  • Henry, S. y Kafura, D. (1981). «Software Structure Metrics Based on Information Flow». IEEE Transactions on Software Engineering, SE-7(5), 510-518. https://doi.org/10.1109/TSE.1981.231113
  • Kitchenham, B. A., Pickard, L. M. y Linkman, S. J. (1990). «An Evaluation of Some Design Metrics». Software Engineering Journal, 5(1), 50-58. https://doi.org/10.1049/sej.1990.0007
  • Yu, X. y Lamb, D. A. (1994). «Metrics Applicable to Software Design». En Software Quality Management, Transactions on Information and Communications Technologies, vol. 8. WIT Press. https://www.witpress.com/Secure/elibrary/papers/SQM94/SQM94024FU.pdf
  • Checkstyle, comprobación ClassFanOutComplexity: https://checkstyle.org/checks/metrics/classfanoutcomplexity.html