Este é um material de referência sobre os Heisenbags. Estamos falando sobre como eles se parecem e como se relacionam com os mainframes - os progenitores da nuvem.
/ foto Lars Zimmermann CC BYHeisenbug (Heisenbug ou Heisenbug) é um termo que descreve erros que alteram propriedades durante a depuração de código. Ou seja, eles desaparecem durante o teste e a depuração, mas aparecem na produção.
O nome "Heisenbag" refere-se ao
princípio da incerteza de Heisenberg da mecânica quântica. Em termos gerais, pode ser descrito como uma mudança inesperada nas propriedades do objeto observado como resultado da observação.
A história
O termo Heisenbug é considerado Bruce Lindsay, um funcionário do IBM Research Center. Ele contribuiu para o desenvolvimento de bancos de dados relacionais e esteve envolvido no desenvolvimento do mecanismo de banco de dados corporativo
IBM System R.Em 1985, enquanto estudava na Universidade de Berkeley, Bruce e
Jim Gray (James Nicholas Gray), um cientista americano na teoria dos sistemas de computadores,
trabalharam no sistema CAL-TSS. Foi escrito especificamente para o mainframe de processador duplo
Control Process 6400 [
PDF , p. 3], no qual os militares processaram grandes quantidades de dados.
Obviamente, durante o processo de desenvolvimento, houve bugs. Mas vários deles eram especiais - assim que os engenheiros tentaram consertá-los, eles desapareceram. Naquela época, Lindsay estava apenas estudando física e o princípio de Heisenberg em particular. De repente, Lindsay se deu conta - ele e Gray testemunharam um fenômeno semelhante: os erros desapareceram porque a observação afetou as propriedades do objeto. A partir daqui, o nome "heisenbag" veio.
Lindsay contou essa história
em uma entrevista com representantes da
Association of Computing Engineering (ACM) em 2003.
Exemplos Heisenbug
Usuários na rede e em plataformas temáticas como o Stack Overflow compartilharam alguns exemplos de heisenbags que encontraram em seus projetos. Um dos residentes da SO tentou calcular a área da figura entre duas curvas com uma precisão de três casas decimais. Para depurar o algoritmo em C ++, ele adicionou a linha:
cout << current << endl;
Mas assim que ele comentou, o código parou de funcionar e fez um loop. O programa
foi o seguinte :
#include <iostream> #include <cmath> using namespace std; double up = 19.0 + (61.0/125.0); double down = -32.0 - (2.0/3.0); double rectangle = (up - down) * 8.0; double f(double x) { return (pow(x, 4.0)/500.0) - (pow(x, 2.0)/200.0) - 0.012; } double g(double x) { return -(pow(x, 3.0)/30.0) + (x/20.0) + (1.0/6.0); } double area_upper(double x, double step) { return (((up - f(x)) + (up - f(x + step))) * step) / 2.0; } double area_lower(double x, double step) { return (((g(x) - down) + (g(x + step) - down)) * step) / 2.0; } double area(double x, double step) { return area_upper(x, step) + area_lower(x, step); } int main() { double current = 0, last = 0, step = 1.0; do { last = current; step /= 10.0; current = 0; for(double x = 2.0; x < 10.0; x += step) current += area(x, step); current = rectangle - current; current = round(current * 1000.0) / 1000.0; //cout << current << endl; //<-- COMMENT BACK IN TO "FIX" BUG } while(current != last); cout << current << endl; return 0; }
A essência do heisenbug : quando não há impressão, o programa realiza comparações com alta precisão nos registros do processador. Além disso, a precisão do resultado excede as capacidades do dobro. Para gerar o valor, o compilador retorna o resultado dos cálculos para a memória principal - enquanto a parte fracionária é descartada. E a comparação subsequente em enquanto leva ao resultado correto. Quando uma linha é comentada, não há truncamento implícito da parte fracionária. Por esse motivo, os dois valores in sempre são desiguais entre si. Como solução para o problema, um dos participantes da discussão sugeriu o uso de uma comparação aproximada dos números de ponto flutuante.
Outra história sobre o heisenbug foi
compartilhada por engenheiros que trabalham com o ambiente de linguagem
Smalltalk-80 no Unix. Eles notaram que o sistema travava se você o deixasse ocioso por um tempo. Mas depois de mover o cursor do mouse, tudo funcionou novamente como de costume.
O problema estava com o planejador Unix, que reduzia a prioridade das tarefas que estão ociosas. Em algum momento, a prioridade foi reduzida tanto que os processos no Smalltalk não tiveram tempo para concluir. A pilha de tarefas cresceu e travou o programa. Quando o usuário moveu o cursor, o sistema operacional restaurou a prioridade e tudo voltou à estaca zero.
Outros * bugs
Existem vários termos que descrevem todos os tipos de erros: Borbag, Mandelbug, Schrödinbag.
Borbag , o oposto de Heisenbug, é um erro comum que é fácil de encontrar e corrigir. Nomeado em homenagem a Niels Bohr, que em 1913 propôs um modelo simples e compreensível da estrutura do átomo. De acordo com este modelo, os elétrons de um átomo se movem em certas órbitas, o que significa que seu momento e raio de movimento podem ser previstos. Da mesma forma, a aparência do Borbags pode ser prevista se as condições necessárias forem criadas para eles.
/ photo OLCF em ORNL CC BYSchroedinbag é um erro que existe e não existe ao mesmo tempo, até que o desenvolvedor o analise. O erro foi nomeado em homenagem a um famoso
experimento mental .
Quanto ao
Mandelbug , este é um erro devido ao qual o sistema se comporta de forma irregular e imprevisível. O fenômeno recebeu o nome do físico, matemático e criador da geometria fractal
Benoit Mandelbrot .
Qual é o resultado
Existem
muitos exemplos de Heisenbags (e outros * bugs). Eles são muito difíceis de encontrar, mas as causas geralmente são comuns: uma variável não inicializada, erros de sincronização em um ambiente multithread ou problemas com algoritmos de
remoção de código morto . Acontece que, para lidar com esses erros, eles precisam ser cortados, mesmo na fase de design do aplicativo.
No blog corporativo de IaaS: