Agregar métricas: sumas, medias, máximos y distribuciones
Casi todas las métricas se miden en piezas pequeñas: un método, una clase. Pero las preguntas suelen ser sobre piezas grandes: ¿qué paquete está peor?, ¿ha empeorado el proyecto este trimestre? Para responderlas hay que agregar: resumir muchos valores en uno. La forma de hacerlo no es un detalle técnico. Con los mismos datos, una suma, una media y un máximo cuentan historias distintas.
Los operadores habituales
Un ejemplo sirve para todos. Una clase tiene diez métodos con estas complejidades ciclomáticas: siete valen 1 (accesores y constructores), uno 2, uno 3 y uno 28.
| Operador | Valor | Qué dice | Qué esconde |
|---|---|---|---|
| Suma | 40 | Cuánta lógica hay en total | Si está repartida o concentrada; crece con el tamaño |
| Media | 4,0 | Cómo es el método «típico», si hubiera uno | Los extremos: los accesores la bajan y el método de 28 la sube |
| Mediana | 1 | El valor del método del centro | Todo lo que no está en el centro, incluido el método de 28 |
| Máximo | 28 | Dónde está el peor caso | Cuántos casos malos hay y cómo es el resto |
| Percentil 90 | 3 | El valor que deja por debajo al 90 % de los métodos | El 10 % de arriba, justo donde está el problema |
| Proporción sobre un umbral | 10 % | Qué parte supera un límite (aquí, v(G) > 10) |
Cuánto lo supera |
(El percentil 90 se ha calculado por rango: el noveno de los diez valores ordenados. Hay otras formas de calcularlo que dan resultados algo distintos con tan pocos datos.)
Ninguno es «el correcto». Cada uno responde a una pregunta:
- Suma para el volumen: cuánto hay que mantener o probar. Por eso
«
WMC» es una suma. - Media para comparar el estilo de dos partes del código de tamaños distintos, sabiendo que se deja engañar por los extremos.
- Máximo y percentiles altos para encontrar problemas.
- Proporciones para seguir la evolución de algo que debería ser raro.
Para quien empieza. Si solo puedes mirar un número por paquete, mira el máximo o el número de elementos por encima del umbral. La media de un paquete casi siempre parece razonable.
Por qué la media engaña
Las métricas de software no se distribuyen como la altura de las personas, alrededor de un valor típico. Se parecen más a la riqueza: muchos elementos pequeños y unos pocos enormes. Concas, Marchesi, Pinna y Serra (2007) estudiaron diez propiedades de un gran sistema en Smalltalk, entre ellas el tamaño de clases y métodos y las jerarquías de herencia, y encontraron de forma sistemática distribuciones de Pareto (leyes de potencias) o, a veces, lognormales; advierten que evaluar un sistema por la media y la desviación típica de sus métricas puede engañar. Louridas, Spinellis y Vlachos (2008) encontraron distribuciones de cola larga en muchos niveles de abstracción, en sistemas y lenguajes muy distintos.
Con distribuciones así, la media está dominada por el grueso de valores pequeños y no representa ni a los pequeños ni a los grandes. Heitlager, Kuipers y Visser (2007) lo dicen para la complejidad: en un sistema Java la media sale siempre baja porque todos los getters y setters valen 1, mientras que, según la experiencia que citan, los problemas de mantenimiento aparecen en los pocos métodos excepcionalmente complejos. Su conclusión es general: promediar tiende a enmascarar las partes de alto riesgo. Serebrenik, van den Brand y Vasilescu (2012) lo resumen así: la media se vuelve poco fiable con distribuciones muy asimétricas, que son las típicas de las métricas de software.
Lo mismo pasa con los defectos: Fenton y Ohlsson (2000) encontraron que pocos módulos concentraban la mayoría (ver la «densidad de defectos»).
La mediana resiste mejor los extremos, pero por eso mismo los ignora: en el ejemplo vale 1 aunque haya un método de 28. Ni media ni mediana sirven para encontrar el problema; las dos sirven para comparar el grueso del código.
Perfiles de riesgo
Heitlager, Kuipers y Visser (2007) propusieron agregar de otra manera. En lugar de un número, un perfil: qué porcentaje de las líneas de código está en métodos de cada categoría de riesgo. Para la complejidad ciclomática usaron la clasificación del Software Engineering Institute:
v(G) del método |
Riesgo |
|---|---|
| 1-10 | Bajo |
| 11-20 | Moderado |
| 21-50 | Alto |
| Más de 50 | Muy alto |
Si en un sistema de 10.000 líneas los métodos de riesgo alto suman 500, el perfil dice «5 % de riesgo alto». Después asignan una nota según el máximo de código permitido en cada categoría:
| Nota | Moderado | Alto | Muy alto |
|---|---|---|---|
++ |
25 % | 0 % | 0 % |
+ |
30 % | 5 % | 0 % |
o |
40 % | 10 % | 0 % |
- |
50 % | 15 % | 5 % |
-- |
más | más | más |
Los propios autores dicen que esos límites salen de la experiencia: en muchas evaluaciones separaban los sistemas de forma parecida a como lo hacían los expertos. Alves, Ypma y Visser (2010) sustituyeron después los cortes de las categorías por valores sacados de un banco de sistemas (ver «de dónde salen los umbrales»).
El perfil tiene dos ventajas sobre la media: pesa por volumen de código, de modo que un método de 300 líneas pesa más que un accesor, y no deja que muchos métodos sencillos tapen unos pocos peligrosos.
Medir la desigualdad
Otra forma de no perder la forma de la distribución es medir directamente cuánto se concentra. La economía tiene índices para eso, pensados para la renta, y varios grupos los han aplicado a métricas de código.
El coeficiente de Gini vale 0 cuando todos los elementos tienen el mismo valor y se acerca a 1 cuando uno lo acumula todo. Con valores de media :
Vasa, Lumpe, Branch y Nierstrasz (2009) lo usaron para comparar sistemas que evolucionan: muchas métricas dieron valores de Gini muy altos y, además, muy estables de una versión a otra del mismo proyecto.
El índice de Theil mide lo mismo con otra fórmula:
Su interés práctico es que se puede descomponer por grupos: dice qué parte de la desigualdad se debe a las diferencias entre grupos y qué parte a las de dentro de cada grupo. Serebrenik y van den Brand (2010) lo propusieron para agregar métricas; con él vieron, por ejemplo, que la desigualdad del tamaño de los ficheros de Debian se explica mejor por el paquete al que pertenece cada fichero que por su lenguaje.
¿Cuál elegir? Vasilescu, Serebrenik y van den Brand (2011) agregaron las líneas de código de clase a paquete en los 106 sistemas del Qualitas Corpus con varios índices (Gini, Theil, Atkinson, Hoover y otros) y con los agregadores tradicionales. Gini, Theil, Atkinson y Hoover resultaron muy correlacionados entre sí: transmiten casi la misma información. El artículo discute qué más conviene tener en cuenta al elegir uno.
Nota. Un índice de desigualdad no sustituye a mirar el máximo: dice que la complejidad está concentrada, no dónde. Y no tiene dirección de calidad: un sistema con un núcleo complejo y muchas piezas sencillas puede estar bien diseñado.
Agregar también cambia las correlaciones
Una advertencia para quien compare métricas agregadas. Landman, Serebrenik, Bouwers y Vinju (2016) midieron la correlación entre complejidad ciclomática y líneas de código en millones de métodos Java y funciones C: método a método solo era moderada, pero al agregar las dos métricas la correlación mejoraba. Zhang, Hassan, McIntosh y Zou (2017) estudiaron once formas de agregar en 255 proyectos y encontraron que la elección cambia las correlaciones entre métricas y con los defectos; en sus modelos de predicción de defectos, usar solo la suma daba el mejor resultado en el 11 % de los proyectos, y usar todas las formas de agregar a la vez, en el 40 %.
La consecuencia: dos métricas que «miden lo mismo» a nivel de paquete pueden no hacerlo a nivel de método, y al revés. Antes de concluir que una métrica es redundante, mira a qué nivel se ha calculado la correlación.
Cómo agrega Stau Metro
Stau Metro calcula cada agregado como una métrica propia, con su id. Lo que sigue resume sus páginas de métrica.
Complejidad ciclomática por paquete, módulo y proyecto.
«v(G)tot» suma la v(G) de los métodos y
«v(G)avg» la divide entre el número de esos métodos, con
el mismo recuento que la métrica de método. La media es por método, no la media de las medias de cada clase: una
clase de cien métodos pesa cien veces más que una de uno. En el paquete entran solo las clases del propio paquete, no
las de sus subpaquetes. Ninguna de las dos tiene umbral de referencia.
Complejidad por clase. «WMC» (suma),
«OCavg» (media) y
«OCmax» (máximo) agregan un recuento por método que no
incluye &&, || ni catch. Por eso el WMC de una clase puede ser menor que la suma de la v(G) de sus métodos.
Las tres se leen juntas: WMC alto con OCavg bajo es una clase con muchos métodos sencillos; OCmax alto con
OCavg bajo, una clase con un método que concentra la complejidad. Del mismo modo,
«OSavg» y «OSmax» hacen
la media y el máximo del tamaño de los métodos, contado en sentencias.
Variantes recursivas de paquete. Muchas métricas de paquete tienen una variante recursiva, marcada con (rec)
tras la sigla, que suma el paquete y todos sus subpaquetes: C(rec) del paquete p incluye las clases de p.q. La
variante normal cuenta solo el paquete. El paquete por defecto, el que no tiene nombre, solo recibe lo suyo (ver el
«número de clases»). Hay variante recursiva, entre otras, para las líneas de código,
el número de clases y de métodos, las líneas de comentario y de Javadoc, los comentarios TODO y los recuentos de
tests.
Proporciones. Una proporción de paquete, módulo o proyecto no es la media de las proporciones de sus partes: se calcula con los recuentos de ese nivel, la suma de los numeradores entre la suma de los denominadores. El «ratio de test» del proyecto suma las líneas de todos los módulos y divide una vez, así que los módulos grandes pesan más; la «cobertura Javadoc de métodos» de un paquete cuenta cada método por igual, y por eso no coincide con la media de los valores de sus clases. Lo mismo vale para el «ratio de comentarios», que tiene además una variante recursiva de paquete.
Qué agregación elegir
- Para encontrar problemas, el máximo o el número de elementos por encima de un umbral. Después, ve al elemento.
- Para comparar partes de tamaño distinto, la media o la mediana, siempre al lado del máximo.
- Para el volumen y el esfuerzo, la suma, sabiendo que casi siempre se parece mucho al tamaño.
- Para el estado general de un sistema, un perfil de riesgo pesado por líneas de código o un índice de desigualdad, mejor que una media.
- Para comparar dos herramientas, comprueba antes qué recuento agrega cada una y sobre qué elementos.
Referencias
- Concas, G., Marchesi, M., Pinna, S. y Serra, N. (2007). «Power-Laws in a Large Object-Oriented Software System». IEEE Transactions on Software Engineering, 33(10), 687-708. https://doi.org/10.1109/TSE.2007.1019
- Fenton, N. E. y Ohlsson, N. (2000). «Quantitative Analysis of Faults and Failures in a Complex Software System». IEEE Transactions on Software Engineering, 26(8), 797-814. https://doi.org/10.1109/32.879815
- Heitlager, I., Kuipers, T. y Visser, J. (2007). «A Practical Model for Measuring Maintainability». 6th International Conference on the Quality of Information and Communications Technology (QUATIC 2007), 30-39. https://doi.org/10.1109/QUATIC.2007.8
- Landman, D., Serebrenik, A., Bouwers, E. y Vinju, J. J. (2016). «Empirical Analysis of the Relationship between CC and SLOC in a Large Corpus of Java Methods and C Functions». Journal of Software: Evolution and Process, 28(7), 589-618. https://doi.org/10.1002/smr.1760
- Louridas, P., Spinellis, D. y Vlachos, V. (2008). «Power Laws in Software». ACM Transactions on Software Engineering and Methodology, 18(1), 1-26. https://doi.org/10.1145/1391984.1391986
- Serebrenik, A. y van den Brand, M. (2010). «Theil Index for Aggregation of Software Metrics Values». 2010 IEEE International Conference on Software Maintenance (ICSM), 1-9. https://doi.org/10.1109/ICSM.2010.5609637
- Serebrenik, A., van den Brand, M. y Vasilescu, B. (2012). «Seeing the Forest for the Trees with New Econometric Aggregation Techniques». ERCIM News, 88. https://ercim-news.ercim.eu/en88/special/seeing-the-forest-for-the-trees-with-new-econometric-aggregation-techniques
- Vasa, R., Lumpe, M., Branch, P. y Nierstrasz, O. (2009). «Comparative Analysis of Evolving Software Systems Using the Gini Coefficient». 2009 IEEE International Conference on Software Maintenance (ICSM), 179-188. https://doi.org/10.1109/ICSM.2009.5306322
- Vasilescu, B., Serebrenik, A. y van den Brand, M. (2011). «You Can't Control the Unfamiliar: A Study on the Relations Between Aggregation Techniques for Software Metrics». 2011 27th IEEE International Conference on Software Maintenance (ICSM), 313-322. https://doi.org/10.1109/ICSM.2011.6080798
- Zhang, F., Hassan, A. E., McIntosh, S. y Zou, Y. (2017). «The Use of Summation to Aggregate Software Metrics Hinders the Performance of Defect Prediction Models». IEEE Transactions on Software Engineering, 43(5), 476-491. https://doi.org/10.1109/TSE.2016.2599161
- Wikipedia, «Theil index» (descomposición del índice por grupos): https://en.wikipedia.org/wiki/Theil_index