12PAD_aula01_doc02

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

1 
 
Um pouco da história das linguagens de programação 
 
Na década de 50, com o intuito de facilitar a vida do programador, minimizando 
seu esforço e fazê-lo abstrair-se do endereçamento direto de memória e da combinação 
de bits, surgiam as primeiras linguagens de montagem (assembly), onde as operações 
realizadas pelo processador eram representadas por mneumônicos como ADD (Adicione), 
SUB (Subtraia), MOV (carrega valores para o registrador) e etc. 
 
É importante ressaltar que cada processador tinha seu respectivo conjunto de 
instruções em linguagem de montagem, na relação de 1 para 1 para o conjunto de 
instruções do processador em linguagem de máquina (set de instruções do processador). 
 
A tabela 2, abaixo, mostra que em linguagem de montagem toda instrução tem 
uma notação simbólica associada (fornecida pelo fabricante do processador). 
 
 
 
Instrução em código de 
máquina 
Hexadecimal 
Instrução em linguagem 
de montagem 
Comentários sobre a instrução 
A1 01 10 MOV AX, [0110] 
Copiar o conteúdo de 0110 no registro 
AX 
03 06 01 12 ADD AX, [0112] 
Adicionar o conteúdo de 0112 à AX e 
por o resultado no AX 
A3 01 14 MOV [0114], AX 
Armazenar AX no endereço da 
memória 0114 
 
Tabela 2: exemplo de programa em linguagem de montagem 
 
Incialmente, tal qual na linguagem de máquina o tipo de problema a ser resolvido 
era simples, geralmente numérico e não existia técnica de programação. Porém a 
necessidade de programação crescia e os programas também, assim as linguagens de 
montagem mais avançada criaram o conceito de macro, que pode-se dizer foi a base da 
criação da técnica da programação modular. Um macro é um trecho de código (módulo) 
que se repete ao longo de um programa, que era escrito uma única vez e chamado 
sempre que necessário. 
 
Abaixo, a figura 1 (Exemplo de código assembly com macro) mostra 2 colunas a 
primeira com o código sem macro e a segundo com o código com a macro de nome 
 
 
2 
 
CHANGE. Perceba que o código é o mesmo alterando apenas o conteudo (P,Q,R,S) que 
vai ser armazendo nos registradores (EAX e EBX). A macro change usa parâmetros (P1 e 
P2) e é chamada 2 vezes, para realizar as trocas de conteúdos desejados). 
 
 
Figura 1: exemplo de código Assembly com Macro 
 
Na final da década de 50 e início da década de 60 surgem as primeiras linguagens 
de alto nível, que são assim chamadas pela sintaxe dos comandos que são bem próximas 
a linguagem humana (no inglês, no caso). A primeira linguagem dessa geração de 
linguagens, que seria a 3ª. Geração (1ª. Geração, a linguagem de máquina e 2ª geração, 
a linguagem assembly) foi o Fortran, desenvolvida inicialmente para computadores IBM, 
destinada a aplicações numérico-científicas (poucos dados e muita computação). Não 
focava a eficiência dos programas na medida em que as estruturas de controle eram 
todas focadas em GOTO (desvio incondicional), que são a implementação das macros nas 
linguagens de 3ª. Geração. Nesse estado da arte, começa a surgir a idéia de 
programação modular, ou seja criação de sub-rotinas para parte de programas que se 
repetem, mas a programação com desvios dificultava a leitura e manutenção dos códigos 
dos programas 
 
A tabela 3, abaixo, mostra o exemplo de um programa em Basic, uma linguagem 
de programação das décadas 60/70, usando desvio incondicional (GOTO), uma forma de 
simular repetições. 
 
 
 
 
 
 
3 
 
 
 
10 REM RESOLVE EQUACAO DO SEGUNDO GRAU 
20 READ A,B,C 
30 IF A=0 THEN GOTO 410 
40 LET D=B*B-4*A*C 
50 IF D<0 THEN GOTO 430 
60 PRINT "SOLUCAO" 
70 IF D=0 THEN GOTO 100 
80 PRINT "PRIMEIRA SOLUCAO",(-B+SQR(D))/(2*A) 
90 PRINT "SEGUNDA SOLUCAO",(-B-SQR(D))/(2*A) 
100 GOTO 20 
200 PRINT "SOLUCAO UNICA",(-B)/(2*A) 
300 GOTO 20 
400 PRINT "A DEVE SER DIFERENTE DE ZERO" 
410 GOTO 20 
420 PRINT "NAO HA SOLUCOES REAIS" 
430 GOTO 20 
490 DATA 10,20,1241,123,22,-1 
500 END 
 
 
 Tabela 3: exemplo de programa em basic, usando GOTO 
 
No início da década de 70 iniciou-se o movimento de técnica de programação 
estruturada, na tentativa de tornar os códigos dos programas mais legíveis. A essa altura 
os programas eram lotados de instruções de desvio incondicional (os chamados GOTO), 
que tiravam a seqüência lógica das instruções do programa e tornavam a leitura e 
conseqüente entendimento do programa em algo muito difícil. Nessa época as 
linguagens de programação eram pobres em estruturas de controle (decisão e repetição) 
e não verificavam consistência de tipos, onde destacavam-se na época: Fortran, Basic e 
Cobol (as mais usadas). 
 
Em 1971 foi criada por Niklaus Wirth a linguagem Pascal, para fins acadêmicos 
de ensino da programação estruturada. Seu pequeno número de comandos básicos pode 
ser combinado de forma a torna-la mais poderosa, mas sem perder a clareza lógica de 
suas construções. O uso de subprogramas permite a técnica de refinamentos sucessivos 
(metodologia top-down) conseguindo hierarquia na estrutura do programa. 
 
Além da técnica de refinamentos sucessivos, a programação estruturada 
caracteriza-se pela construção de programas com 3 estruturas básicas de controle: 
sequencia, decisão e repetição (iteração). 
 
 
 
4 
 
A tabela 4, abaixo, mostra um programa em Pascal que representa a linguagem 
clássica, onde predominava a técnica de programação estruturada. 
 
 
program Soma_Pares; 
 uses crt; 
 var 
 superior, soma, num: integer; 
 begin 
 soma:=0; 
 write ('Entre com o limite superior'); 
 readln (superior); 
 num:=2; 
 
 repeat 
 soma:=soma+num; 
 num:=num+2; 
 until (num > superior); 
 
 writeln('A soma dos números pares de 2 até ', superior,' é ', soma); 
 readln; 
 end. 
 
 
Tabela 4: exemplo de programa em Pascal – Programação estruturada 
 
Durante os anos 80 houve um rápido crescimento do uso de computadores 
pessoais, em função do barateamento do hardware. Surge a fábrica de software e com 
ela a necessidade de produzir e atualizar software com mais rapidez, pois a demanda é 
grande. Assim sendo a reutilização de código, que já vinha sendo perseguida pela técnica 
de programação estruturada, passa a ser um conceito central para a produtividade no 
desenvolvimento de software. Na mesma época, iniciou-se as mudanças das 
metodologias de projeto de programas orientadas para o processo, para orientadas a 
dados, o que precisou que as linguagens implementassem os tipos abstratos de dados 
(TADs). Inicia-se então a programação orientada a objeto, que teve inicio com a 
abstração de dados, a qual encapsula o processamento com objeto de dados oculta o 
acesso a eles e adiciona herança e vinculação dinâmica de tipos.