Guía del aspecto: Evolución del código
El aspecto de evolución responde a una pregunta que las demás métricas no pueden contestar: ¿qué le ha pasado a este código, y dónde se está trabajando? Todas las métricas del resto de la referencia leen el código tal como está hoy. Las de este aspecto leen su historia: qué ficheros cambian, cuánto, junto a cuáles y quién los cambia.
Se calculan sobre el historial del control de versiones (los commits de git, por ejemplo), no sobre el código.
Por eso se llaman a veces métricas de proceso, frente a las métricas de producto. Dos ficheros idénticos hoy
pueden tener historias muy distintas, y la diferencia importa: el código que se toca a menudo es donde se paga la
complejidad y donde se cuelan los errores.
La idea de que el software cambia sin parar tiene una formulación clásica en las leyes de Lehman (1980). La primera, el cambio continuo, dice que un programa en uso tiene que cambiar o se vuelve cada vez menos útil; la segunda, la complejidad creciente, que al cambiarlo su complejidad aumenta salvo que se trabaje para mantenerla o reducirla. Las métricas de este aspecto miden dónde ocurre ese cambio.
Para quien empieza. Ninguna de estas métricas dice si el código es bueno. Dicen dónde mirar primero. Un fichero complicado que nadie toca no molesta; uno complicado que cambia cada semana, sí.
Por dónde empezar
- «Puntos calientes de cambio»: los ficheros que son a la vez complejos y muy modificados. Es la más útil para decidir qué refactorizar, porque cruza el historial con una métrica del código.
- «Acoplamiento de cambio»: los ficheros que cambian juntos. Descubre dependencias que el código no declara.
La «rotación del código» es el ingrediente de la primera, y la «propiedad del código» añade quién hace los cambios.
Las métricas del aspecto
Stau Metro no calcula ninguna: no lee el control de versiones.
| Métrica | Se mide en | Qué dice |
|---|---|---|
| «Rotación del código» (code churn) | fichero, componente, sistema | Cuánto se añade, cambia y borra en un periodo; mejor relativa al tamaño |
| «Acoplamiento de cambio» | pares de ficheros o componentes | Con qué frecuencia dos partes aparecen en los mismos commits |
| «Puntos calientes de cambio» | fichero, clase, componente | Prioridad: frecuencia de cambio cruzada con complejidad |
| «Propiedad del código» | componente, fichero; factor autobús por proyecto | Cómo se reparten los cambios entre personas y cuántas sostienen el proyecto |
Qué hace falta para calcularlas
Las cuatro se sacan del mismo registro, y comparten las mismas decisiones previas:
- El periodo. Lo reciente pesa más: un fichero muy cambiado hace cinco años y estable desde entonces ya no es un problema. Los resultados con seis meses y con tres años son distintos; compara siempre periodos iguales.
- La unidad de cambio. Normalmente el commit. La disciplina del equipo afecta al resultado: quien agrupa el trabajo de un día en un commit crea acoplamientos falsos, y quien parte un cambio en diez los esconde.
- Qué se excluye. Los cambios mecánicos (formato, cabeceras de licencia, código generado), las fusiones enormes y los ficheros que cambian siempre sin ser un problema, como los registros de versiones o las listas de dependencias.
- Renombrados e identidades. Un fichero movido puede partir su historia en dos, y una persona con dos correos cuenta como dos.
El primer paso cabe en una línea de git. Esta orden cuenta en cuántos commits de los últimos doce meses aparece
cada fichero, sin contar las fusiones, y los ordena de más a menos:
git log --since="12 months ago" --no-merges --format= --name-only | grep -v '^$' | sort | uniq -c | sort -rn
Es el eje del cambio de un punto caliente. Para análisis más finos (rotación en líneas, acoplamiento, autores), Code Maat y CodeScene parten del mismo registro; sus opciones están en cada página de métrica.
Cómo se combinan con las métricas del código
Las métricas de evolución dan su mejor resultado cruzadas con las estáticas. Cada cruce responde a una pregunta:
| Métrica del código | Métrica del historial | Lectura del cruce |
|---|---|---|
Complejidad: «WMC», «v(G)», o simplemente «LOC» |
frecuencia de cambio | Punto caliente: complejo y muy cambiado, primer candidato a refactorizar |
Tamaño: «NCLOC» |
rotación absoluta | Rotación relativa: qué parte del componente es nueva o cambiada |
Dependencias: «Dcy», «Dpt*», «Cyclic» |
acoplamiento de cambio | Par que cambia junto sin dependencia en el código: dependencia oculta o duplicación |
| «Densidad de líneas duplicadas» | acoplamiento de cambio | Clones que cambian juntos: el coste real de la duplicación |
| «Cobertura de código» | puntos calientes | Dónde importa más tener tests |
| Cualquiera de las anteriores | propiedad | Un punto caliente con muchos contribuidores ocasionales es el caso más arriesgado |
Por qué cruzar. El argumento es económico: la complejidad es un coste que se paga cada vez que alguien lee o modifica el código, y la frecuencia de cambio dice cuántas veces se paga. Un ejemplo de la «página de puntos calientes» lo muestra: la clase más compleja de un proyecto, tocada una vez en un año, cae al último puesto cuando se cruza con los cambios.
La evidencia favorece al historial. Varios estudios lo han puesto a prueba como predictor de defectos, frente a las métricas del código o, en el caso de Nagappan y Ball, comparando formas de medir la rotación:
- Graves et al. (2000) encontraron que el número de veces que se ha cambiado el código predecía los fallos mejor que su longitud.
- Nagappan y Ball (2005), en Windows Server 2003, explicaron un 81 % de la variación de la densidad de defectos con medidas de rotación relativas, frente a un 5 % con las absolutas.
- Moser, Pedrycz y Succi (2008) concluyeron que, en sus datos de Eclipse, las métricas de cambio clasificaban mejor los ficheros defectuosos que las del código.
- Rahman y Devanbu (2013), con 85 versiones de 12 proyectos de código abierto, concluyeron que las métricas de proceso eran en general más útiles que las del código. Una de sus explicaciones es que las métricas del código cambian poco de una versión a otra, de modo que los modelos que las usan señalan una y otra vez los mismos ficheros, que tienden a tener pocos defectos para su tamaño.
Eso no hace inútiles a las métricas del código. Las del historial dicen dónde; las del código, qué está mal en ese sitio y qué hacer. Un punto caliente se arregla bajando su complejidad, partiendo sus responsabilidades o cortando sus dependencias, y para eso hacen falta las guías de «complejidad», «tamaño» y «acoplamiento».
En Stau Metro. El plugin no lee el historial, pero puede guardar una instantánea de sus métricas y compararla con
un análisis posterior. La comparación da la diferencia neta entre dos momentos, que no es la rotación: un fichero que
gana 100 líneas y pierde otras 100 sale sin cambios. Su pestaña Resumen llama «puntos calientes» a los elementos que
superan los umbrales, un sentido distinto, sin el eje del cambio. Para un punto caliente de cambio hay que cruzar sus
valores, por ejemplo el WMC de cada clase, con un recuento como el de la orden de arriba. Sus métricas de
dependencias sirven para contrastar el acoplamiento de cambio.
Qué no miden
- La calidad del código. Un fichero perfecto que es el núcleo del producto y se amplía cada semana rota mucho. La rotación es un indicio de riesgo, no un defecto.
- La importancia de cada cambio. Corregir una errata y rehacer un algoritmo cuentan lo mismo como commit; en líneas, el cambio mecánico grande pesa más que el delicado pequeño.
- El código nuevo. Un fichero sin historia no puede ser punto caliente, aunque sea complejo desde el primer día.
- La causa. El acoplamiento de cambio no dice cuál de los dos ficheros es el problema, ni si lo hay: un fichero y su test deben cambiar juntos.
- Lo que no pasa por el control de versiones. Las revisiones de código reparten conocimiento y no cuentan como contribución; el código fusionado por una persona en nombre de otra aparece como suyo.
Ojo. La relación con los defectos es en parte circular: los defectos se corrigen cambiando código, así que la rotación posterior a una entrega incluye las correcciones. Por eso Nagappan y Ball miden el cambio antes de la entrega y los defectos después.
Ojo. Las métricas de propiedad hablan de personas. Usarlas para evaluar a alguien las desvirtúa enseguida: la gente cambia su forma de hacer commits y la medida deja de reflejar el conocimiento. Sirven para ver riesgos del sistema, no para juzgar a nadie.
Los resultados empíricos tampoco se trasladan sin más de un proyecto a otro. En la propiedad del código, por ejemplo, el efecto sobre los defectos se confirmó en productos de Microsoft y salió débil en siete proyectos Java de código abierto (ver su «página»). La evidencia en general se discute en «Qué dice la evidencia empírica».
Referencias
- Lehman, M. M. (1980). «Programs, Life Cycles, and Laws of Software Evolution». Proceedings of the IEEE, 68(9), 1060-1076. https://ieeexplore.ieee.org/document/1456074
- 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.
- Nagappan, N. y Ball, T. (2005). «Use of Relative Code Churn Measures to Predict System Defect Density». Proceedings of the 27th International Conference on Software Engineering (ICSE). https://doi.org/10.1145/1062455.1062514
- 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
- Rahman, F. y Devanbu, P. (2013). «How, and Why, Process Metrics Are Better». Proceedings of the 35th International Conference on Software Engineering (ICSE 2013). https://2013.icse-conferences.org/content/how-and-why-process-metrics-are-better.html
- Git, documentación de
git log: https://git-scm.com/docs/git-log - Code Maat: https://github.com/adamtornhill/code-maat