Cluster de erros no código fonte

8

Existem muitas alegações sobre a existência de grupos de bugs ou defeitos. Uma pesquisa simples revela vários resultados, por exemplo: 1 , 2 , 3 , 4 , 5 .

No entanto, todas as evidências citadas são anedóticas e não foi possível encontrar dados concretos para sustentar isso. Embora minha própria experiência não contradiga essas afirmações, as pessoas adoram ver padrões mesmo quando não existem (mesmo uma distribuição uniforme de bugs produzirá agrupamentos, e talvez seja mais fácil lembrar quando você precisar corrigir 10 bugs em um local em vez de 10 coisas não relacionadas em toda a base de código).

Estou genuinamente curioso se esse fenômeno realmente existe, mas não consegui encontrar nenhuma fonte objetiva ou mesmo semi-objetiva (como em teste, experimento, estudo etc.) que mostraria que o agrupamento de defeitos realmente acontece.

Obviamente, estou bem em assumir a hipótese de agrupamento de erros como boa prática (mesmo que seja falsa, não vai doer muito). Por outro lado, dados concretos podem esclarecer por que isso acontece. É por causa daqueles dias que se tem uma dor de cabeça terrível (por qualquer motivo)? Ou talvez porque algumas partes do código sejam difíceis e outras fáceis? Ou talvez seja o lugar de responsabilidade desses dois engenheiros que não se gostam?

Minha pergunta: O efeito de agrupamento de defeitos realmente existe? Existem dados concretos não-anedóticos que são melhor explicados por essa hipótese?

testing debugging maintenance engineering dtldarek
fonte
O motivo é que um bug pode gerar outros erros, isso acontece porque o código está interligado; portanto, enquanto o testador se sente bem ao encontrar muitos erros, às vezes eles não sabem que o programador só precisa corrigir esse erro e deixar todo o resto desaparecido.
kirie
Concordo com a @kirie aqui, que um erro em uma parte da funcionalidade geralmente tem um efeito cascata em outras partes da funcionalidade. O testador pode pensar que são erros distintos, mas na verdade são todos originários do único problema. Além disso, os seres humanos são bem projetados para encontrar padrões, e é por isso que fazemos isso em tudo.
Marshall Tigerus
Muito raramente, tenho um erro que pode sobrescrever uma informação aleatória em qualquer lugar. Com esse tipo de bug no código fonte, o software pode se comportar mal em bilhões de maneiras possíveis.
gnasher729
2
Eu acho que essa é uma pergunta válida e não gostaria de vê-la encerrada, pois o OP solicitou especificamente "dados concretos não anedóticos". No entanto, as respostas dadas até agora não estão fornecendo isso. Prefiro vê-lo protegido e respostas sem links para pesquisas votadas abaixo.
mattnz
@ gnasher729 Não sei que informação de substituição você mencionou, mas isso é comum quando você usa o princípio DRY no estágio inicial, quando muitas funções ainda não foram totalmente testadas, mas já foram usadas muitas vezes.
kirie

Respostas:

3

Não tenho dados em mãos, mas tenho certeza de que a hipótese de agrupamento é verdadeira. Meu palpite é que esses dois casos ocorrem com mais ou menos frequência:

  • um pedaço de código ou algoritmo é complexo (talvez a implementação seja mais complexa do que o necessário) e o programador original não entendeu completamente o que seu código poderia fazer devido à complexidade.

  • o código não foi testado bem

E - é claro - uma combinação de ambos. Testar é difícil, mas testar código complexo é muito mais difícil por uma ordem de magnitude. E com a complexidade crescente, especialmente quando o código não é bem testado, na minha experiência, o número de possíveis bugs em um trecho de código aumenta desproporcionalmente alto.

Portanto, se você encontrar vários erros em um determinado trecho de código, provavelmente é um trecho de código complexo e mal testado, o que oferece uma grande chance de encontrar mais deles na mesma área.

Doc Brown
fonte
2

Estudos formais como esse raramente existem no desenvolvimento de software, provavelmente porque a programação (apesar de sua associação com as máquinas) é primariamente um empreendimento humano, não um empreendimento de máquinas.

Ontem eu estava corrigindo um bug em uma instrução SQL que envolvia duas instruções SELECT e uma UNION. Os dois SELECTs estavam retornando o mesmo resultado devido a um erro simples em um JOIN. Corrigir o problema, no entanto, descobriu outro bug que estava sendo mascarado pelo primeiro.

Robert Harvey
fonte
2

Em minha experiência:

O armazenamento em cluster ocorre quando o trabalho é interrompido. Digamos que alguém seja retirado do projeto para que seu trabalho não seja totalmente testado, ou talvez até concluído, e / ou os resultados não sejam totalmente compreendidos.

O armazenamento em cluster também ocorre devido ao problema do "programador ruim". Digamos que 5 pessoas trabalhem em alguma coisa e uma delas esteja abaixo do padrão. Os erros serão associados ao seu trabalho.

O Princípio de Pareto se aplica (também conhecida como regra 80/20). Aproximadamente 80% dos efeitos vêm de 20% das causas. https://en.wikipedia.org/wiki/Pareto_principle Observe que esta observação data de antes dos computadores.

Matéria escura
fonte
0

Não há paradoxo no agrupamento de bugs. E nossos preconceitos cognitivos acendem a chama.

De acordo com a distribuição normal em um determinado momento, algumas partes da base de código são significativamente mais problemáticas do que outras. Qualquer novo bug é mais provável de ser encontrado na parte do buggy.
Portanto, o que você está prestes a corrigir já está condenado a uma boa chance de ter uma empresa.

É o mesmo que "infortúnios nunca vêm sozinhos".

Vlad
fonte
1
Não tenho certeza de que a distribuição normal nos permita fazer uma inferência como você está sugerindo. Suponho que estamos analisando a densidade de defeitos por unidade de código. Para qualquer distribuição de probabilidade não uniforme, podemos ver que algumas unidades terão mais problemas do que outras. Para distribuições simétricas como a distribuição normal, exatamente metade de todos os módulos terá densidade de defeitos acima da média! Obviamente, isso é consequência de assumir um risco constante de bugs em todas as unidades - mas não é o oposto do que essa pergunta trata: os bugs geram mais bugs? Talvez eu tenha entendido mal esta resposta.
amon
"exatamente metade de ..." sim, mas não tem valor no contexto atual. Desculpe, eu não entendi você Amon. Eu não concordo com a frase exata "erros geram mais erros". Meu argumento é que um bug encontrado é [com probabilidade que não podemos ignorar] destinado a estar entre outros.
Vlad