Métricas de Chidamber y Kemerer (CK)

Actualizado el 15 de noviembre de 2026

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:

  • CBO y 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 la LCOM original» 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 parte RFC, que incluye los métodos propios.
  • Herencia: DIT mira hacia arriba (cuánto hereda la clase) y NOC hacia abajo (a cuántas clases afecta un cambio en ella).
  • Acoplamiento: CBO cuenta clases y RFC cuenta métodos. Las dos altas a la vez suelen señalar una clase con demasiadas responsabilidades.
  • Cohesión: LCOM dice 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, RFC y CBO es 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, DIT y RFC resultan muy significativas, CBO significativa (sobre todo en las clases de interfaz de usuario), WMC solo en parte (p = 0,06) y LCOM no significativa en ningún caso. NOC tambié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