Complejidad de flujo de información de Henry y Kafura
| 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 :
donde es la longitud del procedimiento en líneas de código. El producto 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
IFCde sus procedimientos. - Acoplamiento a través de la estructura: el número de flujos globales posibles entre sus procedimientos. Con procedimientos que solo escriben en la estructura, que solo leen y que hacen las dos cosas:
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 |
.
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). .
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):
.
El módulo de stock lo forman setStock, reserve y available. Su complejidad es . Para
los flujos globales: escriben sin leer setStock y reserve (), lee sin escribir available (), y
ninguno hace las dos cosas (); hay 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
IFCalta 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
IF4de 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 . 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
- «Fan-in y fan-out»: la versión estructural, que solo cuenta llamadas o dependencias; esta les añade los datos compartidos y los multiplica.
- «Número de llamadas a métodos» (
CALL) y «número de veces invocado» (CALLED): los dos ingredientes de llamada del fan-out y el fan-in, contados por separado. - «Líneas de código» (
LOC): el factorlengthde la fórmula. - «Complejidad ciclomática» (
v(G)): mira la complejidad interna del método, la que esta medida deja fuera. - «Acoplamiento por paso de mensajes» (
MPC) y «acoplamiento por abstracción de datos» (DAC): las propuestas posteriores de Li y Henry para clases. - «Falta de cohesión de los métodos» (
LCOM): también agrupa los métodos por los atributos que comparten, pero para medir cohesión en lugar de flujo.
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
- 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
- Kafura, D. y Henry, S. (1981). «Software Quality Metrics Based on Interconnectivity». Journal of Systems and Software, 2(2), 121-131. https://doi.org/10.1016/0164-1212(81)90032-7
- Shepperd, M. (1990). «Design Metrics: An Empirical Analysis». Software Engineering Journal, 5(1), 3-10. https://doi.org/10.1049/sej.1990.0002
- 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
- Li, W. y Henry, S. (1993). «Object-Oriented Metrics that Predict Maintainability». Journal of Systems and Software, 23(2), 111-122. https://doi.org/10.1016/0164-1212(93)90077-B