Complejidad de flujo de información de Henry y Kafura

Actualizado el 15 de noviembre de 2026

Sigla IFC (information flow complexity); en la literatura también aparece sin sigla
Aspecto «Acoplamiento»
Se mide en método (procedimiento); los autores la suman por «módulo», el grupo de procedimientos que usa una misma estructura de datos
Tipo de valor entero, mínimo 0; crece muy deprisa
Dirección más alto es peor
Umbrales de referencia ninguno publicado como norma
Origen Sallie Henry y Dennis Kafura, 1981
Stau Metro no la calcula

En pocas palabras

Mide por cuántos caminos pasa la información a través de un método. Cuenta lo que le llega (llamadas, valores devueltos que usa, datos compartidos que lee) y lo que sale de él (llamadas que hace, valores que devuelve y otro usa, datos compartidos que modifica), multiplica las dos cuentas, eleva el resultado al cuadrado y lo multiplica por la longitud del método. Un método que recibe de muchos sitios y reparte hacia muchos otros es un cruce de caminos: cualquier cambio en él se nota en todas partes.

Qué mide

La conectividad de un procedimiento con su entorno, que para Henry y Kafura es el factor principal de la complejidad estructural de un sistema. A diferencia de la «complejidad ciclomática», que mira dentro del método, esta mira sus conexiones.

Hace falta distinguir tres clases de flujo de información entre procedimientos:

  • Flujo local directo de A a B: A llama a B (y le pasa información).
  • Flujo local indirecto: si A llama a B, y B devuelve un valor que A usa después, hay un flujo de B a A; si A llama a B y a C, y pasa a C un valor devuelto por B, hay un flujo de B a C.
  • Flujo global de A a B: A deposita información en una estructura de datos global y B la recupera de ella.

Con ellos se definen el fan-in y el fan-out informacionales de un procedimiento:

  • fan-in = flujos locales que terminan en él + estructuras de datos globales de las que lee;
  • fan-out = flujos locales que salen de él + estructuras de datos globales que actualiza.

Para quien empieza. En Java, lo más parecido a una «estructura de datos global» es un campo compartido por varios métodos: un atributo de la clase o un campo estático. Leerlo es una entrada; modificarlo, una salida.

Cómo se calcula

Para un procedimiento pp:

IFC(p)=length(p)×(fanin(p)×fanout(p))2\mathit{IFC}(p) = \mathit{length}(p) \times \big(\mathit{fanin}(p) \times \mathit{fanout}(p)\big)^2

donde length\mathit{length} es la longitud del procedimiento en líneas de código. El producto fanin×fanout\mathit{fanin} \times \mathit{fanout} es el número de combinaciones posibles de una fuente de entrada con un destino de salida; el cuadrado expresa la hipótesis de que la complejidad crece más que linealmente con las conexiones.

El artículo define además dos medidas por módulo, que para los autores no es una unidad de compilación, sino el conjunto de procedimientos que acceden a una misma estructura de datos global:

  • Complejidad del módulo: la suma de la IFC de sus procedimientos.
  • Acoplamiento a través de la estructura: el número de flujos globales posibles entre sus procedimientos. Con WW procedimientos que solo escriben en la estructura, RR que solo leen y RWRW que hacen las dos cosas:
flujos=W⋅R+W⋅RW+RW⋅R+RW⋅(RW−1)\mathit{flujos} = W \cdot R + W \cdot RW + RW \cdot R + RW \cdot (RW - 1)

Ejemplo

import java.util.HashMap;
import java.util.Map;

final class Inventory {
    private final Map<String, Integer> stock = new HashMap<>();   // la estructura compartida

    void setStock(String sku, int qty) {
        stock.put(sku, qty);
    }

    boolean reserve(String sku, int qty) {
        int available = available(sku);
        if (available < qty) return false;
        stock.put(sku, available - qty);
        return true;
    }

    int available(String sku) {
        return stock.getOrDefault(sku, 0);
    }
}

final class OrderDesk {
    private final Inventory inventory;

    OrderDesk(Inventory inventory) { this.inventory = inventory; }

    String place(String sku, int qty) {
        if (!inventory.reserve(sku, qty)) return "sin existencias";
        return "reservado";
    }
}

reserve ocupa 6 líneas.

Entra en reserve Sale de reserve
flujo local directo desde place, que la llama flujo local directo hacia available, a la que llama
flujo local indirecto desde available, cuyo resultado usa flujo local indirecto hacia place, que usa su resultado
no lee stock directamente actualiza stock
fan-in = 2 fan-out = 3

IFC(reserve)=6×(2×3)2=6×36=216\mathit{IFC}(\texttt{reserve}) = 6 \times (2 \times 3)^2 = 6 \times 36 = 216.

available ocupa 3 líneas. Le llegan el flujo directo desde reserve y la lectura de stock (fan-in 2); sale el flujo indirecto hacia reserve, que usa lo que devuelve (fan-out 1). IFC=3×(2×1)2=12\mathit{IFC} = 3 \times (2 \times 1)^2 = 12.

setStock solo escribe en stock (fan-out 1); en el código analizado nadie la llama, no usa el resultado de ningún otro método y no lee stock (fan-in 0): IFC=3×(0×1)2=0\mathit{IFC} = 3 \times (0 \times 1)^2 = 0.

El módulo de stock lo forman setStock, reserve y available. Su complejidad es 0+216+12=2280 + 216 + 12 = 228. Para los flujos globales: escriben sin leer setStock y reserve (W=2W = 2), lee sin escribir available (R=1R = 1), y ninguno hace las dos cosas (RW=0RW = 0); hay 2⋅1=22 \cdot 1 = 2 flujos globales posibles.

Cómo interpretarla

El valor absoluto dice poco: depende de cómo se cuenten los flujos y la longitud, y crece tan deprisa que la distribución está dominada por unos pocos procedimientos. Se usa para ordenar y buscar los valores anormalmente altos. No hay un umbral de referencia asentado.

Los autores leen los resultados como síntomas de diseño:

  • Un procedimiento con IFC alta puede hacer más de una función, ser difícil de cambiar por sus muchos efectos sobre el entorno, o revelar un nivel de abstracción que falta: quizá hay que partirlo.
  • Muchos flujos globales en un módulo apuntan a una estructura de datos poco refinada, que quizá convenga dividir.
  • Una complejidad de módulo alta apunta a una mala modularización; lo deseable es que cada procedimiento esté en un solo módulo.

Qué hacer con un valor alto: reduce el fan-in o el fan-out del método, no su longitud, porque son los factores que pesan. Separa lectura y escritura del estado compartido, encapsula la estructura detrás de pocos métodos y parte los métodos que a la vez reciben de muchos sitios y reparten hacia muchos otros.

Ojo. Un método sin ninguna entrada (nadie lo llama, no usa lo que devuelve otro y no lee datos compartidos), o sin ninguna salida, vale 0 aunque tenga cien líneas: el producto se anula. En un análisis parcial, los métodos públicos llamados desde fuera pierden esas entradas y salidas, y su valor queda por debajo del real.

Para profundizar

La validación original. Los autores aplicaron las medidas al código fuente de UNIX y encontraron una correlación fuerte entre la complejidad y la aparición de cambios. Según el resumen de Yu y Lamb (1994), el estudio cubrió 10 módulos con 220 procedimientos; de los cuatro factores comparados (longitud, longitud al cuadrado, fan-in × fan-out y su cuadrado), el último era el que más aportaba, con un coeficiente de correlación de 0,98 con la aparición de cambios. Es una cifra de un único sistema, y conviene leerla junto a los estudios posteriores de abajo.

Críticas.

  • El cuadrado es arbitrario. No hay un modelo que lo justifique más allá de la intuición de que la complejidad crece más que linealmente.
  • La información no se distingue. No separa flujo de control de flujo de datos, ni un entero de una estructura compleja.
  • El cero. Un fan-in o un fan-out nulo anula todo lo demás, incluida la longitud.
  • Mezcla tamaño y conexión. Al multiplicar por la longitud, dos métodos con las mismas conexiones difieren solo por su tamaño, y no se sabe qué parte del valor viene de cada factor. La IF4 de Shepperd quita la longitud.
  • Las métricas simples rinden igual o mejor. Kitchenham, Pickard y Linkman (1990) probaron métricas de diseño basadas en las de Henry y Kafura en un sistema de comunicaciones y discuten los problemas que encontraron al aplicarlas. El fan-out informacional identificaba programas propensos a cambios y a fallos, pero las líneas de código y el número de ramas lo hacían mejor.

La variante IF4 de Shepperd. Shepperd (1990) la redefinió para que pudiera calcularse sobre la arquitectura, antes de escribir el código: quita la longitud, solo cuenta como flujo indirecto el caso del valor devuelto que usa quien llama, e ignora los flujos duplicados. Su medida es (fanin×fanout)2(\mathit{fanin} \times \mathit{fanout})^2. Al validarla sobre 13 sistemas encontró una correlación muy significativa con el esfuerzo de desarrollo (medido como tiempo de conexión al ordenador), mientras que las medidas de diseño basadas en tamaño apenas se asociaban con él.

Henry y Kafura, después. Sallie Henry siguió en la línea: con Wei Li propuso en 1993 dos métricas de acoplamiento para orientación a objetos, «MPC» y «DAC», con la misma idea de medir las conexiones de una clase con las demás.

En orientación a objetos. Las definiciones son de la programación estructurada. Al trasladarlas a Java hay que decidir qué es una estructura global (campos estáticos, atributos de la clase, un singleton), si las llamadas polimórficas cuentan hacia una implementación o hacia todas, y si los parámetros cuentan uno a uno o como un solo flujo. Cada decisión cambia el número.

Relación con otras métricas

En las herramientas

Stau Metro no calcula la IFC ni el fan-in o fan-out informacionales. Sus métricas más cercanas solo cubren la parte de llamadas: «CALL» (NumMethodCalls) cuenta las expresiones de llamada y de creación de objetos de un método, cada aparición por separado, y «CALLED» (NumTimesCalled) cuenta los puntos de llamada que resuelven a un método. Ninguna tiene en cuenta los valores devueltos ni los campos leídos o modificados, y no se combinan en un producto.

Referencias