Métricas de paquetes de Martin
Las métricas de Robert C. Martin miden las dependencias entre paquetes, no el interior de las clases. Responden
a una pregunta de arquitectura: si cambio este paquete, ¿a cuánto código afecta?, y si lo afecta mucho, ¿está hecho
de forma que se pueda ampliar sin tocarlo? Son cinco números por paquete (Ca, Ce, I, A y D), más el
recuento de dependencias cíclicas que sale de un principio posterior del mismo autor.
Para quien empieza. Un paquete del que depende mucho código es difícil de cambiar: cada cambio puede romper a sus usuarios. Martin llama a eso estable, que aquí no significa «que funciona bien» sino «que cuesta cambiar». Su propuesta es que lo difícil de cambiar sea abstracto (interfaces), para poder extenderlo sin modificarlo, y que lo concreto quede en paquetes de los que no depende nadie.
Quién, cuándo y para qué
Martin escribió «OO Design Quality Metrics: An Analysis of Dependencies», fechado el 14 de agosto de 1994 y
publicado en el grupo de noticias comp.lang.c++. El punto de partida es que los diseños muy interdependientes
tienden a ser rígidos, difíciles de reutilizar y de mantener, pero que algunas dependencias son inevitables. Lo que
importa es hacia dónde apuntan: una dependencia de algo muy estable es buena; una de algo inestable, mala.
La unidad de medida es la categoría de clases: un grupo de clases muy cohesionadas que cambian juntas, se reutilizan juntas y comparten un objetivo, y que se publica con su propio número de versión. En Java el equivalente habitual es el paquete; en .NET, el ensamblado. Las dependencias que el artículo quiere gestionar son las que hay entre categorías.
Las ideas se ampliaron después en tres textos del mismo autor: «Granularity» (The C++ Report, 1996), donde aparece el principio de dependencias acíclicas; el libro Agile Software Development: Principles, Patterns, and Practices (2002), que reúne los principios de paquetes; y Clean Architecture (2017), que los trata en sus capítulos 13 («Component Cohesion») y 14 («Component Coupling») hablando de componentes en lugar de paquetes.
Los principios de diseño de paquetes
Martin agrupa seis principios en dos bloques. Los tres primeros dicen qué clases deben ir juntas; los otros tres, cómo deben relacionarse los paquetes. Solo los del segundo bloque tienen métrica:
| Principio | Sigla | Qué pide | Métrica que lo vigila |
|---|---|---|---|
| Equivalencia entre reutilización y publicación | REP |
la unidad que se reutiliza es la unidad que se publica | — |
| Cierre común | CCP |
las clases que cambian juntas van juntas | — |
| Reutilización común | CRP |
las clases que no se reutilizan juntas no deben agruparse | — |
| Dependencias acíclicas | ADP |
el grafo de dependencias entre paquetes no tiene ciclos | «dependencias cíclicas» (Cyclic) |
| Dependencias estables | SDP |
las dependencias van en la dirección de la estabilidad | «inestabilidad» (I) |
| Abstracciones estables | SAP |
un paquete es tan abstracto como estable | «abstracción» (A) y «distancia» (D) |
Ninguna métrica de esta familia mide los tres principios de cohesión. La medida más cercana de cuánto se
relacionan entre sí las clases de un paquete es la «cohesión relacional»
(H), que propuso Larman y no forma parte de la familia.
Las métricas
| Métrica | Sigla | Qué mide | Aspecto | Stau Metro |
|---|---|---|---|---|
| «Acoplamientos aferentes» | Ca |
clases de fuera del paquete que dependen de clases de dentro | «Acoplamiento» | la calcula (AfferentCoupling) |
| «Acoplamientos eferentes» | Ce |
clases del paquete que dependen de clases de fuera | «Acoplamiento» | la calcula (EfferentCoupling) |
| «Inestabilidad» | I |
Ce / (Ca + Ce), de 0 (estable) a 1 (inestable) |
«Diseño de paquetes» | la calcula (Instability) |
| «Abstracción» | A |
clases abstractas e interfaces entre el total de clases | «Diseño de paquetes» | la calcula (Abstractness) |
| «Distancia a la secuencia principal» | D |
cuánto se aparta el paquete de | «Diseño de paquetes» | la calcula (Distance) |
| «Número de dependencias cíclicas» | Cyclic |
con cuántos otros elementos forma ciclo | «Acoplamiento» | la calcula para clases, interfaces y paquetes (NumCyclicDependenciesClass, NumCyclicDependenciesInterface, NumCyclicDependenciesPackage) |
Las cinco primeras son de 1994. El recuento de dependencias cíclicas no aparece en el artículo de Martin: es la forma de medir su principio de dependencias acíclicas de 1996.
Las métricas se encadenan. Ca y Ce dan I; el recuento de clases abstractas da A; I y A dan D:
La secuencia principal
Si se dibuja cada paquete en un plano con I en un eje y A en el otro, los dos extremos ideales son el paquete
estable y abstracto (, ) y el inestable y concreto (, ). Martin advierte que solo
alrededor de la mitad de las categorías de un proyecto pueden tener características tan ideales; para las demás,
lo mejor es estar sobre la recta que une esos dos puntos, , o cerca. La llamó secuencia principal.
El artículo de 1994 define dos distancias a esa recta: la perpendicular, , que va de 0 a
unos 0,707, y la normalizada, , que va de 0 a 1. Las herramientas suelen calcular la
normalizada y llamarla D. Las dos esquinas alejadas de la recta se conocen como zona de dolor (paquetes
concretos de los que depende mucho código) y zona de inutilidad (abstracciones que nadie usa); la página de la
«distancia» explica qué hacer en cada una.
Martin propuso también mirar el sistema entero: calcular la media y la varianza de D sobre todos los paquetes. En
un diseño que siga sus principios, ambas deberían estar cerca de 0, y la varianza sirve para fijar límites de
control que señalen los paquetes excepcionales.
Cómo se leen juntas
Un orden razonable para revisar la estructura de paquetes de un proyecto:
- Ciclos primero. Dentro de un ciclo no hay orden posible y la estabilidad pierde sentido: todos los miembros
dependen de todos. Un
Cyclicmayor que 0 en un paquete pide atención antes que cualquier otra cifra. - Dirección de las dependencias. Para cada dependencia entre dos paquetes, el que depende debería tener una
Imayor que el paquete del que depende. Una flecha de un paquete conIbaja hacia uno conIalta incumple el principio de dependencias estables. - Equilibrio de cada paquete. Una
Dalta dice que abstracción y estabilidad no van acompasadas; mirarAeIpor separado dice en qué zona está el paquete, y los remedios son opuestos.
Ca y Ce no se juzgan solas: no tienen dirección buena ni umbral. Cobran sentido como ingredientes de I y como
pista de dónde actuar cuando I o D señalan un problema.
Validación y críticas
El propio autor. Martin no aportó datos que validaran las métricas, sino su experiencia, y las presentó con reservas explícitas. Una métrica, escribe, no es un dios, sino una medida frente a un estándar arbitrario; puede haber métricas mejores, el estándar puede servir solo para cierto tipo de aplicaciones, y lamentaría que alguien exigiera que todos sus diseños lo cumplieran sin condiciones. Pedía que los diseñadores experimentaran con ellas para averiguar qué tienen de bueno y de malo.
Qué se cuenta. El artículo cuenta clases en Ca y Ce, y con una asimetría que sorprende: Ca cuenta
clases de fuera; Ce, clases de dentro. JDepend cuenta paquetes en las dos, y NDepend, en el nivel de
ensamblado, cuenta tipos de fuera en las dos. La fórmula de I es la misma; los números, no. Las páginas de
«Ca» y «Ce» comparan las
tres definiciones.
Qué se analiza. Ca y Ce solo ven las clases del análisis. Cambiar el ámbito (dejar fuera un módulo, incluir
o no las bibliotecas o los tests) mueve I y, con ella, D.
Lo que no ven. A cuenta clases, no su peso: una interfaz de un método vale lo mismo que una clase de miles de
líneas. Y D supone que todo paquete debería estar en la recta: un paquete concreto y muy usado que no cambia nunca
(tipos de valor, constantes) cae en la zona de dolor sin causar dolor, porque la métrica no sabe con qué frecuencia
cambia. Las métricas de «evolución» sí lo saben.
Agregar D. se pensó para paquetes sueltos, pero también se usa para juzgar arquitecturas enteras.
Alexander Serebrenik, Serguei Roubtsov y Mark van den Brand (2009) formalizaron ese uso en sistemas Java de código
abierto con dos medidas agregadas, la media de y el parámetro de un modelo estadístico ajustado a sus valores,
y obtuvieron de un conjunto de sistemas de referencia valores con los que comparar. Es el mismo problema que trata,
en general, la página sobre «agregación».
En las herramientas
Stau Metro calcula las cinco métricas de 1994 por paquete y el número de dependencias cíclicas para clases,
interfaces y paquetes. Sigue la definición de Martin: Ca y Ce cuentan clases, no paquetes. Las reglas comunes:
- Solo cuentan las clases Java de producción del ámbito analizado: ni las de test, ni las de bibliotecas o del JDK, ni las de Kotlin. Las clases anidadas cuentan como clases propias; las anónimas y locales, como parte de la que las contiene. Cada paquete se mide sin sus subpaquetes.
IyDno tienen valor en un paquete sinCaniCe;Así lo tiene.Des la distancia normalizada, con aviso por encima de 0,7, valor tomado de la regla por defecto de NDepend.Cyclicde paquete tiene umbral de error por encima de 0; en el grafo de paquetes, una dependencia desde o hacia una clase de test no crea un ciclo.Ca,Ce,IyAno tienen umbral.
JDepend (Java, sobre bytecode) calcula Ca, Ce, A, I y D por paquete, contando paquetes en Ca y
Ce; si no se configuran filtros, cuenta también los paquetes del JDK y de las bibliotecas. Detecta y lista los
ciclos entre paquetes.
NDepend (.NET) calcula Ca, Ce, A, I y D por ensamblado, contando tipos, y tiene también Ca y Ce por
namespace, contando namespaces. Dibuja el gráfico de abstracción frente a inestabilidad con las dos zonas y
considera problemática una distancia normalizada mayor que 0,7. Su regla «Avoid namespaces dependency cycles» lista
los ciclos entre namespaces.
MetricsReloaded (plugin de IntelliJ IDEA) tiene el recuento Cyclic para clases, interfaces y paquetes, con
la misma definición: tamaño de la componente del elemento menos uno.
La página de «herramientas» las compara con el resto.
Referencias
- Martin, R. C. (1994). «OO Design Quality Metrics: An Analysis of Dependencies». Artículo fechado el 14 de agosto
de 1994 y publicado en el grupo de noticias
comp.lang.c++. https://groups.google.com/d/msg/comp.lang.c++/-/ouRSXPUpybkJ - Martin, R. C. (1996). «Granularity». The C++ Report, noviembre-diciembre de 1996.
- Martin, R. C. (2002). Agile Software Development: Principles, Patterns, and Practices. Prentice Hall.
- Martin, R. C. (2017). Clean Architecture: A Craftsman's Guide to Software Structure and Design. Pearson. Índice: https://www.pearson.com/en-us/subject-catalog/p/clean-code/P200000009528/9780134494326
- Serebrenik, A., Roubtsov, S. y van den Brand, M. (2009). «Dn-based Architecture Assessment of Java Open Source Software Systems». 2009 IEEE 17th International Conference on Program Comprehension, 198-207. https://doi.org/10.1109/ICPC.2009.5090043
- Wikipedia, «Package principles»: https://en.wikipedia.org/wiki/Package_principles
- DePaul University, SE450, «Martin's principles» (enunciados de los principios): https://condor.depaul.edu/mwright1/se450/lectures/class-07-004.html
- JDepend, documentación: https://github.com/clarkware/jdepend/blob/master/docs/JDepend.html
- NDepend, métricas de código: https://www.ndepend.com/docs/code-metrics
- NDepend, regla ND1407: https://www.ndepend.com/default-rules/NDepend-Rules-Explorer.html?ruleid=ND1407
- MetricsReloaded, código fuente: https://github.com/BasLeijdekkers/MetricsReloaded