Lanza y Marinescu: estrategias de detección
Lo que distingue el trabajo de Michele Lanza y Radu Marinescu no es un conjunto de métricas nuevas, sino una forma de usarlas juntas. Su libro Object-Oriented Metrics in Practice (Springer, 2006) aporta dos herramientas: la pirámide de visión general, que resume un sistema entero en una figura con nueve métricas y seis cocientes, y las estrategias de detección, reglas que combinan varias métricas con umbrales para señalar defectos de diseño concretos, como la «clase dios».
Para quien empieza. Una métrica sola rara vez basta para decir que algo está mal: una clase con muchos métodos puede estar bien organizada. Una estrategia de detección cruza varias: «es muy compleja, y usa muchos datos de otras clases, y sus métodos apenas tienen relación entre sí». Solo cuando se cumplen todas las condiciones se señala la clase.
Quién, cuándo y para qué
Marinescu formula la noción de estrategia de detección en «Detection Strategies: Metrics-Based Rules for Detecting Design Flaws» (20th IEEE International Conference on Software Maintenance, 2004). El libro de 2006, con Lanza, la desarrolla y la aplica a un catálogo de defectos de diseño, que llaman disarmonías. Su subtítulo dice el propósito: Using Software Metrics to Characterize, Evaluate, and Improve the Design of Object-Oriented Systems. Caracterizar es la pirámide; evaluar, las estrategias; mejorar, las recomendaciones de rediseño que acompañan a cada defecto.
El punto de partida es doble. Una métrica sola no responde a las preguntas que importan sobre un sistema, y una métrica es demasiado fina para trabajar con ella directamente: hace falta subir de nivel. Una estrategia de detección es una condición lógica compuesta, basada en métricas, que selecciona los fragmentos de código con ciertas propiedades. Se construye con dos mecanismos:
- Filtros: cada métrica se compara con un umbral, absoluto (
WMC >= 47) o relativo (las diez clases con másWMC). - Composición: los resultados de varios filtros se combinan con
ANDyOR.
Los umbrales
Las reglas no usan números sueltos, sino umbrales con nombre, de dos clases.
Estadísticos. Salen de medir un corpus de proyectos: 45 en Java y 37 en C++. Con la media (AVG) y la
desviación típica (STDEV) de cada métrica se fijan LOW = AVG − STDEV, AVERAGE = AVG, HIGH = AVG + STDEV y
VERY HIGH = 1,5 × HIGH: un valor es muy alto si supera en un 50 % el umbral de alto. Los valores para Java:
| Métrica | LOW |
AVERAGE |
HIGH |
VERY HIGH |
|---|---|---|---|---|
complejidad ciclomática por línea (CYCLO/LOC) |
0,16 | 0,20 | 0,24 | 0,36 |
líneas por método (LOC/NOM) |
7 | 10 | 13 | 19,5 |
métodos por clase (NOM/NOC) |
4 | 7 | 10 | 15 |
El libro da también umbrales para WMC: 31 como alto y 47 como muy alto. Son los que usan PMD y Stau Metro.
Por significado. Para métricas normalizadas se usan fracciones que se entienden sin estadística (ONE THIRD,
HALF, TWO THIRDS…), y para recuentos pequeños, valores de sentido común: NONE es 0; FEW, unos pocos (el
código de PMD, citando el libro, lo sitúa entre 2 y 5); MANY, bastantes más.
La pirámide de visión general
La pirámide reúne en una figura nueve métricas de tres categorías y los cocientes entre ellas:
- Tamaño y complejidad: número de paquetes (
NOP), de clases (NOC), de métodos (NOM), líneas de código (LOC) y complejidad ciclomática total (CYCLO). - Acoplamiento: llamadas distintas a operaciones (
CALLS) y tipos referenciados fuera de la propia rama de herencia (FANOUT). - Herencia: número medio de clases derivadas (
ANDC) y altura media de las jerarquías (AHH).
Los cocientes describen el sistema sin depender de su tamaño: cuántas clases tiene un paquete medio, cuántos métodos una clase, cuántas líneas un método, cuánta lógica de decisión hay por línea, cuántas llamadas hace un método y a cuántos tipos distintos se reparten. Cada cociente se clasifica como bajo, medio o alto según unos valores de referencia. PHP_Depend, que implementa la pirámide para PHP, reproduce esta tabla del libro:
| Cociente | Bajo | Medio | Alto |
|---|---|---|---|
NOC/NOP |
6 | 17 | 26 |
NOM/NOC |
4 | 7 | 10 |
LOC/NOM |
7 | 10 | 13 |
CYCLO/LOC |
0,16 | 0,20 | 0,24 |
CALLS/NOM |
2,01 | 2,62 | 3,2 |
FANOUT/CALLS |
0,56 | 0,62 | 0,68 |
ANDC |
0,25 | 0,41 | 0,57 |
AHH |
0,09 | 0,21 | 0,32 |
La pirámide no señala ninguna clase: es una primera impresión, útil para hacerse una idea de un sistema que no se conoce antes de leer su código.
Las estrategias de detección
El libro agrupa las disarmonías según afecten a la identidad de una clase o un método, a su colaboración con otros o a la jerarquía de clasificación. Algunas de las estrategias, con las métricas que combinan:
| Defecto | Se aplica a | Condición |
|---|---|---|
| Clase dios (God Class) | clase | ATFD > FEW y WMC >= VERY HIGH y TCC < ONE THIRD |
| Envidia de características (Feature Envy) | método | ATFD > FEW y LAA < ONE THIRD y FDP <= FEW |
| Cirugía de escopeta (Shotgun Surgery) | método | CM > MANY y CC > MANY |
| Herencia rechazada (Refused Parent Bequest) | clase | ((NProtM > FEW y BUR < ONE THIRD) o BOvR < ONE THIRD) y ((AMW > AVERAGE o WMC >= AVERAGE) y NOM > AVERAGE) |
Las siglas que aparecen:
ATFD(Access To Foreign Data): atributos de otras clases a los que accede la clase o el método.WMC: la «complejidad ponderada de los métodos».TCC: la «cohesión estrecha de la clase», la fracción de pares de métodos que comparten algún campo.LAA(Locality of Attribute Accesses): la localidad de los accesos a atributos; por debajo de un tercio, el método usa muchos más atributos de otras clases que de la suya.FDP(Foreign Data Providers): de cuántas clases distintas vienen los atributos ajenos que usa.CMyCC(Changing Methods, Changing Classes): cuántos métodos llaman a un método y de cuántas clases son, contando solo las de fuera de su jerarquía de herencia.NProtM,BURyBOvR(Number of Protected Members, Base-class Usage Ratio, Base-class Overriding Ratio): cuántos miembros protegidos ofrece la superclase, cuánto usa la subclase de lo que hereda y cuánto sobrescribe.AMW(Average Method Weight) es la complejidad media de los métodos.
La clase dios es el caso de referencia: una clase que hace demasiado por sí misma (complejidad muy alta), cuyos métodos apenas se relacionan (cohesión baja) y que trabaja con datos de otras clases en lugar de pedirles que hagan el trabajo. Las tres condiciones tienen que cumplirse a la vez. El método cerebro (Brain Method), un método que acumula la funcionalidad de su clase, combina de forma parecida tamaño, complejidad ciclomática, anidamiento y número de variables.
Las métricas de esta referencia que usan
| Métrica del libro | Página aquí | Stau Metro |
|---|---|---|
WMC |
«Complejidad ponderada de los métodos» | la calcula (WeightedMethodComplexity), con aviso por encima de 31 y error por encima de 47 |
TCC |
«Cohesión estrecha y laxa de la clase» | no la calcula |
NOM |
«Número de métodos» (METH) |
la calcula, por paquete, módulo y proyecto |
NOP |
«Número de paquetes» (P) |
la calcula, para el proyecto |
Otras métricas de esta referencia se parecen a las del libro, pero no coinciden en la definición:
- «Complejidad promedio de las operaciones» (
OCavg): una media de complejidad por método de la clase, comoAMW. Stau Metro le pone aviso por encima de 3,1 y error por encima de 4,7, y los presenta como los valores alto y muy alto del libro para Java. - «Número de clases» (
C), «líneas de código» (LOC) y «complejidad ciclomática total» (v(G)tot): los recuentos de tamaño y complejidad de la pirámide. En Stau Metro,Ccuenta también las clases anónimas y locales, yLOCincluye los comentarios; PHP_Depend cuenta enLOClas líneas sin blancos ni comentarios, más cerca de las «líneas sin comentarios» (NCLOC). - «Número de llamadas a métodos» (
CALL): cuenta cada llamada que aparece en un método, mientras que elCALLSde PHP_Depend cuenta una sola vez la misma llamada repetida en un cuerpo. - «Fan-in y fan-out»: la idea del
FANOUTde la pirámide. Stau Metro no tiene esa métrica; lo más cercano es el «número de dependencias» (Dcy) de cada clase, un fan-out estructural que, a diferencia deFANOUT, incluye los tipos de la propia jerarquía. - «Número de hijos» (
NOCde Chidamber y Kemerer) y «profundidad del árbol de herencia» (DIT): por clase, lo queANDCyAHHpromedian para el sistema. Ojo con la sigla: elNOCde la pirámide es el número de clases.
ATFD, LAA, FDP, CM, CC, NProtM, BUR, BOvR y AMW no tienen página en esta referencia.
Validación y críticas
Umbrales de un corpus concreto. Los umbrales estadísticos describen lo habitual en 45 proyectos Java de antes de 2006. Que un valor sea «alto» significa que es alto respecto de ese corpus, no que sea perjudicial. La página sobre «de dónde salen los umbrales» trata el problema en general.
Umbrales con nombre, valores distintos. FEW o MANY se traducen a números al implementar la regla, y cada
herramienta elige. PMD toma FEW = 5 para ATFD, el extremo alto del intervalo; las transparencias de Figueiredo
que resumen el libro ponen 3. Una implementación que tome 2 o 3 señalará más clases dios con la misma regla.
Condiciones nítidas. Una regla con AND de umbrales estrictos deja fuera una clase con WMC de 46 aunque
cumpla todo lo demás, y señala una de 47. Las estrategias ordenan bien los casos extremos; en la frontera, el
resultado depende de una unidad.
Las métricas no saben de contexto. Adam Tornhill (reseña de 2013) recuerda dos objeciones generales a las métricas: no distinguen la complejidad accidental de la esencial, e imponer límites artificiales lleva a adaptar el estilo para cumplir con el número. Del libro valora precisamente que trate el contexto con umbrales sacados de proyectos reales y que combine métricas para detectar disarmonías; de sus visualizaciones dice que son originales, aunque él prefiere leer el código directamente.
Evaluar un detector es difícil. Francesca Arcelli Fontana, Pietro Braione y Marco Zanoni (2012) compararon cuatro detectores automáticos de defectos de código sobre seis versiones de un mismo sistema Java, y señalan que, como las definiciones de esos defectos son informales y subjetivas, medir la eficacia de un detector es a la vez importante y difícil.
En las herramientas
PMD (Java) implementa la estrategia de la clase dios en su regla GodClass, con cita al libro: señala una clase
cuando su WMC llega a 47, su ATFD pasa de 5 y su TCC queda por debajo de 1/3. Su WMC suma la complejidad
ciclomática de los métodos contando && y ||. Tiene también una regla DataClass construida del mismo modo: una
clase con poco comportamiento propio (WOC por debajo de 1/3) que expone sus datos con campos públicos o accesores
(más de 3 con WMC por debajo de 31, o más de 5 con WMC por debajo de 47).
PHP_Depend (PHP) dibuja la pirámide de visión general con los valores de referencia del libro y colorea cada cociente según sea bajo, medio o alto.
Stau Metro no implementa ninguna estrategia de detección ni la pirámide. Calcula WMC, con los umbrales 31 y 47
del libro, pero con un recuento que no incluye &&, || ni catch, así que da valores iguales o más bajos que el
de PMD y supera esos umbrales algo menos a menudo. Calcula también los recuentos METH y P. No calcula TCC ni
ATFD; su métrica de cohesión de clase es la
«falta de cohesión» en la variante LCOM4, que no es
intercambiable con TCC en la regla.
Referencias
- Lanza, M. y Marinescu, R. (2006). Object-Oriented Metrics in Practice: Using Software Metrics to Characterize, Evaluate, and Improve the Design of Object-Oriented Systems. Springer. ISBN 978-3-540-24429-5. https://doi.org/10.1007/3-540-39538-5
- Marinescu, R. (2004). «Detection Strategies: Metrics-Based Rules for Detecting Design Flaws». 20th IEEE International Conference on Software Maintenance (ICSM 2004), 350-359. https://doi.org/10.1109/ICSM.2004.1357820
- Arcelli Fontana, F., Braione, P. y Zanoni, M. (2012). «Automatic Detection of Bad Smells in Code: An Experimental Assessment». Journal of Object Technology, 11(2), 5:1-38. https://doi.org/10.5381/jot.2012.11.2.a5
- Figueiredo, E. Transparencias «Thresholds for Metrics» y «Detection Strategies» (UFMG), que resumen las secciones 2.1, 4.1, 5.3, 5.4, 5.6, 6.5 y 7.3 del libro: https://homepages.dcc.ufmg.br/~figueiredo/disciplinas/lectures/metric-thresholds_v01.pdf, https://homepages.dcc.ufmg.br/~figueiredo/disciplinas/lectures/detection-strategy_v01.pdf
- Tornhill, A. (2013). Reseña de Object-Oriented Metrics in Practice: https://adamtornhill.com/reviews/oometrics.htm
- PMD, reglas de diseño para Java (
GodClass,DataClass): https://docs.pmd-code.org/latest/pmd_rules_java_design.html - PMD, código de las reglas
GodClassRuleyDataClassRule: https://github.com/pmd/pmd - PHP_Depend, «Overview Pyramid»: https://pdepend.org/documentation/handbook/reports/overview-pyramid.html