Densidad de líneas duplicadas
| Sigla | no tiene una asentada; SonarQube la llama duplicated_lines_density |
| Aspecto | «Duplicación» |
| Se mide en | fichero, directorio o paquete, y proyecto |
| Tipo de valor | ratio (porcentaje de 0 a 100) |
| Dirección | más alto es peor |
| Origen | la investigación sobre clones de código (Baker, 1995, y siguientes); la densidad en porcentaje es la definición de SonarQube |
| Stau Metro | no la calcula |
En pocas palabras
Dice qué parte del código está repetida. Si un fichero tiene 200 líneas y 30 de ellas forman parte de un bloque que aparece también en otro sitio, su densidad de duplicación es del 15 %. El código copiado y pegado no es grave por sí mismo, pero cada copia es un sitio más donde corregir el mismo error, y es fácil olvidarse de alguna.
Qué mide
Mide la duplicación de código: fragmentos iguales o muy parecidos en varios sitios del programa. A esos fragmentos se les llama clones, y a un conjunto de fragmentos que se parecen entre sí, grupo de clones.
Importa por el mantenimiento. Si un defecto está en un fragmento, probablemente esté en todas sus copias, y hay que encontrarlas. Si alguien cambia una copia y no las demás, el comportamiento diverge sin que nadie lo haya decidido. Juergens, Deissenboeck, Hummel y Wagner (2009) lo estudiaron en sistemas comerciales y de código abierto: los cambios inconsistentes entre clones eran muy frecuentes y encontraron un número significativo de defectos causados por ellos.
Para quien empieza. Duplicación no es solo «copiar y pegar tal cual». Un bloque copiado al que luego se le cambian los nombres de las variables sigue siendo un clon, y las herramientas buenas lo detectan.
Los cuatro tipos de clon
La clasificación más usada distingue cuatro tipos, de más a menos parecido (Roy, Zibran y Koschke, 2014; los tres primeros vienen de Bellon et al., 2007):
| Tipo | Definición |
|---|---|
| 1 | Fragmentos idénticos salvo en espacios en blanco y comentarios |
| 2 | Estructuralmente idénticos salvo en nombres de identificadores, literales, tipos, formato y comentarios |
| 3 | Como los de tipo 2, pero con sentencias añadidas, eliminadas o modificadas |
| 4 | Con el mismo comportamiento, pero escritos con estructuras sintácticas muy distintas |
A los de tipo 2 y 3 se les llama a veces clones «casi iguales» (near-miss). Los de tipo 1 y 2 tienen límites claros; los de tipo 3 dependen de un umbral de parecido que cada herramienta fija a su manera, y los de tipo 4 exigen comparar comportamiento, no texto.
Cómo se calcula
Es la definición de SonarQube: las líneas duplicadas son las que forman parte de algún bloque duplicado, y el denominador son las líneas físicas del fichero (o la suma en un directorio o proyecto).
El número depende por completo del detector de clones: qué tipos detecta y cuál es el tamaño mínimo de un bloque. Un tamaño mínimo bajo encuentra más clones, muchos de ellos triviales (secuencias de getters, importaciones); uno alto deja fuera duplicaciones reales. Roy, Cordy y Koschke (2009) agrupan las técnicas de detección en textuales, léxicas (por tokens), sintácticas (por árbol sintáctico o por métricas) y semánticas (por grafo de dependencias del programa).
Ejemplo
Los cuatro tipos sobre un mismo método (cada versión estaría en una clase distinta; Item y Line son records
con price(), quantity() y, Line, también isCancelled()):
// Original
static int total(List<Item> items) {
int sum = 0;
for (Item item : items) {
sum += item.price() * item.quantity();
}
return sum;
}
// Tipo 1: solo cambian el formato y un comentario
static int total(List<Item> items) {
int sum = 0; // acumulador
for (Item item : items) { sum += item.price() * item.quantity(); }
return sum;
}
// Tipo 2: cambian los nombres
static int amount(List<Line> lines) {
int acc = 0;
for (Line line : lines) {
acc += line.price() * line.quantity();
}
return acc;
}
// Tipo 3: se ha añadido una sentencia
static int amount(List<Line> lines) {
int acc = 0;
for (Line line : lines) {
if (line.isCancelled()) continue;
acc += line.price() * line.quantity();
}
return acc;
}
// Tipo 4: mismo resultado, otra estructura
static int amount(List<Line> lines) {
return lines.stream().mapToInt(l -> l.price() * l.quantity()).sum();
}
El cálculo de la densidad, con números: un proyecto de 2000 líneas en el que el detector encuentra un bloque de 40 líneas repetido en tres ficheros y otro de 25 líneas repetido en dos. Cuentan todas las líneas de todas las copias:
Fíjate en que la copia «original» también cuenta: la métrica no sabe cuál se escribió primero. Si eliminas la duplicación extrayendo un método común, desaparecen todas las líneas duplicadas, no solo las de las copias.
Cómo interpretarla
No hay un umbral publicado con respaldo empírico. Como orientación, Roy, Zibran y Koschke (2014) recogen estudios que sitúan la proporción de código clonado de un sistema típico entre el 9 % y el 17 %, con casos desde el 5 % hasta el 50 %; esas cifras dependen mucho del detector y de lo que cada estudio considera clon.
Más que el valor global, mira:
- dónde está la duplicación: dentro de un mismo fichero suele ser fácil de quitar; entre módulos puede pedir una biblioteca común;
- qué se duplica: lógica de negocio (merece la pena unificarla) o código repetitivo que el lenguaje obliga a escribir;
- si cambia: un clon que nadie toca no genera inconsistencias; uno que cambia a menudo sí.
Qué hacer con un valor alto. Extrae el código común a un método o una clase, usa genéricos o parametriza las diferencias. En los tipos 2 y 3, decide antes si las diferencias son intencionadas.
Cuándo un valor alto es aceptable. Código generado (que debería excluirse del análisis), tests con datos parecidos escritos a propósito para que cada uno se lea solo, y duplicación impuesta por el lenguaje o el framework. Roy, Zibran y Koschke señalan que la duplicación a veces no se puede evitar y que refactorizar los clones de forma agresiva no parece buena idea.
Ojo. Dos ficheros con la misma densidad no tienen el mismo problema: un 10 % formado por un bloque repetido cuarenta veces no es lo mismo que un 10 % de pequeños parecidos dispersos.
Para profundizar
Clonar no siempre es un error. Kapser y Godfrey (2008), en un artículo titulado precisamente «"Cloning considered harmful" considered harmful», describen patrones de clonación con razones legítimas, como el forking (copiar un componente para evolucionarlo por separado). Roy, Zibran y Koschke (2014) recuerdan además que a veces la duplicación la impone el lenguaje, que no ofrece el mecanismo para una solución genérica eficiente, o un generador de código. La duplicación es un coste de mantenimiento, no un defecto automático.
Lo peligroso es la inconsistencia. Los trabajos sobre la evolución de clones siguen cada grupo a lo largo de versiones (las «genealogías» de clones). Varios estudios encontraron que los cambios inconsistentes entre clones causaban a veces defectos; Roy, Zibran y Koschke (2014) advierten de que hay resultados contradictorios y de que no toda correlación permite concluir una causa.
Detectores de referencia. Baker (1995) describió uno de los primeros detectores para sistemas grandes, basado en encontrar duplicación exacta y casi exacta. CCFinder (Kamiya, Kusumoto e Inoue, 2002) es un detector por tokens para varios lenguajes. Bellon et al. (2007) compararon varios detectores sobre los mismos sistemas; su clasificación por tipos es la que más se usa desde entonces.
Formas de falsear la métrica. Reformatear o renombrar no engaña a un detector de tipo 2, pero añadir o reordenar sentencias puede sacar un clon de un detector que solo ve los tipos 1 y 2. Subir el tamaño mínimo de bloque también baja la densidad sin tocar el código.
Relación con otras métricas
- «Líneas de código» (
LOC): el denominador; con él se pasa de líneas duplicadas a densidad. - «Ratio de deuda técnica» (
TDR): la duplicación es una fuente de deuda; en SQALE, «no hay partes clonadas de 100 tokens o más» es un requisito con su coste de remedio. - «Índice de mantenibilidad» (
MI): no ve la duplicación; los modelos de mantenibilidad posteriores la añadieron como factor propio. - «Densidad de defectos»: los cambios inconsistentes entre clones son una de las causas estudiadas de defectos.
- «Acoplamiento de cambio»: ficheros que cambian siempre juntos; puede ser la huella de una duplicación que obliga a tocar todas las copias.
- «Líneas de código sin comentarios» (
NCLOC): la duplicación infla el tamaño; restar las líneas duplicadas da una idea del tamaño «único».
En las herramientas
Stau Metro no la calcula: no tiene detector de clones, y ninguna de sus métricas mide la duplicación. Sus «líneas de código» por paquete, módulo y proyecto pueden servir de denominador si el número de líneas duplicadas viene de otra herramienta, siempre que las dos cuenten las líneas igual.
SonarQube. Calcula duplicated_lines (líneas que intervienen en duplicaciones), duplicated_blocks,
duplicated_files y duplicated_lines_density, que es duplicated_lines / lines * 100, con lines el número de
líneas físicas. En Java, un bloque es duplicado si tiene al menos 10 sentencias seguidas duplicadas, sea cual sea el
número de tokens y de líneas; en la mayoría de los demás lenguajes, al menos 100 tokens seguidos repartidos en al
menos 10 líneas. Ignora las diferencias de sangrado y de literales de cadena. Las variantes new_… miden lo mismo
sobre el código nuevo.
PMD CPD (copy/paste detector). Busca duplicados por tokens con el algoritmo de Karp-Rabin. Por defecto encuentra
duplicados idénticos; el tamaño mínimo de un duplicado en tokens (--minimum-tokens) es obligatorio y no tiene
valor por defecto. En Java puede ignorar identificadores (--ignore-identifiers), literales (--ignore-literals) y
anotaciones (--ignore-annotations), lo que le permite encontrar clones de tipo 2. Informa de los bloques
duplicados, no de una densidad.
Referencias
- Baker, B. S. (1995). «On Finding Duplication and Near-Duplication in Large Software Systems». WCRE 1995, 86-95.
- Kamiya, T., Kusumoto, S. e Inoue, K. (2002). «CCFinder: A Multilinguistic Token-Based Code Clone Detection System for Large Scale Source Code». IEEE Transactions on Software Engineering, 28(7), 654-670.
- Bellon, S., Koschke, R., Antoniol, G., Krinke, J. y Merlo, E. (2007). «Comparison and Evaluation of Clone Detection Tools». IEEE Transactions on Software Engineering, 33(9), 577-591.
- Kapser, C. y Godfrey, M. W. (2008). «"Cloning Considered Harmful" Considered Harmful: Patterns of Cloning in Software». Empirical Software Engineering, 13, 645-692.
- Roy, C. K., Cordy, J. R. y Koschke, R. (2009). «Comparison and Evaluation of Code Clone Detection Techniques and Tools: A Qualitative Approach». Science of Computer Programming, 74(7), 470-495.
- Juergens, E., Deissenboeck, F., Hummel, B. y Wagner, S. (2009). «Do Code Clones Matter?». Proceedings of the 31st International Conference on Software Engineering (ICSE 2009), 485-495. https://arxiv.org/abs/1701.05472
- Roy, C. K., Zibran, M. F. y Koschke, R. (2014). «The Vision of Software Clone Management: Past, Present, and Future». Ponencia invitada, CSMR-WCRE 2014, 18-33.
- SonarQube, definición de métricas (duplicaciones): https://docs.sonarsource.com/sonarqube-server/latest/user-guide/code-metrics/metrics-definition/
- PMD, «Finding duplicated code with CPD»: https://docs.pmd-code.org/latest/pmd_userdocs_cpd.html