O Que É um Interpretador? Rodando Código Linha a Linha
Um interpretador é um programa que lê seu código-fonte e o executa diretamente, instrução por instrução, sem produzir antes um executável separado.
Linguagens como Python, Ruby e (classicamente) JavaScript são rodadas por um interpretador. Em vez de traduzir o programa inteiro antecipadamente, o interpretador percorre seu código em tempo de execução e realiza cada instrução conforme a encontra. Isso proporciona iteração rápida e depuração fácil, a algum custo na velocidade bruta de execução.
Como um interpretador roda seu código
Um interpretador moderno geralmente faz o parsing do código-fonte em uma representação interna (muitas vezes bytecode) e então executa essa representação em um laço. Como não há um build antecipado separado, você pode mudar uma linha e rodar de novo imediatamente.
Interpretador vs compilador
Um compilador traduz tudo antes de rodar e produz um artifact; um interpretador traduz e roda conforme avança. Muitas linguagens reais combinam ambos: Python compila para bytecode e então o interpreta, e engines de JavaScript interpretam primeiro e compilam os caminhos quentes just in time.
Trade-offs da interpretação
- Startup mais rápido e laços de editar-rodar mais ágeis durante o desenvolvimento.
- Erros muitas vezes surgem só quando a linha problemática de fato roda.
- Geralmente mais lento em computação pesada do que código compilado.
- Portabilidade mais fácil, já que o mesmo código-fonte roda onde quer que o interpretador rode.
Por que o modelo linha a linha importa
Como um interpretador só falha quando alcança uma linha ruim, um erro de sintaxe fundo em uma branch raramente usada pode se esconder até essa branch rodar. É exatamente por isso que testes e linting importam tanto para linguagens interpretadas.
Um exemplo rápido
Rodar python app.py entrega seu arquivo ao interpretador Python, que o executa de cima a baixo. Um erro de digitação na linha 200 não será reportado até a execução alcançar a linha 200, a menos que um linter ou type checker o pegue antes.
Interpretadores no CI
Para linguagens interpretadas, o build muitas vezes é o run de teste, já que é quando a maioria dos erros aparece. Setup de ambiente flaky ou buscas transitórias de pacotes podem quebrar esses runs sem culpa do seu código; runners gerenciados (Latchkey) reexecutam automaticamente tais falhas transitórias para que um soluço de rede durante a instalação de dependências não faça o pipeline falhar.
Principais conclusões
- Um interpretador executa o código-fonte diretamente em tempo de execução em vez de construir antes um artifact.
- Muitas linguagens misturam interpretação e compilação por baixo dos panos.
- Erros muitas vezes só aparecem quando uma linha de fato roda, então testes e linting são essenciais.