Alguém sabe se existe algum tipo de ferramenta para colocar um número em dívida técnica de uma base de código, como uma espécie de métrica de código? Caso contrário, alguém conhece um algoritmo ou conjunto de heurísticas para ele?

Se nenhuma dessas coisas existir até agora, eu estaria interessado em idéias sobre como começar com uma coisa dessas. Ou seja, como posso quantificar a dívida técnica incorrida por um método, uma classe, um espaço para nome, um assembly etc.

Estou mais interessado em analisar e avaliar uma base de código em C #, mas sinta-se à vontade para entrar em contato com outros idiomas também, principalmente se os conceitos forem transcendentes.

Dívida técnica é apenas uma idéia abstrata de que, em algum ponto da linha de projeto, construção, teste e manutenção de um sistema, foram tomadas determinadas decisões para que o produto se torne mais difícil de testar e manter. Ter mais dívida técnica significa que será mais difícil continuar desenvolvendo um sistema - você precisa lidar com a dívida técnica e alocar cada vez mais tempo para o que de outra forma seriam tarefas simples ou investir recursos (tempo e tempo). dinheiro) na redução da dívida técnica, refatorando o código, aprimorando os testes e assim por diante.

Existem várias métricas que podem fornecer algumas indicações sobre a qualidade do código:

• Cobertura de código. Existem várias ferramentas que informam qual porcentagem de suas funções, instruções e linhas são cobertas por testes de unidade. Você também pode mapear os testes de sistema e aceitação de volta aos requisitos para determinar a porcentagem de requisitos cobertos por um teste no nível do sistema. A cobertura apropriada depende da natureza do aplicativo.
• Acoplamento e coesão . Código que exibe baixo acoplamento e alta coesão é geralmente mais fácil de ler, entender e testar. Existem ferramentas de análise de código que podem relatar a quantidade de acoplamento e coesão em um determinado sistema.
• Complexidade ciclomática é o número de caminhos exclusivos através de um aplicativo. Geralmente é contado no nível do método / função. A complexidade ciclomática está relacionada à compreensibilidade e testabilidade de um módulo. Não apenas os valores de complexidade ciclomática mais altos indicam que alguém terá mais problemas ao seguir o código, mas a complexidade ciclomática também indica o número de casos de teste necessários para obter cobertura.
• As várias medidas de complexidade de Halstead fornecem informações sobre a legibilidade do código. Eles contam os operadores e operandos para determinar o volume, a dificuldade e o esforço. Muitas vezes, isso pode indicar o quão difícil será para alguém pegar o código e entendê-lo, geralmente em casos como uma revisão de código ou um novo desenvolvedor na base de código.
• Quantidade de código duplicado. Código duplicado pode indicar potencial para refatoração de métodos. Ter código duplicado significa que há mais linhas para a introdução de um bug e maior probabilidade de os mesmos defeitos existirem em vários locais. Se a mesma lógica comercial existir em vários locais, fica mais difícil atualizar o sistema para levar em conta as alterações.

Muitas vezes, as ferramentas de análise estática poderão alertá-lo sobre possíveis problemas. Obviamente, apenas porque uma ferramenta indica um problema não significa que há um problema - é preciso julgamento humano para determinar se algo pode ser problemático no futuro. Essas métricas apenas fornecem avisos de que talvez seja hora de examinar um sistema ou módulo mais de perto.

No entanto, esses atributos se concentram no código. Eles não indicam prontamente qualquer dívida técnica na arquitetura ou no design do sistema que possa estar relacionada a vários atributos de qualidade.

O sonar possui uma heurística de dívida técnica, além de vários outros recursos úteis para um projeto de software.

Ele também suporta uma ampla variedade de idiomas.

O SonarQube (anteriormente Sonar ) é uma plataforma de código aberto para Inspeção Contínua da qualidade do código ...

• Suporta mais de 25 idiomas: Java, C / C ++, C #, PHP, Flex, Groovy, JavaScript, Python, PL / SQL, COBOL, etc.
• O SonarQube também é usado no Android Deveopment.
• Oferece relatórios sobre código duplicado, padrões de codificação, testes de unidade, cobertura de código, código complexo, possíveis bugs, comentários e design e arquitetura.
• Máquina do tempo e vistas diferenciais.
• Análises totalmente automatizadas: integram-se às ferramentas Maven, Ant, Gradle e de integração contínua (Atlassian Bamboo, Jenkins, Hudson, etc.).
• Integra-se ao ambiente de desenvolvimento Eclipse
• Integra-se com ferramentas externas: JIRA, Mantis, LDAP, Fortify, etc.
• Expansível com o uso de plugins.
• Implementa a metodologia SQALE para calcular dívida técnica ...

Eu odeio usar uma analogia das finanças, mas parece realmente apropriado. Quando você está precificando algo (ativos de qualquer tipo), ele pode ter valor intrínseco e extrínseco. Nesse caso, o código existente tem valor intrínseco que seria uma quantidade correspondente à qualidade relativa do referido código e também teria valor extrínseco (valor do que poderia ser feito com o código) e essas quantidades seriam aditivas. O valor intrínseco pode ser dividido em créditos e débitos (bom versus ruim) usando qualquer metodologia que você esteja usando para pontuar o código (+5 para comentários / legibilidade, -10 para cobertura de código etc.)

Certamente não conheço nenhuma ferramenta que quantifique isso hoje e acho que você teria uma discussão inteiramente nova em suas mãos se argumentar sobre o mérito de diferentes estratégias de "avaliação da dívida", mas eu concordo com Matthew - a dívida é a custo cumulativo de obter o código da melhor maneira possível, usando qualquer método usado para custar as horas de trabalho necessárias para chegar lá.

Outra coisa a considerar é que certamente existe uma medida de custo-benefício em que, à medida que nos aproximamos da "perfeição", o valor de uma hora gasta na base de código está mais do que provavelmente diminuindo exponencialmente, de modo que provavelmente há um problema adicional de otimização. maximizar a utilidade do trabalho realizado.

Entre os desenvolvedores, uma medida razoavelmente confiável da dívida técnica parece ser WTFs / minuto .

_{O problema com essa "métrica" ​​é que normalmente é bastante difícil se comunicar "fora".}

A métrica que funcionou para mim na comunicação da dívida técnica para "pessoas de fora" foi a quantidade de esforço de teste e correção de bugs (especialmente para corrigir bugs de regressão ) necessários para uma entrega bem-sucedida.

Uma palavra de cautela: embora essa abordagem seja bastante poderosa, é melhor verificar novamente com bons WTFs antigos / minuto antes de recorrer a ela. O fato é que é bastante complicado: para obter os dados, é preciso rastrear cuidadosamente o tempo e registrá-lo com precisão pelas categorias apropriadas.

• é muito mais fácil declarar 3 semanas no total gasto na implementação do recurso A do que
   
  eu passei 14 horas no rascunho da implementação do recurso A, depois 29 horas no teste de fumaça e 11 horas na implementação de correções para regressões que descobri, depois de 18 horas testando o controle de qualidade implementação de recursos já. Depois disso, os funcionários do controle de qualidade passaram 17 horas testando o release inicial do candidato. Depois disso, passei 13 horas analisando os bugs enviados pelo controle de qualidade para a liberação inicial do candidato e 3 horas implementando as correções. Depois disso, passei 11 horas testando as alterações que fiz na liberação inicial do candidato. Depois disso...

De qualquer forma, os dados sobre o esforço de teste e correção de bugs foram bastante fáceis de se comunicar na minha experiência.

Para uma versão recente, gastamos cerca de 90% do tempo testando e corrigindo erros de regressão. Para a próxima versão, sugira alocar algum esforço para reduzir esse valor para 60-70%.

Outra palavra de cautela. Dados como 90% acima podem ser interpretados não apenas como uma indicação de dívida técnica, mas também (surpresa surpresa) como uma indicação de que alguém não é muito proficiente em programação / tecnologia específica. "Você apenas comete muitos erros no seu código".

Se houver o risco de os dados serem mal interpretados dessa maneira, ajudará a ter dados de referência adicionais sobre algo menos propenso a WTF para comparação.

• Digamos que, se houver dois componentes / aplicativos semelhantes mantidos pelo (s) mesmo (s) desenvolvedor (es), lançando primeiro a uma "taxa de desperdício" em cerca de 50% e depois em 80-90, isso é um argumento bastante forte a favor de o segundo ser objeto de dívida técnica.

Se houver testadores dedicados no projeto, eles também poderão contribuir para uma avaliação mais objetiva dos dados. Como mencionei em outra resposta ,

Com os testadores, você recebe alguém para fazer backup de sua compreensão dos problemas de design. Quando há apenas desenvolvedores reclamando da qualidade do código , isso geralmente soa como WTFs subjetivos por trás da porta fechada .
 
Mas quando isso é repetido pelo cara do controle de qualidade dizendo que algo como component A100 bugs de regressão para 10 novos recursos, em vez de component B10 bugs de regressão para 20 novos recursos , a comunicação de repente se transforma em outro jogo.

Acho que a pergunta é quanto custaria "recomprar" sua dívida técnica - ou seja, quanto trabalho é necessário para corrigi-la? Bem, cabe à equipe descobrir isso.

Durante o planejamento do sprint, peço à equipe que estime a complexidade de corrigir itens de dívida técnica da mesma maneira que estimaria a complexidade de uma história de usuário. Nesse ponto, é um jogo de negociação entre a equipe e o proprietário do produto para determinar qual dívida técnica é alta o suficiente para ser feita no sprint atual (substituindo as histórias reais do usuário) e o que pode esperar.

Se você não está fazendo scrum, eu me ateria à minha premissa - a dívida técnica deve ser medida pelo custo do remédio.

Existe uma plataforma bastante forte chamada CASTprocurar dívida técnica em grandes aplicações. Nós o usamos em um projeto em que assumimos uma grande melhoria em um sistema legado. Ele não informa o que estava na cabeça das pessoas que escreveram o código, mas examina o código e encontra falhas de código e arquitetura, depois quantifica a dívida técnica, se você quiser. O uso real de analisar isso, no entanto, não é o valor de $, mas a lista de problemas já existentes no código. Isso informa sobre uma parte da dívida técnica que você possui (então eu discordo de algumas das respostas acima). Existe alguma dívida técnica puramente baseada em design e muito subjetiva - como a pornografia - você a conhece quando a vê e conhece o contexto. Eu argumentaria se isso é realmente uma dívida "técnica". Existe alguma dívida técnica puramente na implementação e acredito que '

Aqui está um seminário on-line do MIT que descreve a pesquisa sobre dívida técnica em grandes sistemas de software: http://sdm.mit.edu/news/news_articles/webinar_050613/sturtevant-webinar-technical-debt.html

Os autores escreveram código para analisar um projeto e extrair métricas de 'complexidade arquitetônica'. Essas métricas mostraram ter um forte relacionamento com a densidade de defeitos, a produtividade do desenvolvedor e a rotatividade da equipe de desenvolvimento.

O trabalho descrito no Webinar baseia-se na pesquisa de modularidade realizada por Alan MacCormack e Carliss Baldwin na Harvard Business School. Gostaria de olhar para os papéis deles também. O 'custo de propagação' deles pode ser o que você está procurando.

Eu diria que as métricas de código padrão podem ser usadas como uma visão relativa de alto nível do endividamento técnico. O VS Ultimate inclui um analisador de código que fornece um "Índice de Manutenção" com base na complexidade ciclomática, acoplamento, LoC e profundidade de herança. Você pode mergulhar em qualquer ponto problemático e ver detalhes (até o nível da função). Acabei de executá-lo no meu projeto e as pontuações mais baixas que obtivemos foram 69 em nosso pacote de dados (configurando e inicializando o EF) e em nosso conjunto de testes. Todo o resto tinha 90 anos ou mais. Existem outras ferramentas que fornecerão mais métricas, como as discutidas no PPP do tio Bob.

Eu não pensaria em dívida técnica como dólares, onde você precisa de um modelo sofisticado para quantificá-la. Eu pensaria nisso como favores. Se alguém lhe faz um favor e é provável que você esqueça, anote. Quando você toma um atalho, anote-o. Isso ajuda você a se lembrar, e mais impotentes o obrigam a reconhecê-lo. Nenhuma ferramenta sofisticada é necessária. O bloco de notas ou Ecxel podem fazer o truque.

Eu trabalho para uma empresa que está investigando exatamente isso. Abaixo estão três métricas acionáveis ​​que recomendamos analisar ao lidar com dívidas técnicas. Para mais informações sobre "como" e "quando" para rastreá-los, reunimos um artigo de resumo 3 Métricas para Entender e Combater a Dívida Técnica .

Quais são seus pensamentos? Fico feliz em responder a quaisquer perguntas e com fome de ouvir o seu feedback :).

Propriedade para evitar defeitos e dívida tecnológica indesejada

A propriedade é um indicador importante da saúde da engenharia.

As partes da base de código que recebem contribuições de muitas pessoas acumulam lixo ao longo do tempo, enquanto as que recebem contribuições de menos pessoas tendem a estar em um estado melhor. É mais fácil manter altos padrões em um grupo restrito e bem informado sobre sua parte da base de código.

Isso fornece algum poder preditivo: partes fracas da base de código provavelmente acumularão dívidas ao longo do tempo e se tornarão cada vez mais difíceis de trabalhar. Em particular, é provável que a dívida seja assumida involuntariamente , simplesmente como efeito colateral de informações incompletas e propriedade diluída da qualidade do código.

Isso é um tanto análogo à tragédia dos bens comuns .

Coesão para melhorar a arquitetura

A coesão é um indicador final de componentes bem definidos.

A coesão e sua contraparte, o acoplamento, são há muito reconhecidas como conceitos importantes a serem focados ao projetar software.

Diz-se que o código tem alta coesão quando a maioria de seus elementos se une. A alta coesão é geralmente preferível porque está associada à capacidade de manutenção, reutilização e robustez. Coesão alta e acoplamento frouxo tendem a andar de mãos dadas.

Além de ser associada a um código mais reutilizável e sustentável, a alta coesão também minimiza o número de pessoas que precisam se envolver para modificar uma determinada parte da base de código que aumenta a produtividade.

Rotação para identificar áreas problemáticas

A rotatividade (atividade repetida) ajuda a identificar e classificar áreas prontas para refatoração em um sistema crescente.

À medida que os sistemas crescem, fica mais difícil para os desenvolvedores entender sua arquitetura. Se os desenvolvedores tiverem que modificar muitas partes da base de código para fornecer um novo recurso, será difícil para eles evitar a introdução de efeitos colaterais que causam bugs, e serão menos produtivos porque precisam se familiarizar com mais elementos e conceitos.

É por isso que é importante lutar pela responsabilidade única de criar um sistema mais estável e evitar consequências não intencionais. Enquanto alguns arquivos são hubs de arquitetura e permanecem ativos à medida que novos recursos são adicionados, é uma boa idéia escrever código de maneira a fechar os arquivos e revisar rigorosamente, testar e controlar as áreas de agitação de controle de qualidade.

O Churn apresenta esses arquivos ativos para que você possa decidir se eles devem ser divididos para reduzir a área de mudança da superfície da sua base de código.

Se você tem um bom histórico através de um rastreador de bugs ou algum tipo de software ágil, pode mantê-lo simples. Tempo gasto na conclusão de tarefas básicas. Além disso, confiabilidade das estimativas quando o projeto era jovem versus agora.