PARADIGMAS DE PROGRAMAÇÃO: UMA INTRODUÇÃO
Paradigmas de Programação
No contexto de desenvolvimento de software, paradigma significa um modelo para estruturar e representar problemas, cuja solução deseja-se obter através de um programa, construído a partir de uma linguagem de programação (SEBESTA, 2018). Existem diferentes paradigmas para desenvolver programas, tais como: imperativo, lógico, funcional, orientado a eventos e orientado a objetos, entre outros. Em algumas linguagens de programação, dependendo dos recursos oferecidos, é possível programar em mais de um paradigma (por exemplo, é muito comum algumas linguagens permitirem o desenvolvimento baseado no paradigma imperativo e, também, orientado a objeto). Neste caso, dependerá do conhecimento do programador (desenvolvedor de software) a utilização dos recursos mais adequados para a solução de cada um dos problemas.
Os diferentes paradigmas também podem envolver o domínio da aplicação das linguagens de programação, tais como: desenvolvimento de sistemas para uso comercial (Sistemas de Informação), aplicações matemáticas e aprendizado de programação, entre outros.
Sebesta (2018) elenca alguns motivos para que um estudante da área de Informática estude conceitos e diferentes paradigmas de linguagens de programação:
- Capacidade intelectual influenciada pelo poder expressivo das linguagens nas quais nos comunicamos, ou seja, quanto mais linguagens conhecermos, maior será a nossa capacidade intelectual. Isso vale para as línguas nas quais nos comunicamos, por meio da linguagem natural (Português, Inglês, Italiano, Francês, etc.) e, também, por meio das diferentes linguagens de programação por meio das quais nós, desenvolvedores de software, podemos nos expressar para solucionar problemas;
- Limitar-se à linguagem natural limita a capacidade de expressar os pensamentos em termos de profundidade e abstração. A abstração nos permite, literalmente, abstrair detalhes, para que possamos nos focar na solução do problema, de forma mais genérica. À medida que vamos quebrando o problema em partes, podemos aprofundar os detalhes necessários para sua implementação. A abstração também compreende a definição de classes e métodos (no chamado POO – Paradigma Orientado a Objeto) e no uso de diferentes estruturas de dados;
- O conhecimento de uma variedade mais ampla de recursos de linguagens de programação reduz as limitações no desenvolvimento de software, ou seja, podemos encontrar diferentes formas de resolver problemas, mesmo que a linguagem de programação não ofereça os recursos necessários, de forma nativa. Por exemplo: vamos supor que precisemos utilizar uma estrutura de dados do tipo pilha em nosso programa. Entretanto, a linguagem de programação que estamos utilizando não suporta ponteiros. Podemos, então, criar uma pilha utilizando uma estrutura de dados mais simples, um vetor (ou matriz unidimensional);
- Maior conhecimento para a escolha de linguagens apropriadas: quanto mais linguagens de programação conhecemos, maior será a nossa capacidade de definir qual a linguagem mais adequada de acordo com o tipo de problema que precisamos resolver;
- Capacidade aumentada para aprender novas linguagens: quanto mais linguagens de programação conhecemos, maior será o nosso potencial para aprendermos outras linguagens de programação, pois nosso cérebro já estará preparado para buscar as características mais importantes e recursos diferenciados de cada linguagem.
Domínios de Programação
Atualmente, os computadores são usados em uma infinidade de áreas (desde o controle de usinas elétricas até à armazenagem de registros de talões de cheques). Ficaria inviável pensarmos em inúmeras atividades rotineiras sem o uso da Tecnologia da Informação: acesso à Internet, transações bancárias, compras com cartões de débito e/ou crédito, Educação a Distância, enfim, uma infinidade de tarefas diárias que necessitam do computador (e de programas, escritos em uma linguagem de programação). Devido a essa diversidade de aplicações, linguagens de programação com propósitos muito diferentes têm sido desenvolvidas, tais como linguagens específicas para o desenvolvimento de jogos. Entre os domínios de programação, destacam-se:
- Aplicações Científicas: os primeiros computadores digitais (década de 40) foram inventados para aplicações científicas: estruturas de dados simples com um grande número de operações aritméticas com ponto-flutuante. Entre as linguagens de programação para o desenvolvimento de aplicações científicas citam-se o Algol e o Fortran;
- Aplicações comerciais: o uso de computadores para aplicações comerciais iniciou-se na década de 50. As linguagens de programação destinadas ao desenvolvimento deste tipo de aplicação possuem facilidades para produzir relatórios e armazenar dados. Exemplos deste tipo de linguagem de programação são a linguagem COBOL (Common Business Oriented Language) e o Clipper (Clipper/dBase);
- Aplicações de IA (Inteligência Artificial): são aplicações computacionais caracterizadas pelo uso de computações simbólicas ao invés de numéricas. Uma lista, por exemplo, pode armazenar conhecimento sobre um determinado problema, ao invés de dados. Sendo assim, sistemas de IA processam conhecimento, não dados (LORENZI; SILVEIRA, 2011). Entre as linguagens que podem ser aplicadas no contexto da IA destacam-se LISP e PROLOG (PROgramming in LOgic);
- Programação de Sistemas: compreendem as linguagens de programação para o desenvolvimento de Sistemas Operacionais (software básico). Os Sistemas Operacionais precisam ter execução rápida e recursos de baixo nível para permitir a interface com os dispositivos externos. Entre as linguagens de programação com este propósito citam-se: PL/S, BLISS, Extended ALGOL e C. O Sistema Operacional Unix (precursor do Linux) foi desenvolvido em Linguagem C;
- Linguagens de Scripting: são linguagens utilizadas colocando-se uma lista de comandos (script) em um arquivo para serem executados. Um exemplo são os arquivos BATCH (arquivos com a extensão .BAT). No Sistema Operacional MS-DOS (Microsoft Disk Operating System) era muito com criarmos arquivos .BAT que continham diversos comandos, tais como comandos de configuração do sistema, que deviam ser executado ao ligarmos o computador. Isto era possível por meio de um arquivo denominado AUTOEXEC.BAT (um arquivo autoexecutável). Existem outros tipos de linguagens de script, tais como: Action Script (executada no Adobe Flash), Open Script (executada no Multimedia ToolBook Instructor) e a linguagem Python, entre outras;
- Linguagens de programação para propósitos especiais, tais como linguagens para a geração de relatórios, criação de jogos e simulação de sistemas. Por exemplo, a linguagem RPG (Report Program Generator), para geração de relatórios comerciais e a linguagem de simulação de sistemas GPSS (General Purpose Simulation System).
Critérios de Avaliação de uma Linguagem de Programação
Os critérios de avaliação destacados nesta seção são baseados em Sebesta (2018).
Legibilidade
A legibilidade é um critério de avaliação que diz respeito à facilidade com que os programas podem ser lidos e entendidos. Este entendimento é importante para a manutenção dos programas. Antes de 1970 o desenvolvimento de software era baseado na escrita de código, ou seja, o mais importante era, efetivamente, escrever os programas. Na década de 70 a codificação passou para o segundo plano, dando lugar à manutenção (a facilidade de manutenção é determinada pela legibilidade dos programas). A legibilidade pode ser avaliada por meio das seguintes características:
- simplicidade global;
- ortogonalidade;
- instruções de controle;
- tipos de dados e estruturas e
- sintaxe (SEBESTA, 2018).
Legibilidade: Simplicidade Global
A simplicidade global significa que, uma linguagem com muitos componentes básicos é mais difícil de ser aprendida do que uma com poucos desses componentes. Geralmente, os desenvolvedores de software que precisam usar uma linguagem grande tendem a aprender um subconjunto dela e ignorar seus outros recursos. Este é um exemplo do que acontece com linguagens de programação mais complexas, como é o caso de Java (SEBESTA, 2018).
Ocorrem problemas de legibilidade sempre que o autor do programa tenha aprendido um subconjunto diferente daquele com o qual o leitor está familiarizado. Isso fica claro quando dizemos que programar é uma atividade criativa, ou seja, não é algo que pode ser, a princípio, automatizado, pois cada um de nós pode criar programas diferentes, com recursos diferentes, para resolver um mesmo problema (SEBESTA, 2018).
Algumas características que podem reduzir a legibilidade são:
- a multiplicidade de recursos e;
- a sobrecarga.
A multiplicidade de recursos diz respeito à existência de mais de uma maneira de realizar uma mesma operação. Por exemplo, uma operação de incrementar um contador, que pode ser feita de várias maneiras (algumas com resultados diferentes inclusive):
- contador = contador + 1
- contador += 1
- contador++
- ++contador
A sobrecarga (overloading) de operador acontece quando um único símbolo tem mais de um significado. Por exemplo: o sinal de adição (+) pode ser usado para adição de números inteiros e para matrizes (arrays), como mostram os exemplos abaixo:
- 10+20 ´resulta 30
- “10”+”20” ´resulta “1020”
Outro exemplo de sobrecarga ocorre no paradigma de Orientação a Objetos, quando descrevemos um mesmo método com diferentes assinaturas. Quando usamos a herança, podemos sobrescrever um método da classe-pai (BERTAGNOLLI, 2009).
Legibilidade: Ortogonalidade
A característica da ortogonalidade significa que um conjunto relativamente pequeno de construções primitivas pode ser combinado em um número relativamente pequeno de maneiras para construir as estruturas de controle e de dados da linguagem. Por exemplo, supondo que uma linguagem de programação tenha 4 tipos de dados primitivos: integer, float, double e character e 2 operadores de tipo: array e pointer (SEBESTA, 2018). Se os 2 operadores de tipo puderem ser aplicados a si mesmos e aos quatro tipos de dados primitivos, um grande número de estruturas de dados poderá ser definido, tais como:
- Arrays de integer, float, double e character
- Pointer (ponteiros) para integer, float, double, character e arrays
Porém, se não for permitido aos ponteiros apontar para arrays, muitas dessas possibilidades seriam eliminadas. A ortogonalidade parte de uma simetria de relações entre primitivas. Os ponteiros devem ser capazes de apontar para qualquer tipo de variável ou estrutura de dados para que uma linguagem de programação seja ortogonal. A falta de ortogonalidade acarreta exceções às regras de uma linguagem de programação, fazendo com que os desenvolvedores de software tenham que encontrar outras formas e/ou recursos para realizar suas implementações.
Legibilidade: Instruções de Controle
As instruções de controle que envolvem desvios (os chamados “gotos”) dificultam a legibilidade de um programa. Para aumentar a legibilidade deve-se utilizar a programação estruturada e eliminar comandos de desvio (goto). Isso pode ser feito utilizando-se sub-rotinas (procedimentos e funções) e, em paradigmas como o da Orientação a Objeto, por meio de métodos (SEBESTA, 2018).
Sebesta (2018) coloca que pode-se restringir o uso de instruções goto para tornar os programas mais legíveis, destacando-se que elas devem preceder seus alvos, exceto quando usadas para formar laços; seus alvos nunca devem estar muito distantes; e seu número dever ser limitado (ou até mesmo nulo, se possível).
Legibilidade: Tipos de Dados e Estruturas
A presença de facilidades adequadas para definir tipos de dados e estruturas de dados em uma linguagem de programação é outro auxílio significativo para a legibilidade. Algumas linguagens de programação mais modernas possuem estruturas de dados já implementadas, para que os desenvolvedores possam utilizar pilhas, filas, listas e outras estruturas. Em algumas linguagens é preciso construir métodos para implementar estas estruturas, geralmente utilizando-se ponteiros (pointers – alocação dinâmica de memória) (SEBESTA, 2018).
Legibilidade: Considerações sobre a Sintaxe
As regras de sintaxe de uma linguagem de programação também podem contribuir (ou não) para a legibilidade de um programa. Seguem alguns exemplos (SEBESTA, 2018) de regras de sintaxe que podem dificultar a legibilidade de um programa:
- Restringir os identificadores a tamanhos muito pequenos. Na linguagem FORTRAN 77, por exemplo, os identificadores podiam ter apenas 6 caracteres no máximo;
- Palavras especiais ou reservadas: a legibilidade de um programa é fortemente influenciada pelas formas das palavras especiais, tais como o método para formar instruções compostas ou grupos de instruções (ex.: begin – end, abrir e fechar chaves {}). Utilizar os mesmos símbolos não é adequado. O mais correto seria utilizar end for, end if, end while, ao invés de usar somente fechar chaves, por exemplo;
- Em algumas linguagens, como no FORTRAN 90, palavras especiais como DO e END são nomes válidos de variáveis, o que dificulta o entendimento: como saber se está sendo utilizado um identificador (variável) ou um comando da linguagem?
Ainda considerando a sintaxe, destacam-se as características que envolvem a forma e o significado. Neste sentido, os desenvolvedores de linguagens de programação devem projetar instruções a fim de que sua aparência indique, pelo menos parcialmente, ou seja, sua finalidade é um auxílio para a legibilidade. A semântica (significado) deve seguir diretamente da sintaxe ou da forma.
Esse princípio é violado por duas construções de linguagem idênticas ou similares quanto à aparência, mas com significados diferentes, dependendo, por exemplo, do contexto.
Capacidade de Escrita (Writability)
A capacidade de escrita, ou writability, é a medida de quão facilmente uma linguagem pode ser utilizada para criar programas para um domínio de problema escolhido. A maioria das características da linguagem que afeta a legibilidade também afeta a capacidade de escrita (escrever um programa exige uma releitura frequente da parte que já foi escrita pelo programador) e é essencial para a manutenção de sistemas (SEBESTA, 2018).
A capacidade de escrita pode ser considerada com base nas características de:
- simplicidade e ortogonalidade;
- suporte para abstração; e
- expressividade (SEBESTA, 2018).
Simplicidade e Ortogonalidade
Caso uma linguagem de programação tenha um grande número de diferentes construções, alguns programadores podem não estar familiarizados com todas elas. Isso pode levar ao uso inadequado de alguns recursos e ao desuso de outros que podem ser mais elegantes ou mais eficientes. Um número menor de construções primitivas e um conjunto consistente de regras para combiná-las (ortogonalidade) é muito melhor do que existir um grande número de primitivas(SEBESTA, 2018).
Apesar disso, uma ortogonalidade demasiada pode resultar em prejuízo para a capacidade de escrita, pois erros ao escrever programas podem não ser detectados, uma vez que quase todas as combinações de primitivas são permitidas. É preciso existir um equilíbrio.
Suporte para Abstração
A abstração é a capacidade de definir e, depois, de usar estruturas ou operações complexas de uma maneira que permita ignorar muitos dos detalhes de implementação. Isto é possível, por exemplo, por meio da implementação de métodos. Se criarmos métodos para manipular uma estrutura de dados do tipo pilha (inserir dados na pilha – empilhar, retirar dados da pilha – desempilhar e assim por diante) outros desenvolvedores poderão, posteriormente, manipular uma pilha apenas chamando estes métodos, sem necessidade de conhecer os detalhes da nossa implementação (SEBESTA, 2018).
O grau de abstração permitido por uma linguagem de programação é muito importante para a sua capacidade de escrita (writability). As linguagens de programação podem suportar duas categorias distintas de abstração: processo e dados. Um exemplo de abstração de processo é o uso de subprogramas (métodos) para que o mesmo código não precise ser replicado muitas vezes. Basta chamar o método para executá-lo quantas vezes for necessário.
A abstração de dados envolve a aplicação de diferentes estruturas de dados e formas de manipulá-las em uma linguagem de programação (por exemplo, diferentes formas para manipular uma árvore binária).
Expressividade
A expressividade é a capacidade de que operadores muito poderosos permitam que uma grande quantidade de computação seja realizada com um programa muito pequeno. Por exemplo:
- contador = contador +1
- contador++ ´o operador ++ faz a mesma operação do que as instruções anteriores
Um exemplo de expressividade, utilizando a linguagem Python, é o operador de atribuição (sinal de igualdade =). Podemos realizar atribuições múltiplas em Python, tais como:
- x, y = 10, 20 # nesta mesma linha, a variável x está recebendo o valor 10 e a variável y o valor 20, respectivamente
Confiabilidade
Um programa é considerado confiável se ele se comportar de acordo com as suas especificações sob todas as condições. Isto pode ser verificado por meio de inúmeros testes que devem ser realizados antes do software ser disponibilizado aos usuários. A confiabilidade pode ser medida por meio de:
- verificação de tipos;
- manipulação de exceções; e
- aliasing (SEBESTA, 2018).
Confiabilidade: verificação de tipos
A verificação de tipos pode ser realizada por meio de testes, para identificar se existem erros de tipo em um programa, por meio do compilador ou durante a execução do programa. A verificação em tempo de compilação é desejável pois, quanto mais cedo forem detectados erros em um programa, menos dispendioso serão as suas correções. Um exemplo de erro bem comum é quando declaramos uma variável do tipo inteiro e, o usuário ao entrar com os dados, digita um caracter alfabético. Este é um erro de semântica, pois a variável (identificar) declarado não permite o armazenamento de caracteres que não sejam numéricos.
Confiabilidade: Manipulação de Exceções
A manipulação de exceções (exceptions) é a capacidade de um programa interceptar erros em tempo de execução, pôr em prática medidas corretivas e, depois, prosseguir com a execução. Esta possibilidade é um grande auxílio para a confiabilidade dos programas. Um exemplo de manipulação de exceções é o bloco Try…Catch da linguagem de programação Java.
Confiabilidade: Aliasing
O conceito de aliasing é o de existirem dois ou mais métodos, ou nomes, distintos para fazer referência à mesma célula da memória. Isto se configura como um recurso perigoso em uma linguagem de programação. Por exemplo, se criarmos um método que receberá um parâmetro com passagem por referência (apontando para a mesma área de memória), estaremos modificando o valor desta área de memória dentro do método – este é um problema e um exemplo de aliasing.
Em algumas linguagens o aliasing é usado para superar deficiências nas facilidades de abstração de dados. Entretanto, algumas linguagens o restringem muito, para aumentarem sua confiabilidade.
Custo
A última característica a ser avaliada é o custo de uma linguagem de programação. O custo final de uma linguagem de programação é uma função de muitas de suas características (SEBESTA, 2018):
- custo para treinar desenvolvedores, compreendendo as características ligadas à simplicidade e à ortogonalidade;
- custo para escrever (writability) programas na linguagem;
- custo para compilar programas na linguagem;
- custo para executar programas (influenciado pelo projeto da linguagem);
- custo do sistema de implementação da linguagem;
- custo da má confiabilidade;
- custo da manutenção de programas.
Influências sobre o Projeto de uma Linguagem de Programação
Ao projetar uma linguagem de programação o desenvolvedor (ou uma equipe de desenvolvedores) deve levar em consideração aspectos ligados à:
- arquitetura do computador e
- metodologia de programação (SEBESTA, 2018).
A arquitetura dos computadores exerceu um efeito crucial sobre o projeto das linguagens de programação, em especial a arquitetura de von Neumann. Nesta arquitetura, dados e programas são armazenados na mesma memória e as variáveis (identificadores) são os recursos centrais dos programas. As linguagens de programação que seguem esta arquitetura, na sua grande maioria, são chamadas de imperativas, tais como C, COBOL, Pascal e Clipper, entre outras.
Quanto às metodologias de programação, pode-se implementar linguagens que usam comandos de desvio (goto), baseadas em programação estruturada (projeto top-down) ou baseadas no Paradigma de Orientação a Objetos.
A seguir temos um exemplo de um trecho de código-fonte escrito em linguagem BASIC, utilizando comandos de desvio (goto). Para utilizar comandos de desvio precisamos que as linhas do código-fonte sejam numeradas (para podermos indicar para qual linha a execução deve ser desviada) ou que o trecho do código seja nomeado com um rótulo (label). No exemplo temos o uso do comando GOTO nas linhas 30 e 70. Caso o usuário não pressione a tecla S ele receberá a mensagem Pressione a tecla S e o programa voltará à execução para a linha 10. Caso o usuário pressione a tecla S o programa encerrará a execução (END na linha 50).
10 PRINT “Pressione uma tecla:”
20 TECLA$=INPUT$(1)
30 IF TECLA$<>”S” AND TECLA$<>”s” THEN GOTO 60
50 END
60 PRINT “Pressione a tecla S” 70 GOTO 10
Categorias de Linguagens de Programação
Existem quatro categorias principais de linguagens de programação, compreendendo, então, quatro paradigmas principais:
- imperativas,
- funcionais,
- lógicas e
- orientadas a objeto.
Existem outras categorias, tais como as linguagens orientadas a eventos. Algumas vezes uma linguagem de programação é baseada em um dos quatro paradigmas principais e possui recursos de outro paradigma. Por exemplo, Java é uma linguagem de programação orientada a objeto mas, quando utilizamos componentes da interface gráfica (tais com janelas e botões), também será preciso desenvolver código de acordo com a ocorrência de eventos (paradigma de orientação a eventos), tais como clique com o mouse sobre um botão.
Seguem alguns exemplos de linguagens de programação de acordo com as principais categorias:
- Imperativas: C, Pascal, COBOL, Clipper;
- Funcionais: LISP, Scheme;
- Lógicas: PROLOG;
- Orientadas a Objeto: C#, Java, SmallTalk.
Métodos de Implementação de Linguagens de Programação
A linguagem de máquina do computador é seu conjunto de macroinstruções. A sua própria linguagem de máquina é a única que a maioria dos computadores compreende para executar as instruções de um programa (SEBESTA, 2018). Para que um desenvolvedor possa criar programas em uma linguagem de programação de alto nível (mais próxima da nossa linguagem natural), é preciso converter o código-fonte em um código que possa ser executado e entendido pelo computador. Essa conversão pode ser feita por um programa compilador, por exemplo.
Um computador poderia ser projetado e construído com uma linguagem de alto nível particular como sua linguagem de máquina, mas seria complexo, caro e inflexível. Seria muito difícil utilizar outras linguagens de alto nível neste mesmo computador. Antigamente, muitos computadores eram desenvolvidos desta forma e só podiam ser programados com uma única linguagem (como se fosse uma linguagem proprietária). Atualmente isso seria inviável, devido ao alto custo e dificuldades de aprendizado de inúmeras linguagens de programação.
A opção de projeto de máquina mais prática implementa, em hardware, uma linguagem de nível muito mais baixo, que oferece as operações primitivas mais comumente necessárias e exige que o software de sistema (por exemplo, o Sistema Operacional) crie uma interface com os programas de nível mais elevado, tais como as IDEs (Integrated Development Environment), que são ambientes integrados para desenvolvimento de software (por exemplo, o NetBeans e o Visual Studio).
Um sistema de implementação de uma linguagem de programação não pode ser o único software em um computador. Faz-se necessário um grande conjunto de programas, que compõem o Sistema Operacional, que fornece primitivas de mais alto nível do que as de linguagem de máquina, facilitando o acesso aos recursos do computador (SEBESTA, 2018).
As primitivas de um Sistema Operacional (SO) oferecem gerenciamento de recursos do sistema, operações de entrada e saída, um sistema de gerenciamento de arquivos, editores de texto, entre outros recursos necessários para que um programa possa ser executado, interagindo com o usuário e com os dispositivos de hardware.
Como os sistemas de implementação de linguagens de programação necessitam de muitas das facilidades do SO, eles comunicam-se com o SO ao invés de diretamente com o processador (em linguagem de máquina).
O SO e as implementações são dispostos em camadas sobre a interface da linguagem de máquina de um computador. Essas camadas podem ser abstraídas como computadores virtuais, que oferecem interfaces de alto nível para os usuários, neste caso, os desenvolvedores de software. A Figura 1 apresenta esta abstração de camadas.
Compilação
A implementação de uma linguagem de programação compilada significa que os programas podem ser traduzidos para linguagem de máquina, que pode ser executada diretamente no computador. Este método tem a vantagem de uma execução de programa muito rápida, pois é gerado um arquivo executável durante o processo de compilação. O processo de compilação é dividido em diferentes fases:
- análise léxica;
- análise sintática;
- geração do código intermediário e análise semântica (SEBESTA, 2018):
-
- O analisador léxico reúne os caracteres do código-fonte em unidades léxicas que são os identificadores, as palavras especiais, os operadores e os símbolos de pontuação. Os comentários são ignorados;
- O analisador sintático recebe, como entrada, as unidades do analisador léxico (tokens) e usa-as para construir estruturas hierárquicas chamadas árvores de análise (parse trees), as quais representam a estrutura sintática de um programa. A análise sintática verifica se o código-fonte foi construído de forma a respeitar as regras de sintaxe da linguagem de programação;
- O gerador de código intermediário produz um programa em uma linguagem diferente, no nível intermediário entre o código-fonte e a saída final do compilador, que é um programa em linguagem de máquina. As linguagens intermediárias se parecem com as linguagens Assembly. O analisador semântico faz parte do gerador de código intermediário e verifica se há erros difíceis de serem detectados durante a análise sintática, tais como erros de tipo.
A primeira fase da análise, a análise léxica, divide o código-fonte em tokens, a partir de categorias, tais como identificadores e palavras reservadas. Por exemplo, supondo que o analisador léxico irá decompor a seguinte instrução (escrita em pseudocódigo):
calculo = 5 * quadrado + 10 | |
Lexemas | Tokens |
calculo | identificador |
= | literal inteiro |
* | operador de multiplicação |
quadrado | identificador |
+ | operador de adição |
10 | literal inteiro |
Esta lista de tokens será a entrada para o analisador sintático que, por meio de árvores de análise, verificará se as regras de sintaxe estão sendo cumpridas. Antigamente era preciso digitar todo o código-fonte e submetê-lo ao processo de compilação para verificar se existiam ou não erros de sintaxe. Atualmente, as IDEs são mais inteligentes e, à medida que o desenvolvedor de software vai digitando o código-fonte, já vão sendo mostrados possíveis erros de sintaxe e/ou mensagens de aviso (warnings), tais como variáveis que são declaradas e não são efetivamente utilizadas no programa.
A segunda fase é a análise sintática, por meio de árvores de análise sintática ou parse trees. Supondo que vamos criar uma árvore da mesma instrução utilizada no exemplo da análise léxica: calculo = 5 * quadrado + 10. Podemos, de acordo com as regras de sintaxe da linguagem de programação, abstrairmos esta instrução da seguinte forma:
<atribuição> <- <identificador> = <expressão>
Esta abstração significa que, um comando de atribuição, segundo as regras de sintaxe de uma linguagem de programação, pode ser representado por um identificador (variável criada pelo programador) recebendo o valor de um expressão aritmética.
A árvore de análise, para este comando, poderia ser construída como mostra a Figura 2.
A verificação da sintaxe pode ser realizada a partir da leitura dos nodos (nós) folha da árvore (destacados com uma elipse ao seu redor): calculo = 5 * quadrado +10.
A geração de código intermediário é a criação de um programa em linguagem semelhante à linguagem Assembly, que utiliza mnemônicos para acessar os registradores do processador (tais como AX, BX, CX). A Figura 3 apresenta exemplos de instruções escritas em Assembly.
Ao final do processo de compilação temos o código executável de um programa, em linguagem de máquina. Apesar de a linguagem de máquina gerada por um compilador possa ser executada diretamente no hardware, quase sempre ela deve ser executada com algum outro código, tais como programas do Sistema Operacional, que permitem o acesso a diferentes recursos da máquina. Para isso é necessário vincular (ou ligar) os programas de usuários aos programas de sistema e, também, a bibliotecas, por meio de um linkeditor (SEBESTA, 2018).
A execução de um programa em código de máquina (arquivo executável) em um computador com arquitetura de von Neumann ocorre em um processo chamado ciclo buscar-executar. Os programas residem na memória volátil (ou memória RAM – Random Access Memory) mas são executados na CPU (Central Process Unit ou UCP – Unidade Central de Processamento). Cada instrução a ser executada precisa ser transferida da memória para o processador. O endereço da instrução seguinte a ser executada é mantido em um registro chamado contador de programa (SEBESTA, 2018). A Figura 4 apresenta uma abstração da arquitetura de von Neumann.
De acordo com a Figura 4, temos:
- Periféricos de entrada: que permitem a interação do usuário com o programa que está sendo executado;
- Periféricos de saída: que permitem que o usuário receba os resultados (respostas) do programa em execução;
- Unidade Central de Processamento: que faz a execução das instruções do programa, buscando, na memória, cada linha do programa que deve ser executado e, também, os valores armazenados nas variáveis. O fluxo entre a UCP e a memória é de mão dupla, pois as instruções são lidas na memória, enviadas para a UCP e os resultados são devolvidos para a memória.
Por exemplo, supondo a execução da instrução calculo = 5 * quadrado = 10:
- a UCP, por meio do contador de programa, irá buscar esta instrução na memória;
- a UCP irá buscar o valor armazenado na variável quadrado;
- a UCP irá realizar o cálculo, primeiro da multiplicação (pela ordem de precedência), 5 * quadrado e, depois, irá somar este resultado ao número inteiro 10;
- a UCP irá devolver o resultado para a memória, armazenando-a na variável cálculo.
Interpretação Pura
Na extremidade oposta à compilação, os programas podem ser interpretados por outro programa chamado interpretador, sem nenhuma conversão. Exemplos de linguagens interpretadas são o dBase (precursor da linguagem de programação Clipper) e a linguagem PROLOG, entre outras (SEBESTA, 2018).
O programa interpretador funciona como um simulador de software de uma máquina cujo ciclo buscar-executar lida com instruções de programa em linguagem de alto nível ao invés de instruções em código de máquina. Essa simulação de software fornece uma máquina virtual para a linguagem. Como vantagem ao processo de compilação, ao ocorrer um erro de execução, pode-se apontar a linha do código fonte onde tal erro ocorreu (SEBESTA, 2018).
Como desvantagem, a interpretação pode ser de 10 a 100 vezes mais lenta do que a compilação. A principal causa dessa lentidão é a decodificação mais lenta das instruções em linguagem de alto nível, bem mais complexas do que as instruções em linguagem de máquina. Além disso, a interpretação também exige mais espaço de memória, pois, além do código-fonte, a tabela de símbolos deve estar presente na interpretação, para que o interpretador faça a análise sintática, instrução a instrução (SEBESTA, 2018).
Sistemas de Implementação Híbridos
Alguns sistemas de implementação de linguagens são um meio-termo entre os compiladores e os interpretadores. Estes sistemas convertem programas em linguagem de alto nível para uma linguagem intermediária projetada para permitir uma fácil interpretação. Ao invés de traduzir o código fonte em uma linguagem intermediária (tal como a linguagem Assembly), este tipo de sistema interpreta o código intermediário, ou seja, a entrada para o sistema híbrido é o código intermediário (SEBESTA, 2018).
A linguagem de programação Perl utiliza este tipo de sistema. Além disso, as implementações iniciais da linguagem de programação Java eram todas híbridas e, para executar um programa, era necessário contar com um software denominado máquina virtual Java (SEBESTA, 2018).
Considerações sobre Sintaxe e Semântica
O estudo das linguagens de programação pode ser dividido em sintaxe e semântica. Sintaxe significa que uma instrução (ou comando) da linguagem está construída corretamente, de acordo com as regras da respectiva linguagem. A semântica tem relação com o sentido, ou seja, se aquela instrução faz sentido. Por exemplo, em linguagem natural, se escrevermos: Apague a luz. Esta frase está escrita corretamente (sintaxe) e faz sentido (semântica). E se escrevêssemos: Apague a porta? A sintaxe continua correta mas o sentido não (a não ser que estejamos desenhando uma casa e queremos, literalmente, apagar a porta). Em programação de computadores isto também acontece. Por exemplo:
a = 10 + 20
Esta instrução está escrita corretamente, do ponto de vista da sintaxe e da semântica. A variável a irá receber a soma dos valores 10 e 20, resultando no valor 30. E se escrevêssemos a seguinte instrução:
a = 10 + “a”
A sintaxe desta instrução está adequada, ou seja, uma variável recebe o resultado de uma expressão aritmética (de uma soma). O problema é que não faz sentido (semântica), somar o número inteiro 10 com a letra (caracter alfabético e não uma variável) a. Em algumas linguagens de programação, como a linguagem PHP, o resultado de uma expressão destas seria “10a” mas, na maioria das linguagens, esta instrução contém um erro de semântica.
A sintaxe de uma linguagem de programação é a forma de suas expressões, de suas instruções e de suas unidades de programa. A semântica é o significado destas três características (SEBESTA, 2018). Por exemplo, vamos analisar a sintaxe de uma instrução if (seleção simples) de acordo com as regras da linguagem C:
if (<expressão>) <instrução>
As informações destacadas entre os sinais de maior e menor <> indicam que, nestes locais, será introduzido o código-fonte criado pelo desenvolvedor. Em <expressão> será colocada uma expressão (lógica ou relacional), que será validada. Caso a expressão resulte verdadeiro (true), a <instrução> logo após o if será executado. Esta é a semântica, o significado deste comando: se o valor atual da <expressão> for verdadeiro, a <instrução> será selecionada para execução.
A sintaxe e a semântica estão estreitamente relacionadas, ou seja, em uma linguagem de programação bem projetada, a semântica deve seguir-se diretamente da sintaxe. Isto quer dizer que a forma de uma instrução deve sugerir fortemente o que esta pretende realizar. Descrever a sintaxe é mais fácil do que a semântica, em parte porque uma notação concisa e aceita universalmente está disponível para a descrição da sintaxe, mas nenhuma foi desenvolvida ainda para a semântica (SEBESTA, 2018). A semântica (o sentido) é a parte criativa da programação, ou seja, diferentes programadores podem, utilizando as regras de sintaxe, construírem programas diferentes que solucionam um mesmo problema.
As linguagens, sejam naturais, tais como o Português, ou linguagens de programação, como a linguagem Java, são conjuntos de sequências de caracteres de algum alfabeto. As sequências são chamadas de sentenças ou instruções. As regras de sintaxe especificam quais sequências de caracteres do alfabeto da linguagem podem ser utilizadas no desenvolvimento de programas na respectiva linguagem (SEBESTA, 2018).
As descrições formais das linguagens de programação, em nome da simplicidade, não incluem descrições das unidades sintáticas de nível mais baixo (identificadores, literais, operadores e palavras especiais).
Em 1959 foi criado um documento que introduziu uma nova notação formal para especificar a sintaxe das linguagens de programação, conhecido como Forma de Backus-Naur ou simplesmente BNF, a partir de estudos anteriores dos pesquisadores John Backus (ALGOL 58) e Peter Naur (ALGOL 60). Essa notação é uma metalinguagem, ou seja, uma linguagem usada para descrever outra linguagem. Assim, a BNF é uma metalinguagem para as linguagens de programação (SEBESTA, 2018).
A BNF usa abstrações para estruturas sintáticas, representadas entre os sinais de maior e menor <>. Uma simples instrução de atribuição poderia ser representada pela abstração <atribuição>. No entanto, a definição real de <atribuição> poderia ser dada por:
<atribuição> → <var> = <expressão>
onde, o símbolo à esquerda da seta (LHS – left-hand side) é a abstração que está sendo definida e o texto à direita (RHS) é a definição do LHS, consistido em uma mistura de tokens, lexemas e de referências a outras abstrações. O exemplo significa que a abstração <atribuição> deriva em uma abstração <var> que recebe uma abstração <expressão>. Essa é uma definição da BNF, também chamada de regra ou produção (SEBESTA, 2018).
As abstrações em uma descrição BNF são chamadas símbolos não-terminais (nodos que precisam ser expandidos em uma árvore sintática) e os tokens e os lexemas são chamados de símbolos terminais (nodos folha de uma árvore sintática).
Os símbolos não-terminais podem ter mais de uma definição, representando diferentes possibilidades de escrita daquela instrução em uma determinada linguagem de programação. Por exemplo, a instrução if (ou comando_if) pode ser construído de diferentes formas:
<comando_if> → if <expressão_lógica> then <comando>
<comando_if> → if <expressão_lógica> then <comando> else <comando>
Estas diferentes possibilidades podem ser representadas pelo símbolo | (que representa um ou):
<commando_if> → if <expressão_lógica> then <comando>
| if <expressão_lógica> then <comando> else <comando>
Para descrevermos uma lista de itens usando a BNF, ao invés de usarmos a forma Matemática, onde listas de tamanho variável são escritas usando-se três pontos: 1, 2, …, devemos utilizar a recursão (ou recursividade). Uma regra é recursiva se o LHS aparecer em seu RHS, como no exemplo abaixo, onde a abstração <lista_de_identificadores> aparece no RHS, remetendo ao LHS.
<lista_de_identificadores> → identificador
| identificador, <lista_de_identificadores>
Vamos utilizar um exemplo de uma BNF com um número reduzido de regras, para compreendermos o processo de derivação de um pequeno programa. A BNF tem 5 regras (5 abstrações):
<programa>, <lista_de_comandos>,
<comando>, <variável> e <expressão>.
<programa> → início <lista_de_comandos> fim
<lista_de_comandos> → <comando>
| <comando>; <lista_de_comandos>
<comando> → <variável> := <expressão>
<variável> → A | B | C
<expressão> → <variável> + <variável>
| <variável> – <variável>
| <variável>
Analisando-se esta pequena gramática, de uma linguagem de programação hipotética, temos que um programa (representado pela abstração <programa>) é uma lista de comandos, precedida pela palavra reservada início e terminada pela palavra reservada fim:
<programa> → início <lista_de_comandos> fim
Uma lista de comandos, representada pela abstração <lista_de_comandos> pode ser apenas uma instrução (abstração <comando>) ou uma lista de diferentes comandos que existem nesta linguagem hipotética, separados por um ponto-e-vírgula (;).
<lista_de_comandos> → <comando>
| <comando>; <lista_de_comandos>
Esta linguagem tem um único comando, que é o comando de atribuição:
<comando> → <variável> := <expressão>
Além disso, por ser uma linguagem bastante enxuta, só podem ser usadas as variáveis pré-determinadas (pela abstração <variável>) A, B ou C.
<variável> → A | B | C
As expressões permitidas (por meio da abstração <expressão>) podem ser a soma de duas variáveis, a subtração de duas variáveis ou atribuir o valor de uma variável à outra. Estas expressões são definidas pela abstração <expressão>.
<expressão> → <variável> + <var>
| <variável> – <variável>
| <variável>
Conhecendo a gramática da linguagem, é possível saber o que podemos escrever com a mesma, ou seja, quais programas são permitidos. Por exemplo, seguindo a gramática anterior é possível escrevermos a sentença A:=A+B?
E a sentença A:=A*C? Esta sentença é permitida?
Para validarmos estas sentenças, ou seja, verificarmos se estão escritas corretamente de acordo com a sintaxe da linguagem, podemos criar as árvores de análise sintaticamente correspondentes (ou parse trees), como vimos, anteriormente.
Parse Trees
Vamos fazer, então, o processo de derivação de um programa, seguindo a gramática da linguagem hipotética da seção anterior, para verificarmos se é possível escrevemos o seguinte programa:
programa inicio A:=A+B;
fim
O processo de derivação começa com o símbolo de iniciar <programa>, e o símbolo => representa “deriva”. Cada abstração deve ser derivada sequencialmente, substituindo um dos não-terminais (símbolos entre os sinais de maior e menor <>) por uma definição do mesmo, constante da gramática da linguagem. Nessa definição o não-terminal substituído sempre é o da extrema esquerda na forma sentencial anterior (derivação à esquerda). A derivação prossegue até que a forma sentencial não contenha nenhum símbolo não- terminal. Vejamos o exemplo:
<programa>=> início <lista_de_comandos> fim
=> início <comando> fim
=> início <variável> := <expressão> fim
=> início A := <expressão> fim
=> início A:= <variável> + <variável> fim
=> início A:= A + <variável> fim
=> início A:= A + B fim
Vamos analisar o processo de derivação passo-a-passo. Começamos pela abstração <programa>, que é uma lista de comandos, que começam com a palavra reservada início e terminam com a palavra reservada fim:
<programa> => início <lista_de_comandos> fim
O próximo passo da derivação é resolver a abstração <lista_de_comandos>. Como queremos apenas um comando, pois o nosso programa de exemplo só tem uma atribuição, vamos derivar <lista_de_comandos> como <comando>:
=> início <comando> fim
A próxima derivação é escolher um comando permitido pela linguagem. Na nossa linguagem hipotética, o único comando existente é o de atribuição (atribuir uma expressão a uma variável):
=> início <variável> := <expressão> fim
Seguindo o processo de derivação, devemos derivar a primeira abstração <variável> e, pelonossoprogramadeexemplo, precisamosderivarnovamenteem A:
=> início A := <expressão> fim
Agora precisamos derivar, primeiro, a abstração mais à esquerda, que é
<expressão> e verificarmos se existe a expressão que queremos utilizar (no caso a soma de duas variáveis):
=> início A:= <variável> + <variável> fim
Ainda seguindo o processo de derivação, devemos derivar a primeira abstração
<variável>e, pelonossoprogramadeexemplo, precisamosderivarnovamenteem A:
=> início A:= A + <variável> fim
Agora vamos derivar a segunda abstração <variável> e, pelo nosso programa de exemplo, precisamos derivar em B:
=> início A:= A + B fim
Como não temos mais nenhuma abstração (nenhum símbolo não-terminal), significa que conseguimos fazer a derivação do nosso programa de exemplo, comprovando que é possível escrevê-lo com a gramática desta linguagem hipotética. E como ficaria aárvoredeanálisedesteprograma? Vejamosna Figura 5.
Segundo Sebesta (2018), a gramática de uma linguagem descreve a estrutura sintática hierárquica da linguagem que define, sendo que todo vértice interno de uma árvore de análise é um símbolo não-terminal, toda folha é um símbolo terminal e toda árvore secundária de uma análise descreve uma instância de uma abstração na instrução.