Tempo de execução x tempo de compilação
Respostas:
A diferença entre tempo de compilação e tempo de execução é um exemplo do que os teóricos de cabeça pontuda chamam de distinção de fase . É um dos conceitos mais difíceis de aprender, especialmente para pessoas sem muita experiência em linguagens de programação. Para abordar esse problema, acho útil perguntar
- Quais invariantes o programa atende?
- O que pode dar errado nesta fase?
- Se a fase for bem-sucedida, quais são as pós-condições (o que sabemos)?
- Quais são as entradas e saídas, se houver?
Tempo de compilação
- O programa não precisa satisfazer nenhum invariável. De fato, não precisa ser um programa bem formado. Você pode alimentar esse HTML para o compilador e vê-lo vomitar ...
- O que pode dar errado no momento da compilação:
- Erros de sintaxe
- Erros de digitação
- (Raramente) falhas de compilador
- Se o compilador tiver êxito, o que sabemos?
- O programa foi bem formado - um programa significativo em qualquer idioma.
- É possível começar a executar o programa. (O programa pode falhar imediatamente, mas pelo menos podemos tentar.)
- Quais são as entradas e saídas?
- A entrada era o programa que estava sendo compilado, além de quaisquer arquivos de cabeçalho, interfaces, bibliotecas ou outro vodu que ele precisava importar para ser compilado.
- Esperamos que a saída seja código de montagem ou código de objeto realocável ou mesmo um programa executável. Ou se algo der errado, a saída é um monte de mensagens de erro.
Tempo de execução
- Não sabemos nada sobre os invariantes do programa - eles são o que o programador colocou. Os invariantes em tempo de execução raramente são impostos pelo compilador; precisa da ajuda do programador.
O que pode dar errado são erros em tempo de execução :
- Divisão por zero
- Desreferenciando um ponteiro nulo
- Falta de memória
Também pode haver erros que são detectados pelo próprio programa:
- Tentando abrir um arquivo que não existe
- Tentando encontrar uma página da web e descobrindo que um suposto URL não está bem formado
- Se o tempo de execução for bem-sucedido, o programa termina (ou continua) sem travar.
- Entradas e saídas são inteiramente da responsabilidade do programador. Arquivos, janelas na tela, pacotes de rede, trabalhos enviados para a impressora, o nome dele. Se o programa lança mísseis, isso é uma saída e acontece apenas em tempo de execução :-)
Penso nisso em termos de erros e quando eles podem ser capturados.
Tempo de compilação:
string my_value = Console.ReadLine();
int i = my_value;
Um valor de sequência não pode ser atribuído a uma variável do tipo int, portanto, o compilador sabe ao certo em tempo de compilação que esse código tem um problema
Tempo de execução:
string my_value = Console.ReadLine();
int i = int.Parse(my_value);
Aqui, o resultado depende de qual sequência foi retornada por ReadLine (). Alguns valores podem ser analisados para um int, outros não. Isso só pode ser determinado em tempo de execução
.appextensão? ou acontece no lançamento sempre que o usuário inicia o aplicativo?
Tempo de compilação: o período em que você, desenvolvedor, está compilando seu código.
Tempo de execução: o período em que um usuário está executando seu software.
Você precisa de uma definição mais clara?
int x = 3/0você não faça nada com essa variável. Não imprimimos nem nada. Isso ainda será considerado um erro de tempo de execução?
( edite : o seguinte se aplica a C # e linguagens de programação semelhantes e fortemente tipadas. Não sei se isso ajuda você).
Por exemplo, o seguinte erro será detectado pelo compilador (em tempo de compilação ) antes de você executar um programa e resultará em um erro de compilação:
int i = "string"; --> error at compile-time
Por outro lado, um erro como o seguinte não pode ser detectado pelo compilador. Você receberá um erro / exceção no tempo de execução (quando o programa for executado).
Hashtable ht = new Hashtable();
ht.Add("key", "string");
// the compiler does not know what is stored in the hashtable
// under the key "key"
int i = (int)ht["key"]; // --> exception at run-time
A tradução do código-fonte em coisas que acontecem na [tela | disco | rede] pode ocorrer (aproximadamente) de duas maneiras; chame-os de compilar e interpretar.
Em um programa compilado (exemplos são c e fortran):
- O código fonte é alimentado em outro programa (geralmente chamado de compilador - vá figura), que produz um programa executável (ou um erro).
- O executável é executado (clicando duas vezes nele ou digitando seu nome na linha de comando)
Dizem que as coisas que acontecem na primeira etapa acontecem em "tempo de compilação", as coisas que acontecem na segunda etapa acontecem em "tempo de execução".
Em um programa interpretado (exemplo: MicroSoft basic (em DOS) e python (eu acho)):
- O código fonte é alimentado em outro programa (geralmente chamado de intérprete) que o "executa" diretamente. Aqui, o intérprete serve como uma camada intermediária entre o seu programa e o sistema operacional (ou o hardware em computadores realmente simples).
Nesse caso, a diferença entre tempo de compilação e tempo de execução é bastante mais difícil de definir e muito menos relevante para o programador ou usuário.
Java é uma espécie de híbrido, em que o código é compilado no bytecode, que é executado em uma máquina virtual que geralmente é um intérprete para o bytecode.
Há também um caso intermediário no qual o programa é compilado no bytecode e executado imediatamente (como em awk ou perl).
Basicamente, se o seu compilador puder entender o que você quer dizer ou o que é um valor "em tempo de compilação", ele pode codificar isso no código de tempo de execução. Obviamente, se seu código de tempo de execução precisar fazer um cálculo toda vez que for executado mais devagar, portanto, se você puder determinar algo em tempo de compilação, é muito melhor.
Por exemplo.
Dobragem constante:
Se eu escrever:
int i = 2;
i += MY_CONSTANT;
O compilador pode executar essa calibração em tempo de compilação, porque sabe o que é 2 e o que é MY_CONSTANT. Como tal, evita realizar um cálculo a cada execução.
Tempo de compilação:
As coisas que são feitas no momento da compilação não custam (quase) nenhum custo quando o programa resultante é executado, mas podem ter um grande custo quando você cria o programa.
Tempo de execução:
Mais ou menos exatamente o oposto. Pouco custo quando você cria, mais custo quando o programa é executado.
Do outro lado; Se algo for feito em tempo de compilação, ele será executado apenas em sua máquina e se algo for em tempo de execução, será executado em sua máquina de usuários.
Relevância
Um exemplo de onde isso é importante seria um tipo de unidade. Uma versão em tempo de compilação (como Boost.Units ou minha versão em D ) acaba sendo tão rápida quanto resolver o problema com o código de ponto flutuante nativo, enquanto uma versão em tempo de execução acaba tendo que reunir informações sobre as unidades em que um valor é e faça verificações nelas ao longo de cada operação. Por outro lado, as versões em tempo de compilação exigem que as unidades dos valores sejam conhecidas em tempo de compilação e não possam lidar com o caso de origem da entrada em tempo de execução.
Seguindo a resposta similar anterior da pergunta Qual é a diferença entre erro em tempo de execução e erro do compilador?
Erros de compilação / tempo de compilação / sintaxe / semântica: ocorreram erros de compilação ou de tempo de compilação devido a erro de digitação, se não seguirmos a sintaxe e a semântica adequadas de qualquer linguagem de programação, os erros de tempo de compilação serão gerados pelo compilador. Eles não permitem que seu programa execute uma única linha até você remover todos os erros de sintaxe ou até você depurar os erros de tempo de compilação.
Exemplo: falta um ponto-e-vírgula em C ou digitação incorreta intcomo Int.
Erros de tempo de execução: erros de tempo de execução são os erros gerados quando o programa está em execução. Esses tipos de erros farão com que seu programa se comporte inesperadamente ou podem até matá-lo. Eles são freqüentemente chamados de exceções.
Exemplo: suponha que você esteja lendo um arquivo que não existe, resultará em um erro de tempo de execução.
Leia mais sobre todos os erros de programação aqui
Como um complemento para as outras respostas, eis como eu explicaria isso a um leigo:
Seu código-fonte é como o modelo de um navio. Ele define como o navio deve ser feito.
Se você entregar seu projeto para o estaleiro, e eles encontrarem um defeito durante a construção do navio, eles deixarão de construir e o informarão imediatamente, antes que o navio saia da doca seca ou toque na água. Este é um erro em tempo de compilação. O navio nunca estava realmente flutuando ou usando seus motores. O erro foi encontrado porque impedia que o navio fosse feito.
Quando seu código é compilado, é como se o navio estivesse sendo concluído. Construído e pronto para ir. Quando você executa seu código, é como lançar o navio em uma viagem. Os passageiros estão embarcando, os motores estão funcionando e o casco está na água, então isso é tempo de execução. Se o seu navio tiver uma falha fatal que o afunda em sua viagem inaugural (ou talvez alguma viagem depois de dores de cabeça extras), ele sofreu um erro de execução.
Por exemplo: Em um idioma fortemente tipado, um tipo pode ser verificado no tempo de compilação ou no tempo de execução. Em tempo de compilação, isso significa que o compilador reclama se os tipos não são compatíveis. Em tempo de execução significa que você pode compilar bem o seu programa, mas em tempo de execução, ele lança uma exceção.
Simplesmente em diferença de palavras entre tempo de compilação e tempo de execução.
tempo de compilação: o desenvolvedor grava o programa no formato .java e converte no Bytecode, que é um arquivo de classe. Durante esta compilação, qualquer erro ocorre pode ser definido como erro de tempo de compilação.
Tempo de execução: o arquivo .class gerado é usado pelo aplicativo por sua funcionalidade adicional e a lógica está errada e gera um erro que é um erro de tempo de execução
Aqui está uma citação de Daniel Liang, autor de 'Introdução à programação JAVA', sobre o assunto de compilação:
"Um programa gravado em um idioma de alto nível é chamado de programa fonte ou código fonte. Como um computador não pode executar um programa fonte, um programa fonte deve ser convertido em código de máquina para execução . A tradução pode ser feita usando outra ferramenta de programação chamada um intérprete ou um compilador ". (Daniel Liang, "Introdução à programação JAVA" , p8).
...Ele continua...
"Um compilador converte todo o código-fonte em um arquivo de código de máquina e o arquivo de código de máquina é então executado"
Quando inserimos código de alto nível / legível por humanos, isso é, a princípio, inútil! Ele deve ser traduzido em uma sequência de 'acontecimentos eletrônicos' em sua minúscula CPU! O primeiro passo para isso é a compilação.
Simplificando: um erro em tempo de compilação ocorre durante esta fase, enquanto um erro em tempo de execução ocorre mais tarde.
Lembre-se: Só porque um programa é compilado sem erros não significa que será executado sem erros.
Um erro em tempo de execução ocorrerá na parte pronta, em execução ou em espera de um ciclo de vida de programas, enquanto um erro em tempo de compilação ocorrerá antes do estágio 'Novo' do ciclo de vida.
Exemplo de um erro em tempo de compilação:
Um erro de sintaxe - como o seu código pode ser compilado nas instruções no nível da máquina, se forem ambíguas? Seu código precisa estar em conformidade 100% com as regras sintáticas do idioma, caso contrário, não poderá ser compilado no código de máquina em funcionamento .
Exemplo de um erro de tempo de execução:
Falta de memória - Uma chamada para uma função recursiva, por exemplo, pode levar ao estouro da pilha, dada uma variável de um determinado grau! Como isso pode ser antecipado pelo compilador !? Eu não posso.
E essa é a diferença entre um erro em tempo de compilação e um erro em tempo de execução
Tempo de compilação:
As coisas que são feitas no momento da compilação não custam (quase) nenhum custo quando o programa resultante é executado, mas podem ter um grande custo quando você cria o programa. Tempo de execução:
Mais ou menos exatamente o oposto. Pouco custo quando você cria, mais custo quando o programa é executado.
Do outro lado; Se algo for feito em tempo de compilação, ele será executado apenas em sua máquina e se algo for em tempo de execução, será executado em sua máquina de usuários.
Tempo de compilação: o tempo gasto para converter o código-fonte em um código de máquina para que ele se torne um executável é chamado de tempo de compilação.
Tempo de execução: quando um aplicativo está em execução, é chamado de tempo de execução.
Erros de tempo de compilação são esses erros de sintaxe, faltando erros de referência de arquivo. Erros de tempo de execução ocorrem após o código-fonte ter sido compilado em um programa executável e enquanto o programa está sendo executado. Exemplos são falhas no programa, comportamento inesperado do programa ou recursos não funcionam.
Imagine que você é um chefe e tem uma assistente e uma empregada, e você dá a eles uma lista de tarefas a serem executadas, o assistente (tempo de compilação) pega essa lista e faz um check-up para ver se as tarefas são compreensíveis e que você não escreveu em nenhuma linguagem ou sintaxe embaraçosa, então ele entende que você deseja designar alguém para um trabalho, para que ele o designe para você e ele entende que você quer café, para que o papel dele acabe e a empregada (tempo de execução) começa a executar essas tarefas, então ela vai fazer um café para você, mas de repente ela não encontra café para fazer, então ela para de fazê-lo ou age de maneira diferente e faz um chá para você (quando o programa age de maneira diferente porque ele encontrou um erro )
Aqui está uma extensão da resposta à pergunta "diferença entre tempo de execução e tempo de compilação?" - Diferenças nas despesas gerais associadas ao tempo de execução e tempo de compilação?
O desempenho em tempo de execução do produto contribui para sua qualidade, fornecendo resultados mais rapidamente. O desempenho em tempo de compilação do produto contribui para sua pontualidade, encurtando o ciclo de edição, compilação e depuração. No entanto, o desempenho em tempo de execução e o desempenho em tempo de compilação são fatores secundários na obtenção de qualidade oportuna. Portanto, deve-se considerar melhorias no desempenho em tempo de execução e tempo de compilação somente quando justificado por melhorias na qualidade geral do produto e pontualidade.
Uma ótima fonte para mais leituras aqui :
Eu sempre pensei nisso em relação à sobrecarga de processamento do programa e como isso afeta o desempenho conforme indicado anteriormente. Um exemplo simples seria definir a memória absoluta necessária para o meu objeto no código ou não.
Um booleano definido recebe x memória, que está no programa compilado e não pode ser alterado. Quando o programa é executado, ele sabe exatamente quanta memória alocar para x.
Por outro lado, se eu apenas definir um tipo de objeto genérico (ou seja, um tipo de espaço reservado indefinido ou talvez um ponteiro para algum blob gigante), a memória real necessária para o meu objeto não será conhecida até que o programa seja executado e atribua algo a ele , portanto, ele deve ser avaliado e a alocação de memória etc. será manipulada dinamicamente no tempo de execução (mais sobrecarga no tempo de execução).
Como ele é manipulado dinamicamente dependeria do idioma, do compilador, do sistema operacional, do seu código etc.
Porém, nessa nota, isso realmente depende do contexto em que você está usando o tempo de execução versus o tempo de compilação.
podemos classificá-los sob dois grupos amplos: ligação estática e ligação dinâmica. É baseado em quando a ligação é feita com os valores correspondentes. Se as referências forem resolvidas no tempo de compilação, será uma ligação estática e se as referências forem resolvidas no tempo de execução, será uma ligação dinâmica. A ligação estática e a dinâmica também são chamadas de ligação precoce e ligação tardia. Às vezes, eles também são chamados de polimorfismo estático e polimorfismo dinâmico.
Joseph Kulandai.
A principal diferença entre tempo de execução e tempo de compilação é:
- Se houver algum erro de sintaxe e verificação de tipo no seu código, ele lançará um erro de tempo de compilação, em que local como tempo de execução: ele verifica após a execução do código. Por exemplo:
int a = 1
int b = a/0;
aqui a primeira linha não possui ponto e vírgula no final ---> erro em tempo de compilação após executar o programa enquanto executa a operação b, resultado é infinito ---> erro em tempo de execução.
- O tempo de compilação não procura a saída da funcionalidade fornecida pelo seu código, enquanto o tempo de execução o faz.
aqui está uma resposta muito simples:
Tempo de execução e tempo de compilação são termos de programação que se referem a diferentes estágios do desenvolvimento de programas de software. Para criar um programa, o desenvolvedor primeiro escreve o código fonte, que define como o programa funcionará. Programas pequenos podem conter apenas algumas centenas de linhas de código fonte, enquanto programas grandes podem conter centenas de milhares de linhas de código fonte. O código fonte deve ser compilado no código da máquina para se tornar um programa executável. Esse processo de compilação é chamado de tempo de compilação (pense em um compilador como um tradutor)
Um programa compilado pode ser aberto e executado por um usuário. Quando um aplicativo está em execução, ele é chamado de tempo de execução.
Os termos "tempo de execução" e "tempo de compilação" são frequentemente usados pelos programadores para se referir a diferentes tipos de erros. Um erro de tempo de compilação é um problema como um erro de sintaxe ou uma referência de arquivo ausente que impede que o programa seja compilado com êxito. O compilador produz erros de tempo de compilação e geralmente indica qual linha do código fonte está causando o problema.
Se o código-fonte de um programa já foi compilado em um programa executável, ele ainda pode ter erros que ocorrem enquanto o programa está sendo executado. Os exemplos incluem recursos que não funcionam, comportamento inesperado do programa ou falhas no programa. Esses tipos de problemas são chamados de erros de tempo de execução, pois ocorrem no tempo de execução.
IMHO, você precisa ler muitos links, recursos para ter uma idéia da diferença entre o tempo de execução e o tempo de compilação, porque é um assunto muito complexo. Tenho uma lista abaixo de algumas fotos / links que eu recomendo.
Além do que foi dito acima, quero acrescentar que algumas vezes uma imagem vale mais que 1000 palavras:
- a ordem dos dois: primeiro é o tempo de compilação e, em seguida, você executa. Um programa compilado pode ser aberto e executado por um usuário. Quando um aplicativo está em execução, ele é chamado de tempo de execução: tempo de compilação e, em seguida, tempo de execução1
;
CLR_diag tempo de compilação e, em seguida, tempo de execução2
from Wiki
https://en.wikipedia.org/wiki/Run_time https://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase)
Tempo de execução, tempo de execução ou tempo de execução podem se referir a:
Informática
Tempo de execução (fase do ciclo de vida do programa) , o período durante o qual um programa de computador está executando
Biblioteca de tempo de execução , uma biblioteca de programas projetada para implementar funções integradas em uma linguagem de programação
Sistema de tempo de execução , software projetado para suportar a execução de programas de computador
Execução de software, o processo de execução de instruções uma por uma durante a fase do tempo de execução
Lista de compiladores
https://en.wikipedia.org/wiki/List_of_compilers
- pesquise no google e compare erros de tempo de execução vs erros de compilação:
;
- Na minha opinião, uma coisa muito importante a saber: 3.1 a diferença entre compilar versus compilar e o ciclo de vida da compilação https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html
3.2 a diferença entre estas três coisas: compilar versus compilar versus tempo de execução
https://www.quora.com/What-is-the-difference-between-build-run-and-compile Fernando Padoan, desenvolvedor que está um pouco curioso para o design da linguagem Respondido em 23 de fevereiro Estou voltando ao passado em relação para outras respostas:
correr está fazendo com que algum executável binário (ou um script, para linguagens interpretadas) seja, bem ... executado como um novo processo no computador; compilar é o processo de analisar um programa escrito em uma linguagem de alto nível (superior se comparado ao código da máquina), verificar sua sintaxe, semântica, vincular bibliotecas, talvez fazer alguma otimização e criar um programa executável binário como saída. Esse executável pode estar na forma de código de máquina ou algum tipo de código de bytes - ou seja, instruções direcionadas a algum tipo de máquina virtual; a construção geralmente envolve verificar e fornecer dependências, inspecionar o código, compilar o código em binário, executar testes automatizados e empacotar os binários resultantes e outros ativos (imagens, arquivos de configuração, bibliotecas etc.) em algum formato específico de arquivo implementável. Observe que a maioria dos processos é opcional e alguns dependem da plataforma de destino para a qual você está construindo. Como exemplo, o empacotamento de um aplicativo Java para Tomcat produzirá um arquivo .war. Criar um executável Win32 a partir do código C ++ poderia apenas gerar o programa .exe ou também empacotá-lo dentro de um instalador .msi.
Veja este exemplo:
public class Test {
public static void main(String[] args) {
int[] x=new int[-5];//compile time no error
System.out.println(x.length);
}}O código acima é compilado com sucesso, não há erro de sintaxe, é perfeitamente válido. Mas, no tempo de execução, lança o seguinte erro.
Exception in thread "main" java.lang.NegativeArraySizeException
at Test.main(Test.java:5)
Como quando, em tempo de compilação, certos casos foram verificados, após esse tempo de execução, certos casos foram verificados, uma vez que o programa satisfaz todas as condições em que você obterá uma saída. Caso contrário, você receberá tempo de compilação ou erro de tempo de execução.
classe pública RuntimeVsCompileTime {
public static void main(String[] args) {
//test(new D()); COMPILETIME ERROR
/**
* Compiler knows that B is not an instance of A
*/
test(new B());
}
/**
* compiler has no hint whether the actual type is A, B or C
* C c = (C)a; will be checked during runtime
* @param a
*/
public static void test(A a) {
C c = (C)a;//RUNTIME ERROR
}
}
class A{
}
class B extends A{
}
class C extends A{
}
class D{
}
Não é uma boa pergunta para SO (não é uma questão de programação específica), mas não é uma pergunta ruim em geral.
Se você acha que é trivial: e quanto ao tempo de leitura versus tempo de compilação, e quando essa distinção é útil? E os idiomas em que o compilador está disponível em tempo de execução? Guy Steele (sem manequim, ele) escreveu 7 páginas no CLTL2 sobre EVAL-WHEN, que os programadores de CL podem usar para controlar isso. 2 frases mal são suficientes para uma definição , que por si só está longe de ser uma explicação .
Em geral, é um problema difícil que os designers de linguagem parecem tentar evitar. Eles costumam dizer "aqui está um compilador, ele faz coisas em tempo de compilação; tudo depois disso é tempo de execução, se diverte". C foi projetado para ser simples de implementar, não o ambiente mais flexível para computação. Quando você não tem o compilador disponível em tempo de execução ou a capacidade de controlar facilmente quando uma expressão é avaliada, você tende a acabar com hacks no idioma para falsificar usos comuns de macros, ou os usuários criam padrões de design para simular tendo construções mais poderosas. Uma linguagem simples de implementar pode definitivamente ser uma meta que vale a pena, mas isso não significa que é o design final da linguagem de programação. (Não uso muito EVAL-WHEN, mas não consigo imaginar a vida sem ela.)
E o espaço de problemas em torno do tempo de compilação e do tempo de execução é enorme e ainda inexplorado. Isso não quer dizer que o SO seja o lugar certo para a discussão, mas encorajo as pessoas a explorar esse território ainda mais, especialmente aquelas que não têm noções preconcebidas sobre o que deveria ser. A questão não é simples nem tola, e poderíamos pelo menos apontar o inquisidor na direção certa.
Infelizmente, não conheço boas referências sobre isso. O CLTL2 fala um pouco sobre isso, mas não é bom para aprender.