Pesquise em livros e/ou sites da Internet a diferença entre linguagens de programação compiladas e linguagens de programação interpretadas. Cite exemplos desses dois tipos de linguagens.

Passo 1

O que o enunciado pede:
  • Pesquisar e explicar a diferença entre linguagens de programação compiladas e linguagens interpretadas.
  • Citar exemplos de linguagens de cada tipo.
Informações disponíveis:
  • Somente o pedido acima (não há código ou figura anexa). Vou responder com explicações didáticas, exemplos e comparação prática.

Passo 2

O que é uma linguagem “compilada” — explicação simples e analogia:
  • Ideia central: uma linguagem compilada é transformada, antes de rodar, em código de máquina (ou em um artefato muito próximo disso) por um programa chamado compilador.
  • Analogia: pense no compilador como uma fábrica que converte uma “receita escrita” num produto final pronto para uso. Depois que o produto (o executável) sai da fábrica, ele roda diretamente na máquina sem precisar da fábrica.
  • O processo típico (etapas básicas do compilador, explicadas de forma simples):
    1. Leitura do código-fonte: o compilador pega o texto do programa.
    2. Análise léxica e sintática: quebra o texto em pedaços (tokens) e verifica se a “gramática” está correta (tipo de checagem de erros iniciais).
    3. Análise semântica: verifica significados (por exemplo, se você usa uma variável sem declarar).
    4. Otimizações: tenta melhorar o desempenho do código (remover instruções desnecessárias, reorganizar).
    5. Geração de código de máquina (ou código nativo): produz um arquivo executável ou biblioteca que o sistema operacional roda.
  • Consequência prática: depois da compilação você tem um binário/executável que costuma rodar rápido e independente do compilador.

Passo 3

Vantagens e desvantagens práticas das linguagens compiladas (jeito de prova para lembrar):
  • Vantagens:
    • Performance em tempo de execução geralmente melhor (o código já vem otimizado para a arquitetura).
    • Distribuição: você pode entregar apenas o binário (sem código-fonte) em muitos casos.
    • Erros de certos tipos (ex.: de tipos, em linguagens estáticas) são detectados antes de rodar.
  • Desvantagens:
    • Ciclo editar-compilar-executar pode ser mais pesado (tempo de compilação).
    • Menos flexível para mudanças dinâmicas no tempo de execução (embora existam técnicas para isso).
  • Exemplos típicos: C, C++, Rust, Go, Fortran, Swift (compiladas AOT — ahead-of-time).

Passo 4

O que é uma linguagem “interpretada” — explicação simples e analogia:
  • Ideia central: uma linguagem interpretada é executada por um programa chamado interpretador que lê e executa o código fonte (ou uma representação intermediária) linha por linha, em tempo de execução.
  • Analogia: o interpretador é como um chef que lê a receita e vai cozinhando passo a passo conforme lê — não há produto final pronto antes de começar.
  • Modos de interpretação (formas comuns, explicadas):
    • Interpretação direta do código-fonte: o interpretador lê e executa cada instrução na hora.
    • Compilação para bytecode + interpretação: o código é primeiro transformado numa forma intermediária (bytecode) e depois um interpretador/VM executa esse bytecode (ex.: CPython gera bytecode .pyc e interpreta).
    • Ambiente REPL (Read-Eval-Print Loop): permite testar expressões rapidamente sem compilar todo o programa.

Passo 5

Vantagens e desvantagens práticas das linguagens interpretadas (jeito de prova para lembrar):
  • Vantagens:
    • Desenvolvimento rápido: editar e rodar sem etapas de compilação demoradas, ótimo para prototipagem.
    • Portabilidade: o mesmo código-fonte pode rodar em várias plataformas se o interpretador estiver presente.
    • Flexibilidade: facilidades para metaprogramação, carregamento dinâmico de código, scripting.
  • Desvantagens:
    • Normalmente mais lentas em execução que código nativo puro.
    • Dependência do interpretador instalado no ambiente de execução.
  • Exemplos típicos: Python, Ruby, PHP, Perl, Bash. (Nota: alguns destes usam bytecode interno, mas na prática são tratados como “interpretados”.)

Passo 6

Modelos híbridos — não é tudo “preto no branco”
  • Muitas linguagens modernas misturam técnicas:
    • Compilação para bytecode + VM: Java e C# são compiladas para bytecode (bytecode .class ou IL) e depois executadas em uma VM (JVM, CLR). A VM pode interpretar ou compilar JIT (just-in-time).
    • JIT (compilação em tempo de execução): o ambiente monitora o programa e compila trechos “quentes” para código nativo enquanto roda — melhora muito a performance. Ex.: V8 (Chrome/Node.js), HotSpot (JVM), PyPy (Python).
    • Transpilação: linguagens como TypeScript são transformadas em JavaScript antes da execução; isso não é compilação para máquina, mas converte de uma linguagem para outra.
  • Consequência: classificar uma linguagem como “compilada” ou “interpretada” às vezes perde nuances — o que importa para um problema real é o modelo de execução adotado pela implementação.

Passo 7

Comparação direta (quais critérios lembrar na prova)
  • Performance: compilada (melhor) vs interpretada (pior, exceto quando há JIT).
  • Ciclo de desenvolvimento: interpretada (mais rápido iterativamente) vs compilada (pode exigir compilação).
  • Portabilidade: interpretada/bytecode+VM (mais portável) vs código nativo (depende da arquitetura).
  • Segurança/erros: compilada/estática (erros detectados cedo) vs interpretada/dinâmica (erros em runtime).
  • Deploy: binário (compilada) vs código-fonte e interpretador (interpretada).

Passo 8

Exemplos claros e práticos para decorar (a resposta que o professor quer)
  • Linguagens comumente descritas como compiladas:
    • C
    • C++
    • Rust
    • Go
    • Fortran
    • Swift (quando compilado para código nativo)
  • Linguagens comumente descritas como interpretadas:
    • Python (implementação CPython: compila para bytecode e interpreta)
    • Ruby
    • PHP
    • Perl
    • Bash / Shell scripting

Passo 9

Dicas rápidas para a prova (memorização e resposta curta)
  • Se a questão pede “compilada vs interpretada”, explique o fluxo: compilador → código nativo vs interpretador → executa diretamente. Cite um exemplo de cada e mencione que há híbridos (Java, JavaScript com JIT) caso a pergunta permita nuance.
  • Frase curta para gravar: “Compilada = traduz antes e roda rápido; interpretada = executa na hora e facilita desenvolvimento.”

Resposta

Diferença: Linguagens compiladas são traduzidas antecipadamente para código nativo por um compilador (resultado: executável/binário; vantagem: execução mais rápida); linguagens interpretadas são executadas por um interpretador que lê e executa o código em tempo de execução (vantagem: desenvolvimento mais rápido e portabilidade).
Exemplos compiladas: C, C++, Rust, Go, Fortran, Swift.
Exemplos interpretadas: Python, Ruby, PHP, Perl, Bash.

Exercícios relacionados