Longitud de Halstead
| Sigla | N |
| Aspecto | «Complejidad» |
| Se mide en | método, clase |
| Tipo de valor | puntuación (entero, mínimo 0) |
| Dirección | informativa: ni alto ni bajo es mejor |
| Origen | Maurice H. Halstead, 1977 |
| Familia | «Medidas de Halstead» |
| Stau Metro | HalsteadLengthMethod, HalsteadLengthClass |
En pocas palabras
Mide el tamaño de un método o de una clase contando sus piezas: cada operador (=, +, if, return, una
llamada a un método…) y cada operando (una variable, un campo, un literal). Cada aparición cuenta, aunque se repita.
Es como contar las palabras de un texto en lugar de sus líneas: no le afecta cómo esté formateado el código.
Qué mide
El tamaño léxico del código. Las líneas de código dependen del estilo: la misma expresión puede ocupar una línea o cinco. La longitud de Halstead no ve saltos de línea ni comentarios; solo ve los elementos con los que se escribe el cálculo.
Halstead dividía cualquier programa en dos clases de tokens:
- Operadores: lo que actúa. Símbolos aritméticos, lógicos y de asignación, palabras clave del lenguaje y llamadas a funciones.
- Operandos: aquello sobre lo que se actúa. Variables, constantes y literales.
Con esas dos clases se definen cuatro recuentos básicos, de los que salen todas las demás medidas de la familia:
| Símbolo | Significado |
|---|---|
n1 |
operadores distintos |
n2 |
operandos distintos |
N1 |
apariciones de operadores, con repeticiones |
N2 |
apariciones de operandos, con repeticiones |
La longitud usa los dos recuentos con repeticiones. Su pareja, el «vocabulario», usa los dos de elementos distintos.
Cómo se calcula
La fórmula es trivial. Lo difícil es decidir qué es un operador y qué es un operando, y ahí Halstead no dejó
unas reglas cerradas para cada lenguaje: cada herramienta fija las suyas. Las dudas habituales son los signos de
puntuación (paréntesis, llaves, punto y coma), las declaraciones (tipos, modificadores, nombres de parámetros) y los
nombres de métodos. El ejemplo de la página de Wikipedia, por ejemplo, cuenta (), {}, la coma y el punto y coma
como operadores; Stau Metro no los cuenta (ver «En las herramientas»). Por eso dos herramientas casi nunca dan la
misma longitud para el mismo código.
Ejemplo
Con las reglas de Stau Metro:
class Prices {
static final int TAX = 21;
double withTax(double price, boolean exempt) { // operadores: double, double, boolean
if (exempt) { // operador: if operando: exempt
return price; // operador: return operando: price
}
double factor = 1 + TAX / 100.0; // operadores: double, =
// operandos: factor, «1 + TAX / 100.0»
return Math.round(price * factor * 100) // operadores: return, *, *, round
/ 100.0; // operador: /
// operandos: price, factor, 100, 100.0
}
}
Para el método withTax:
- Operadores: 3 + 1 + 1 + 2 + 5 = 12 apariciones (
N1). - Operandos: 1 + 1 + 2 + 4 = 8 apariciones (
N2). - .
Tres detalles del recuento. Los nombres withTax, price y exempt de la cabecera no cuentan: son declaraciones
sin inicializador. 1 + TAX / 100.0 es una expresión constante, que el compilador resuelve, y cuenta como un
solo operando, sin su + ni su /. Y factor, al declararse con valor inicial, aporta el = y su propio nombre,
igual que si se hubiera escrito double factor; factor = ….
Para la clase Prices se suma todo lo que hay en ella: lo del método más class, static, final, int, el =
de TAX (5 operadores) y los operandos TAX y 21 (2). La longitud de la clase es .
Este mismo ejemplo se sigue en las páginas de «vocabulario», «volumen», «dificultad», «esfuerzo» y «errores estimados».
Cómo interpretarla
Es una medida de tamaño, y como tal no tiene un valor bueno ni malo; Stau Metro no le asigna umbrales. Sirve:
- como alternativa a las líneas de código, cuando el formato del código varía mucho entre ficheros o equipos;
- comparada con el vocabulario: una longitud muy superior al vocabulario indica que se repiten mucho los mismos elementos (el mismo campo, el mismo literal);
- como ingrediente del «volumen», que es la medida de tamaño que Halstead usaba en el resto de sus fórmulas.
Un método con una longitud alta es, sin más, un método largo en tokens. Si además su «dificultad» es alta, merece la misma atención que cualquier método largo y enrevesado: extraer partes con nombre suele bajar las dos.
Ojo. No compares longitudes calculadas por herramientas distintas. Que una cuente los paréntesis y los punto y coma y otra no basta para que los valores no se parezcan.
Para profundizar
Longitud estimada. Halstead propuso estimar la longitud a partir del vocabulario solo, sin contar repeticiones:
Su hipótesis era que, en un programa bien escrito, y se parecen. En el ejemplo, con y , , el doble de la longitud real (20): la estimación no está pensada para fragmentos tan cortos. Stau Metro no calcula .
Críticas. La parte teórica de la software science de Halstead (la que justifica fórmulas como o el esfuerzo) fue revisada con dureza por Shen, Conte y Dunsmore (1983), que repasaron también los estudios experimentales publicados desde 1977. La longitud en sí no depende de esa teoría: es un recuento, y vale como medida de tamaño siempre que se sepa qué cuenta.
Formas de falsearla. Como cualquier medida de tamaño, baja al comprimir el código (expresiones encadenadas, variables temporales eliminadas) sin que el código sea más fácil de leer.
Relación con otras métricas
- «Vocabulario de Halstead» (
n): los mismos elementos sin repeticiones; se lee junto aN. - «Volumen de Halstead» (
V): se calcula multiplicandoNpor el logaritmo del vocabulario. - «Dificultad» (
D), «esfuerzo» (E) y «errores estimados» (B): las medidas derivadas de la familia; las tres dependen de los recuentos de esta página. - «Tiempo de programación de Halstead» (
T): otra derivada, que Stau Metro no calcula. - «Líneas de código» (
LOC) y «líneas de código sin comentarios» (NCLOC): otras medidas de tamaño del mismo método o clase, sensibles al formato. - «Número de expresiones» (
EXP): otra forma de medir el tamaño de un método por sus piezas sintácticas. - «Perfil de criterios de calidad (mantenibilidad)» (
QCP_MAINT) y «(fiabilidad)» (QCP_RLBTY): en Stau Metro, incluyenNen su fórmula.
En las herramientas
Stau Metro (HalsteadLengthMethod por método, HalsteadLengthClass por clase). Recorre el árbol sintáctico de
Java y cuenta:
- como operador: cada palabra clave, incluidos modificadores (
public,static,final), tipos primitivos yvoid,class,new,this,instanceof; cada signo de una operación aritmética, lógica, relacional o de desplazamiento; cada signo de asignación (=,+=…); cada++y--; el operador condicional, como un único operador?:; y cada llamada a un método que se pueda resolver, identificada por el método llamado (dos llamadas al mismo método son el mismo operador; dos sobrecargas distintas, operadores distintos, salvo si sus parámetros solo difieren en el paquete de un tipo). Una expresiónnewaporta solo la palabra clavenew: la llamada al constructor no cuenta como operador; - como operando: cada referencia a una variable, un parámetro o un campo, con el texto tal como está escrito, y
cada literal (números, cadenas, caracteres,
true,falseynull); - una declaración con inicializador (
int x = a) aporta el=y el nombre declarado como operando.
No cuentan: los signos de puntuación (paréntesis, llaves, corchetes, comas, punto y coma, el punto), la flecha
-> de las lambdas y el :: de las referencias a métodos; los nombres de tipos que no son primitivos (String,
List); los nombres de métodos en su declaración; los nombres de parámetros y de variables declaradas sin valor
inicial; las llamadas y las referencias que no se pueden resolver; y las anotaciones enteras, con sus argumentos.
Una constante de enumerado no cuenta como variable inicializada: enum Color { RED, GREEN, BLUE } vale 1 (solo
enum).
Una expresión que el compilador evalúa como constante (literales y constantes final combinados con operadores,
como MAX + 1) cuenta como un único operando, identificado por su texto. Las referencias cualificadas cuentan
por partes: en a.b, con a variable, cuentan a y a.b; this.f y f son operandos distintos, aunque
designen el mismo campo.
Qué entra en cada nivel:
- Método. Todo lo que hay en la declaración, cabecera incluida (modificadores, tipo de retorno si es primitivo
o
void, tipos primitivos de los parámetros,throws), y todo su cuerpo, incluidas sus lambdas y las clases anónimas o locales declaradas dentro. Los constructores cuentan como métodos; un constructor vacío sin modificadores vale 0. No se calcula para métodos abstractos (tampoco para los métodos abstractos de las interfaces; sí para sus métodosdefault,staticyprivate). Los métodos de una clase anónima o local declarada dentro de un método no tienen valor propio: ya cuentan en ese método. Los de una clase anónima en el inicializador de un campo sí lo tienen; una lambda en ese mismo sitio no cuenta en ningún método. - Clase. Todo lo que hay en la clase: cabecera, campos, inicializadores y todos sus métodos, abstractos incluidos (su cabecera suma, aunque no tengan valor propio), con las clases anónimas y locales que contengan. Las clases con nombre anidadas se miden aparte y no cuentan en la que las contiene. Se calcula para clases, clases abstractas, enumerados y records; no para interfaces ni para clases anónimas o locales.
Entra todo el código Java del ámbito analizado, de producción y de test. Kotlin no se mide.
Radon (Python) calcula las mismas medidas básicas de Halstead a partir de , , y ; su documentación no detalla qué cuenta como operador ni como operando.
Referencias
- Halstead, M. H. (1977). Elements of Software Science. Elsevier North-Holland.
- Shen, V. Y., Conte, S. D. y Dunsmore, H. E. (1983). «Software Science Revisited: A Critical Analysis of the Theory and Its Empirical Support». IEEE Transactions on Software Engineering, SE-9(2), 155-165. https://doi.org/10.1109/TSE.1983.236460
- Wikipedia, «Halstead complexity measures»: https://en.wikipedia.org/wiki/Halstead_complexity_measures
- Radon, introducción a las métricas: https://radon.readthedocs.io/en/latest/intro.html