Qué dice la evidencia empírica
Que una métrica tenga sentido no basta: hay que comprobar que se relaciona con algo que importa. Los estudios empíricos buscan esa relación con los defectos (qué clases o ficheros acaban teniendo fallos), con el esfuerzo de mantenimiento y, más recientemente, con lo que tarda una persona en entender un fragmento de código. Esta página resume lo que han encontrado los trabajos más citados, qué críticas han recibido y qué se puede sacar en limpio.
Para quien empieza. Casi todos estos estudios son de correlación: observan que las clases con un valor alto tienen más defectos, no que el valor alto los cause. Y casi todo correlaciona con el tamaño. Esas dos ideas explican buena parte de lo que sigue.
Las métricas de Chidamber y Kemerer como predictoras de defectos
El estudio fundacional es el de Basili, Briand y Melo (1996). Recogieron datos de ocho sistemas de gestión de
información en C++, de tamaño medio, desarrollados por equipos de estudiantes a partir de los mismos requisitos, y
estudiaron las seis métricas de «Chidamber y Kemerer» como predictoras de las clases
con fallos. Varias resultaron útiles para predecir esas clases pronto, en el diseño, y lo hacían mejor que las
métricas de código tradicionales, que solo se pueden recoger más tarde. El
«acoplamiento entre objetos» (CBO) y la
«respuesta para la clase» (RFC) fueron predictores significativos; la
«falta de cohesión» de su definición original no, porque sus valores
apenas variaban.
El resultado tuvo mucho eco, y con él la idea de que las métricas de diseño orientado a objetos «predicen defectos». Tenía dos limitaciones: eran ocho versiones de una misma aplicación, escritas por estudiantes, y, como mostraron trabajos posteriores, parte de lo observado podía deberse al tamaño de las clases.
El efecto de confusión del tamaño
El Emam, Benlarbi, Goel y Rai (2001) repitieron el análisis con un framework de telecomunicaciones en C++, las métricas de Chidamber y Kemerer y parte de las de «Lorenz y Kidd». Sin tener en cuenta el tamaño, sus resultados coincidían con los de estudios anteriores. Al controlar el tamaño de la clase, ninguna de las métricas seguía asociada a los fallos. Su conclusión fue que había que poner en duda las validaciones anteriores. La explicación intuitiva: una clase grande tiene más acoplamiento, más métodos y más ocasiones de fallar, y lo que parecía un efecto del diseño podía ser solo un efecto del volumen.
El debate siguió. Zhou, Xu, Leung y Chen (2014) volvieron sobre la cuestión con sistemas de código abierto y concluyeron que el efecto de confusión del tamaño existe en general, y que eliminarlo mejora los modelos de predicción. Gil y Lalouche (2017) dieron un paso más: con las transformaciones no paramétricas adecuadas, la validez de una métrica se puede predecir a partir de su correlación con el tamaño, con valores de que en algún caso llegan a 0,97. Sjøberg, Anda y Mockus (2012), comparando cuatro implementaciones independientes de un mismo sistema, concluyeron que el tamaño está infravalorado como medida de mantenibilidad (ver el «índice de mantenibilidad»).
La lección práctica: antes de atribuirle a una métrica un poder predictivo, compárala con las «líneas de código». Si no añade nada sobre el tamaño, no dice nada nuevo.
Ojo. Dividir por el tamaño tampoco resuelve el problema. Relacionar con el tamaño un cociente que ya lleva el tamaño en el denominador produce artefactos, como el falso «tamaño de clase óptimo» que discute la página de la «densidad de defectos».
Lo que dicen las revisiones sistemáticas
Radjenović, Heričko, Torkar y Živkovič (2013) revisaron 106 artículos sobre métricas para predecir defectos, publicados entre 1991 y 2011. Las métricas orientadas a objetos se usaban casi el doble (49 % de los usos) que las de código tradicionales (27 %) o las de proceso (24 %). Sus conclusiones, ponderando la calidad de cada estudio:
CBO,WMCyRFCson las mejores de las de Chidamber y Kemerer, eficaces en todo tipo de estudios. Las de acoplamiento funcionan mejor que las de herencia y cohesión.LCOMqueda a medio camino: eficaz en estudios pequeños, poco en el conjunto.- «
DIT» y «NOC» no son fiables:DITsolo fue significativa en algunos estudios pequeños, yNOCa veces en sentido contrario al esperado. - Las líneas de código tienen una eficacia moderada: correlación fuerte en estudios pequeños y débil en los grandes.
- Las métricas de complejidad no son malas predictoras, pero hay otras mejores, y están muy correlacionadas con las líneas de código. Las «medidas de Halstead» salen mal paradas.
- Las métricas de proceso son mejores que cualquier métrica estática del código para predecir los defectos posteriores a la entrega.
Hall, Beecham, Bowes, Gray y Counsell (2012) revisaron 208 estudios de predicción publicados entre 2000 y 2010, y mostraron que el resultado depende también de cómo se construye el modelo (ver la «densidad de defectos»).
Métricas de producto frente a métricas de proceso
Las métricas de producto miden el código tal como está; las de proceso, cómo ha llegado a estar así: cuántas veces ha cambiado, cuánto, quién lo ha tocado. Varios estudios coinciden en que las segundas predicen mejor los defectos:
- Graves, Karr, Marron y Siy (2000), en un sistema muy grande y longevo, encontraron que el número de veces que se había cambiado un módulo predecía sus fallos mejor que su longitud.
- Moser, Pedrycz y Succi (2008) clasificaron mejor los ficheros defectuosos de Eclipse con métricas de cambio que con métricas del código.
- Rahman y Devanbu (2013) construyeron modelos sobre 85 versiones de 12 proyectos de código abierto y concluyeron que las métricas de código son, en general, menos útiles que las de proceso. Su explicación: las métricas de código cambian muy poco de una versión a otra, y los modelos basados en ellas se estancan.
Esto no invalida las métricas de producto: miden propiedades que importan aunque no predigan bien los defectos, y están disponibles sin historial. Las páginas de «rotación del código», de «puntos calientes de cambio» y de «propiedad del código» tratan las de proceso.
La complejidad, bajo sospecha
Las críticas a las métricas de complejidad vienen de lejos. Shepperd (1988) revisó la evidencia sobre la «complejidad ciclomática» y concluyó que en muchos conjuntos de datos aportaba poco más que las líneas de código. Landman, Serebrenik, Bouwers y Vinju (2016) revisaron la cuestión con 17,6 millones de métodos Java y 6,3 millones de funciones C: la correlación lineal entre las dos, método a método, es solo moderada, porque la dispersión crece con el tamaño. No basta, dicen, para concluir que la complejidad ciclomática es redundante con las líneas de código. Al agregar las dos métricas, la correlación mejora (ver «agregar métricas»).
La crítica más dura llega desde la comprensión del código. Scalabrino, Bavota, Vendome, Linares-Vásquez, Poshyvanyk y Oliveto (2021) evaluaron 121 métricas de código, de documentación y del desarrollador frente a 444 evaluaciones de comprensión hechas por 63 desarrolladores. Su resultado, que ellos mismos llaman «negativo»: ninguna de las 121 métricas capta la comprensibilidad del código, ni siquiera las que se suponen relacionadas, como las de legibilidad y complejidad. Combinarlas en modelos mejoraba algo, pero quedaba lejos de ser útil en la práctica.
La validación de la complejidad cognitiva
La «complejidad cognitiva» se diseñó precisamente para medir la dificultad de entender un método. Muñoz Barón, Wyrich y Wagner (2020) la validaron reuniendo unas 24.000 evaluaciones de comprensión de 427 fragmentos de código procedentes de estudios previos. Encontraron que se correlaciona con el tiempo que se tarda en comprender un fragmento y con la valoración subjetiva de su dificultad; los resultados para el acierto en las tareas de comprensión y para las medidas fisiológicas fueron mixtos. Los autores la presentan como la primera métrica basada solo en el código validada para algún aspecto de la comprensibilidad.
Leído junto al de Scalabrino y sus colegas, este estudio no cierra la cuestión: la relación entre una métrica de código y la comprensión es, en el mejor de los casos, parcial.
Qué se puede concluir y qué no
Se puede concluir:
- El tamaño está detrás de casi todo. Casi todas las métricas se relacionan con los defectos en parte porque se relacionan con el tamaño. Cualquier análisis serio lo controla.
- El acoplamiento es la propiedad de diseño con más apoyo.
CBOyRFCsalen bien en el estudio original y en la revisión de Radjenović y sus colegas. - La historia del código predice los defectos mejor que su estado. Si tienes historial de cambios, úsalo.
- Las métricas sirven para priorizar, no para sentenciar. Señalan dónde mirar primero; no sustituyen la revisión.
No se puede concluir:
- Que bajar una métrica reduzca los defectos. Los estudios son observacionales; no prueban que refactorizar para
bajar
CBOevite fallos. - Que un umbral publicado valga para tu proyecto. Los resultados cambian entre sistemas, lenguajes y versiones (ver «de dónde salen los umbrales»).
- Que una métrica sea inútil porque no predice defectos. Una métrica puede describir bien el código sin servir
como predictor:
DITdice algo cierto sobre la jerarquía aunque no anticipe fallos. - Que los resultados se generalicen sin más. Muchos estudios usan pocos sistemas, sistemas de estudiantes o un solo lenguaje, y los propios autores advierten de ello.
Referencias
- Basili, V. R., Briand, L. C. y Melo, W. L. (1996). «A Validation of Object-Oriented Design Metrics as Quality Indicators». IEEE Transactions on Software Engineering, 22(10), 751-761. https://doi.org/10.1109/32.544352
- El Emam, K., Benlarbi, S., Goel, N. y Rai, S. N. (2001). «The Confounding Effect of Class Size on the Validity of Object-Oriented Metrics». IEEE Transactions on Software Engineering, 27(7), 630-650. https://doi.org/10.1109/32.935855
- Gil, Y. y Lalouche, G. (2017). «On the Correlation between Size and Metric Validity». Empirical Software Engineering, 22(5), 2585-2611. https://doi.org/10.1007/s10664-017-9513-5
- Graves, T. L., Karr, A. F., Marron, J. S. y Siy, H. (2000). «Predicting Fault Incidence Using Software Change History». IEEE Transactions on Software Engineering, 26(7), 653-661. https://doi.org/10.1109/32.859533
- Hall, T., Beecham, S., Bowes, D., Gray, D. y Counsell, S. (2012). «A Systematic Literature Review on Fault Prediction Performance in Software Engineering». IEEE Transactions on Software Engineering, 38(6), 1276-1304. https://doi.org/10.1109/TSE.2011.103
- 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
- Moser, R., Pedrycz, W. y Succi, G. (2008). «A Comparative Analysis of the Efficiency of Change Metrics and Static Code Attributes for Defect Prediction». Proceedings of the 30th International Conference on Software Engineering (ICSE), 181-190. https://doi.org/10.1145/1368088.1368114
- Muñoz Barón, M., Wyrich, M. y Wagner, S. (2020). «An Empirical Validation of Cognitive Complexity as a Measure of Source Code Understandability». Proceedings of the 14th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM 2020), 1-12. https://doi.org/10.1145/3382494.3410636
- Radjenović, D., Heričko, M., Torkar, R. y Živkovič, A. (2013). «Software Fault Prediction Metrics: A Systematic Literature Review». Information and Software Technology, 55(8), 1397-1418. https://doi.org/10.1016/j.infsof.2013.02.009
- Rahman, F. y Devanbu, P. (2013). «How, and Why, Process Metrics Are Better». 2013 35th International Conference on Software Engineering (ICSE), 432-441. https://doi.org/10.1109/ICSE.2013.6606589
- Scalabrino, S., Bavota, G., Vendome, C., Linares-Vásquez, M., Poshyvanyk, D. y Oliveto, R. (2021). «Automatically Assessing Code Understandability». IEEE Transactions on Software Engineering, 47(3), 595-613. https://doi.org/10.1109/TSE.2019.2901468
- Shepperd, M. (1988). «A Critique of Cyclomatic Complexity as a Software Metric». Software Engineering Journal, 3(2), 30-36.
- Sjøberg, D., Anda, B. y Mockus, A. (2012). «Questioning Software Maintenance Metrics: A Comparative Case Study». Proceedings of the ACM-IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM 2012), 107-110. https://doi.org/10.1145/2372251.2372269
- Zhou, Y., Xu, B., Leung, H. y Chen, L. (2014). «An In-Depth Study of the Potentially Confounding Effect of Class Size in Fault Prediction». ACM Transactions on Software Engineering and Methodology, 23(1), 1-51. https://doi.org/10.1145/2556777