Densidad de defectos

Actualizado el 15 de noviembre de 2026

Sigla no tiene una asentada
Aspecto «Mantenibilidad»
Se mide en cualquier unidad a la que se puedan atribuir defectos: módulo, componente, versión o sistema
Tipo de valor ratio (defectos por mil líneas, o por punto de función), mínimo 0
Dirección más alto es peor
Stau Metro no la calcula

En pocas palabras

Cuenta los defectos que se han encontrado en un trozo de software y los divide entre su tamaño. Así se pueden comparar un módulo grande y uno pequeño: 10 defectos en 100 000 líneas no son lo mismo que 10 defectos en 1000. A diferencia de casi todas las demás métricas de esta referencia, no sale de leer el código, sino del historial de errores.

Qué mide

Es una medida muy extendida de la calidad observada del código: no la que se supone a partir de su estructura, sino la que se ha visto en forma de fallos. Por eso se usa como variable que predecir: buena parte de los estudios que validan las métricas de código (complejidad, acoplamiento, cohesión) lo hacen comprobando si predicen dónde se concentran los defectos.

Dos términos que conviene separar:

  • Defecto (o fault): un error en el código, el que se corrige.
  • Fallo (failure): lo que ve el usuario cuando el programa no hace lo que debe. Un defecto puede no producir nunca un fallo, o producir muchos.

Qué se cuenta como defecto cambia de un estudio a otro: solo los fallos tras la entrega, todos los defectos conocidos o solo los que aparecen a partir de cierta fase de pruebas. Antes de comparar dos densidades, comprueba que cuentan lo mismo.

Cómo se calcula

densidad de defectos=defectostaman˜o\text{densidad de defectos} = \frac{\text{defectos}}{\text{tamaño}}

Con el tamaño en miles de líneas de código (KLOC), el resultado se lee como «defectos por cada mil líneas». También se usan los «puntos de función», que no dependen del lenguaje.

Para que el número signifique algo hay que fijar cuatro cosas:

  1. Qué es un defecto: un error confirmado, no cada incidencia abierta. Los duplicados y las peticiones de mejora no cuentan.
  2. Qué periodo: antes de la entrega (en pruebas), después (en producción) o ambos. Las dos densidades se comportan de forma distinta.
  3. A qué unidad se atribuye: al módulo donde se corrigió. Si una corrección toca varios, hay que decidir si cuenta en todos o en uno.
  4. Cómo se mide el tamaño: con o sin comentarios y líneas en blanco, con o sin código generado (ver «líneas de código» y «líneas de código sin comentarios»).

Ejemplo

Dos módulos de un mismo sistema, con los defectos corregidos durante un año:

Módulo Defectos Tamaño Densidad
billing 12 8000 líneas (8 KLOC) 12 / 8 = 1,5 defectos/KLOC
export 3 500 líneas (0,5 KLOC) 3 / 0,5 = 6 defectos/KLOC

export tiene la densidad más alta, cuatro veces la de billing, pero billing tiene cuatro veces más defectos. Las dos lecturas son ciertas y responden a preguntas distintas: dónde es más probable que esté un defecto por línea y dónde hay más defectos que buscar. Si vas a dedicar una semana de revisión, el recuento te dice dónde vas a encontrar más; la densidad, qué módulo está peor hecho para su tamaño, siempre que los dos se hayan probado y usado por igual.

Cómo interpretarla

No hay umbrales universales. La densidad depende tanto del producto como del proceso que encuentra los defectos: un equipo que prueba más encuentra más y sale peor parado. Úsala para comparar dentro de un mismo sistema, con los mismos criterios, o para seguir su evolución en el tiempo.

Qué hacer con una densidad alta. Busca la causa, no el número: requisitos confusos, un diseño que obliga a repetir lógica, falta de tests en esa zona. Cruza la densidad con la «cobertura de código» y con los «puntos calientes de cambio»: un módulo que cambia mucho y tiene muchos defectos por línea es el mejor candidato a refactorizar.

Ojo. Una densidad baja puede querer decir que el código es bueno o que nadie lo ha probado ni usado: un módulo que no se ejecuta no revela defectos, sea cual sea su tamaño o su complejidad.

Ojo. No conviertas la densidad en objetivo de un equipo. Es fácil de mejorar sin mejorar nada: registrando menos defectos, agrupándolos o escribiendo más líneas.

Para profundizar

El problema del cociente. Dividir por el tamaño parece neutral, pero no lo es. Una parte de la literatura sostenía que los componentes demasiado pequeños o demasiado grandes tienen más defectos de lo que les toca por su tamaño: una curva en U con un tamaño óptimo en medio. Se la conoce como «conjetura de Ricitos de Oro» (Goldilocks conjecture), y Hatton (1997) la defendió para los componentes de software. El Emam y sus colegas (2000) la revisaron y mostraron que el aparente óptimo y la idea de que las clases pequeñas tienen proporcionalmente más defectos son un artefacto matemático de los análisis previos, que relacionaban con el tamaño un cociente que ya lleva el tamaño en el denominador. En tres sistemas (dos en C++ y uno en Java) y con cuatro medidas de tamaño no encontraron ningún efecto umbral: la relación entre tamaño de clase y defectos era continua. Si quieres relacionar defectos y tamaño, trabaja con el recuento y trata el tamaño como una variable más, en lugar de dividir por él.

Los defectos se concentran. Fenton y Ohlsson (2000) estudiaron dos versiones de un gran sistema comercial y encontraron que un número pequeño de módulos concentraba la mayoría de los defectos encontrados antes de la entrega, y uno muy pequeño, la mayoría de los encontrados en producción. Su estudio dio además un resultado contraintuitivo: los módulos con más defectos antes de la entrega estaban entre los que menos tenían después. De ahí concluyen que, con defectos de antes de la entrega, una densidad alta indica más bien que las pruebas fueron exhaustivas que una mala calidad. Andersson y Runeson (2007) replicaron el estudio en tres proyectos de telecomunicaciones: confirmaron la concentración, pero no el resultado contraintuitivo. En sus datos, los módulos con muchos defectos en una fase de pruebas también los tenían en la siguiente, y antes y después de la entrega.

Predecirla a partir del código. Fenton y Neil (1999) revisaron los modelos que predicen defectos a partir de métricas de tamaño y complejidad, y concluyeron que muchos solo modelan una parte del problema y lo plantean mal. Propusieron modelos más completos con redes bayesianas. Fenton y Ohlsson ya advertían de que sus propios resultados no valen como leyes generales porque no tienen en cuenta el esfuerzo de prueba ni el uso real. Hall et al. (2012), en una revisión sistemática de 208 estudios de predicción de defectos publicados entre 2000 y 2010, encontraron que los modelos que mejor funcionan suelen usar técnicas sencillas (Naïve Bayes, regresión logística) y combinaciones de variables, y que el modo de construir el modelo influye en su rendimiento.

Métricas de código que la estiman. Halstead propuso estimar los defectos latentes a partir del volumen o del esfuerzo; es lo que calcula la métrica de «errores estimados de Halstead». No es una densidad medida, sino una predicción a partir del tamaño, y no sustituye al historial real.

Relación con otras métricas

En las herramientas

Stau Metro no la calcula: no lee el historial de incidencias ni el control de versiones. La métrica más cercana es la de «errores estimados de Halstead» (B), por método y por clase, que su ayuda describe como «la estimación empírica de Halstead del número de defectos latentes […] basada solo en su tamaño y dificultad», y que recomienda tratar «como una señal aproximada de dónde centrar las pruebas, no como un recuento literal de defectos». Se diferencia en todo lo esencial: predice a partir del código, no cuenta defectos reales, y no está dividida por el tamaño. Para calcular una densidad real con el plugin, sus líneas de código por paquete, módulo o proyecto sirven de denominador; los defectos hay que sacarlos del gestor de incidencias.

Referencias

  • Fenton, N. E. y Neil, M. (1999). «A Critique of Software Defect Prediction Models». IEEE Transactions on Software Engineering, 25(5), 675-689.
  • 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
  • Andersson, C. y Runeson, P. (2007). «A Replicated Quantitative Analysis of Fault Distributions in Complex Software Systems». IEEE Transactions on Software Engineering, 33(5), 273-286.
  • Hatton, L. (1997). «Reexamining the Fault Density-Component Size Connection». IEEE Software, 14(2), 89-97.
  • El Emam, K., Benlarbi, S., Goel, N., Melo, W., Lounis, H. y Rai, S. N. (2000). The Optimal Class Size for Object-Oriented Software: A Replicated Study. National Research Council Canada, informe ERB-1074.
  • 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.