As compilações longas são coisa do passado?

Existem inúmeras histórias de guerra sobre quanto tempo uma compilação pode levar. Até o xkcd fez uma menção a isso.

Agora, não programo há muito tempo e acabei sendo exposto principalmente a Java e Python (e Python é uma linguagem interpretada, não compilada). Percebo que é possível que eu não tenha encontrado projetos que demoram muito para serem compilados, mas mesmo para aplicativos de tamanho decente, ele foi instantâneo para mim (geralmente tratado em segundo plano por um IDE) ou demorou mais de 30 segundos ou mais para um projeto extremamente grande. Mesmo em um ambiente de negócios (onde os quadrinhos acontecem), nunca tive código demorando tanto para compilar.

Acabei de não ter sido exposto a projetos com longos tempos de compilação? É uma relíquia do passado que não é mais algo que acontece nos dias modernos? Por que uma compilação levaria tanto tempo?

A compilação pode demorar um pouco, especialmente para projetos grandes escritos em linguagens como C, C ++ ou Scala. A compilação de partes em segundo plano pode reduzir o tempo de compilação, mas, ocasionalmente, é necessário fazer uma nova compilação. Fatores que podem levar a longos tempos de compilação incluem:

• Código de tamanho grande, obviamente. Grandes projetos terão centenas de milhares de linhas de código.

• A #includediretiva de pré-processador de C , que efetivamente faz com que o mesmo código seja compilado centenas de vezes. O sistema macro tem problemas semelhantes, pois funciona no nível do texto. O pré-processador realmente aumenta o tamanho do código que é realmente passado para o compilador. Observar um arquivo após o pré-processamento (por exemplo, via gcc -E) deve abrir seus olhos.

• Os modelos do C ++ são Turing completos, o que significa que, em teoria, você pode executar cálculos arbitrários em tempo de compilação. Ninguém realmente quer fazer isso, mas mesmo muitos casos simples resultam em algum tempo gasto especializando os modelos.

• Scala é uma linguagem bastante jovem, e o compilador é terrivelmente sub-otimizado. Atualmente, o compilador usa um número muito grande de passes de compilação (C foi projetado para exigir apenas duas passagens de compilação). A digitação é uma dessas passagens e pode levar algum tempo devido ao complicado sistema de tipos apresentado pelo idioma.

Compilação não é a única coisa que leva tempo. Após a compilação do projeto, um conjunto de testes deve ser executado. O tempo gasto com isso pode variar de alguns segundos a algumas horas (se os testes forem mal escritos).

Não é de modo algum uma relíquia do passado. Um dos projetos em que trabalho exige 45 minutos para uma construção limpa do zero. Além do nosso próprio código, também precisamos extrair e construir a fonte de várias grandes bibliotecas C e C ++ de repositórios externos. Compilar e vincular códigos C e C ++ é computacionalmente caro. Como você aponta, o Python normalmente é implementado como uma linguagem interpretada, e o Java geralmente usa um compilador JIT (Just in Time), para que seus projetos estejam ignorando a compilação inicial e os custos de vinculação. O preço pago é mais demorado e (pelo menos para o Python) menor velocidade de execução.

Quando os tempos de construção demoram tanto, torna-se mais importante aproveitar os sistemas de integração contínua como Jenkins ou TeamCity . Isso permite que desenvolvedores individuais evitem (principalmente) a dor de construir do zero, enquanto ainda testam que as mudanças não estão quebrando a construção.

Projetos grandes podem levar muito tempo. Pode levar uma hora ou mais para um projeto grande o suficiente. Existem algumas bibliotecas que eu tenho que compilar a partir da fonte no meu computador que levam muito tempo - por exemplo, opencascade. O próprio kernel Linux também leva muito tempo se você precisar construí-lo do zero.

No entanto, existem outros processos de compilação que podem levar muito mais tempo. O design do circuito digital (para ASICs ou FPGAs) requer um local e uma etapa da rota. A etapa do local e da rota é onde o posicionamento de portas lógicas, flip-flops, registradores, RAMs e outros componentes individuais é determinado juntamente com o roteamento da fiação de interconexão. O software usa modelos de tempo para determinar os atrasos de gate e roteamento para possíveis posicionamentos, compara-os com os limites fornecidos pelas restrições de tempo e, em seguida, ajusta os locais de posicionamento e os caminhos dos fios para tentar atender aos requisitos de tempo. Às vezes, o software precisa redimensionar portas e adicionar buffers para atender ao tempo. Essa etapa é extremamente intensiva em termos de computação e pode levar muitas horas ou até dias para ser concluída. Também não é realmente muito paralelo. Havia um design de FPGA em que eu trabalhava há um ano ou mais que consumia cerca de metade de um FPGA Virtex 6 HXT 565 (~ 300k de 565k LUTs) e levava cerca de 7 horas para concluir o local e a rota. Não consigo imaginar quanto tempo levaria para rodar e rodar em algo como um design de CPU Core i7 - provavelmente pelo menos várias semanas.

Outras respostas já mencionaram que sim, o código em projetos grandes, onde grandes significam 500k linhas ou mais, pode levar um tempo significativo, especialmente ao construir do zero.

O ponto adicional é que alguns projetos precisam ser criados para vários ambientes de destino. Quando as máquinas que hospedam esses ambientes não estão disponíveis, a compilação deve ser feita por compilação cruzada, em série nas máquinas que você possui. Isso pode levar a tempos de construção significativos . Para um projeto em que trabalhei, a construção noturna levaria 10 horas. Ai de você que quebrou!

Eu acrescentaria que você não se safaria dessa desculpa por perder tempo. Uma pessoa profissional deve estar a planear as suas tarefas de modo que eles não têm algo útil para fazer em tais períodos.

Um pouco dos dois. C ++ (e C em menor grau) eram notórios por seus tempos de compilação lentos, especialmente em hardware de período. Por volta da virada do milênio, trabalhei em um projeto que demorou cerca de 4 horas para ser construído devido a macro travessuras.

Hoje em dia as coisas estão melhores, mas 30 segundos é bastante baixo em minha experiência - especialmente em compilações formais, nas quais as coisas precisam ser verificadas no controle de origem, testes de unidade executados, instaladores construídos e tudo enviado a alguma SAN em algum lugar.

Depende do projeto e do ambiente em que é compilado. Eu trabalhei em projetos C ++ que levaram vários minutos para compilar (configurados como vários projetos no MSVS), o que provavelmente é tempo suficiente para uma luta de espadas.

Se você trabalha para uma grande empresa com um grande código e base de dados (Proctor and Gamble, Google etc.) ou para uma pequena empresa ou startup focada em um ou dois produtos principais que são muito complexos (por exemplo, simulação e renderização científicas), esperar a compilação de um grande projeto é algo realista, mesmo em máquinas poderosas. Isso pode afetar a maneira como você desenvolve e depura o código (bem como a frequência com que você escolhe atualizar e mesclar alterações por meio de controle de versão).