τTau SolutionsReferencia

Herramientas: qué calcula cada una y en qué difieren

Actualizado el 15 de noviembre de 2026

Dos herramientas pueden dar números distintos para la misma métrica del mismo código, y las dos pueden tener razón: cada una aplica su propia definición. Esta página reúne lo que las páginas de métrica cuentan en su sección «En las herramientas»: qué es cada herramienta, qué métricas de esta referencia calcula y dónde están las diferencias que más cambian los valores. El detalle de cada regla está en la página de la métrica enlazada.

Para quien empieza. Una sigla no es una definición. CBO, LCOM o WMC en dos herramientas pueden ser métricas distintas con el mismo nombre. Antes de comparar dos valores, o de aplicar un umbral leído en otro sitio, comprueba que los dos salen de la misma definición.

Por qué no coinciden

Las diferencias vienen casi siempre de una de estas cinco fuentes:

  • La variante. Algunas métricas tienen varias definiciones publicadas. La «falta de cohesión» tiene al menos cinco, y el «factor de acoplamiento», dos revisiones con denominadores distintos.
  • Qué construcciones cuentan. En la «complejidad ciclomática», si suman los && y ||, los catch o el default de un switch.
  • Qué elementos entran. Clases anónimas y lambdas, código de test, clases de bibliotecas, métodos que genera el compilador en enumerados y records.
  • La unidad. Clases o paquetes en los «acoplamientos aferentes»; sentencias o líneas en el tamaño de un método.
  • Lo que se lee. Código fuente o bytecode. JaCoCo, por ejemplo, cuenta los saltos condicionales que emite el compilador, no las construcciones escritas.

Las herramientas

Stau Metro

Complemento para IntelliJ IDEA. Recorre el código fuente con el árbol sintáctico del IDE y calcula 303 métricas agrupadas en 142 conceptos, a nivel de método, clase, interfaz, paquete, módulo, proyecto y tipo de fichero. Todas las métricas de esta referencia marcadas como calculadas por Stau Metro en el «índice» son suyas. Las métricas de código son de Java; de Kotlin solo cuenta «ficheros» y «líneas», y de XML y HTML, también ficheros y líneas («XML», «L(XML)», «HTML», «L(HTML)»).

Rasgos que conviene conocer al comparar con otras:

  • Métricas de dependencias como «Dcy» o «CBO» solo ven clases con código fuente en el proyecto: las del JDK y las de bibliotecas no cuentan. En cambio, «DIT» sigue la cadena de superclases también por las de bibliotecas y cuenta hasta Object inclusive.
  • El código de test entra salvo que la métrica diga lo contrario. Las métricas de paquete de Martin lo excluyen, y varias de tamaño tienen variantes separadas de producción y de test («LOCp», «LOCt»).
  • Calcula la variante LCOM4 de la cohesión, y sus WMC, OCavg y OCmax usan un recuento de decisiones sin &&, || ni catch, distinto del de su v(G).
  • Entre las métricas de esta referencia, no calcula, por ejemplo, NPath, TCC, LCOM1, LCOM*, ABC, el tiempo de Halstead, el índice de mantenibilidad, la duplicación, la cobertura ni nada que salga del control de versiones; el «índice» dice cuáles calcula.

MetricsReloaded

Complemento de métricas para IntelliJ IDEA y los demás IDE de la plataforma IntelliJ. De las herramientas de esta referencia, es la que más siglas comparte con Stau Metro: en muchas métricas el nombre coincide y las reglas de detalle no. Las páginas de métrica describen, según su documentación o su código fuente, cómo calcula:

Las diferencias más frecuentes: en OCavg, WMC y los QCP, en un switch clásico suma también el grupo de default y no cuenta las reglas con flecha; en CSO incluye los métodos de Object, y en ISO toma todos los métodos que el IDE atribuye a la interfaz y resta 13 fijos por los de Object; en CF divide entre TC(TC−1)/2TC(TC-1)/2 e incluye las dependencias hacia las superclases.

SonarQube

Plataforma de análisis continuo de la calidad para muchos lenguajes, Java entre ellos. Sus métricas tienen nombres propios en minúsculas. Las que corresponden a páginas de esta referencia son:

SonarQube Página Nota
complexity «v(G)», «v(G)tot» por función; el total es «básicamente la suma»; no define una media
regla S3776 «CogC» umbral por defecto 15
regla S134 «NBD» solo if, bucles, switch y try
regla S107 «NP» máximo 7
lines, ncloc «LOC», «NCLOC» lines son líneas físicas
comment_lines, comment_lines_density «CLOC», «COM_RAT» sin cabeceras de fichero ni comentarios vacíos
classes, functions, statements, files «C», «METH», «STAT», «FILES» functions ignora en Java los métodos de clases anónimas
duplicated_lines_density «densidad de líneas duplicadas» bloques de 10 sentencias en Java
sqale_debt_ratio «ratio de deuda técnica» 30 minutos por línea por defecto
cobertura, tests «cobertura», «JTM» la cobertura se importa de otras herramientas

Checkstyle

Analiza código fuente Java contra reglas configurables. No produce un informe de métricas, sino avisos: las comprobaciones de métricas tienen un máximo y señalan lo que lo supera. Las comprobaciones que tocan métricas de esta referencia son CyclomaticComplexity («v(G)», máximo 10), NPathComplexity («NPath», 200), NestedIfDepth y NestedForDepth («IF_NEST» y «LOOP_NEST», contando desde 0), ParameterNumber («NP», 7), ThrowsCount («THROWS», 4), ReturnCount («RETURN»), ClassFanOutComplexity («fan-out», lo más parecido a «CBO», 20), ClassDataAbstractionCoupling («DAC», que pese al nombre cuenta clases instanciadas, 7), MethodLength («LOC», 150), ExecutableStatementCount (más cerca de «STAT» que de «EXEC», 30), MissingJavadocMethod («Jm», solo métodos públicos por defecto) e InterfaceIsType («ISA»).

PMD

Analizador estático multilenguaje, centrado sobre todo en Java y Apex. Sus reglas para Java (casi todas del conjunto de diseño; OnlyOneReturn es de estilo de código) cubren «v(G)» (avisa con 10 o más por método y 80 por clase), «CogC» (15 o más), «NPath» (200), «IF_NEST» (AvoidDeeplyNestedIfStmts, 3), «NP» (ExcessiveParameterList, 10), «RETURN» (OnlyOneReturn), «STAT» (NcssCount, 60 por método y 1500 por clase) y «CBO» (CouplingBetweenObjects, 20). Calcula «WMC» y «TCC» para su regla GodClass (WMC de 47 o más, ATFD mayor que 5 y TCC menor que 1/3). Su detector de copias, CPD, busca «duplicados» por tokens y da bloques, no una densidad.

JaCoCo

Biblioteca de cobertura de código para Java. Mide sobre bytecode: da los contadores de «cobertura» (instrucciones, ramas, líneas, métodos, clases) y una «complejidad ciclomática» calculada con las ramas que emite el compilador, sin contar los catch.

JDepend

Según su documentación, recorre directorios de ficheros de clase y de fuente Java y da métricas de diseño por paquete: las de «Martin» («A», «I», «D»), los ciclos entre paquetes («Cyclic») y recuentos de clases concretas, abstractas e interfaces («C», «AC»). Lo decisivo al comparar: su Ca y su Ce cuentan paquetes, no clases: responden a la idea de «PDpt» y «PDcy», aunque sus reglas sobre qué es una dependencia no son las mismas. Lee el bytecode y, sin filtros, cuenta también los paquetes de la JDK y de las librerías.

NDepend y JArchitect

NDepend es una herramienta de calidad de código para .NET; JArchitect documenta métricas equivalentes para Java. Las páginas de esta referencia citan sus definiciones de «LCOM y LCOM HS», la «cohesión relacional» H (de 1,5 a 4,0 como intervalo bueno), «Ca» y «Ce» por ensamblado (tipos) y por namespace (namespaces: NamespaceCa y NamespaceCe, el equivalente de «PDpt» y «PDcy»), el «orden de nivel», que deja sin valor a los elementos de un ciclo y a los que dependen de uno, la regla de «ciclos» y «A», «I» y «D» por ensamblado, con 0,7 como distancia problemática.

CK

Herramienta de Aniche que calcula métricas de clase y de método de código Java por análisis estático, sin necesitar el código compilado. Calcula «CBO» (y CBO Modified, en los dos sentidos), FAN-IN y FAN-OUT, «RFC», «WMC», «LCOM» en la versión de 1994, «LCOM*», «TCC y LCC», y recuentos como loopQty («LOOP»), comparisonsQty (más amplio que «NULL»), tryCatchQty (distinto de «CAUGHT»), los métodos de cada clase («METH») y las clases anónimas, internas y lambdas («LAMBDA»).

Aivosto Project Analyzer

Analizador para Visual Basic y VB.NET. Documenta con detalle las métricas «MOOD» («AHF», «MHF», «AIF», «MIF», «PF», «CF»), las de «Chidamber y Kemerer» («DIT», «NOC») y varias medidas de cohesión: LCOM1 a «LCOM4», «TCC y LCC». Numera las LCOM a su manera: su LCOM3 es la recomendada de Henderson-Sellers.

Radon

Herramienta para Python. Calcula las «medidas de Halstead» («volumen», «dificultad», «esfuerzo», «tiempo», «errores estimados») y el «índice de mantenibilidad», del que documenta cuatro fórmulas. Sus errores estimados usan V/3000V/3000, no E2/3/3000E^{2/3}/3000.

Code Maat, CodeScene y git

Las métricas de «evolución» salen del control de versiones, no del código. Code Maat, de Adam Tornhill, lee un registro de git y da «acoplamiento de cambio», «rotación», revisiones por fichero para los «puntos calientes» y «propiedad del código». CodeScene, comercial y del mismo autor, busca puntos calientes por frecuencia de commits o por rotación relativa. git log --numstat da la materia prima: líneas añadidas y borradas por commit y fichero.

Otras herramientas

Herramienta Lenguaje Métricas citadas en esta referencia
Eclipse Metrics (complemento de Eclipse) Java «LCOM*», «SIX»
Visual Studio .NET «DIT», «MI»
Testwell CMTJava y CMT++ Java (CMTJava); C, C++ y C# (CMT++) «tiempo de Halstead», «MI»
HCL OneTest Embedded C y C++ «tiempo de Halstead»
Understand varios, Java entre ellos «ratio de comentarios»
Sonargraph Java, Kotlin, C#, Python, Go, TypeScript, C y C++ «CCD, ACD, NCCD»
Lattix C y C++, Java, JavaScript, .NET, Python, Ruby y otros «NCCD»
CodeQL Java «cohesión relacional»
Analizo C, C++, C#, Java y Python «LCOM4»
ckjm Java «WMC» (como número de métodos)
PHP_Depend PHP NOP («número de paquetes»)
PIT Java «puntuación de mutación»
clang-tidy C y C++ «CogC»
RuboCop, CodeNarc Ruby, Groovy «ABC»
ENVY/QA Smalltalk «SIX»
Truck-Factor repositorios git «factor autobús»

Dónde más difieren

Complejidad ciclomática

Es la métrica en la que más se nota que cada herramienta elige qué cuenta. En el ejemplo de su página, Stau Metro da 9 y una herramienta que no cuente && y || daría 7.

Herramienta && y || catch case Sobre
Stau Metro sí sí uno por grupo o regla, sin default fuente
Checkstyle sí sí uno por case; opción de contar el switch como 1 fuente
PMD en condiciones de control; opción para quitarlos sí (y throw) sin default fuente
SonarQube (Java) sí no figura uno por case fuente
JaCoCo las ramas del compilador no las ramas del compilador bytecode

Complejidad ponderada de los métodos (WMC)

Chidamber y Kemerer dejaron sin definir a propósito cómo se mide la complejidad de cada método, y cada herramienta lo resolvió a su modo:

Herramienta Peso de cada método
Stau Metro 1 más sus decisiones, sin &&, || ni catch; cuentan las reglas con flecha, no el default
MetricsReloaded igual, pero cuenta el grupo de default y no las reglas con flecha
PMD su CYCLO, con catch, throw y los operadores lógicos de las condiciones
CK la complejidad de McCabe
ckjm 1: su WMC es el número de métodos

Líneas de código

Herramienta Métrica Líneas vacías Comentarios
Stau Metro «LOC» no sí
Stau Metro «NCLOC» no no
SonarQube lines sí (líneas físicas) sí
SonarQube ncloc no no
Checkstyle MethodLength sí por defecto (countEmpty) sí por defecto

NCLOC y ncloc siguen el mismo criterio por fichero; las diferencias pueden venir de qué ficheros entran. En las líneas de comentario, SonarQube descarta las cabeceras de fichero de Java y los comentarios vacíos, y Stau Metro no.

Acoplamiento entre objetos (CBO)

Herramienta Sentido Qué cuenta Fuera
Stau Metro los dos cualquier referencia entre clases JDK y bibliotecas
CK, CBO saliente cualquier tipo usado en la clase tipos de Java
CK, CBO Modified los dos referencias que hace y que recibe tipos de Java
PMD saliente tipos de atributos, variables locales y retornos —
Checkstyle (ClassFanOutComplexity) saliente otros tipos usados java.lang y una lista de clases comunes

Acoplamiento de paquetes

Stau Metro cuenta clases en «Ca» y «Ce», como Martin; JDepend cuenta paquetes; NDepend, tipos por ensamblado (en Ce, los tipos de fuera que se usan, no los de dentro que los usan) y namespaces por namespace. Como la «inestabilidad» y la «distancia» se calculan con ellos, el mismo paquete puede caer en sitios distintos del diagrama de Martin según la herramienta.

Falta de cohesión (LCOM)

Herramienta Calcula Rango
Stau Metro «LCOM4»: grupos de métodos conectados 0 o más; 1 es lo ideal
CK, LCOM «versión de 1994»: pares sin campos comunes menos pares con ellos 0 o más
CK, LCOM* la ecuación 13 de Henderson-Sellers, no la recomendada 0 a 1
NDepend, LCOM HS «la recomendada de Henderson-Sellers» 0 a 2
NDepend, LCOM 1−∑MF/(M⋅F)1 - \sum MF/(M \cdot F) 0 a 1
Eclipse Metrics LCOM* de Henderson-Sellers —
Aivosto (entre otras variantes), Analizo LCOM4 0 o más

Ningún par de filas con fórmula distinta es comparable, y los umbrales tampoco se trasladan.

Cómo comparar valores entre herramientas

  • Compara dentro de una misma herramienta. La evolución de una métrica en el tiempo, medida siempre igual, dice más que un valor suelto comparado con otra herramienta.
  • Busca la definición, no la sigla. En Stau Metro, D es a la vez la «dificultad de Halstead» y la «distancia a la secuencia principal»; Ce es una cosa en JDepend y otra en Martin.
  • Mira el borde del umbral. Con el mismo número, unas avisan por encima y otras desde él: para la complejidad cognitiva, PMD avisa con 15 y Stau Metro con más de 15. Ver «de dónde salen los umbrales».
  • Un umbral va con su definición. El umbral de 10 de McCabe no vale igual para un recuento que no suma && y ||; los del artículo de CF de 1995 no valen para el denominador de 1994.
  • Revisa el alcance. Código de test, clases anónimas, métodos generados, bibliotecas: muchas discrepancias desaparecen al igualar lo que entra.
  • Fuente o bytecode. JaCoCo y JDepend leen clases compiladas; lo que cuentan es lo que deja el compilador, no lo que está escrito.
  • Ratios y agregados. Comprueba si el ratio es una fracción o un porcentaje, y si el valor de un paquete es una suma, una media o un máximo (ver «agregación»).

Referencias