τTau SolutionsFundamentos

De dónde salen los umbrales

Actualizado el 15 de noviembre de 2026

Un umbral convierte un número en un juicio: por encima de 10, este método «es demasiado complejo». Es lo que hace útil una métrica en el día a día, y también lo más frágil de ella. Cada umbral sale de algún sitio, y ese origen dice cuánto vale. Esta página repasa las cuatro procedencias habituales, sus críticas, los umbrales de referencia que trae Stau Metro y cómo ajustar uno a tu proyecto.

Para quien empieza. Un umbral no separa el código bueno del malo. Separa el código que conviene mirar del que probablemente no. Un valor por encima del umbral es una pregunta, no un veredicto.

Cuatro procedencias

La opinión experta

El caso más conocido es el 10 de McCabe, que en 1976 lo propuso como «un límite superior razonable, aunque no mágico»; Watson y McCabe (1996) admiten hasta 15 en equipos con experiencia, diseño formal y un plan de tests completo (ver la «complejidad ciclomática»). Del mismo tipo son el 200 de la «complejidad NPath» o el «más de tres argumentos requiere una justificación muy especial» de Robert C. Martin (ver el «número de parámetros»).

Su ventaja es que llevan detrás la experiencia de alguien. Su problema, como señalan Alves, Ypma y Visser (2010), es que no se pueden reproducir ni generalizar: el 10 de McCabe nació en un contexto concreto y no pretendía valer en todos.

La estadística de un banco de sistemas

La idea es medir muchos sistemas y llamar «alto» a lo que se sale de lo habitual. La forma más sencilla, propuesta por Erni y Lewerentz (1996), es tomar la media μ\mu y la desviación típica σ\sigma del proyecto y fijar el umbral en μ+σ\mu + \sigma (o en μ−σ\mu - \sigma si lo malo es el valor bajo).

Lanza y Marinescu (2006) siguen la misma línea con un banco de 45 proyectos Java y 37 C++: «bajo» es la media menos la desviación típica, «alto» la media más la desviación típica y «muy alto» un 50 % más que «alto». En Java, eso da, por ejemplo, 13 líneas por método como valor alto y 19,5 como muy alto (según el resumen de Figueiredo). Los umbrales de «WMC» (31 y 47) y de «OCavg» (3,1 y 4,7) de Stau Metro proceden, según sus páginas, de esos valores «alto» y «muy alto» para Java. Los dos pares cumplen la regla del 50 %: 31 × 1,5 = 46,5 y 3,1 × 1,5 = 4,65, redondeados a 47 y 4,7.

El punto débil es que media y desviación típica describen bien una distribución normal, y las métricas de código no lo son: son muy asimétricas, con muchos valores pequeños y una cola larga (ver «agregar métricas»). Con datos así, μ+σ\mu + \sigma no señala el 16 % de los casos que señalaría en una normal, sino una fracción que cambia de una métrica a otra.

Alves, Ypma y Visser (2010) propusieron un método que no supone ninguna distribución. Sobre un banco de 100 sistemas Java y C#:

  1. Pesan cada método por sus líneas de código, de modo que se razona sobre porcentaje de código y no sobre porcentaje de métodos.
  2. Juntan los sistemas normalizando su tamaño, para que uno enorme no domine el resultado.
  3. Leen el umbral como un percentil del código: el valor que deja por debajo el 70 %, el 80 % o el 90 % del código del banco.

Para la complejidad ciclomática obtienen 6 y 8 para el 70 % y el 80 %; para el 90 %, el artículo da 14 en un pasaje y 15 en otro. Esos cortes son los que separan las categorías de riesgo bajo, moderado, alto y muy alto del modelo de mantenibilidad del Software Improvement Group, en el que Heitlager, Kuipers y Visser (2007) usaban la tabla 1-10, 11-20, 21-50 y más de 50 (ver «perfiles de riesgo»).

El método es robusto frente a valores extremos y produce umbrales que se pueden reproducir. Pero dice qué es habitual en el banco, no qué es bueno: si todo el banco tiene métodos complejos, el umbral sale alto.

La relación con los defectos

La tercera vía busca el valor que mejor separa las clases con defectos de las que no los tienen. Shatnawi, Li, Swain y Newman (2010) lo hicieron con curvas ROC: para cada posible umbral se calcula cuántas clases defectuosas detecta y cuántas sanas marca por error, y se elige el punto de mejor equilibrio. Lo aplicaron a las métricas de Chidamber y Kemerer en tres versiones de Eclipse, y encontraron umbrales para algunas de ellas que separaban las clases sin errores de las que tenían errores de impacto alto. Shatnawi (2010) usó otra técnica, derivada de la regresión logística, para fijar umbrales a distintos niveles de riesgo aceptable.

Es la vía con un criterio externo más claro, pero tiene dos problemas que señalan Alves y sus colegas: los umbrales obtenidos no siempre son monótonos y cambian de una versión a otra del mismo sistema. Y depende de tener un historial de defectos fiable, que pocos proyectos tienen.

El valor por defecto de una herramienta

En la práctica, la mayoría de los umbrales que se aplican son los que trae configurados una herramienta: el 10 de Checkstyle y PMD para la complejidad ciclomática, el 15 de SonarQube para la «complejidad cognitiva», el 0,7 de NDepend para la «distancia a la secuencia principal». Un valor por defecto hereda la procedencia de lo que haya detrás (a veces una fuente, a veces una convención) y, además, va ligado a la forma de contar de esa herramienta.

Ojo. El mismo umbral no significa lo mismo en dos herramientas que cuentan distinto. La complejidad ciclomática de un método cambia según se cuenten o no &&, || y catch (ver la tabla de «la complejidad ciclomática»).

Críticas de fondo

  • Puede que no haya umbral. Un umbral supone que el riesgo cambia de golpe en un punto. Benlarbi, El Emam, Goel y Rai (2000) lo buscaron en dos sistemas de telecomunicaciones en C++ y no encontraron efecto umbral en ninguna de las métricas de Chidamber y Kemerer que estudiaron: ningún valor a partir del cual la propensión a fallos deje de ser estable y crezca deprisa. El Emam y sus colegas (2002), con tres sistemas y cuatro medidas de tamaño, tampoco lo encontraron para el tamaño de clase, y mostraron que el aparente tamaño óptimo era un artefacto matemático (ver la «densidad de defectos»). Si el riesgo crece de forma continua, cualquier corte es arbitrario.
  • Depende del contexto. Lenguaje, dominio, edad del código y convenciones del equipo mueven las distribuciones. Un umbral sacado de un banco de sistemas Java no vale sin más para un analizador sintáctico ni para código generado.
  • Falta evidencia para la mayoría. La documentación de Microsoft reconoce que no hay un estándar aceptado para la profundidad de herencia por falta de datos (ver la «profundidad del árbol de herencia»); es la situación de casi todas las métricas.
  • Invita a jugar con el número. Un umbral que se vigila se puede esquivar: partir un método en trozos sin sentido o meter los parámetros en un Map baja la métrica y empeora el código (las páginas de métrica lo señalan en sus avisos).

Los umbrales de referencia de Stau Metro

Stau Metro trae umbrales de referencia para trece métricas, en dos niveles: aviso y error. Se superan de forma estricta: en una métrica en la que más alto es peor, el aviso salta con valor > umbral, y un método con v(G) = 10 no avisa. En una en la que más alto es mejor, la comparación es valor < umbral, aunque ninguna de las trece es de ese tipo. Ninguna proporción tiene umbral de referencia en el catálogo.

Métrica Nivel Aviso por encima de Error por encima de Procedencia, según su página
«NCLOC» método 30 100 Convención del plugin, no un valor publicado
«v(G)» método 10 20 El 10, de McCabe (1976), y es el valor por defecto de Checkstyle y PMD; la página no da procedencia para el 20
«CogC» método 15 25 15: regla S3776 de SonarQube y regla de PMD; 25: comprobación de clang-tidy
«NBD» método 3 5 3: regla S134 de SonarQube, que cuenta algo distinto; 5: convención del plugin
«NP» método 5 7 7: máximo por defecto de Checkstyle (ParameterNumber) y SonarQube (S107); la página no da otra fuente para el 5
«WMC» clase 31 47 Valores «alto» y «muy alto» de Lanza y Marinescu (2006) para Java; PMD usa también 47
«OCavg» clase 3,1 4,7 Valores «alto» y «muy alto» de Lanza y Marinescu (2006) para Java
«CBO» clase 13 20 Ninguna fuente publicada
«RFC» clase 50 100 Ninguna fuente publicada primaria
«LCOM» clase 1 — Misma lectura que Aivosto para LCOM4: 1 es el caso bueno
«DIT» clase 5 8 Aivosto recomienda 5 o menos y cita fuentes que admiten 8
«Cyclic» paquete — 0 El valor deseable es 0 (principio de dependencias acíclicas de Martin): cualquier ciclo es un error
«D» paquete 0,7 — Regla por defecto de NDepend

Tres detalles para leer la tabla:

  • WMC y OCavg de Stau Metro no cuentan &&, || ni catch, así que dan valores iguales o más bajos que los de una herramienta que sí los cuenta: con ellos, los umbrales de Lanza y Marinescu se superan algo menos a menudo.
  • Los umbrales de v(G), CogC, NBD y NP se aplican a cada método; los agregados (v(G)avg, OCmax...) no tienen umbral de referencia.
  • La misma sigla en otro nivel no hereda el umbral: NCLOC solo tiene umbral en el método, y Cyclic solo en el paquete.

Cada perfil puede heredar estos valores, poner los suyos o desactivarlos, por separado para el aviso y el error y para cada sentido (por encima o por debajo). En el catálogo, los umbrales de las proporciones se guardan como fracción (0,2 = 20 %); al escribir uno propio en un perfil, se escribe en porcentaje.

Cómo adaptar un umbral a tu proyecto

  1. Averigua qué cuenta tu herramienta. Antes de adoptar un umbral publicado, comprueba que la métrica que mide tu herramienta es la misma que usó la fuente. Si no, el número no es comparable.
  2. Mira tu propia distribución. Ordena los valores y mira los percentiles altos, mejor pesados por líneas de código, como hacen Alves y sus colegas. Un umbral que marca el 40 % del código no sirve para priorizar; uno que no marca nada, tampoco.
  3. Decide para qué es. Para revisar código nuevo conviene un umbral estricto y con pocas excepciones; para priorizar deuda en código antiguo, uno que señale solo la cola de la distribución.
  4. Separa aviso y error. El aviso invita a mirar; el error debería reservarse para lo que de verdad no quieres aceptar sin discusión.
  5. Anota las excepciones. Un switch que traduce códigos o una clase generada pueden superar el umbral con razón. Es mejor excluirlos de forma explícita que subir el umbral para todos.
  6. Vigila la tendencia, no solo el corte. Un valor que sube en cada versión dice más que uno que está justo por encima del límite.

Referencias

  • Alves, T. L., Ypma, C. y Visser, J. (2010). «Deriving Metric Thresholds from Benchmark Data». 2010 IEEE International Conference on Software Maintenance (ICSM), 1-10. https://doi.org/10.1109/ICSM.2010.5609747
  • Benlarbi, S., El Emam, K., Goel, N. y Rai, S. (2000). «Thresholds for Object-Oriented Measures». Proceedings of the 11th International Symposium on Software Reliability Engineering (ISSRE 2000), 24-38. https://doi.org/10.1109/ISSRE.2000.885858
  • El Emam, K., Benlarbi, S., Goel, N., Melo, W., Lounis, H. y Rai, S. N. (2002). «The Optimal Class Size for Object-Oriented Software». IEEE Transactions on Software Engineering, 28(5), 494-509. https://doi.org/10.1109/TSE.2002.1000452
  • Erni, K. y Lewerentz, C. (1996). «Applying Design-Metrics to Object-Oriented Frameworks». Proceedings of the 3rd International Software Metrics Symposium (METRICS), 64-74. https://doi.org/10.1109/METRIC.1996.492444
  • Figueiredo, E. Definition of Thresholds (transparencias de curso, UFMG), con los umbrales estadísticos de Lanza y Marinescu: https://homepages.dcc.ufmg.br/~figueiredo/disciplinas/lectures/metrics-thresholds_v01.pdf
  • Heitlager, I., Kuipers, T. y Visser, J. (2007). «A Practical Model for Measuring Maintainability». 6th International Conference on the Quality of Information and Communications Technology (QUATIC 2007), 30-39. https://doi.org/10.1109/QUATIC.2007.8
  • Lanza, M. y Marinescu, R. (2006). Object-Oriented Metrics in Practice. Springer. https://doi.org/10.1007/3-540-39538-5
  • McCabe, T. J. (1976). «A Complexity Measure». IEEE Transactions on Software Engineering, SE-2(4), 308-320. https://ieeexplore.ieee.org/document/1702388
  • Shatnawi, R. (2010). «A Quantitative Investigation of the Acceptable Risk Levels of Object-Oriented Metrics in Open-Source Systems». IEEE Transactions on Software Engineering, 36(2), 216-225. https://doi.org/10.1109/TSE.2010.9
  • Shatnawi, R., Li, W., Swain, J. y Newman, T. (2010). «Finding Software Metrics Threshold Values Using ROC Curves». Journal of Software Maintenance and Evolution: Research and Practice, 22(1), 1-16. https://doi.org/10.1002/smr.404
  • Watson, A. H. y McCabe, T. J. (1996). Structured Testing: A Testing Methodology Using the Cyclomatic Complexity Metric. NIST Special Publication 500-235.