Rotación del código (code churn)

Actualizado el 15 de noviembre de 2026

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. git no distingue una línea cambiada de una borrada y otra añadida. En la salida de git log --numstat, una línea modificada aparece como una borrada y una añadida. Por eso las «añadidas» de git se 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 M7 alto suele ser desarrollo nuevo; mucha rotación con M4 alto y cambios pequeños (M8 bajo) 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

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