Herramientas: qué calcula cada una y en qué difieren
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,LCOMoWMCen 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||, loscatcho eldefaultde unswitch. - 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 hastaObjectinclusive. - 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
LCOM4de la cohesión, y susWMC,OCavgyOCmaxusan un recuento de decisiones sin&&,||nicatch, distinto del de suv(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:
- complejidad: «
OCavg», «WMC», «iv(G)», «ev(G)», «CogC», «NBD», «IF_NEST», «LOOP_NEST», «CDENS», «NP», «OPavg» y los tres QCP («QCP_CRCT», «QCP_MAINT», «QCP_RLBTY»); - tamaño: «
CSO», «CSA», «CSOA», «ISO», «ISA», «ISOA», «OSavg», «OSmax», «Cons», «Inner», «Command» y «Query»; - acoplamiento: «
Level», «Level*», «Cyclic» y «CF»; - MOOD y encapsulación: «
AHF», «MHF», «AIF», «MIF», «PF» y «E_RAT».
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 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 , no .
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 |
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,
Des a la vez la «dificultad de Halstead» y la «distancia a la secuencia principal»;Cees 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 deCFde 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
- Stau Metro y sus reglas: las secciones «En las herramientas» de cada página de métrica.
- MetricsReloaded: https://github.com/BasLeijdekkers/MetricsReloaded
- SonarQube, definición de métricas: https://docs.sonarsource.com/sonarqube-server/latest/user-guide/code-metrics/metrics-definition/
- SonarQube, lenguajes: https://docs.sonarsource.com/sonarqube-server/latest/analyzing-source-code/languages/overview/
- Checkstyle: https://checkstyle.org/
- PMD: https://pmd.github.io/; reglas de diseño para Java:
https://docs.pmd-code.org/latest/pmd_rules_java_design.html; reglas de estilo de código (
OnlyOneReturn): https://docs.pmd-code.org/latest/pmd_rules_java_codestyle.html; CPD: https://docs.pmd-code.org/latest/pmd_userdocs_cpd.html - JaCoCo: https://www.jacoco.org/jacoco/; contadores: https://www.jacoco.org/jacoco/trunk/doc/counters.html
- JDepend: https://github.com/clarkware/jdepend
- NDepend: https://www.ndepend.com/; métricas: https://www.ndepend.com/docs/code-metrics
- JArchitect, métricas: https://www.jarchitect.com/metrics
- CK: https://github.com/mauricioaniche/ck
- ckjm: https://www.spinellis.gr/sw/ckjm/doc/metric.html
- Aivosto Project Analyzer, métricas MOOD: https://www.aivosto.com/project/help/pm-oo-mood.html; cohesión: https://www.aivosto.com/project/help/pm-oo-cohesion.html
- Radon: https://radon.readthedocs.io/en/latest/intro.html
- Testwell CMT++ y CMTJava (Verifysoft), lenguajes: https://www.verifysoft.com/en_cmtx.html
- Understand (SciTools), lenguajes: https://support.scitools.com/support/solutions/articles/70000582794-supported-languages
- Sonargraph (hello2morrow), lenguajes: https://www.hello2morrow.com/products/sonargraph
- Lattix, lenguajes: https://docs.lattix.com/lattix/whyUseLattixArchitect/Comprehensive_Coverage_of_Technologies.html
- Analizo, lenguajes que reconoce: https://github.com/analizo/analizo (
lib/Analizo/LanguageFilter.pm) - Code Maat: https://github.com/adamtornhill/code-maat
- git,
git log: https://git-scm.com/docs/git-log