Quais são as métricas úteis para capturar para o código-fonte?
Como as métricas, como por exemplo, linhas de código (executáveis) ou complexidade ciclomática, ajudam na garantia da qualidade ou como elas são benéficas em geral para o processo de desenvolvimento de software?
code-quality
metrics
cschol
fonte
fonte
Respostas:
"Medir a produtividade do software por linhas de código é como medir o progresso em um avião, quanto pesa." - Bill Gates
fonte
Dê uma olhada nas postagens de Jeff sobre o assunto:
Uma visita da Metrics Maid
Engenharia de software: morta?
Também existe uma publicação antiga, mas boa, de Joel, intimamente relacionada às métricas de software, e eu recomendo fortemente a sua leitura: The Econ 101 Management Method
O ponto chave, para mim, é esse, citando Jeff: "O uso responsável das métricas é tão importante quanto coletá-las em primeiro lugar".
fonte
O que me confunde sobre as métricas de código é que isso não é feito mais. A maioria das empresas informa sobre a eficiência de seus funcionários, fornecedores e sistemas, mas ninguém parece querer informar sobre código. Definitivamente, concordo com as respostas que afirmam que mais linhas de código são uma responsabilidade, mas o que seu código faz é mais importante.
Linhas de Código: Como mencionei, essa é uma medida vital e deve ser levada mais a sério, mas em cada nível. Funções, classes, arquivos e interfaces podem indicar código de fazer tudo que é difícil de manter e caro a longo prazo. É infinitamente difícil comparar o total de linhas de código versus o que um sistema faz. Pode ser algo que faz muitas coisas e, nesse caso, haverá muitas linhas de código!
Complexidade: É bom fazer essa medição em bases de código nas quais você não trabalhou e pode fornecer uma boa indicação de onde estão as áreas problemáticas. Como uma anedota útil, medi a complexidade em uma de minhas próprias bases de código, e a área de maior complexidade era a que eu passava mais tempo quando precisava alterá-la. Trabalhar para reduzir a complexidade resultou em uma redução maciça no tempo de manutenção. Se o gerenciamento tivesse essas medidas em mãos, ele poderia planejar a refatoração de iterações ou o redesenho de áreas específicas de um sistema.
Duplicação de código: Esta é uma medida muito importante para mim. A duplicação de código é um sinal muito ruim e pode apontar problemas profundos em níveis baixos do design de um sistema ou desenvolvedores que são coladores de cópias, causando grandes problemas a longo prazo e sistemas que são inatingíveis.
Gráficos de dependência Encontrar dependências ruins e dependências circulares são uma medida importante no código. Isso quase sempre aponta para um design de alto nível incorreto que precisa ser revisado. Às vezes, uma dependência pode absorver muitas outras desnecessárias, porque alguém está usando addNumber em uma biblioteca de email para fazer seus cálculos financeiros. Todos ficam chocados quando a biblioteca de email é alterada e o financiamento é interrompido. Se tudo depende de uma coisa, também pode apontar bibliotecas que fazem tudo que são difíceis de manter e mal projetadas.
Uma boa medida sempre indica que todos os recursos de um sistema têm uma pequena área ocupada. Menos dependências, menos complexidades, menos duplicação. Isso aponta para um acoplamento fraco e alta coesão.
fonte
Essa "métrica do código fonte" não será uma porcaria?
SLOC (Raw Source Lines of Code) é a métrica mais antiga, mais fácil e mais básica que existe.
Halstead originalmente propôs um monte de métricas. Muitas pessoas estavam se divertindo muito com programas de medição de escrita até que algum esporte estragado fizesse o estudo óbvio, e demonstraram que cada uma das métricas de Halstead estava fortemente correlacionada diretamente com o SLOC.
Nesse ponto, as métricas de Halstead foram abandonadas, porque o SLOC é sempre mais fácil de medir.
fonte
As métricas de código-fonte para garantia de qualidade visam dois objetivos:
Ambos levam a escrever código da maneira mais simples possível. Isso significa:
fonte
Que eu saiba, o número de bugs encontrados está diretamente relacionado às linhas de código (provavelmente rotatividade), linguagem do módulo, programador e domínio.
Não conheço nenhuma outra métrica direta e prática bem correlacionada com bugs.
Uma coisa que eu gostaria de fazer é começar a executar os números para diferentes projetos em que estou participando - Test Coverage :: kLOC e discutir a "qualidade percebida" para ver se há uma correlação.
fonte
As métricas são úteis apenas se você souber o que fazer com as respostas recebidas. Em essência, uma métrica de software é como um termômetro. O fato de você medir algo a 98,6 ° F não significa nada até você saber qual é a temperatura normal . A temperatura acima é boa para a temperatura corporal, mas muito ruim para sorvete.
Métricas comuns que podem ser úteis são:
As duas primeiras medidas avaliam as tendências. Você encontra bugs mais rapidamente do que pode corrigi-los? Dois resultados possíveis: talvez precisemos de mais recursos para consertar bugs, talvez precisemos parar de implementar novos recursos até o alcançarmos. Os dois segundos fornecem uma imagem de quão perto você está de ser feito. As equipes ágeis chamam de gráfico de "queima".
Complexidade ciclomática é uma métrica interessante. No conceito básico, é o número de caminhos de execução exclusivos em uma função / método. Em um ambiente pesado de teste de unidade, isso corresponde ao número de testes necessários para verificar todos os caminhos de execução. No entanto, apenas porque você tem um método que tem uma complexidade ciclomática de 96 não significa que seja necessariamente um código de buggy - ou que você precisa escrever 96 testes para fornecer confiança razoável. Não é incomum o código gerado (por meio de geradores WPF ou analisador) criar algo tão complexo. Ele pode fornecer uma idéia aproximada do nível de esforço necessário para depurar um método.
Bottom Line
Toda medida que você faz precisa ter o seguinte definido ou é inútil:
As métricas que você utiliza podem variar bastante de projeto para projeto. Você pode ter algumas métricas usadas em projetos, mas a definição de "normal" será diferente. Por exemplo, se um projeto descobriu uma média de 5 erros / semana e o novo projeto descobriu 10 erros / semana, isso não significa necessariamente que algo está errado. Pode ser que a equipe de teste seja mais meticulosa desta vez. Além disso, a definição de "normal" pode mudar ao longo da vida do projeto.
A métrica é apenas um termômetro, o que você faz com ela depende de você.
fonte
O código fonte é um passivo, não um ativo. Com isso em mente, medir linhas de código é análogo ao rastreamento de dólares gastos durante a construção de uma casa. Isso precisa ser feito se você quiser ficar abaixo do orçamento, mas não necessariamente pensaria que gastar US $ 1.000 por dia é melhor do que gastar US $ 50 por dia; você gostaria de saber quanto da casa foi construída para esse dinheiro. É o mesmo com as linhas de código em um projeto de software.
Em resumo, não há métricas úteis para o código-fonte, porque a medição do código-fonte por si só não é útil.
fonte
Como o código fonte é simplesmente uma combinação de sequência, seleção e repetição. Se eu descrevesse o software mais ideal que poderíamos esperar razoavelmente produzir, seria o seguinte. Software com quase 100% de cobertura de código de teste usando a menor quantidade de linhas de código necessária para realizar o trabalho e, no entanto, flexível o suficiente para suportar alterações.
fonte
Uma anedota para mostrar por que as contagens do KLOC são inúteis (e até prejudiciais) para medir o desempenho.
Anos atrás, trabalhei em um grande projeto (mais de 70 pessoas em nossa empresa, outras 30 em nosso cliente) que usavam as contagens da KLOC como a única medida de desempenho de equipes e indivíduos.
Para o nosso esforço do ano 2000 (informa há quanto tempo :): fizemos uma grande limpeza da seção do código pela qual minha equipe era responsável. Terminamos o lançamento escrevendo cerca de 30.000 linhas de código, não três meses ruins de trabalho para 5 pessoas. Também acabamos descartando outras 70.000 linhas de código, um trabalho muito bom por 3 meses de trabalho, especialmente combinado com o novo código.
Resultado final do trimestre: -40.000 linhas de código. Durante a análise de desempenho após o trimestre, recebemos uma repreensão oficial da empresa por não atender às nossas exigências de produtividade de 20.000 linhas de código produzidas por trimestre (afinal, as ferramentas mostraram que produzimos -40.000 linhas de código), o que resultaria em todos nós listados como de baixo desempenho e ignorados em promoções, treinamento, aumento de salário etc. etc., se o gerente de projeto e a equipe de controle de qualidade não tivessem intervindo e conseguido a reprimenda revertida e substituída por uma recomendação.
Alguns meses depois (essas coisas levam tempo), fomos informados de que a empresa estava revisando seus padrões de produtividade e contratamos uma equipe de especialistas para criar um novo sistema baseado na análise de pontos de função.
fonte
Estou surpreso que ninguém tenha mencionado os testes de declaração / decisão de cobertura de unidade (porcentagem de código exercido por testes de unidade) ainda.
A cobertura do código é útil, pois você sabe qual porcentagem do aplicativo não falha catastrofricamente; com o restante de sua utilidade depende da qualidade dos testes de unidade.
fonte
Quanto menor o commit, melhor, geralmente. Trata-se de ferramentas de SCM, não de código em si, mas é uma métrica muito mensurável. Quanto menor o commit, mais fácil é ver cada alteração como uma unidade atômica; mais fácil é reverter mudanças específicas e identificar quando as coisas quebraram.
Contanto que nenhum commit interrompa a compilação ...
fonte
Essas não são métricas absolutas muito úteis em termos de progresso, mas podem ser usadas para fornecer uma idéia geral do estado do código.
Consideravelmente a Complexidade Ciclomática Eu descobri que é útil em termos de visualização da modularidade de uma determinada base de código. Você geralmente deseja uma baixa complexidade, pois isso significa que o número de fontes por módulo é baixo e há muitos módulos.
fonte
Costumo trabalhar em um pacote C ++ gigante e, ao procurar um código problemático que valha a pena refatorar a Complexidade Ciclomática ou o horrível FanIn / FanOut, geralmente são boas bandeiras vermelhas para procurar. A correção de problemas normalmente leva a melhorias em toda a base de código.
É claro que esses números podem servir apenas como uma dica sobre o que valeria a pena examinar. Tornar isso um limite rígido após o qual falhar uma compilação ou recusar uma consolidação seria ridículo.
fonte
Existem muitas situações no meu trabalho em que uso métricas de código:
Ao escrever o código
O maior e talvez o mais importante uso no meu trabalho diário é no Checkstyle , uma ferramenta para desenvolvedores de java que verifica continuamente as métricas (entre outras coisas) do meu código em relação a um conjunto de regras que definimos e sinaliza lugares onde meu código não cumprir essas regras. À medida que desenvolvo o código, ele informa em tempo real se meus métodos se tornam muito longos, complexos ou acoplados, o que me permite retroceder e pensar em refatorá-lo para algo melhor.
Os desenvolvedores são totalmente livres para violar todas as regras, pois nunca se aplicam a todas as situações. As "regras" existem para estimular o pensamento e dizer "Ei, essa é a melhor maneira de fazer isso?"
Durante revisões de controle de qualidade / código
A primeira coisa que geralmente faço quando faço uma revisão de código é verificar a cobertura do código que estou revisando em conjunto com uma ferramenta de cobertura de código que destaca quais linhas de código foram cobertas. Isso me dá uma idéia geral de quão completo é o código de teste. Realmente não me importo se a cobertura é de 20% ou 100%, desde que o código importante seja bem testado. Assim, a porcentagem coberta é um tanto sem sentido, mas 0% com certeza se destaca como um polegar dolorido como algo que eu quero examinar com cuidado.
Também verifico quais métricas acordadas pela equipe foram "quebradas", se houver, para ver se concordo com o desenvolvedor que estava OK ou se posso sugerir maneiras de melhorá-las. O fato de essas métricas de desenvolvimento terem sido acordadas em nossa equipe para a criação de um novo código fez com que grandes incursões na melhoria de nosso código. Escrevemos muito menos métodos monolíticos e somos muito melhores no princípio da responsabilidade única agora.
Tendências de melhorias no código herdado Temos muitos códigos herdados que gostaríamos de melhorar. As métricas a qualquer momento são bastante inúteis, mas o que é importante para nós é que, com o tempo, a cobertura do código aumenta e coisas como complexidade e acoplamento diminuem. Portanto, nossas métricas são conectadas ao servidor de Integração Contínua, permitindo que analisemos o tempo para garantir que estamos no caminho certo.
Conhecendo uma nova base de código A única vez em que utilizo linhas de métrica de código-fonte é ao olhar para uma base de código com a qual não estou familiarizado. Isso me permite avaliar rapidamente o tamanho aproximado do projeto em comparação com outros com os quais trabalhei. Usando outras métricas, também posso ter uma idéia mais aproximada da qualidade do projeto.
O principal é usar métricas como pontos de partida para tendências, discussões ou caminhos a seguir e não gerenciá-las religiosamente para números exatos. Mas acredito firmemente que eles podem ajudá-lo a melhorar o código correto quando usado corretamente.
fonte
P: Quais são as métricas úteis para capturar para o código-fonte?
Para negócios:
A: Número de horas-homem
Para o supervisor do programador:
A: Não importa. Vamos fazer tudo hoje
Para auto-estima do codificador:
A: Número de SLOC (linhas de código-fonte)
Para a mãe do codificador:
A: Coma mais desses pães franceses macios e beba chá
continuou nos comentários abaixo ...
fonte
Lembre-se: Todo o código pode ser reduzido em pelo menos 1 instrução. Todo o código possui pelo menos 1 bug. Portanto, todo o código pode ser reduzido a uma única instrução que não funciona. Espero que ajude!
fonte