Qual é o significado da regra 90/10 de otimização de programa?

Segundo a Wikipedia, a regra 90/10 da otimização de programas afirma que "90% do tempo de execução de um programa é gasto na execução de 10% do código" (veja o segundo parágrafo aqui ).

Eu realmente não entendo isso. O que exatamente isso significa? Como 90% do tempo de execução pode ser gasto apenas executando 10% do código? E os outros 90% do código então? Como eles podem ser executados em apenas 10% do tempo?

Existem dois princípios básicos em jogo aqui:

• Algum código é executado com muito mais frequência do que outro código. Por exemplo, algum código de manipulação de erros pode nunca ser usado. Algum código será executado somente quando você iniciar seu programa. Outro código será executado repetidamente enquanto o programa é executado.
• Algum código leva muito mais tempo para ser executado do que outro código. Por exemplo, uma única linha que executa uma consulta em um banco de dados ou extrai um arquivo da Internet provavelmente levará mais de milhões de operações matemáticas.

A regra 90/10 não é literalmente verdadeira. Varia de acordo com o programa (e duvido que exista alguma base para os números específicos 90 e 10; alguém provavelmente os tirou do ar). Mas o ponto é que, se você precisar que seu programa seja executado mais rapidamente, provavelmente apenas um pequeno número de linhas é significativo para que isso aconteça. Identificar as partes lentas do seu software geralmente é a maior parte da otimização.

Esse é um insight importante e significa que as decisões que parecem contra-intuitivas para um novo desenvolvedor geralmente podem estar corretas. Por exemplo:

• Há muito código que não vale a pena tornar "melhor" , mesmo que esteja fazendo as coisas de uma maneira simplista e burra. Você poderia escrever um algoritmo de pesquisa mais eficiente para o aplicativo XYZ? Sim, mas na verdade uma comparação simples de cada valor leva uma quantidade trivial de tempo, mesmo que existam milhares de valores. Portanto, simplesmente não vale a pena. Pode ser difícil para os novos desenvolvedores evitarem otimizações desnecessárias, porque em seu programa de graduação gastava muito tempo escrevendo o algoritmo "correto" (o que significa mais eficiente). Mas, no mundo real, o algoritmo correto é aquele que funciona e roda com rapidez suficiente.
• Alterações que tornam seu código muito mais longo e mais complexo ainda podem ser uma conquista de desempenho. Por exemplo, no aplicativo FOO, pode valer a pena adicionar centenas de linhas de nova lógica, apenas para evitar uma única chamada ao banco de dados.

Esta não é uma lei da natureza, mas uma regra de ouro resultante de uma vasta experiência. Também é conhecida como regra 80/20 e é apenas uma aproximação aproximada.

Loops, Ramos e outro controle de fluxo.

Cada local que possui um if, você terá um ramo que é ocupado com mais frequência do que o outro ramo. Assim, é gasto mais tempo de execução executando essa parte do programa, e não a outra parte.

Cada local que possui um loop que é executado mais de uma vez, você tem um código que é executado mais do que o código circundante. Assim, mais tempo é gasto lá.

Como exemplo, considere:

def DoSomeWork():
    for i in range(1000000):
        DoWork(i)
    except WorkExeption:
        print("Oh No!")

Aqui, o print("Oh No!")único será executado apenas no máximo uma vez, e muitas vezes nunca, enquanto o DoWork(i)ocorrerá cerca de um milhão de vezes.

Rotações.

Estou tentado a parar por aí! :-)

Considere este programa

1. do_something

2. loop 10 times
3.    do_another_thing

4.    loop 5 times
5.        do_more_stuff

A linha 1 é executada uma vez, enquanto a linha 3 é executada 10 vezes. Olhando cada linha por vez

1 1   0.8%
2 10  8.3%
3 10  8.3%
4 50 41.3%
5 50 41.3%

Duas linhas representam 83% do tempo de execução (assumindo que todas as linhas demoram aproximadamente o mesmo tempo para serem executadas. Portanto, 40% do programa leva> 80%.

Com exemplos maiores e mais reais, isso aumenta e apenas uma pequena quantidade de linhas é responsável por grande parte do tempo de execução.

A regra 90/10 (ou como às vezes é 80/20) é uma "regra de ouro" - apenas aproximadamente verdadeira.

Veja também Princípio de Pareto

Como você perguntou apenas sobre o tempo de execução, este exemplo pode ser útil:

int main() {
    sleep(90); // approximately 10% of the program.
    // other 90% of the program:
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    return 0;
}

Para ser um pouco mais sério, significa que, no código da vida real, você quase sempre chama uma função pesada em um loop (em vez de sleep(90);), enquanto o restante, 10% do tempo, realiza alguns cálculos de passagem única.

Outro exemplo é o tratamento de erros em alguns serviços de alta disponibilidade. Qualquer serviço altamente disponível é projetado para funcionar por uma quantidade infinita de tempo em condições normais. Ele opera normalmente 99% do tempo, mas ocasionalmente, em caso de erro, executa alguma manipulação e recuperação de erros, que podem ser ainda mais logicamente complexas do que o próprio serviço.

O raciocínio 90/10 significa que uma pequena parte do seu código será repetida ou usada mais do que outras. Isso geralmente é usado para sugerir que você concentre 90% do seu esforço de desenvolvimento / otimização nesses 10% do seu código.

Pense em um processador de texto normal, como o Microsoft Word ou o OpenOffice :

• O diálogo de preferências não é muito usado;
• As sub-rotinas que desenham caracteres são usadas o tempo todo.

Esse ditado também é usado nas ciências da administração ... Esta é uma lição para a própria vida ... Significado: concentre a maior parte de seus esforços, a fim de obter mais resultados.

Imagine um programa como este:

print "H"
print "e"
print "l"
print "l"
print "o"
for i=0 to 1,000,000
    print "How long now?"
next
print "B"
print "y"
print "e"

Observe como existem 11 linhas aqui onde 3 dos 11 são o loop for, onde quanto tempo é gasto nesse pequeno pedaço de código? Um pouco enquanto as outras 8 linhas estão apenas imprimindo um único caractere. Portanto, lembre-se de que, embora um código possa ser curto, isso não indica com que frequência ele é executado e quanto tempo levará.

Além do loop, como mencionado por outras ótimas respostas, também existem princípios DRY a serem considerados. Bem escrito, o código orientado a objetos tem muitas partes reutilizáveis. As partes que são reutilizadas, por definição, são usadas pelo menos duas vezes mais que algo que é executado apenas uma vez. Se você tiver muito código OO, poderá potencialmente reutilizar algumas classes e métodos várias vezes e alguns outros pedaços de código apenas uma vez.

Como mencionado em outras respostas, provavelmente é melhor gastar esforços para tornar o código usado com mais frequência melhor do que melhorar o código usado apenas uma única vez.

Isso não é uma regra, é apenas um cara que editou a Wikipedia com alguns números retirados do nada e a chamou de regra. Compare com o Princípio de Pareto, que é mais firmemente estabelecido em outros contextos. Eu gostaria de ver quais pesquisas foram feitas (se houver) sobre a precisão dessa "regra".

Mas basicamente a resposta para sua pergunta é: algum código é executado com muito mais frequência do que outro código. Loops são frequentemente a razão disso. Outras razões são chamadas demoradas, por exemplo, para recursos externos, como serviços da Web ou mídia de armazenamento.

É uma reinterpretação do "princípio de Pareto", que afirma "para muitos eventos, aproximadamente 80% dos efeitos vêm de 20% das causas.", Também conhecida como regra 80/20. Essa regra é aplicada principalmente à economia, por isso faz sentido que ela seja proposta novamente para a programação.

É apenas um padrão que foi observado por um longo período de tempo.

Aqui está um vídeo muito bom sobre padrões como este, e também explica o Princípio de Pareto.

https://www.youtube.com/watch?v=fCn8zs912OE&ab_channel=Vsauce