Métricas de McCabe
Las métricas de McCabe miden la lógica de decisión de un método a partir de su grafo de flujo de control: por
dónde puede ir la ejecución y cuántos caminos distintos hay que recorrer para probarla. La primera es la complejidad
ciclomática v(G). Las otras dos, la complejidad esencial
ev(G) y la de diseño iv(G), son reducciones del mismo grafo que contestan preguntas más finas: cuánta de esa
lógica rompe la programación estructurada y cuánta decide qué otros métodos se llaman.
Alrededor de ellas hay un grupo de métricas que McCabe no definió como tales y que se construyen sumando, promediando o tomando el máximo de su complejidad por método: por clase, por paquete, por módulo o por proyecto.
Para quien empieza. No hace falta dibujar ningún grafo. La complejidad ciclomática se calcula contando: empieza en 1 y suma 1 por cada
if, bucle,case,&&o||. La página de la «complejidad ciclomática» lo explica con un ejemplo.
Quién, cuándo y para qué
Thomas J. McCabe publicó «A Complexity Measure» en 1976, en IEEE Transactions on Software Engineering. El objetivo era práctico: una medida de la complejidad de un módulo que sirviera para limitarla y, sobre todo, para probarlo. El número ciclomático del grafo de control es el tamaño de un conjunto base de caminos, y de ahí sale el método de prueba estructurada (basis path testing): un test por cada camino de ese conjunto. El mismo artículo propuso 10 como límite superior razonable, «aunque no mágico».
La sección VI de ese artículo trata ya de cómo son los grafos de los programas no estructurados, y define con ese
fin la complejidad esencial. Era la época del debate sobre el goto, y McCabe buscaba una medida continua de lo
estructurado que es un programa en lugar de un «todo o nada».
En 1989, McCabe y Charles W. Butler extendieron la prueba estructurada al diseño en Communications of the ACM: la complejidad de diseño de cada módulo y, a partir de su suma sobre el programa, la complejidad de integración, que da el número de tests de integración independientes.
El informe NIST 500-235 de Watson y McCabe (1996) reúne el conjunto en una metodología, Structured Testing, y describe con detalle las reducciones esencial y de diseño. Mantiene el límite de 10 y admite hasta 15 en equipos con experiencia, diseño formal y un plan de tests completo.
Las tres medidas
| Medida | Sigla | Pregunta que contesta | Valores | Stau Metro |
|---|---|---|---|---|
| «Complejidad ciclomática» | v(G) |
¿cuántos caminos independientes tiene el método? | 1 o más | la calcula (CyclomaticComplexity) |
| «Complejidad ciclomática esencial» | ev(G) |
¿cuánta de su lógica no se deja estructurar? | entre 1 y v(G); nunca 2 en la definición de McCabe |
la calcula (EssentialCyclomaticComplexity) |
| «Complejidad de diseño» | iv(G) |
¿cuántas de sus decisiones gobiernan llamadas a otros métodos? | entre 1 y v(G) |
la calcula (DesignComplexity) |
Las tres se definen sobre el mismo grafo y las tres son, al final, la complejidad ciclomática de un grafo:
v(G)es la del grafo completo, , que en código estructurado equivale al número de decisiones binarias más 1.ev(G)es la del grafo que queda al eliminar, de dentro afuera, las primitivas de la programación estructurada (secuencia, selección, iteración). Un método estructurado vale 1.iv(G)es la del grafo que queda al aplicar la reducción de diseño: se eliminan las partes que no contienen llamadas a otros módulos. Un método cuyas decisiones son todas locales vale 1.
Aunque las dos reducciones se parezcan, el informe NIST señala que no hay relación matemática entre ev(G) e
iv(G): la esencial elimina primitivas haya o no llamadas en ellas, y solo primitivas completas.
Cómo se leen juntas
Las dos reducciones se interpretan respecto a v(G), que es su cota superior:
v(G)alta conev(G)= 1: mucha lógica, pero bien estructurada. Se puede repartir extrayendo métodos sin pelearse con los saltos.ev(G)cerca dev(G): casi toda la lógica depende de salidas anticipadas,break,continueothrow. Ojo: las cláusulas de guarda subenev(G)y suelen hacer el método más legible; mira la «complejidad cognitiva» antes de «estructurar».iv(G)cerca dev(G): el método es un coordinador; cada camino es un escenario de integración distinto. La proporcióniv(G) / v(G)dice qué parte de su complejidad es de diseño.
Para probar, v(G) es el número de tests del conjunto base de caminos del método, e iv(G), el de los caminos que
importan al integrarlo con los demás.
Las métricas que la agregan
v(G) se mide por método. Para hablar de una clase o de un paquete hay que agregarla, y la forma de agregar cambia
lo que se ve. Las agregadas que tienen página en esta referencia son:
| Métrica | Sigla | Nivel | Agregación | Familia | Recuento en Stau Metro |
|---|---|---|---|---|---|
| «Complejidad ciclomática total» | v(G)tot |
paquete, módulo, proyecto | suma | McCabe | el de v(G) |
| «Complejidad ciclomática promedio» | v(G)avg |
paquete, módulo, proyecto | media | McCabe | el de v(G) |
| «Complejidad ponderada de los métodos» | WMC |
clase | suma | «Chidamber y Kemerer» | sin &&, || ni catch |
| «Complejidad promedio de las operaciones» | OCavg |
clase | media | ninguna | sin &&, || ni catch |
| «Complejidad máxima de las operaciones» | OCmax |
clase | máximo | ninguna | sin &&, || ni catch |
WMC merece una nota aparte: es de Chidamber y Kemerer (1994), que dejaron sin definir a propósito la complejidad
de cada método. La ponderación ciclomática es la más extendida, pero no la única; con ponderación unitaria, WMC
es el número de métodos.
Las tres formas de agregar responden a preguntas distintas:
- La suma (
v(G)tot,WMC) mide el volumen de lógica. Crece con el tamaño, y una clase de cincuenta métodos de complejidad 1 vale lo mismo que una de cinco métodos de complejidad 10. - La media (
v(G)avg,OCavg) describe el estilo del código y permite comparar partes de tamaño muy distinto. Los accesores y los constructores triviales valen 1 y la bajan. - El máximo (
OCmax) saca a la luz el método que concentra la complejidad. La distribución dev(G)es muy asimétrica: unos pocos métodos acumulan casi todas las decisiones, y la media los diluye.
Lee siempre el máximo junto a la media. Una clase con diez métodos triviales y uno de complejidad 25 tiene una media por debajo de 4.
Ojo. En Stau Metro,
v(G)totyv(G)avgusan exactamente el recuento dev(G), peroWMC,OCavgyOCmaxusan otro, que no incluye&&,||nicatch. ElWMCde una clase puede ser menor que la suma de lav(G)de sus métodos.
Validación y críticas
v(G) es la métrica de McCabe más estudiada y la más criticada. Las críticas principales, desarrolladas en su
página, son:
- Se correlaciona mucho con el tamaño. Shepperd (1988) revisó la evidencia y concluyó que, en muchos conjuntos de datos, aporta poco más que las líneas de código.
- No cumple varias propiedades de Weyuker (1988) para una medida de complejidad; por ejemplo, no cambia al reordenar las sentencias.
- Ignora el anidamiento. Tres
ifseguidos y tres anidados valen lo mismo. Es la motivación directa de la complejidad cognitiva de Campbell. - Ignora los datos. No ve la complejidad de las expresiones ni de las estructuras de datos, que es justo lo que miran las «medidas de Halstead».
- Castiga construcciones inofensivas. Un
switchplano de veinte casos vale 21 y se lee de un vistazo.
Las dos reducciones tienen críticas propias. ev(G) es hija del problema del goto; en Java lo que la sube son
salidas anticipadas y excepciones, y no hay acuerdo en que sean un defecto. iv(G) depende de qué se considere una
llamada en un lenguaje orientado a objetos (un new, una referencia a método, una llamada a la propia clase), y
cada herramienta lo decide a su manera.
Además, las herramientas para Java no construyen el grafo: aproximan las reducciones sobre el árbol sintáctico.
En la aproximación de Stau Metro, una sola cláusula de guarda da ev(G) = 2, un valor que la definición de McCabe
no puede producir; el informe NIST propone precisamente esa propiedad para evaluar herramientas.
Variantes y sucesoras. Myers (1977) propuso contar las condiciones compuestas de forma explícita, y de ahí sale
la variante «extendida» que suma cada && y ||, la más usada hoy. La
«complejidad NPath» de Nejmeh (1988) cuenta caminos completos en lugar de
independientes. La «complejidad cognitiva» de Campbell (2018)
cuenta casi las mismas construcciones, pero penaliza el anidamiento. La
«profundidad de anidamiento» mide la dimensión que v(G) no ve.
Dónde reaparece. El «índice de mantenibilidad» usa v(G)
como uno de sus tres ingredientes, junto al volumen de Halstead y las líneas de código.
En las herramientas
Qué calcula cada herramienta, según su documentación o su código fuente (ver «Referencias»):
| Herramienta | v(G) |
ev(G) |
iv(G) |
Agregadas |
|---|---|---|---|---|
| Stau Metro | sí | sí (aproximación sintáctica) | sí (aproximación sintáctica) | WMC, OCavg, OCmax, v(G)tot, v(G)avg |
| Checkstyle | sí | no figura | no figura | no figura |
| PMD | sí (CYCLO) |
no figura | no figura | WMC (suma de CYCLO); la regla CyclomaticComplexity avisa también de las clases cuya suma llega a 80 |
| SonarQube (Java) | sí | no figura | no figura | la del conjunto del código es «básicamente la suma» de las funciones |
| JaCoCo | sí, sobre el bytecode | no figura | no figura | la resume por clase, paquete y grupo |
| MetricsReloaded | sí | sí (aproximación sintáctica) | sí (aproximación sintáctica) | WMC, OCavg, OCmax, v(G)tot, v(G)avg |
«No figura» quiere decir que no se ha encontrado en la documentación consultada, no que se haya comprobado que no existe.
Ni siquiera v(G) da el mismo número en todas: unas cuentan catch y otras no, unas cuentan cada case y otras
cada grupo de etiquetas, y JaCoCo cuenta las ramas que genera el compilador. Las tablas de detalle están en la página
de la «complejidad ciclomática»; las diferencias de ev(G) e
iv(G) entre Stau Metro y MetricsReloaded, en las páginas de cada una.
Stau Metro calcula las tres medidas por método y las cinco agregadas, sobre código Java. Solo v(G) tiene
umbral de referencia por método: aviso por encima de 10 y error por encima de 20.
Las agregadas de clase WMC (31 y 47) y OCavg (3,1 y 4,7) tienen los suyos, que Stau Metro presenta como los
valores «alto» y «muy alto» de Lanza y Marinescu (2006) para Java.
Referencias
- McCabe, T. J. (1976). «A Complexity Measure». IEEE Transactions on Software Engineering, SE-2(4), 308-320. https://doi.org/10.1109/TSE.1976.233837
- Myers, G. J. (1977). «An Extension to the Cyclomatic Measure of Program Complexity». ACM SIGPLAN Notices, 12(10), 61-64.
- Nejmeh, B. A. (1988). «NPATH: A Measure of Execution Path Complexity and Its Applications». Communications of the ACM, 31(2), 188-200. https://doi.org/10.1145/42372.42379
- Shepperd, M. (1988). «A Critique of Cyclomatic Complexity as a Software Metric». Software Engineering Journal, 3(2), 30-36.
- Weyuker, E. J. (1988). «Evaluating Software Complexity Measures». IEEE Transactions on Software Engineering, 14(9), 1357-1365.
- McCabe, T. J. y Butler, C. W. (1989). «Design Complexity Measurement and Testing». Communications of the ACM, 32(12), 1415-1425. https://doi.org/10.1145/76380.76382
- Chidamber, S. R. y Kemerer, C. F. (1994). «A Metrics Suite for Object Oriented Design». IEEE Transactions on Software Engineering, 20(6), 476-493. https://doi.org/10.1109/32.295895
- Watson, A. H. y McCabe, T. J. (1996). Structured Testing: A Testing Methodology Using the Cyclomatic Complexity Metric. NIST Special Publication 500-235. https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication500-235.pdf
- Lanza, M. y Marinescu, R. (2006). Object-Oriented Metrics in Practice. Springer. https://doi.org/10.1007/3-540-39538-5
- Campbell, G. A. (2018). «Cognitive Complexity: An Overview and Evaluation». Proceedings of the 2018 International Conference on Technical Debt, 57-58.
- Wikipedia, «Cyclomatic complexity» (sección VI del artículo de 1976 y complejidad esencial): https://en.wikipedia.org/wiki/Cyclomatic_complexity
- Checkstyle, comprobación
CyclomaticComplexity: https://checkstyle.sourceforge.io/checks/metrics/cyclomaticcomplexity.html - PMD, reglas de diseño para Java: https://docs.pmd-code.org/latest/pmd_rules_java_design.html
- SonarQube, definición de métricas: https://docs.sonarsource.com/sonarqube-server/latest/user-guide/code-metrics/metrics-definition/
- JaCoCo, contadores de cobertura (también la complejidad ciclomática y su resumen por clase, paquete y grupo): https://www.jacoco.org/jacoco/trunk/doc/counters.html
- MetricsReloaded, código fuente (métricas que registra para Java): https://github.com/BasLeijdekkers/MetricsReloaded