Esse artigo faz parte da revista .NET Magazine edição 52. Clique aqui para ler todos os artigos desta edição

plexidade do seu código

Encontre problemas e calcule a complexidade no seu sistema

 

Quantas vezes você se deparou com a seguinte situação : seu gerente comunica que você será o responsável por manter um novo sistema desenvolvido por alguém que você nunca ouviu falar (que provavelmente já saiu da empresa), em uma linguagem que pode não ser a sua especialidade, e que provavelmente em breve você terá que fazer adaptações no mesmo para que se adeque às novas necessidades da empresa ? Para piorar, você deverá ser capaz de entender, explicar e testar cada parte do sistema.

Como identificar os pontos críticos do código do novo sistema ? Será que o sistema é realmente complexo ou está mal escrito? Será que as suas alterações irão piorar ainda mais as coisas?

Também podemos imaginar um outro cenário: você está no meio do desenvolvimento de uma nova aplicação e gostaria de “medir” o código que está sendo gerado, para que você seja capaz de indentificar pontos que poderão ser problemáticos para manter no futuro. Ou seja, você gostaria de identificar pontos onde você já poderia estar aplicando técnicas de refactoring.

Acho que essas são situações comuns no dia-a-dia do desenvolvedor, ou seja, lidar com questões de complexidade de código. Será que o código é realmente complexo ou será que eu é que sou o problema? Como justificar ou explicar isso para meu gerente?

Complexidade é um tema que pode ser extremamente subjetivo, pois depende do problema em si e de quem está por resolvê-lo.  Algo complexo pode ser definido como: “Difícil de separar, analisar ou resolver” (webster.com). Trazendo para a área de desenvolvimento, podemos dizer que complexidade é o “esforço necessário para entender e modificar o código corretamente”.

A idéia deste artigo é apresentar algumas maneiras simples de medir a complexidade de código, através de ferramentas que implementam métricas conhecidas. Não nos aprofundaremos em questões de design ou em discussões filosóficas. O intuito é apresentar meios realmente simples e intuitivos de medir a complexidade e, se utilizado durante o ciclo de desenvolvimento, mostrar como isso pode trazer benefícios para garantir a manutenabilidade do código.

 

Mas como medir a complexidade do código?

Para medir a complexidade usaremos as chamadas métricas estáticas, que são métricas baseadas no código-fonte da aplicação. Essas métricas podem ser tanto relacionadas à formatação (identação, espaços em branco, padrão de nomenclatura etc.) quanto relacionadas à lógica, como por exemplo o número de caminhos diferentes dentro de um método, número de condições e blocos, nível de parametrização etc. Neste artigo focaremos nas métricas de lógica.

Com a finalidade de ilustrar a utilização dessas métricas, utilizaremos a ferramenta Studio Tools, que pode ser baixada gratuitamente em  http://www.exactmagic.com/products/studiotools/index.html.  O Studio Tools é um Add-in para o VS.NET 2005 ou 2008, ou seja, você deverá primeiro instalá-lo na sua máquina e então configurar o VS.NET para utilizá-lo. Para isso, depois de instalado o Add-in, vá até o menu Tools>Add-in Manager, como mostrado na Figura 1.

 

Figura 1. Adicionando o StudioTools

Selecione o “Studio Tools Metrics” e deixe marcado para que ele seja carregado automaticamente na abertura do VS.NET, como mostrado na figura 2.

 

Figura 2. Ativando o Studio Tools para abrir com o VS

O Studio Tools implementa métricas conhecidas e falaremos sobre algumas delas a seguir. Ele aplica estas métricas sobre o código compilado e apresenta o resultado em uma janela como na Figura 3.  Nesta janela podemos visualizar e ordenar o resultado da análise do código como um todo, o que é muito legal, pois permite identificar facilmente quais são os piores métodos de uma solução inteira, ou podemos agrupar os resultados por assembly, namespace ou tipo (classe).

 

Figura 3. Métricas geradas pelo Add-In StudioTools

 

Complexity

Esta métrica (Cyclomatic Complexity) foi introduzida por Thomas McCabe em 1976 e é uma métrica que mede a complexidade lógica e é bastante usada. Ela mede o número de caminhos independentes dentro do código e de forma simplificada,  ela é calculada através da contagem do número de pontos de decisão (blocos de if, switch¸ do, while, for loops). Basicamente, a idéia por trás desta métrica é que o código que possui muitos pontos de decisão ou muitas saídas, é mais difícil de entender ou manter.

Cyclomatic complexity é também útil para determinar a testabilidade do código. Quanto maior o valor, maior a dificuldade e risco relacionado ao teste do código. Esta métrica é uma boa indicação do número de testes unitários necessários para testar o código. Alguns valores padrão para esta métrica são mostrados na Tabela 1.

 

...
Quer ler esse conteúdo completo? Tenha acesso completo