Fan-in y fan-out
| 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 significa « usa »:
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:
donde es el fan-out del procedimiento y 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:
.
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
- «Complejidad de flujo de información de Henry y Kafura» (
IFC): la versión informacional, que suma datos compartidos y multiplica fan-in por fan-out. - «Número de llamadas a métodos» (
CALL): el fan-out de un método, pero contando cada llamada y no los métodos distintos. - «Número de veces invocado» (
CALLED): el fan-in de un método en número de sitios de llamada. - «Número de dependencias» (
Dcy) y «número de dependientes» (Dpt): el fan-out y el fan-in estructurales de una clase sobre el grafo de dependencias. - «Acoplamientos eferentes» (
Ce) y «aferentes» (Ca): lo mismo entre paquetes; de ellos sale la «inestabilidad» (I). - «Acoplamiento entre objetos» (
CBO): junta los dos sentidos en un solo número. - «Número de dependencias transitivas» (
Dcy*) y «dependientes transitivos» (Dpt*): el fan-out y el fan-in a cualquier distancia. - «Respuesta para la clase» (
RFC): los métodos de la clase más los que llaman; es un fan-out de métodos a nivel de clase.
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