Complexidade Ciclomática

Funções devem fazer uma coisa apenas. Fazê-la bem. Fazer somente ela. — Uncle Bob

A primeira regra de funções é que elas devem ser pequenas. — Uncle Bob

A segunda regra de funções é que elas devem ser ainda menores. — Uncle Bob

A complexidade ciclomática é uma métrica utilizada para mensurar a complexidade de um determinado módulo — uma classe, um método — a partir da contagem dos caminhos possíveis que ele pode executar. Através dela conseguimos nortear uma das questões mais intrigantes do desenvolvimento de software: como modularizar um software para que ele seja testável e fácil de manter?

def auth():
    if user.isValid():
        return True
    else:
        showMessage("Invalid credentials")
        return False

Devemos sempre manter o número de caminhos o menor possível, pois quanto menor o número de caminhos mais fácil fica entender o código. Na prática a função auth() possui complexidade 2 e isso quer dizer que precisamos escrever pelo menos 2 testes unitários para cobrir todos os possíveis caminhos. Para calcular basta contar as instruções do método (if, for, while, case, catch, and, or), além disso, todo método já tem pelo menos um caminho, sendo assim seu contador já inicializa com 1.

+--------------+------------------------------------------------+
| Complexidade |                   Avaliação                    |
+--------------+------------------------------------------------+
| 1-10         | Método simples. Baixo risco.                   |
| 11-20        | Método razoavelmente complexo. Moderado risco. |
| 21-50        | Método muito complexo. Elevado risco.          |
| 51-N         | Método de altíssimo risco e bastante instável. |
+--------------+------------------------------------------------+

Não é obrigatório, mas, o ideal para um método é algo em torno de complexidade 10.

Bad Fix

Outra métrica tirada a partir da complexidade ciclomática é a probalidade de alguma correção/alteração injetar novos bugs. O pessoal da Aivosto, desenvolveu a seguinte tabela:

+----------------+-----------+
|       CC       | “bad fix” |
+----------------+-----------+
| 1-10           | 5%        |
| 20-30          | 20%       |
| >50            | 40%       |
| próximo de 100 | 60%       |
+----------------+-----------+

Conclusão

Sempre que possível, a menos que seja um código trivial, é bom pensar sobre o assunto e analisar o código em busca de simplificação. Um bom começo são os artigos de refactoring do Martin Fowler.

[1] A Complexity Measure

[2] Complexity Metrics