Métricas de Chidamber y Kemerer (CK)
Las métricas de Chidamber y Kemerer, conocidas por las iniciales CK, son seis medidas de clase pensadas para
el diseño orientado a objetos. Cada una mira una cara distinta de la clase: cuánta lógica tiene, dónde está en la
jerarquía de herencia, con cuántas otras clases se relaciona, cuánto código puede ponerse en marcha al llamarla y si
sus métodos forman una unidad. Muchas de las propuestas posteriores (las de Li y Henry, las variantes de LCOM, los
marcos de Briand y sus coautores) parten de ellas o las corrigen.
Para quien empieza. No hace falta aprenderse las seis a la vez. Si solo vas a mirar dos, mira la «complejidad ponderada de los métodos» (
WMC), que dice cuánta lógica acumula una clase, y el «acoplamiento entre objetos» (CBO), que dice con cuántas clases está enredada. Las otras cuatro matizan lo que esas dos señalan.
Quién, cuándo y para qué
Shyam R. Chidamber y Chris F. Kemerer trabajaban en la Sloan School of Management del MIT. Publicaron la propuesta dos veces:
- 1991, «Towards a Metrics Suite for Object Oriented Design», en el congreso OOPSLA. Las métricas se desarrollaron durante varios meses con un equipo de ingenieros de una organización que llevaba años diseñando con orientación a objetos en C++, aunque la intención era que no dependieran del lenguaje. El artículo no trae datos: evalúa las métricas sobre el papel.
- 1994, «A Metrics Suite for Object Oriented Design», en IEEE Transactions on Software Engineering. Es la versión que se cita casi siempre. Revisa varias definiciones y añade datos recogidos con una herramienta automática en dos organizaciones. En el documento de trabajo de diciembre de 1992 que la precede, el sitio A es una empresa de software con 634 clases de dos bibliotecas de interfaz gráfica en C++, y el sitio B, un fabricante de semiconductores con 1459 clases de un sistema de fabricación escrito en Smalltalk.
El propósito era doble. Por un lado, dar a los gestores de proyectos medidas con las que seguir y mejorar un proceso
de desarrollo que estaba adoptando una tecnología nueva. Por otro, responder a la crítica que pesaba sobre las
métricas anteriores: la falta de una base teórica. Siguiendo a Wand y Weber, tomaron como base la ontología de Bunge,
en la que los objetos son cosas con propiedades; de ahí sale, por ejemplo, la idea de que dos métodos se «parecen»
en los campos que comparten, que da lugar a LCOM. Después evaluaron cada métrica contra las propiedades que
Weyuker (1988) había propuesto para una medida de complejidad. En la versión de 1992-1994 dejaron fuera tres de las
nueve, por triviales o por no encajar con el diseño orientado a objetos (una exige que el valor cambie al reordenar
las declaraciones), y examinaron las seis restantes.
Las seis métricas
| Métrica | Sigla | Qué mide | Aspecto | Stau Metro |
|---|---|---|---|---|
| «Complejidad ponderada de los métodos» | WMC |
suma de la complejidad de los métodos declarados en la clase | «Complejidad» | la calcula (WeightedMethodComplexity) |
| «Profundidad del árbol de herencia» | DIT |
superclases por encima de la clase hasta la raíz | «Herencia» | la calcula (DepthOfInheritance) |
| «Número de hijos» | NOC |
subclases inmediatas | «Herencia» | la calcula (NumChildren) |
| «Acoplamiento entre objetos» | CBO |
clases distintas acopladas con la clase | «Acoplamiento» | la calcula (CouplingBetweenObjectsClass) |
| «Respuesta para la clase» | RFC |
métodos de la clase más los métodos distintos a los que llaman | «Acoplamiento» | la calcula (ResponseForClass) |
| «LCOM de Chidamber y Kemerer» | LCOM |
pares de métodos que no comparten campos | «Cohesión» | no la calcula |
| «Falta de cohesión de los métodos» | LCOM4 |
variante posterior: grupos de métodos sin relación | «Cohesión» | la calcula (LackOfCohesionOfMethodsClass) |
La última fila no es de Chidamber y Kemerer: es la variante de Hitz y Montazeri (1995) que algunas herramientas,
Stau Metro entre ellas, entregan bajo la sigla LCOM. Está en la tabla porque, en esas herramientas, es lo que
ocupa el lugar de la sexta métrica de la familia. Stau Metro calcula además el
«CBO de una interfaz», la adaptación del mismo recuento
a interfaces, que la familia original no contempla.
Qué cambió entre 1991 y 1994
Las dos versiones comparten nombres y casi el mismo texto, pero no siempre la definición. Las diferencias explican buena parte de la confusión que hay hoy entre herramientas:
CBOy la herencia. En 1991 contaba solo los acoplamientos no relacionados con la herencia. La versión de 1994 quita esa restricción. Unas herramientas cuentan hoy la superclase como clase acoplada y otras no.RFC, uno o todos los niveles. El texto de 1991 habla de todos los métodos que pueden invocarse en respuesta a un mensaje, y se ha leído como el cierre transitivo de las llamadas; la de 1994 se queda en las llamadas directas.LCOM, dos fórmulas. La de 1991 habla de «conjuntos disjuntos formados por la intersección», una frase que leída al pie de la letra no define nada; la de 1994 resta los pares de métodos que comparten campos de los que no comparten. La «página de laLCOMoriginal» cuenta las dos.
WMC cambió menos, pero arrastra una indefinición deliberada: los autores no dijeron cómo se mide la complejidad de
cada método, para que valiera con cualquier medida. Unas herramientas suman la
«complejidad ciclomática» y otras dan peso 1 a cada método.
Cómo se leen juntas
Las seis cubren cuatro dimensiones. Ninguna se basta sola, y varias crecen con el tamaño de la clase:
- Volumen y lógica:
WMC, y en parteRFC, que incluye los métodos propios. - Herencia:
DITmira hacia arriba (cuánto hereda la clase) yNOChacia abajo (a cuántas clases afecta un cambio en ella). - Acoplamiento:
CBOcuenta clases yRFCcuenta métodos. Las dos altas a la vez suelen señalar una clase con demasiadas responsabilidades. - Cohesión:
LCOMdice si los métodos trabajan sobre los mismos datos.
Una combinación que conviene vigilar es la de una clase con WMC alto, LCOM alto y CBO alto: grande, sin
unidad interna y conectada con medio sistema. Es la candidata clásica a partirse. Lanza y Marinescu formalizaron una
idea parecida, con otra combinación (WMC, el acceso a datos de otras clases y TCC), en la estrategia de detección de
la clase dios (ver sus «estrategias de detección»). Otra lectura, de la documentación de
Aivosto y recogida en las páginas de «DIT» y
«NOC»: NOC alto con WMC alto indica complejidad en lo alto de la
jerarquía.
Ojo. Antes de concluir que una clase es «compleja» o «acoplada», compárala con su tamaño en «líneas de código sin comentarios»: buena parte de lo que señalan
WMC,RFCyCBOes que la clase es grande.
Validación y críticas
Críticas a las definiciones. Las primeras llegaron enseguida. Churcher y Shepperd (1995) señalaron que no estaba
claro qué cuenta como método de una clase y pidieron reglas para cada lenguaje antes de aplicar las métricas. Hitz y
Montazeri (1996) revisaron la suite desde la teoría de la medición; la LCOM4 sale de su trabajo previo sobre
cohesión. Henderson-Sellers, Constantine y Graham (1996) mostraron que la LCOM de 1994 da el mismo valor a clases
muy distintas y propusieron una alternativa normalizada, la
«LCOM*». Briand, Daly y Wüst (1998, 1999), en sus marcos de
medidas de cohesión y de acoplamiento, comprobaron que LCOM, CBO y RFC incumplen cada una alguna de las
propiedades que debería tener una medida de ese tipo. El detalle de cada crítica está en la página de cada métrica.
Evidencia. Tres estudios marcan la historia de la familia:
- Li y Henry (1993) usaron cinco de las seis (todas salvo
CBO) junto con otras métricas suyas para predecir el esfuerzo de mantenimiento en dos sistemas comerciales. Su trabajo es la «familia de Li y Henry». - Basili, Briand y Melo (1996) las probaron como predictoras de las clases con fallos en ocho sistemas en C++
desarrollados por equipos de estudiantes con los mismos requisitos. En el informe técnico que precede al artículo,
DITyRFCresultan muy significativas,CBOsignificativa (sobre todo en las clases de interfaz de usuario),WMCsolo en parte (p = 0,06) yLCOMno significativa en ningún caso.NOCtambién fue significativa, pero en sentido contrario al esperado: cuantos más hijos, menos fallos, algo que los autores relacionan con la reutilización. - El Emam, Benlarbi, Goel y Rai (2001) mostraron que, en sus datos, la asociación de estas métricas con los fallos desaparecía al controlar el tamaño de la clase. Es la advertencia que conviene recordar al leerlas.
La conclusión prudente es que las métricas CK sirven para ordenar y señalar clases que merece la pena revisar,
no para predecir fallos con independencia del tamaño. La página
«qué dice la evidencia empírica» pone estos estudios en contexto.
Lo que separa a unas herramientas de otras
Antes de comparar valores entre herramientas o de aplicar un umbral publicado, mira qué decide cada una aquí:
| Métrica | Decisión abierta |
|---|---|
WMC |
peso de cada método: 1 o su complejidad ciclomática, y con qué reglas |
DIT |
si la raíz vale 0 o 1, y si cuentan las superclases de bibliotecas |
NOC |
si cuentan las subclases fuera del ámbito analizado |
CBO |
si cuenta en los dos sentidos o solo las clases usadas, si incluye la herencia y las bibliotecas |
RFC |
si entran los constructores y las llamadas a bibliotecas, y cuántos niveles de llamadas |
LCOM |
cuál de las variantes (1991, 1994, LCOM4, LCOM*) se calcula con ese nombre |
En las herramientas
Stau Metro calcula cinco de las seis a nivel de clase, sobre código Java, y la sexta en su variante LCOM4.
Trae un perfil predefinido, «Métricas de Chidamber-Kemerer», con esas seis métricas de clase. Sus umbrales de
referencia son: WMC aviso por encima de 31 y error por encima de 47; DIT por encima de 5 y de 8; CBO por
encima de 13 y de 20; RFC por encima de 50 y de 100; LCOM aviso por encima de 1. NOC no tiene umbral. En
resumen: su WMC suma un recuento de decisiones sin &&, || ni catch; su DIT cuenta hasta Object
inclusive; su CBO cuenta en los dos sentidos, con la herencia y sin las clases del JDK ni de bibliotecas; su RFC
sigue un solo nivel de llamadas, con los métodos de bibliotecas. Las reglas completas están en cada página.
ckjm (Spinellis) analiza el bytecode de las clases compiladas. Calcula las seis métricas CK más Ca y NPM.
Da peso 1 a cada método en WMC, calcula LCOM con la definición de 1994 y su CBO es el acoplamiento eferente.
CK (Aniche) analiza el código fuente Java. Calcula CBO (solo las dependencias), una variante CBO Modified en
los dos sentidos, DIT, NOC, RFC, WMC como complejidad de McCabe y LCOM con la definición de 1994, que su
documentación califica de poco fiable; ofrece también LCOM*, TCC y LCC.
MetricsReloaded (complemento para IntelliJ IDEA) trae, según su código fuente, un perfil «Chidamber-Kemerer metrics» con las seis métricas de clase.
Aivosto Project Analyzer (Visual Basic y VB.NET) calcula las seis. Su WMC es el número de métodos, sin
ponderar; su RFC suma los métodos de la clase y los que estos llaman directamente, y ofrece además una medida
completa, RFC', que sigue todo el árbol de llamadas; a la LCOM original la llama LCOM1.
PMD no tiene la suite como tal: su regla CouplingBetweenObjects cuenta tipos de atributos, variables locales y
retornos, y su regla GodClass usa WMC.
Referencias
- Chidamber, S. R. y Kemerer, C. F. (1991). «Towards a Metrics Suite for Object Oriented Design». Proceedings of OOPSLA '91, ACM SIGPLAN Notices, 26(11), 197-211.
- Chidamber, S. R. y Kemerer, C. F. (1992). A Metrics Suite for Object Oriented Design. CISR WP n.º 249, Sloan WP n.º 3524-93, Center for Information Systems Research, MIT. http://hdl.handle.net/1721.1/48424
- Chidamber, S. R. y Kemerer, C. F. (1994). «A Metrics Suite for Object Oriented Design». IEEE Transactions on Software Engineering, 20(6), 476-493. https://doi.org/10.1109/32.295895
- Weyuker, E. J. (1988). «Evaluating Software Complexity Measures». IEEE Transactions on Software Engineering, 14(9), 1357-1365.
- Churcher, N. I. y Shepperd, M. J. (1995). «Comments on "A Metrics Suite for Object Oriented Design"». IEEE Transactions on Software Engineering, 21(3), 263-265.
- Hitz, M. y Montazeri, B. (1995). «Measuring Coupling and Cohesion In Object-Oriented Systems». Proceedings of the International Symposium on Applied Corporate Computing, Monterrey (México).
- Hitz, M. y Montazeri, B. (1996). «Chidamber and Kemerer's Metrics Suite: A Measurement Theory Perspective». IEEE Transactions on Software Engineering, 22(4), 267-271.
- Henderson-Sellers, B., Constantine, L. L. y Graham, I. M. (1996). «Coupling and Cohesion (Towards a Valid Metrics Suite for Object-Oriented Analysis and Design)». Object Oriented Systems, 3, 143-158.
- Li, W. y Henry, S. (1993). «Object-Oriented Metrics that Predict Maintainability». Journal of Systems and Software, 23(2), 111-122. https://doi.org/10.1016/0164-1212(93)90077-B
- Basili, V. R., Briand, L. C. y Melo, W. L. (1995). A Validation of Object-Oriented Design Metrics as Quality Indicators. Informe técnico CS-TR-3443 / UMIACS-TR-95-40, Universidad de Maryland. https://www.cs.umd.edu/~basili/publications/technical/T102.pdf
- Basili, V. R., Briand, L. C. y Melo, W. L. (1996). «A Validation of Object-Oriented Design Metrics as Quality Indicators». IEEE Transactions on Software Engineering, 22(10), 751-761.
- Briand, L. C., Daly, J. W. y Wüst, J. (1998). «A Unified Framework for Cohesion Measurement in Object-Oriented Systems». Empirical Software Engineering, 3, 65-117.
- Briand, L. C., Daly, J. W. y Wüst, J. K. (1999). «A Unified Framework for Coupling Measurement in Object-Oriented Systems». IEEE Transactions on Software Engineering, 25(1), 91-121. https://doi.org/10.1109/32.748920
- El Emam, K., Benlarbi, S., Goel, N. y Rai, S. N. (2001). «The Confounding Effect of Class Size on the Validity of Object-Oriented Metrics». IEEE Transactions on Software Engineering, 27(7), 630-650.
- ckjm, descripción y métricas: https://www.spinellis.gr/sw/ckjm/ y https://www.spinellis.gr/sw/ckjm/doc/metric.html
- CK, métricas de código Java de Maurício Aniche: https://github.com/mauricioaniche/ck
- MetricsReloaded, código fuente: https://github.com/BasLeijdekkers/MetricsReloaded
- Aivosto, «Chidamber & Kemerer object-oriented metrics suite»: https://www.aivosto.com/project/help/pm-oo-ck.html
- PMD, reglas de diseño para Java: https://docs.pmd-code.org/latest/pmd_rules_java_design.html