Fundamentos de Programação Compilação e Interpretação de Programas e Linguagens de Programação - v1 - 1597350622 PDF

Fundamentos de Programação
Compilação e Interpretação de Programas e

Conceitos sobre Linguagens de Programação
CONTEÚDO
Compilação ....................................................................................................................... 3
Compiladores ......................................................................................................................... 3
Fases....................................................................................................................................... 4
Análise ................................................................................................................................ 4
Síntese ................................................................................................................................ 8
Etapas Pós-Compilação .......................................................................................................... 9
Montadores (Assemblers) .................................................................................................. 9
Editor de Ligações (Link-editor) ........................................................................................ 10
Empacotadores (Packer) .................................................................................................. 11
Carregadores (Loader) ...................................................................................................... 11
Interpretação .................................................................................................................. 13
Compilador Just-in-time (JIT) ............................................................................................... 13
Comparativo entre Compilação e Interpretação................................................................. 15
Conceitos sobre Linguagens de Programação .................................................................. 16
Paradigmas das Linguagens de Programação ..................................................................... 16
Paradigma Imperativo (ou Procedural) ............................................................................ 16
Paradigma Declarativo ..................................................................................................... 19
2
www.resumosdeti.com.br
O conteúdo deste resumo é de uso exclusivo de Pierry Pereira - E-mail: pierryangelo@gmail.com - ID: 14461 - Data: 7 de fevereiro de 2020,
vedada, por quaisquer meios e a qualquer título, a sua reprodução, cópia, divulgação e distribuição, sujeitando-se os infratores à
responsabilização civil e criminal.
Compilação
Compiladores
- Um compilador é um programa que lê um programa escrito numa linguagem – a
linguagem fonte – e o traduz num programa equivalente numa outra linguagem – a
linguagem alvo.
- Como importante etapa deste processo de tradução, o compilador relata a seu usuário a
presença de erros no programa fonte.
- Uma linguagem alvo pode ser uma outra linguagem de programação ou a linguagem de
máquina de uma família de computadores.
- Classificação:
• Compiladores de Uma Passagem (um passo)
▪ O programa alvo ou objeto já é o produto final do compilador, ou seja, o
programa em linguagem de máquina desejado.
• Compiladores de Passagens Múltiplas (n passos)

▪ No caso de n passos, teremos programas objeto intermediários que serão o
programa fonte do próximo passo.
▪ No próximo passo, novo programa objeto é gerado e assim sucessivamente.
▪ Os programas objeto gerados nos passos intermediários são ditos escritos
em uma linguagem intermediária.
3
FCC
Linguagens de alto nível cumprem tarefas mais substanciais com um número menor de
comandos, mas exigem programas tradutores denominados compiladores para converter
programas em linguagem de alto nível para linguagem de máquina.
Em relação à compilação de programas:
- Tem como resultado um arquivo objeto com códigos em linguagem de máquina.
Fases
- Existem duas fases no processo de compilação: a análise e a síntese.
- Análise
• Divide o programa fonte nas partes constituintes e cria uma representação
intermediária dos mesmos.
▪ Léxica (tokens)
▪ Sintática (árvore sintática)
▪ Semântica (incoerências semânticas)
▪ Geração de Código Intermediário
- Síntese
• A partir da representação intermediária constrói o programa alvo desejado.
▪ Otimização do Código
▪ Geração do Código
Análise
- O texto de entrada (na linguagem fonte) é examinado, verificado e compreendido.
- A parte de análise divide o programa fonte nas partes constituintes e cria uma
representação intermediária do mesmo.
4
• Em alguns casos, a representação intermediária pode tomar a forma de um

programa em uma linguagem intermediária, a partir da qual seja fácil a tradução
para a linguagem objeto desejada.
- Durante a análise, o compilador deve ser capaz de detectar se o programa é inválido por
qualquer razão, isto é, não corresponde em algum trecho à linguagem para a qual o
compilador foi escrito.
• Neste caso é gerada uma mensagem de erro.
- Por razões de conveniência prática, a fase de análise normalmente se subdivide em:

• Análise Léxica;
• Análise Sintática;
• Análise Semântica;
• Geração de Código Intermediário.
FCC
Existem duas partes na compilação: a análise e a síntese. A parte de análise divide o
programa fonte nas partes constituintes e cria uma representação intermediária do
mesmo. Durante a análise, as operações implicadas pelo programa fonte são determinadas
e registradas em uma estrutura denominada de árvore.
Análise Léxica
- Também chamada de linear, esquadrinhamento (Scanner).
- A função do analisador léxico é ler o código fonte, caracter a caracter, buscando a
separação e identificação dos elementos componentes do programa fonte, denominados
símbolos léxicos ou tokens.
• O analisador léxico é uma função que transforma sequências de caracteres em
sequências de símbolos (palavras ou “tokens”).
• O fluxo de caracteres que constitui o programa é lido da esquerda para a direita e
agrupado em tokens, que são sequencias de caracteres tendo um significado
coletivo.
• Normalmente esses componentes são especificados através de expressões
regulares.
- Cada símbolo é guardado na tabela de símbolos e, depois, classificado de acordo com a

linguagem.
• Palavras reservadas;
• Operadores;
• Comandos;
• Variáveis;
5
• Tipos básicos.
- É também de responsabilidade desta fase a eliminação de elementos "decorativos" do

programa, tais como espaços em branco, marcas de formatação de texto e comentários.
FCC
Durante a análise léxica, as palavras ou lexemas são guardados na tabela de símbolos e
classificados de acordo com a linguagem, em palavras reservadas, comandos, variáveis e
tipos básicos.
Identificação de sequências de caracteres de entrada e produção de uma sequência de
elementos de saída, os tokens. Nesta fase, verifica-se se cada caractere do programa fonte
pertence ao alfabeto da linguagem, identificando os tokens e desprezando comentários e
espaços em branco. Os tokens constituem classes de símbolos, tais como palavras
reservadas, delimitadores, identificadores etc.
CESPE
A construção da tabela de símbolos é atividade que pode ser iniciada durante a análise
léxica.
Durante a compilação de um código-fonte, a fase do compilador que é responsável por
produzir uma sequência de tokens é a análise léxica.
Análise Sintática
- Também chamada de hierárquica, Análise Gramatical ou Parsing.
- A análise sintática, ou análise gramatical é o processo de se determinar se uma cadeia de
símbolos léxicos pode ser gerada por uma gramática.
- O analisador sintático é o cerne do compilador, responsável por verificar se os símbolos
contidos no programa fonte formam um programa válido, ou não.
- A análise sintática deve reconhecer a estrutura global do programa, descrita através de
gramáticas livres de contexto.
- Através da análise léxica é obtido um grupo de tokens, para que o analisador sintático use
um conjunto de regras para construir uma árvore sintática da estrutura.
- Os caracteres ou tokens são agrupados hierarquicamente em coleções aninhadas com
significado coletivo.
• Em outras palavras, agrupam-se os tokens em frases gramaticais.
• Estas frases são usadas pelo compilador para sintetizar uma saída.
• As frases gramaticais são representadas por árvores.
6
- Tipos de analisadores sintáticos:

• Top-down
• Bottom-up
FCC
A Análise Sintática é responsável pela verificação da boa formação dos comandos da
linguagem, de acordo com as regras especificadas pela gramática da linguagem, pois
sentenças mal formadas, geralmente, interrompem o processo de compilação e são
apresentadas como mensagens de erro.
No fim da análise sintática, temos a representação do programa original de forma
hierárquica, onde o programa é representado por uma árvore sintática.
Na compilação, a análise consiste em três fases. Na análise sintática, os caracteres ou
tokens são agrupados hierarquicamente em coleções aninhadas com significado coletivo.
Essa fase envolve o agrupamento dos tokens do programa fonte em frases gramaticais, que
são usadas pelo compilador, a fim de sintetizar a saída. Usualmente, as frases gramaticais
do programa fonte são representadas por uma árvore gramatical.
Identificação de sequências de símbolos que constituem estruturas como expressões e
comandos, através de uma varredura, ou parsing, da representação interna do programa
fonte, produzindo uma estrutura em árvore, chamada árvore de derivação.
Análise Semântica
- A análise semântica se encarrega da verificação das regras restantes.
- Essas regras tratam quase sempre da verificação de que os objetos são usados no
programa da maneira prevista em suas declarações, por exemplo, verificando se não há
erros de tipos.
- Verificações são realizadas para assegurar que componentes de um programa se
combinam de forma significativa.
- Esta fase verifica erros semânticos no programa fonte e captura informações de tipo para
a fase subsequente de geração de código.
- Utiliza a estrutura hierárquica determinada pela fase de análise sintática, a fim de
identificar os operadores e operandos das expressões e enunciados.
7
FCC
A análise semântica mais comum consiste na verificação da consistência de tipos dos
operandos envolvidos em operações aritméticas ou dos parâmetros passados a
procedimentos.
Verificação das estruturas quanto ao sentido, ou seja, se o programa não possui erros de
significado. Por exemplo, verifica se um identificador declarado como variável é utilizado
como tal, se existe compatibilidade entre operandos e operadores em expressões etc.
Geração de Código Intermediário

- Na fase de geração de código intermediário, ocorre a transformação da árvore sintática
em uma representação intermediária do código fonte.
- Esta linguagem intermediária é mais próxima da linguagem objeto do que o código fonte,
mas ainda permite uma manipulação mais fácil do que se o código assembly ou código de
máquina fosse utilizado.
Síntese
- O texto de saída (na linguagem objeto) é gerado, de forma a corresponder ao texto de
entrada.
- A síntese constrói o programa alvo desejado, a partir da representação intermediária.
- Fase de análise → dependente da linguagem de programação em questão;
- Fase de síntese → dependente principalmente da máquina alvo.
• A máquina na qual o código gerado deverá ser executado eventualmente.
Otimização do Código
- A otimização de código é a estratégia de examinar o código intermediário, produzido
durante a fase de geração de código intermediário com objetivo de produzir, através de
algumas técnicas, um código que execute com bastante eficiência.
- Utilizam-se técnicas que detectam padrões dentro do código produzido e os substitui por
códigos mais eficientes.
Geração do Código
- A fase de geração de código final é a última fase da compilação.
- A geração de um bom código objeto é difícil devido aos detalhes particulares das
máquinas para os quais o código é gerado.
- Contudo, é uma fase importante, pois uma boa geração de código pode ser, por exemplo,
duas vezes mais rápida que um algoritmo de geração de código ineficiente.
8
- Um código-objeto não é imediatamente executável, visto que ainda há código binário a

ser incluído no programa, tais como bibliotecas.
As fases de um compilador:
Etapas Pós-Compilação
Montadores (Assemblers)
- Traduz um programa escrito em linguagem de montagem (assembly) em um equivalente
em linguagem de máquina;
- Em geral, não pode ser executado diretamente pela máquina, por conter referências a
sub-rotinas e dados especificados em outros arquivos;
- É dependente da arquitetura da máquina
• A linguagem de montagem é traduzida para uma linguagem de máquina (binária).
• Ambas são dependentes do hardware.
9
FCC
O programador de linguagem de montagem tem acesso a aspectos e instruções
disponíveis na arquitetura alvo não disponíveis em linguagens de alto nível.
CESPE
O compilador, em contraste com o montador, opera sobre uma linguagem de alto nível,
enquanto o montador opera sobre uma linguagem de montagem.
Montador é um programa de computador que realiza a conversão de uma linguagem de
montagem (assembly) para código de máquina.
Editor de Ligações (Link-editor)

- São programas que recebem como entrada um conjunto de arquivos-objeto, bibliotecas
padrão, arquivos de controle, parâmetros diversos e bibliotecas compartilhadas e os
unem em um módulo, denominado Módulo de Carga, que é posteriormente carregado na
memória.
- Programa que liga objetos gerados por um compilador ou montador formando o
executável.
• É ele quem gera o executável e não o compilador.
- Recebem como entrada arquivos objetos e geram como saída o programa final em
linguagem de máquina.
- Gera um programa executável a partir de um ou mais arquivos objeto.
- Resolução das chamadas de funções através da unificação dos objetos num único
executável.
FCC
O linkeditor tem como função unir diversos códigos objetos para gerar um arquivo
executável.
Compiladores, montadores e ligadores são softwares que convertem programas de um
formato de código (entrada) para um mais próximo ao formato executável compreendido
pela máquina (saída). Os ligadores geram como saída programas executáveis em
linguagem de máquina.
CESPE
Programas ligadores podem produzir ligação estática ou dinâmica, sendo comum, em
interpretadores de programas orientados a objeto, o uso de ligação dinâmica, o que
permite apoiar a implementação de polimorfismo.
10
Empacotadores (Packer)
- Compacta um executável e gera outro executável auto extraível.
- Packer muda a assinatura do executável.
- Possibilita criação de vírus com assinaturas diferentes.
- Comprimem, cifram e ofuscam o executável.
- Dificultam a identificação do compilador usado por ferramentas adequadas.
- Impossibilita a análise estática, pois o packer é quem se torna o ator principal.
- Decifragem sob demanda.
Carregadores (Loader)
- São programas que transferem o código de máquina de um módulo objeto para memória
e encaminham o início de sua execução.
- Para executar um programa, um loader deve ser utilizado.
- O carregador é, em geral, parte do sistema operacional.
- Copia o arquivo em formato binário para a memória.
- Tarefas Principais:
• Verifica se o programa existe;
• Dimensiona a quantidade de memória necessária;
• Solicita ao SO a quantidade de memória necessária;
• Copia o código para a memória;
• Ajusta os endereços do código executável.
- Tipos de Carregadores:
• Binários / Absolutos
▪ São mais simples
▪ Apenas copiam o arquivo em formato binário para a memória, de tal forma
que o arquivo executável é simplesmente uma imagem binária do programa
em execução na memória.
▪ Programa que usa carregadores absolutos é associado com localizações
específica de memória, e por isso deve sempre ser carregado na mesma área
de memória.
▪ Exemplo: programas com extensão .COM
• Realocáveis
▪ O programa executável realocável é semelhante ao programa executável
absoluto, exceto pelo fato que os endereços são todos relativos a zero (não
são absolutos)
11
▪ A informação de quais endereços relativos devem ser alterados quando o

programa for colocado em execução estão junto com o arquivo executável.
▪ Exemplo: programas com extensão .EXE.
12
Interpretação
- A Interpretação é o processo de execução em que cada instrução é traduzida e executada
em seguida.
- O resultado desta tradução não é armazenado ou gravado em lugar algum e é utilizado
apenas no instante da execução da referida instrução.
- Existe uma análise do comando e posterior tradução para a linguagem de máquina que
são etapas análogas às executadas pelo compilador.
- Interpretadores
• Conversor on-line (incremental), onde a tradução e a execução das instruções
ocorrem passo a passo, a cada instrução.
• Execução simultânea à leitura, logo após a análise.
• Recebem como entrada arquivos texto contendo programas em linguagem
assembly, linguagem de alto nível, arquivos binários com instruções de máquina e
os executam diretamente.
• OBS: Processadores são interpretadores implementados em hardware.
- Implementação Híbrida
• Mescla compilação com interpretação;
• Programas fonte são traduzidos para uma linguagem intermediária que é
interpretada;
• Tem maior portabilidade que uma linguagem compilada;
• São mais rápidas que uma linguagem interpretada;
• Ex: Bytecode Java.
FCC
O processo híbrido combina a execução eficiente e a portabilidade de programas. A base
é a existência de um código intermediário, mais fácil de ser interpretado e não específico
de uma plataforma computacional. O método é dividido em duas etapas: compilação para
um código intermediário e interpretação desse código. Um exemplo é a linguagem Java
que utiliza a JVM.
Compilador Just-in-time (JIT)

- Um compilador JIT, o qual traduz código intermediário para código de máquina, é usado
em métodos na primeira vez em que eles são chamados.
- Na prática, um compilador JIT transforma um sistema híbrido em um sistema de
compilação adiada.
13
- Esta técnica é normalmente utilizada para incrementar o desempenho de programas

"executados" - na verdade, interpretados - em máquinas virtuais.
- Em sistemas computacionais baseados em máquinas virtuais, como Java e .NET, o

processo de compilação traduz o código fonte para uma representação intermediária
conhecida pelo termo bytecode.
• Esta representação intermediária não está associada a nenhum código de máquina
específico e pode ser transportada para várias arquiteturas de computador
distintas.
• Em cada arquitetura específica, essa representação intermediária é interpretada -
ou executada em uma máquina virtual.
- Nos ambientes que oferecem o recurso de JIT, a máquina virtual responsável pela
execução dos bytecodes resultantes da compilação do programa fonte realiza a tradução
desse bytecode para código de máquina nativo enquanto o executa.
- No caso mais comum, cada trecho de código é traduzido no instante em que está para ser
executado pela primeira vez, daí derivando o nome "just-in-time".
- Exemplos:
• Java
▪ No caso do ambiente Java, o compilador de Java traduz o programa fonte
para uma representação intermediária (programa objeto) conhecida pelo
termo bytecode.
▪ Posteriormente, o programa objeto será interpretado pela máquina virtual
Java.
• .NET
▪ No caso do ambiente .NET, a representação intermediária é conhecida pelo
termo Microsoft Intermediate Language (MSIL), que será interpretada pela
máquina virtual do ambiente .NET, chamada Common Language Runtime.
FCC
O .NET framework consiste em dois componentes principais. Um deles é a biblioteca de
classes do framework. O outro, que gerencia a execução de memória, execução de thread,
execução de código, verificação de segurança de código, compilação e outros serviços do
sistema, é denominado Common Language Runtime.
Um compilador do tipo JIT- Just in Time tem sido utilizado em linguagens como Java e C#.
Na prática, JIT transforma um sistema híbrido em um sistema de compilação adiada.
14
Comparativo entre Compilação e Interpretação

- Compilador atua sobre todo o programa fonte gerando um programa objeto.
- Interpretador executa cada comando e não gera um objeto após a execução.
• Em nova execução o interpretador executará todas as etapas novamente.
- Os programas compilados em geral apresentam maior desempenho e introduzem
otimizações no código gerado que não podem ser implementadas por interpretadores,
entretanto, se houver qualquer alteração no código fonte nova compilação é necessária.
- A técnica de interpretação passou a se justificar muito mais com o aumento da
interconexão de computadores em rede e com a distribuição das aplicações.
Vantagens Desvantagens
Execução mais rápida Várias etapas de tradução
Permite estruturas de programação Programação final é maior,
Compiladores mais completas para a sua execução necessitando mais memória
Permite a otimização do código-fonte Processo de correção de erros e
deputação é mais demorado
Depuração do programa é mais Execução do programa é mais
simples lenta
Consome menos memória Estruturas de dados demasiado
Interpretadores
simples
Resultado imediato do programa ou Necessário fornecer o programa
rotina desenvolvida fonte ao utilizador
FCC
Em relação à interpretação:
- O programa é executado a partir do arquivo fonte sem que haja a necessidade de gerar
um arquivo objeto e muito menos um executável.
- As instruções (ou blocos de instruções) do código fonte vão sendo executadas na
medida em que são traduzidas.
No contexto do módulo executável de um programa de computador:
• Menor tempo de execução → compilação
• Menor consumo de memória → compilação
• Maior tempo na execução de loop’s → interpretação
• Menor dificuldade de identificação de erros → interpretação
15

- Linguagem de programação é um método padronizado para comunicar instruções para
um computador, sendo constituída por um conjunto de regras sintáticas e semânticas
usadas para definir um programa de computador.
- Linguagem de Alto Nível

• Linguagem com um nível de abstração relativamente elevado, longe do código de
máquina e mais próximo a linguagem humana.
• Estão diretamente relacionadas à arquitetura do computador.
• O programador de uma linguagem de alto nível não precisa conhecer
características do processador, como instruções e registradores.
- Linguagem de Baixo Nível

• Linguagem que compreende as características da arquitetura do computador.
• Utiliza somente instruções do processador e para isso é necessário conhecer os
registradores da máquina.
• Nesse sentido, estão diretamente relacionadas com a arquitetura do computador.
• Exemplo: Assembly → que trabalha diretamente com os registradores do
processador.
Paradigmas das Linguagens de Programação

- Paradigma de programação é um padrão ou estilo que agrupam linguagens com certas
características comuns.
FCC
O paradigma de programação fornece e determina a visão que o programador possui
sobre a estruturação e execução do programa.
Paradigma Imperativo (ou Procedural)

- No paradigma imperativo, há uma grande preocupação quanto ao detalhamento do
funcionamento do programa.
- O programa é visto como um conjunto de rotinas e sub-rotinas (daí ser também conhecida
como procedural ou procedimental)
- Enfatizam-se as mudanças de estado do programa (registrada por meio de suas variáveis
globais e locais).
- Nesta forma de programação, há um foco maior em “como um programa deve executar
uma tarefa”, em vez de focar em “o que o programa deve fazer”.
16
- Neste paradigma, podemos encontrar alguns dos sub paradigmas mais empregados
atualmente:
• Programação estruturada;
• Programação orientada a objetos e;
• Programação concorrente.
FCC
Programar o computador significa "dar ordens a ele," as quais são executadas
sequencialmente. Em tal paradigma, "representar" a solução de um problema para ser
resolvido pelo computador envolve escrever uma série de ações que, se executadas
sequencialmente, levam à solução. Trata-se do paradigma procedural.
As linguagens de programação imperativas são caracterizadas por três conceitos:
Variáveis, Atribuições e Laços de Iteração.
- Programação Estruturada
• Na programação estruturada, o programador deve descrever todo o seu programa
por meio de instruções, estruturas de dados e sub-rotinas e qualquer programa
pode ser reduzido a três tipos de estruturas:
▪ Sequência, decisão e interação.
• Algumas das linguagens de programação consideradas estruturadas são:
▪ Pascal, C, COBOL e Fortran.
• Vantagens:
▪ Geralmente são linguagens mais fáceis de aprender, uma vez que envolve
um menor número de conceitos distintos do que aqueles apresentados por
outros paradigmas, como a programação orientada a objetos;
▪ Permitem a modularização, isto é, a criação de módulos independentes
lógica e fisicamente, facilitando assim o desenvolvimento e manutenção de
sistemas;
▪ São úteis na resolução de problemas mais simples.
• Desvantagens:
▪ Apresentam maiores dificuldades na representação de soluções para certos
“problemas do mundo real”, que geralmente são mais complexos;
▪ Além disso, apresentam baixa manutenibilidade quando empregadas em
problemas mais complexos, geralmente problemas onde conceitos como
herança e polimorfismo poderiam ajudar a abstrair certas partes dos
mesmos.
17
FCC
Na programação estruturada é adequado e fundamental o conhecimento e uso de
construções de sequência, repetição e seleção.
- Programação Orientado a Objetos

• Na programação orientada a objetos, compreende-se a necessidade de
compreender o problema por meio da relação existente entre as diversas
entidades que participam do mesmo, sendo assim, a solução para o problema deve
ser implementada levando-se em consideração os objetos e suas interações que
sejam pertinentes ao universo do problema.
• Alguns exemplos de linguagens orientadas a objetos são C++, Object Pascal e Java.
• Vantagens:
▪ Graças aos novos conceitos introduzidos por meio da orientação a objetos,
conseguiu-se uma melhor organização do código, geralmente separado em
classes e bibliotecas;
▪ Outra vantagem é um melhor reaproveitamento do código, por meio de
conceitos como herança.
• Desvantagem:
▪ A programação orientada a objetos apresenta um maior número de
conceitos e abstrações necessárias, quando comparada à programação
estruturada, o que pode tornar seu aprendizado um pouco mais complexo.
- Programação Concorrente
• Com o desenvolvimento da tecnologia, surgiu um novo conceito: o paralelismo, isto
é, a possibilidade de executar-se mais de uma tarefa paralelamente, seja por meio
de vários núcleos processadores, seja por meio de um só, executando-se assim um
paralelismo emulado.
• A programação concorrente visa estudar e propor como melhor desenvolver
programas visando esse cenário, onde processos executam simultaneamente e
concorrem por recursos, como a memória e o próprio processamento.
• Várias linguagens oferecem suporte à programação concorrente, como Java, C#,
C++, C e Object Pascal. Como se pode perceber, uma mesma linguagem pode
oferecer suporte a mais de um sub paradigma.
• Vantagens:
▪ Aumento do desempenho, na medida em que melhor se utiliza de todos os
recursos computacionais disponíveis;
▪ Possibilidade de melhor modelagem dos programas, pois determinados
problemas computacionais são concorrentes por natureza.
18
• Desvantagens:
▪ Programação mais complexa, com possíveis erros decorrentes da própria
concorrência;
▪ Difícil depuração devido ao aspecto não-determinístico que a solução pode
tomar.
Paradigma Declarativo
• A programação declarativa trata-se de uma abordagem focada em descrever o que
o programa deve fazer e menos em como seus procedimentos devem funcionar.
• Sendo assim, apresenta-se como um paradigma oposto ao paradigma imperativo,
uma vez que se preocupa com “o que deve fazer”, em vez de preocupar-se com
“como deve ser feito”.
• Na programação declarativa, não há a ideia de estado do programa, como ocorre
na programação imperativa.
• Dentro do paradigma declarativo, podemos identificar a programação funcional, a
programação lógica e a programação restritiva.
As linguagens definidas por este paradigma não podem ser consideradas como
linguagens de programação, e sim, como sublinguagens.
- Programação Funcional
• A programação funcional busca descrever o programa em torno de funções.
• O código-fonte de um programa escrito em linguagem funcional pode ser
interpretado como um conjunto de funções que recebem zero ou mais argumentos
como entrada e retornam sempre um valor em sua saída.
• Cada função, então, deve realizar um conjunto de operações sobre os parâmetros
de entrada a fim de obter a saída.
• Algumas linguagens que se utilizam dessa abordagem são APL, Lisp, ML, Haskell,
OCaml e F#.
• Vantagem:
▪ Há uma maior transparência referencial, uma vez que todo o programa é
composto por funções, tornando-se mais fácil efetuar uma inspeção do
código.
• Desvantagem:
▪ Não oferece alocação explícita de memória ou declaração explícita de
variáveis, necessários para a resolução de muitos problemas reais.
FCC
No âmbito das linguagens de programação puramente funcionais, considere:
19
- Elas não utilizam variáveis.

- Construções iterativas não são possíveis sem variáveis.
- Sem variáveis, a repetição deve ser feita por meio de recursão e não por meio de laços.
- Programação Lógica
• Esta é a abordagem da programação que faz forte uso da lógica matemática para a
resolução de problemas, geralmente por meio de valores ou objetos e relações
entre os mesmos, formulando-se assim proposições e regras.
• Duas linguagens de programação foram fundamentais para este paradigma,
criando-se a partir delas duas famílias de linguagens lógicas: Planner e Prolog.
• Dentre as linguagens de programação derivadas de Planner, podemos destacar QA-
4, Popler, Conniver e QLisp.
• Já dentre as linguagens de programação derivadas de Prolog, podemos apontar
Mercury, Visual Prolog, Oz e Frill.
• Vantagem:
▪ Muito úteis em problemas que possam ser resolvidos por meio de dedução
ou inferência.
• Desvantagem:
▪ Pode haver explosão combinatorial da base de conhecimento levando a
grande desperdício de recursos computacionais.
- Programação Restritiva
• A programação restritiva nasceu da programação lógica (motivo pelo qual muitos
autores apontam-na como parte da programação lógica). Ela se utiliza de restrições
na definição de relações entre as variáveis. Em inglês, denomina-se Constraint
Programming.
• Seu uso pode ser interessante em problemas cuja solução possa, de certa forma,
ser restrita a um número de valores. Tal tipo de problema é conhecido como CSP
(Constraint Satisfaction Problem), no qual são dados:
▪ Um conjunto finito de variáveis;
▪ Uma função que mapeia cada variável a um domínio finito;
▪ Um conjunto finito de restrições.
20

Fundamentos de Programação Compilação e Interpretação de Programas e Linguagens de Programação - v1 - 1597350622 PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Fundamentos de Programação Compilação e Interpretação de Programas e Linguagens de Programação - v1 - 1597350622 PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Fundamentos de Programação

Compilação e Interpretação de Programas e

• Compiladores de Passagens Múltiplas (n passos)

• Em alguns casos, a representação intermediária pode tomar a forma de um

- Por razões de conveniência prática, a fase de análise normalmente se subdivide em:

- Cada símbolo é guardado na tabela de símbolos e, depois, classificado de acordo com a

- É também de responsabilidade desta fase a eliminação de elementos "decorativos" do

- Tipos de analisadores sintáticos:

Geração de Código Intermediário

- Um código-objeto não é imediatamente executável, visto que ainda há código binário a

Editor de Ligações (Link-editor)

▪ A informação de quais endereços relativos devem ser alterados quando o

Compilador Just-in-time (JIT)

- Esta técnica é normalmente utilizada para incrementar o desempenho de programas

- Em sistemas computacionais baseados em máquinas virtuais, como Java e .NET, o

Comparativo entre Compilação e Interpretação

Conceitos sobre Linguagens de Programação

- Linguagem de Alto Nível

- Linguagem de Baixo Nível

Paradigmas das Linguagens de Programação

Paradigma Imperativo (ou Procedural)

- Programação Orientado a Objetos

- Elas não utilizam variáveis.

Você também pode gostar