Los proyectos de desarrollo de software modernos suelen implicar docenas de piezas móviles que los programadores de equipos distribuidos ensamblan de forma intrincada.
Cuando el código subyacente, en su arquitectura e implementación, es menos complejo, resulta más fácil de entender.
Y cuando se comprende el código base, esto contribuye en gran medida a mejorar su calidad y facilidad de mantenimiento.
La complejidad ciclomática es una medida cuantitativa de la complejidad de un programa informático que se utiliza en informática.
En esencia, refleja el número de rutas linealmente independientes a través del código fuente de un programa.
Al supervisar esta métrica, se pueden identificar áreas de código que son potencialmente problemáticas o excesivamente complejas, lo que las hace más difíciles de mantener y más susceptibles a errores.
Comprender la complejidad ciclomática le ayudará a escribir un código mejor y más limpio.
En este artículo, exploraremos qué es la complejidad ciclomática, cómo se calcula y por qué es importante. También discutiremos cómo probar y analizar esta complejidad, y las herramientas disponibles para ayudarle a gestionarla de manera eficaz.
¿Qué es la complejidad ciclomática?
La complejidad ciclomática es una métrica de ingeniería de software introducida por Thomas J. McCabe en 1976. Esta métrica es una puntuación numérica que representa el número de rutas diferentes que puede tomar un programa durante su ejecución.
Una puntuación más alta significa más rutas de ejecución (mayor complejidad), mientras que una puntuación más baja significa menos rutas (menor complejidad).
Los programas con una alta complejidad ciclomática tienden a ser más propensos a errores y más difíciles de probar y mantener. Por otro lado, un valor de complejidad ciclomática más bajo sugiere que el programa es muy legible y más fácil de entender, probar y modificar.
Al cuantificar la complejidad de un programa, los desarrolladores están mejor preparados para abordar y priorizar las modificaciones del código, la refactorización y las pruebas. Cuando se trata de gestionar bases de código más grandes, en las que el riesgo de errores aumenta con la complejidad, la métrica de complejidad ciclomática resulta especialmente útil.
¿Cuál es la fórmula para calcular la complejidad ciclomática?
La fórmula para calcular la complejidad ciclomática es relativamente sencilla. Empiece por observar el gráfico de flujo de control del programa, una representación gráfica de todas las rutas que pueden recorrerse a través de un programa durante su ejecución.
- Ejemplos de gráficos de flujo de control de escenarios de programación simples
(a) Sentencia if-then-else
(b) Bucle while
(c) Un bucle natural con una sentencia if break en el medio
(d) Un bucle con dos puntos de entrada
Al observar un gráfico de flujo de control, representaríamos el número de aristas del gráfico como E, mientras que N representa el número de nodos del gráfico.
La fórmula para la complejidad ciclomática C es:
C = E - N + 2P
donde P representa el número de componentes conectados. Para un solo programa, P = 1.
Este cálculo nos da el número de rutas linealmente independientes a través del código. Indica el número mínimo de rutas que hay que probar para garantizar que cada punto de decisión se ejecute al menos una vez. Cuando C es alto, entonces tienes un código más complejo con más rutas, lo que significa un mayor esfuerzo de mantenimiento y pruebas.
Una conclusión simple que podemos sacar al considerar la complejidad ciclomática es la siguiente: si las sentencias if, while, for o switch añaden complejidad porque cada condición introduce una nueva ruta en el flujo del programa. Como desarrollador, puedes mirar esta fórmula y evaluar rápidamente la complejidad de cualquier parte de tu programa.
Comprender y aplicar esta fórmula le ayudará a mantener su código limpio, eficiente y fácil de mantener.
¿Cuál es un ejemplo de complejidad ciclomática?
Para ilustrar la complejidad ciclomática con un ejemplo práctico, veamos un fragmento básico de código escrito en JavaScript. Este ejemplo nos ayudará a comprender cómo se calcula la complejidad ciclomática y por qué es importante.
Esta sencilla función de JavaScript comprueba si un usuario tiene derecho a un descuento en función de varias condiciones:
function checkDiscount(age, membershipDuration) {
let discount;
if (age > 60) {
discount = 25; // Senior discount
} else if (membershipDuration > 5) {
discount = 15; // Loyalty discount
} else {
discount 0; // No discount
}
return discount;
}Podemos representar estas líneas de código con el siguiente gráfico de flujo de control:
Veamos cómo se calcula la complejidad ciclomática.
En primer lugar, busquemos los puntos de decisión en la función. En nuestro ejemplo, hay dos condiciones:
- if (edad > 60)
- else if (duraciónDeLaMembresía > 5).
Cada punto de decisión puede dar lugar a diferentes resultados:
- La condición edad > 60 es verdadera
- La primera condición es falsa, pero duraciónDeLaMembresía > 5 es verdadera.
- Ambas condiciones son falsas.
Al observar el gráfico de flujo de control, vemos que el número total de aristas es 8. El número total de nodos es 7. Y como toda la función es un único componente conectado, P = 1. Al aplicar la fórmula, obtenemos lo siguiente:
C = E - N + 2P
= 8 - 7 + 2(1)
= 3
Esta puntuación de complejidad ciclomática de 3 indica que hay tres rutas distintas a través del código. Cada una de estas rutas debe probarse para garantizar que se cubren todos los escenarios. Al desglosar nuestro código de forma metódica como esta, aclaramos lo que se necesita para las pruebas de software y resaltamos la complejidad de nuestro código, una complejidad que podría simplificarse.
Cómo probar la complejidad ciclomática
Probar la complejidad ciclomática, en pocas palabras, significa asegurarse de que se han probado adecuadamente todas las rutas posibles del programa. Una cobertura adecuada del código de prueba es importante si se quiere mantener la calidad y la fiabilidad del código.
Una vez calculada la complejidad ciclomática del código, desglósalo para identificar cuáles son esas rutas. Un consejo: cada punto de decisión del código (como las sentencias condicionales o los bucles) suele contribuir a una nueva ruta.
Una vez que haya identificado sus rutas, cree casos de prueba para cada una de ellas. El objetivo es ejecutar cada ruta al menos una vez. Esto garantiza que se prueben todos los aspectos funcionales del código y le ayudará a detectar posibles errores en la lógica del código.
Utilice herramientas de prueba automatizadas para ejecutar sus casos de prueba. Después de analizar los resultados de las pruebas, compruebe si hay fallos o comportamientos inesperados. Cada caso de prueba fallido puede indicar un error o una falla en esa ruta de su código fuente.
Si todas sus pruebas pasan, pero cree que la complejidad ciclomática es demasiado alta, puede considerar la posibilidad de refactorizar el código para simplificarlo. Esto puede implicar desglosar funciones complejas en otras más simples o reducir el número de puntos de decisión. Después de la refactorización, repita el proceso de prueba para asegurarse de que el nuevo código mantiene o mejora la calidad.
Al determinar periódicamente la complejidad ciclomática y luego probar el código en consecuencia, puede mantener un nivel de complejidad manejable. Esto simplifica el proceso de prueba y su base de código, lo que da como resultado un software más confiable y fácil de mantener.
Cómo realizar un análisis de complejidad ciclomática
El análisis de código de complejidad ciclomática implica revisar el código fuente de su programa para comprender su estructura e identificar áreas donde se puede reducir la complejidad.
Para ello, se debe empezar por recopilar todo el código fuente que necesita ser analizado. Puede tratarse de un módulo específico o de un conjunto de funciones, o incluso de una aplicación completa, dependiendo de su enfoque.
Se pueden utilizar herramientas como los analizadores de código estático para automatizar el proceso de cálculo de la complejidad ciclomática de cada función o módulo. Estas herramientas le ayudarán a obtener una visión general rápida de la complejidad de su código.
A partir de ahí, identifique las partes del código con puntuaciones de complejidad elevadas. Estas son las áreas que pueden resultar difíciles de comprender, probar y mantener. Priorice las áreas que deben refactorizarse. La determinación de cuáles son esas áreas dependerá de su complejidad y de la importancia de su funcionalidad dentro de la aplicación. Céntrese en las áreas en las que la reducción de la complejidad reportará beneficios significativos para la mantenibilidad y la fiabilidad.
A medida que refactoriza y la complejidad ciclomática disminuye, es posible que observe que el número de casos de prueba también disminuye. Después de la refactorización, vuelva a ejecutar las pruebas (que también se han reescrito) para asegurarse de que no ha estropeado nada. A continuación, vuelva a calcular la complejidad ciclomática para asegurarse de que los cambios han reducido efectivamente la complejidad.
Al realizar análisis de complejidad ciclomática con regularidad, los equipos de desarrollo pueden gestionar de forma proactiva su base de código, asegurándose de que se mantenga limpia, comprobable y fácil de mantener. Esta práctica le ayudará a mejorar la calidad del código y, en última instancia, hará que sus procesos de desarrollo sean más eficientes.
¿Qué herramientas y software existen para la complejidad ciclomática?
Identificar y tratar las áreas de código con alta complejidad ciclomática es crucial para mantener un software de alta calidad y fácil de mantener. Existen muchas herramientas y soluciones de software que ayudan a los desarrolladores a evaluar y supervisar esta complejidad.
- SonarQube Server es una herramienta integral de calidad del código que se integra directamente en su flujo de trabajo de desarrollo. Proporciona informes detallados sobre la complejidad ciclomática, entre otras métricas de software. SonarQube Server ayuda a identificar el código complejo que podría necesitar refactorización y es compatible con más de 30 lenguajes de programación (incluidos Java, Python y Go) y marcos de trabajo.
- SonarQube Cloud es un servicio basado en la nube que proporciona revisión automatizada del código para el análisis de la complejidad. Esto resulta especialmente útil para la integración continua/implementación continua (CI/CD) y el entorno de la plataforma DevOps, ya que ofrece información en tiempo real sobre los cambios en el código y su impacto en la complejidad.
- SonarQube for IDE es un complemento IDE que proporciona información al instante a los desarrolladores mientras escriben código, lo que les ayuda a mantener una baja complejidad desde el principio. Se puede utilizar en IDE populares como Visual Studio, Eclipse e IntelliJ IDEA.
Estas herramientas proporcionan información valiosa sobre la complejidad del código, lo que ayuda a los equipos a tomar decisiones informadas sobre dónde centrar sus esfuerzos de refactorización para mejorar la mantenibilidad y simplificar la depuración.
Conclusión
Comprender y gestionar la complejidad ciclomática es importante si se desea desarrollar software limpio y de alta calidad. Esta métrica sirve de guía a los desarrolladores para identificar áreas que pueden ser propensas a errores o difíciles de mantener. Mediante la medición y el análisis regulares de la complejidad ciclomática, se puede garantizar que el código sea eficiente y fácil de mantener.
Para empezar a utilizar herramientas que le ayudarán a mantener baja la complejidad ciclomática y alta la calidad del software, utilice las herramientas de SonarSource de forma gratuita hoy mismo.