Rotación del código (code churn)
| Sigla | sin sigla asentada (las medidas relativas de Nagappan y Ball se numeran M1 a M8) |
| Aspecto | «Evolución del código» |
| Se mide en | fichero, componente o sistema, sobre el historial de versiones de un periodo |
| Tipo de valor | recuento de líneas o de cambios (absoluta); cociente (relativa) |
| Dirección | más alto es peor como indicio de riesgo |
| Origen | Munson y Elbaum (1998); medidas relativas, Nagappan y Ball (2005) |
| Stau Metro | no la calcula |
En pocas palabras
Mide cuánto se ha tocado un fichero o un componente en un periodo: líneas añadidas, cambiadas y borradas, y número de cambios. Se saca del control de versiones, no del código. La idea es sencilla: el código que se modifica mucho antes de una entrega suele llegar a ella con más defectos que el que apenas se toca. Medida en proporción al tamaño del componente, es uno de los indicadores de riesgo mejor estudiados.
Qué mide
Mide la actividad de cambio, no una propiedad del código en un instante. Es una métrica de proceso: dos ficheros idénticos hoy pueden tener una rotación muy distinta según su historia.
Importa porque cada cambio es una ocasión de introducir un error, y porque el código que se rehace una y otra vez suele ser el que nadie termina de entender o el que está mal repartido. Graves et al. (2000), con los datos de cambios de un sistema muy grande y longevo, encontraron que las medidas sacadas del historial de cambios predecían la tasa de fallos mejor que las métricas del producto: por ejemplo, el número de veces que se ha cambiado el código indicaba mejor cuántos fallos tendría que su longitud.
Términos:
- Rotación absoluta: líneas o cambios en bruto. Crece con el tamaño del componente y con la duración del periodo.
- Rotación relativa: la absoluta normalizada por algo, como el tamaño en líneas, el número de ficheros o el tiempo. Es la que permite comparar componentes de tamaño distinto.
Cómo se calcula
Se fija una línea base (una versión o una fecha) y una versión nueva, y se comparan con una utilidad tipo
diff. Nagappan y Ball (2005) usaron estas medidas absolutas de cada componente (un binario de Windows):
| Medida | Definición |
|---|---|
| Total LOC | líneas ejecutables sin comentarios de los ficheros del componente en la versión nueva |
| Churned LOC | líneas añadidas más líneas cambiadas entre la línea base y la versión nueva |
| Deleted LOC | líneas borradas entre las dos versiones |
| File count | número de ficheros que forman el componente |
| Weeks of churn | tiempo acumulado que un fichero estuvo abierto para edición en el control de versiones |
| Churn count | número de cambios hechos a los ficheros del componente entre las dos versiones |
| Files churned | número de ficheros del componente que cambiaron |
Con ellas definieron ocho medidas relativas:
| Medida | Cociente | Qué capta |
|---|---|---|
M1 |
Churned LOC / Total LOC | proporción de código nuevo o cambiado |
M2 |
Deleted LOC / Total LOC | proporción de código borrado |
M3 |
Files churned / File count | proporción de ficheros tocados |
M4 |
Churn count / Files churned | cuántas veces se tocó cada fichero cambiado |
M5 |
Weeks of churn / File count | extensión temporal de los cambios |
M6 |
Lines worked on / Weeks of churn | líneas trabajadas por semana; lines worked on = churned + deleted |
M7 |
Churned LOC / Deleted LOC | desarrollo nuevo frente a corrección: alto en funcionalidades nuevas |
M8 |
Lines worked on / Churn count | tamaño medio de cada cambio |
Las medidas se comprueban entre sí: M1, M2 y M7 se contrastan unas con otras, y M8 con M3, M4, M5 y
M6.
Nota.
gitno distingue una línea cambiada de una borrada y otra añadida. En la salida degit log --numstat, una línea modificada aparece como una borrada y una añadida. Por eso las «añadidas» degitse aproximan a churned LOC (añadidas + cambiadas), y las «borradas», a deleted LOC más las cambiadas.
Ejemplo
El componente billing tiene 10 ficheros y 2.000 líneas de código sin comentarios en la versión nueva. Entre la
línea base y la versión nueva cambiaron cuatro ficheros:
| Fichero | Cambios | Líneas añadidas o cambiadas | Líneas borradas |
|---|---|---|---|
Invoice.java |
5 | 120 | 60 |
TaxRules.java |
4 | 90 | 30 |
Payment.java |
2 | 30 | 10 |
Refund.java |
1 | 10 | 0 |
| Total | 12 | 250 | 100 |
Medidas relativas (M5 y M6 necesitan el tiempo de edición, que aquí no se tiene):
M1= 250 / 2.000 = 0,125: un 12,5 % del componente es nuevo o cambiado.M2= 100 / 2.000 = 0,05.M3= 4 / 10 = 0,4: se tocaron cuatro de cada diez ficheros.M4= 12 / 4 = 3: cada fichero tocado cambió tres veces de media.M7= 250 / 100 = 2,5: se añadió bastante más de lo que se borró, lo que apunta a funcionalidad nueva.M8= (250 + 100) / 12 ≈ 29,2 líneas trabajadas por cambio.
En absoluto, Invoice.java es el fichero con más rotación. Para compararlo con otro fichero habría que dividir por
su tamaño, como hace M1 con el componente.
Cómo interpretarla
No hay umbrales publicados de validez general. La rotación se usa para ordenar: qué componentes, dentro del mismo sistema y del mismo periodo, concentran el cambio.
- Usa la relativa, no la absoluta. Es el hallazgo central de Nagappan y Ball: en Windows Server 2003, un modelo de regresión con las medidas absolutas explicaba un 5 % de la variación de la densidad de defectos (R² = 0,052), y uno con las ocho medidas relativas, un 81 % (R² = 0,811).
- Compara periodos iguales. Un mes de rotación no se compara con un año.
- Lee la composición, no solo el total. Mucha rotación con
M7alto suele ser desarrollo nuevo; mucha rotación conM4alto y cambios pequeños (M8bajo) suele ser un fichero que se corrige una y otra vez.
Qué hacer con un valor alto: revisa con más cuidado (más revisión de código, más tests) los componentes que más rotan antes de una entrega; si un fichero rota mucho porque mezcla responsabilidades, divídelo. Cruzada con la complejidad, la rotación da los «puntos calientes de cambio».
Cuándo un valor alto es aceptable. En código nuevo, en una migración planificada o en un renombrado masivo. Los cambios mecánicos (formato, cabeceras de licencia, código generado) inflan la cifra sin añadir riesgo; conviene excluirlos.
Ojo. La rotación es un indicio de riesgo, no una medida de calidad del código. Un fichero perfecto que se amplía cada semana porque es el núcleo del producto rota mucho.
Para profundizar
Evidencia. Munson y Elbaum (1998), según el resumen de Nagappan y Ball, estudiaron un sistema empotrado de tiempo real de unas 300 KLOC en C y encontraron que las métricas de rotación estaban entre las más correlacionadas con los informes de problemas. Nagappan y Ball (2005) analizaron la rotación entre Windows Server 2003 y su Service Pack 1 (44,97 millones de líneas, 2.465 binarios) y, con un análisis discriminante, separaron binarios propensos y no propensos a fallos con un 89,0 % de acierto. Moser, Pedrycz y Succi (2008) compararon métricas de cambio y métricas del código para clasificar ficheros de Eclipse como defectuosos o no, y concluyeron que, en esos datos, las de cambio eran más eficaces.
Cambios recientes y grandes. El mejor modelo de Graves et al. (2000) mide el potencial de fallos de un módulo como la suma de las contribuciones de todas las veces que ha cambiado, con más peso para los cambios grandes y recientes. Es una forma de rotación ponderada en el tiempo.
Limitaciones. Los cambios a mano y los automáticos pesan lo mismo. Los movimientos y renombrados de ficheros pueden aparecer como un borrado completo y un fichero nuevo. Y 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 propias correcciones. Por eso Nagappan y Ball miden la rotación antes de la entrega y la comparan con los defectos de después.
Granularidad. La medida se puede calcular por fichero, por paquete o por componente. Cuanto más grande es la unidad, más estable es la cifra y menos dice sobre dónde actuar.
Relación con otras métricas
- «Puntos calientes de cambio»: cruzan la frecuencia de cambio con la complejidad; la rotación es uno de sus dos ejes.
- «Acoplamiento de cambio»: también sale del historial, pero mira qué ficheros cambian juntos, no cuánto cambia cada uno.
- «Propiedad del código»: mira quién hace los cambios que la rotación cuenta.
- «Líneas de código sin comentarios» (
NCLOC): el denominador natural de la rotación relativa; Nagappan y Ball normalizan por líneas ejecutables sin comentarios. - «Densidad de defectos»: la variable que Nagappan y Ball predicen con la rotación relativa.
En las herramientas
Stau Metro. No la calcula: no lee el control de versiones. Puede crear una instantánea de las métricas y compararla más tarde con un análisis nuevo; la comparación muestra qué elementos son nuevos, cuáles han desaparecido y, en los que cambian, el valor actual junto al de la instantánea, por ejemplo el de las «líneas de código». Eso es la diferencia neta entre dos momentos, no la rotación: un fichero que gana 100 líneas y pierde otras 100 sale sin cambios en la comparación y con 200 líneas trabajadas en la rotación.
git. git log --numstat da, por commit y fichero, el número de líneas añadidas y borradas («similar a
--stat, pero en decimal y sin abreviar la ruta»); en los ficheros binarios escribe - en vez de números. Sumando
esas cifras por fichero en un periodo se obtiene la rotación absoluta.
Code Maat (herramienta de línea de órdenes de Adam Tornhill, licencia GPL v3). Lee un registro de git
generado con, por ejemplo:
git log --all --numstat --date=short --pretty=format:'--%h--%ad--%aN' --no-renames --after=YYYY-MM-DD
y ofrece, entre otros, los análisis abs-churn (rotación absoluta por fecha), entity-churn (líneas añadidas y
borradas por fichero, ordenadas por las añadidas) y author-churn (por autor). El análisis abs-churn solo está
disponible con registros de git.
CodeScene. Usa por defecto la frecuencia de commits de cada fichero para buscar puntos calientes, y ofrece la rotación relativa (el cambio medido en líneas, en relación con el tamaño del fichero) como criterio alternativo.
Referencias
- Munson, J. C. y Elbaum, S. G. (1998). «Code Churn: A Measure for Estimating the Impact of Code Change». Proceedings of the International Conference on Software Maintenance (ICSM), 24-31.
- 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
- 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.
- 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
- Git, documentación de
git log: https://git-scm.com/docs/git-log - Code Maat: https://github.com/adamtornhill/code-maat
- CodeScene, guía de puntos calientes: https://docs.enterprise.codescene.io/versions/4.1.4/guides/technical/hotspots.html