Métrica ABC
| Sigla | ABC |
| Aspecto | «Complejidad» |
| Se mide en | método, clase, paquete (cualquier trozo de código: los vectores se suman) |
| Tipo de valor | vector de tres recuentos <A,B,C> y su magnitud (número real con un decimal, mínimo 0) |
| Dirección | más alto es peor |
| Umbrales de referencia | ninguno en la fuente original; 17 por método en RuboCop (Ruby), 60 por método en CodeNarc (Groovy) |
| Origen | Jerry Fitzpatrick, 1997 |
| Stau Metro | no la calcula |
En pocas palabras
Mide cuánto trabajo hace un trozo de código contando tres cosas: cuántas veces guarda un valor en una variable
(A, de assignment), cuántas veces llama a otro método (B, de branch) y cuántas comparaciones o
decisiones hace (C, de condition). Las tres cifras se dan juntas, como <5,5,4>, y se resumen en un solo
número. A diferencia de las líneas de código, no cambia por partir una sentencia en varias líneas.
Qué mide
Fitzpatrick la presentó como una medida de tamaño, no de complejidad, pensada para sustituir a las líneas de código. Su argumento: un programa imperativo solo hace tres cosas útiles, que son guardar datos, comprobar condiciones y ceder el control a otra rutina. Si se cuentan esas tres operaciones, el resultado no depende del estilo de quien escribe. En su artículo muestra la misma rutina escrita en 5 y en 15 líneas: las líneas varían el triple, mientras que las operaciones que cuenta el ABC son las mismas en las dos.
Los tres componentes, con sus definiciones originales:
- Asignación (A): una transferencia explícita de datos a una variable.
- Rama (B): un salto explícito hacia delante, fuera del ámbito actual. En la práctica, una llamada a una
función o a un método. No tiene nada que ver con las ramas de un
if. - Condición (C): una prueba lógica o booleana.
El vector dice además de qué tipo es el código. DeMarco distinguía programas «fuertes en datos» y «fuertes en funciones»; Fitzpatrick propone reconocerlos porque domina A o B, y añade «fuertes en lógica» para los que domina C, aunque reconoce que no hay pautas sobre cuándo un componente domina.
Ojo. La «B» no son ramas del flujo de control. Quien venga de la complejidad ciclomática tiende a leer «branches» como
ify bucles; en ABC esas decisiones van a la C, y la B cuenta llamadas.
Cómo se calcula
Se cuentan los tres componentes y se calcula la magnitud del vector:
La magnitud se redondea a una décima y, según Fitzpatrick, no debe darse sin el vector: suma tres cosas distintas suponiendo que son ortogonales y de escala comparable, una hipótesis que él mismo deja abierta.
Las reglas de Fitzpatrick para Java son siete:
| Regla | Componente |
|---|---|
cada operador de asignación: =, *=, /=, %=, +=, <<=, >>=, &=, |=, ^=, >>>=, salvo en la declaración de una constante (final) |
A |
cada ++ y --, prefijo o sufijo |
A |
| cada llamada a una función o a un método de una clase | B |
cada aparición del operador new |
B |
cada operador de comparación: ==, !=, <=, >=, <, > |
C |
cada else, case, default, try, catch y ? |
C |
cada condición unaria: un valor que se usa directamente como booleano, como if (done) |
C |
La lista de operadores de asignación del artículo no incluye -=, ni para Java ni para C o C++; parece un descuido,
porque -= guarda un valor igual que +=.
Lo que no cuenta también es significativo:
if,for,whileyswitchno suman por sí mismos. Unif (x > 0)suma 1 por el>; unif (ready), 1 por la condición unaria.&&y||no suman. Lo que suma es cada condición que unen: ena > 0 && b > 0suman los dos>.- Los operadores aritméticos no suman.
x = y + 6vale<1,0,0>, aunquex = add(y, 6)valga<1,1,0>: la regla mira el lenguaje, no la implementación. returnno suma: Fitzpatrick considera el retorno un salto hacia atrás, no hacia delante.- Las declaraciones de constantes no suman, porque no guardan datos sino que dan nombre a un valor.
El vector de un módulo es la suma de los vectores de sus partes: el de una clase es la suma de los de sus métodos, y así hacia arriba. Las magnitudes, en cambio, no se suman.
Ejemplo
record Order(boolean isLate, int total) { }
static int countLate(List<Order> orders, int limit) {
int count = 0; // A: =
for (int i = 0; i < orders.size(); i++) { // A: =, ++ B: size() C: <
Order o = orders.get(i); // A: = B: get()
if (o.isLate() && o.total() > limit) { // B: isLate(), total() C: isLate() unaria, >
count++; // A: ++
} else { // C: else
System.out.println("on time: " + o); // B: println()
}
}
return count;
}
- A: 1 + 2 + 1 + 1 = 5 (tres
=y dos++). - B: 1 + 1 + 2 + 1 = 5 (cinco llamadas;
System.outes un campo, no una llamada). - C: 1 + 2 + 1 = 4 (el
<, la condición unariaisLate(), el>y elelse).
Se escribe <5,5,4> y 8,1. Para comparar: la complejidad ciclomática de este método es 4 (1 más el for, el if
y el &&), mientras que el return final y las palabras clave for e if no suman en ningún componente del ABC.
Cómo interpretarla
Fitzpatrick no propuso umbrales: la presentó como una medida de tamaño para comparar y estimar. Los umbrales que se encuentran vienen de herramientas para otros lenguajes:
| Herramienta | Lenguaje | Umbral por defecto |
|---|---|---|
RuboCop (Metrics/AbcSize) |
Ruby | 17 por método; su documentación lee hasta 17 como satisfactorio, de 18 a 30 como insatisfactorio y más de 30 como peligroso |
CodeNarc (AbcMetric) |
Groovy | 60 por método y 60 de media por clase |
Ninguno de los dos se calibró para Java, y las reglas de recuento de cada herramienta difieren algo de las originales (ver «En las herramientas»). Úsalos como orden de magnitud.
Cómo leer el vector.
- A alta: el método manipula mucho estado local o de campos. Puede estar haciendo a mano lo que haría una estructura de datos o una expresión.
- B alta: el método coordina, delega en muchos otros. Es normal en un orquestador; en un método de lógica de negocio puede indicar que conoce demasiados colaboradores.
- C alta: el método toma muchas decisiones. Lo mismo que una «complejidad ciclomática» alta: candidato a extraer métodos o a sustituir condicionales por polimorfismo.
Qué hacer con una magnitud alta. Lo mismo que con un método largo: extrae métodos con nombre. El vector dice por dónde empezar: si domina C, por las decisiones; si domina A, por los cálculos intermedios.
Nota. Como el vector es aditivo y empieza en cero, un método vacío vale
<0,0,0>aunque ocupe tres líneas. Fitzpatrick lo destaca como ventaja frente a las líneas de código.
Para profundizar
Usos que proponía su autor. Fitzpatrick sugería medir la productividad en ABC por día en lugar de líneas por día, estimar plazos dividiendo el ABC previsto de un proyecto entre esa productividad y expresar la fiabilidad en defectos por ABC en lugar de por línea. Ninguna de estas aplicaciones se validó en el artículo.
Evidencia. La única evidencia del artículo original es un experimento propio, sin publicar en el momento: 18 desarrolladores ordenaron por tamaño un conjunto de métodos de C++ y su orden se correlacionó, según Fitzpatrick, de forma significativamente mayor con la magnitud ABC que con las líneas de código. El propio autor pide más investigación para validarla en programas grandes y frente a otras medidas.
La magnitud es una decisión, no un resultado. Fitzpatrick advierte que la raíz de la suma de cuadrados supone que los tres componentes tienen escalas comparables, y que la investigación podría aconsejar una suma ponderada u otra fórmula. Por eso pide publicar siempre el vector: si cambia el cálculo de la magnitud, los vectores siguen valiendo.
Diferencias entre herramientas. Las reglas originales se escribieron para C, C++ y Java. Las implementaciones
para otros lenguajes añaden o cambian reglas: GMetrics cuenta como rama el acceso a una propiedad de Groovy y la
desreferencia segura ?., y añade operadores de comparación propios del lenguaje; RuboCop puede contar una sola
vez las llamadas repetidas a un mismo atributo sin argumentos. Los valores de dos herramientas no son comparables
sin mirar sus reglas.
Relación con Halstead. Fitzpatrick la propone para superar tanto las líneas de código como el recuento de tokens de la software science de Halstead, cuyas conclusiones considera muy discutidas. Sigue contando tokens, pero solo los que representan las tres operaciones fundamentales, y con reglas fijadas para cada lenguaje.
Formas de falsearla. Encadenar llamadas en lugar de usar variables intermedias baja A sin que el método haga
menos; sustituir una cadena de if … else por una búsqueda en un Map cambia varias C por una sola B. Estos
cambios mueven puntos de un componente a otro, y conviene saberlo antes de interpretar el perfil del vector.
Relación con otras métricas
- «Complejidad ciclomática» (
v(G)): cuenta decisiones; su información está, con otras reglas, en el componente C.ify bucles suman env(G)y no en C; los operadores de comparación, al revés. - «Número de llamadas a métodos» (
CALL): casi el mismo recuento que el componente B. - «Longitud de Halstead» (
N) y «volumen de Halstead» (V): la medida de tamaño por tokens a la que ABC quería sustituir; cuentan todos los operadores y operandos, no solo tres clases. - «Número de sentencias» (
STAT) y «líneas de código sin comentarios» (NCLOC): otras medidas de tamaño independientes, en distinto grado, del formato. - «Puntos de función» (
FP): Fitzpatrick sitúa ABC como medida de código que complementa, sin sustituirlos, a los puntos de función, que se calculan sobre la especificación.
En las herramientas
Stau Metro no calcula la métrica ABC. Tiene recuentos cercanos a dos de sus componentes, pero ninguno a la A:
- El «número de llamadas a métodos» (
NumMethodCalls, por método) cuenta las llamadas a métodos y las creaciones de objetos que aparecen en el cuerpo del método. Es casi la B; la diferencia es que no cuenta la creación de arrays, mientras que la regla de Fitzpatrick suma cadanew. - La «complejidad ciclomática» (
CyclomaticComplexity) cuenta decisiones, pero con otras reglas que la C: sumaif, bucles y operadores&&y||, y no los operadores de comparación ni loselse.
CodeNarc (regla AbcMetric, para Groovy, con GMetrics). Aplica las reglas de Fitzpatrick (asignaciones y ++
y -- en A; llamadas y new en B; comparaciones, else, case, default, try, catch, ? y condiciones
unarias en C), con los operadores propios de Groovy. Mide métodos y campos inicializados con una closure. Avisa
por defecto por encima de 60 por método y de 60 de media en una clase; el total por clase está desactivado.
RuboCop (Metrics/AbcSize, para Ruby). Comprueba que el ABC de cada método no supere un máximo, 17 por defecto.
Si se desactiva CountRepeatedAttributes (por defecto vale true), las llamadas repetidas a un mismo método sin
argumentos cuentan como una sola rama.
Referencias
- Fitzpatrick, J. (1997). «Applying the ABC Metric to C, C++, and Java». C++ Report, junio de 1997. https://wstomv.win.tue.nl/edu/2ip30/references/ABCmetric.pdf
- DeMarco, T. (1982). Controlling Software Projects. Prentice-Hall.
- Halstead, M. H. (1977). Elements of Software Science. Elsevier North-Holland.
- CodeNarc, reglas de tamaño y complejidad: https://codenarc.org/codenarc-rules-size.html
- GMetrics, métrica ABC: https://dx42.github.io/gmetrics/metrics/AbcMetric.html
- RuboCop, departamento
Metrics: https://docs.rubocop.org/rubocop/latest/cops_metrics.html