Docsity Linguagem de Programacao Trabalho

Linguagem de programação
(trabalho)
Algoritmos
Universidade Federal do Rio de Janeiro (UFRJ)
22 pag.
Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

Downloaded by: pedro-freitas-psg (drjaesta.geral@gmail.com)
INSTITUTO BENJAMIN CONSTANT – IBC
João Batista dos Santos Pimentel
LINGUAGEM DE PROGRAMAÇÃO
Manaus – Am
2014

2
João Batista dos Santos Pimentel
LINGUAGEM DE PROGRAMAÇÃO
Projeto de pesquisa apresentado

para obtenção de nota na
disciplina Lógica de
Programação do curso Técnico
de Automação Industrial do
Instituto Benjamin Constant -
IBC.
Prof.(o): Alacy Serrão
Manaus – Am
2014

3
Sumário
Introdução ............................................................................................................................ 4
1. História das Linguagens de Programação...................................................................... 4
2. Primeiras linguagens de programação ............................................................................ 5
3. Classificação das linguagens de programação em gerações ........................................... 6

3.1 Linguagens de primeira geração ................................................................................... 8
3.2 Linguagens de Segunda Geração .................................................................................. 8
3.3 Linguagens de Terceira Geração ................................................................................... 8
3.4 Linguagens de quarta geração ...................................................................................... 9
3.5 Linguagens de quinta geração .................................................................................... 10
4. Classificação das linguagens de programação em tipos................................................ 10
5. Interpretador e Compilador .......................................................................................... 12

5.1 Compiladores .............................................................................................................. 12
5.2 Interpretador .............................................................................................................. 14
6. Programação estruturada .............................................................................................. 15
7. Programação Modular ................................................................................................... 16
8. Programação orientada à objetos .................................................................................. 17
9. Programação Linear ...................................................................................................... 19
10. Principais linguagens atuais......................................................................................... 19
Conclusão ............................................................................................................................ 21
Referências ......................................................................................................................... 22

4
Introdução
Um computador é uma máquina que, para realizar algo, precisa que alguém lhe
indique o que fazer de uma forma que ele entenda. Para que você possa fazer isso, é preciso
que:
 Conheça o computador e os recursos disponíveis;
 Saiba o que quer que o computador faça;
 Instrua o computador, através de um programa escrito em uma linguagem de
programação.
O hardware do computador, constituído de placas e dispositivos mecânicos e
eletrônicos, precisa do software para lhe dar vida: programas, com finalidades bem
determinadas, que façam o que os usuários querem ou precisam. Alguns programas maiores,
como processadores de texto, planilhas eletrônicas e navegadores da Internet, são de fato
agrupamentos de dezenas de programas relacionados entre si.
As linguagens de programação são usadas para descrever algoritmos; isto é,
seqüências de passos que levam à solução de um problema. Uma linguagem de programação
pode ser considerada como sendo uma notação que pode ser usada para especificar algoritmos
com precisão.
1. História das Linguagens de Programação
Como muitos "primeiros" na história, a primeira linguagem de programação moderna

é difícil de ser identificada. No início, as restrições do hardware definiam a linguagem.
Cartões perfurados dispunham de até 80 colunas, mas algumas das colunas tinham que ser
usados para um número de seqüência de cada cartão. Fortran incluía algumas palavras-chave
que eram as mesmas palavras em Inglês, como "IF" (se), "GOTO" (vá para) e "CONTINUE"
(continue). O uso de um tambor magnético para a memória significava que os programas de
computador também tinham que ser intercalados com as rotações do tambor. Assim, os
programas eram mais dependentes do hardware do que hoje.
Para algumas pessoas, a resposta depende de quanta energia e legibilidade humana
são necessárias antes que o status de "linguagem de programação" seja concedido. Os teares
de Jacquard e a máquina diferencial de Charles Babbage, ambos tinham linguagens simples e
extremamente limitadas para descrever as ações que estas máquinas deviam executar.
Na década de 1940 os primeiros computadores elétricos, reconhecidamente
modernos, foram criados. A velocidade limitada capacidade da memória forçava os

5
programadores a escrever a mão economicamente programas em linguagem de montagem

(linguagem de máquina). Logo se descobriu que a programação em linguagem assembly
exigia um grande esforço intelectual e era muito sujeita a erros.
Em 1948, durante este período algumas linguagens importantes foram desenvolvidas:
 1943 - Plankalkül (Konrad Zuse)
 1943 - ENIAC coding system
 1949 - C-10
2. Primeiras linguagens de programação
Na década de 1950 as primeiras três linguagens de programação modernas, cujos

descendentes ainda estão em uso difundido hoje foram concebidas:
 FORTRAN (1954), a "FORmula TRANslator", inventada por John Backus e outros.;
 LISP, a "LISt Processor", inventada por John McCarthy e outros.;
 COBOL, a COmmon Business Oriented Language, criada pelo Short Range
Committee, com grande influência de Grace Hopper.
Outro marco na década de 1950 foi a publicação, por um comitê de cientistas
americanos e europeus, de "uma nova linguagem para os algoritmos", a ALGOL 60 através da
publicação do relatório "The ALGOL 60 Report (the "ALGOrithmic Language")". Este
relatório consolidou muitas idéias que circulavam na época e apresentou duas inovações
chave quanto ao projeto de linguagens:
 Estrutura de blocos aninhados: pedaços significativos de código poderiam ser
agrupados em bloco de instruções, sem ter que ser transformados em procedimentos
separados e ser explicitamente chamados;
 Escopo léxico: um bloco podia ter suas próprias variáveis não acessíveis fora do
bloco, e muito menos manipuláveis de fora do bloco.
 Outra inovação, relacionada a esta última, foi na forma como a linguagem foi
descrita:
 Uma notação matemática exata, Backus-Naur (BNF), foi utilizada para descrever a
sintaxe da linguagem. Quase todas as linguagens de programação posteriores
utilizaram uma variante da BNF para descrever a parte livre de contexto de sua
sintaxe.
Algol 60 foi particularmente influente na concepção das linguagens posteriores,
algumas das quais logo se tornaram mais populares. Os grandes sistemas da Burroughs foram

6
projetados para serem programados em um subconjunto estendido do Algol, a WFL (Work

Flow Language).
Algumas ideias-chave da linguagem Algol foram tomadas, produzindo-se a
linguagem ALGOL 68:
 A sintaxe e semântica se tornaram ainda mais ortogonais, com rotinas anônimas, um
sistema recursivo de digitação com funções de ordem superior, etc;
 não somente a parte livre de contexto da linguagem, mas a sintaxe da linguagem
completa e a semântica foram definidos formalmente, em termos da gramática de
Van Wijngaarden, um formalismo desenvolvido especificamente para esta
finalidade.
O período compreendido entre o final dos anos 1960 à década de 1970 trouxe um
grande florescimento de linguagens de programação. A maioria dos principais paradigmas de
linguagem agora em uso foram inventados durante este período:
 Simula, inventada nos anos 1960 por Nygaard e Dahl como um super conjunto de
Algol 60, foi a primeira linguagem a suportar o conceito de classes.
 C, uma das primeiras linguagens de programação de sistemas, foi desenvolvido por
Dennis Ritchie e Ken Thompson nos laboratórios da Bell entre 1969 e 1973.
 Smalltalk (meados de 1970) forneceu uma base completa para o projeto de uma
linguagem orientada a objetos.
 Prolog, projetada em 1972 por Colmerauer, Roussel, e Kowalski, foi a primeira
linguagem de programação do paradigma lógico.
 ML built a polymorphic type system (inventada por Robin Milner em 1973) uma
linguagem funcional, baseada em Lisp, estaticamente tipada.
Cada uma dessas línguas gerou toda uma família de descendentes, e linguagens mais
modernas contam, pelo menos, com uma delas em sua ascendência.
3. Classificação das linguagens de programação em gerações
As linguagens de programação podem ser agrupadas em dois grandes grupos:

linguagens de baixo nível e linguagens de alto nível.
As linguagens de baixo nível são restritas a linguagem de máquina e tem uma forte
relação entre as operações implementadas pela linguagem e as operações implementadas pelo
hardware.

7
As linguagens de alto nível por outro lado, aproximam-se das linguagens utilizadas
por humanos para expressar problemas e algoritmos. Cada declaração numa linguagem de alto
nível equivale a várias declarações numa linguagem de baixo nível.
A vantagem principal das linguagens de alto nível é a abstração. Isto é o processo
em que as propriedades essenciais requeridas para a solução do problema são extraídas
enquanto esconde os detalhes da implementação da solução adotada pelo programador. Com o
nível de abstração aumentado, o programador pode concentrar-se mais na solução do
problema ao invés de preocupar-se como o hardware vai tratar do problema.
No início da computação os programadores eram obrigados a programar usando
linguagem de máquina, que nada mais é do que seqüências de dígitos binários (0s e 1s).
Esta representação tinha muitas desvantagens:
 Há uma grande probabilidade de erro em todos os estágios do processo de
programação.
 A programação mesmo sendo com algoritmos simples resulta em longos programas,
o que dificulta o processo de validação e detecção de erros.
 O cálculo de endereços de memória devem ser feitos manualmente, com um árduo
trabalho e uma grande probabilidade de erros.
Algumas das desvantagens podem ser superadas fazendo com que o computador seja
o responsável pelo estágio de tradução. O programa ainda é escrito em termos de operações
básicas de máquina, mas a tradução em código binário é feita pelo computador. O programa
que faz essa tradução é chamado de assembler. Até mesmo o mais simples dos assemblers
modernos podem reconhecer endereçamentos simbólicos e mnemônicos representado
operações de máquina.
Para especificar uma instrução para adicionar o conteúdo de localização ival para o
acumulador. O assembler então faz a tradução para a string equivalente de 0s e 1s. O
assembler também trata do problema de cálculo de endereço, usando nomes em formato de
texto para endereçar os dados. A conseqüência desta automação de tradução é que os
programas em linguagem Assembly são muito mais fáceis de escrever e depurar que
programas em linguagem de máquina.
Existem centenas de linguagens de programação, desenvolvidas desde o início da
computação. Essas linguagens foram agrupadas de acordo com suas e características e época
em que foram desenvolvidas em 4 gerações:

8
3.1 Linguagens de primeira geração
A primeira geração de linguagens remonta aos dias da codificação em linguagem de

máquina, surgidas com o início da computação na década de 50, especificamente de 1950 a
1962. A Linguagem de máquina e Assembly representam esta primeira geração das linguagens
de programação.
Essas linguagens totalmente dependentes da máquina, exibem o mais baixo nível de
abstração que uma linguagem pode ser representada.
Essas linguagens somente devem ser usadas quando as linguagens de mais alto nível
não satisfizerem as necessidades ou não forem suportadas.
3.2 Linguagens de Segunda Geração
A segunda geração de linguagens de programação foi desenvolvida de 1962 a 1974 e

serviu de base para o desenvolvimento das modernas linguagens de programação.
As características marcantes das linguagens de segunda geração foram o amplo uso
com grande familiaridade e aceitação no mercado, sistemas de execução em tempo real e
desenvolvimento de gerenciadores de base de dados.
As linguagens Fortran, Cobol, Algol e algumas extensões como Basic, foram os
representantes dessa segunda geração.
Fortran é uma linguagem ainda muito utilizada na área de engenharia e pela
comunidade científica. Cobol é uma linguagem que foi aceita e ainda continua em uso para
aplicações comerciais. Algol foi o precursor de muitas linguagens de terceira geração, por
oferecer ricamente estruturas de controle e tipos de dados. Basic foi uma linguagem
originalmente criada para o aprendizado e teve seu uso bastante reduzido já na década de 70.
3.3 Linguagens de Terceira Geração
As linguagens de terceira geração também chamadas de linguagens de programação

modernas ou estruturadas são caracterizadas pela grande capacidade procedural e estrutural de
seus dados, foram desenvolvidas de 1974 a 1986.
As linguagens de terceira geração tiveram como principais características a
possibilidade de criar sistemas distribuídos, incorporar recursos mais inteligentes, e exigir um
hardware menos robusto. Podem ser divididas em duas grandes categorias: linguagens de
propósito geral e linguagens especializadas.

9
As linguagens de propósito gerais foram desenvolvidas baseadas principalmente na

linguagem Algol e servem para uma infinidade de aplicações envolvendo desde a área
científica, até a área comercial. As linguagens C, Pascal, PL/1 e Modula-2 são as principais
linguagens desta categoria, sendo que as duas primeiras continuam bastante usadas
atualmente.
As linguagens especializadas são caracterizadas pela forma sintática não usual com
que foram desenvolvidas para uma aplicação distinta. Centenas de linguagens especializadas
estão em uso atualmente. Dentre as linguagens que encontram aplicações na área de
engenharia de software podemos destacar a linguagem Lisp desenvolvida especialmente para
manipular símbolos e listas, Prolog desenvolvida para tratar e representar conhecimentos
Smalltalk criada para representar os dados em forma de objetos, sendo a primeira a ser
puramente orientada a objetos, APL desenvolvida para manipular vetores, e a linguagem
Forth desenvolvida para desenvolver softwares para microprocessadores.
3.4 Linguagens de quarta geração
A quarta geração das linguagens de programação foram desenvolvidas a partir de

1986 e teve como características principais a geração de sistemas especialistas, o
desenvolvimento de inteligência artificial e a possibilidade de execução dos programas em
paralelo.
No decorrer da história temos percebido uma evolução para uma abstração maior na
geração de programas, usando linguagens de mais alto nível.
A primeira geração de linguagens de programação trabalhavam com um reduzido
conjunto de instruções a nível de máquina. A segunda e terceira geração de linguagens de
programação foram desenvolvidas num nível que representam os programas computacionais,
distinta e independentemente da arquitetura do processador, mas com completa descrição
detalhada dos procedimentos algorítmicos do programa. Com o passar do tempo, as
linguagens de quarta geração foram desenvolvidas com um nível de abstração ainda mais alto.
As linguagens de quarta geração, conhecidas também como linguagens artificiais
contém uma sintaxe distinta para representação de estruturas de controle e dos dados. Essas
linguagens por combinarem características procedurais e não procedurais, representam estas
estruturas com um alto nível de abstração, eliminando a necessidade de especificar
algoritmicamente esses detalhes.

10
As linguagens de quarta geração podem ser classificadas em três categorias:

linguagens de consulta, geradoras de programas e outras linguagens (4GL).
As linguagens de consulta foram desenvolvidas para manipular bases de dados,
permitindo o gerenciamento de um grande número de informações armazenadas em arquivos.
As linguagens geradoras de programas representam uma sofisticada classe das
linguagens 4GL. Permitem ao usuário ou programador criar facilmente programas complexos
em linguagens de terceira geração, utilizando bem menos declarações e comandos. Estas
linguagens possuem um nível bem mais alto que as de terceira geração.
Enquadradas como outras linguagens de quarta geração temos as linguagens usadas
em sistemas de apoio à decisão, linguagens utilizadas para modelagem de sistemas,
linguagens de prototipação, e linguagens de especificação formal que produzem código de
máquina.
3.5 Linguagens de quinta geração
A nova geração das linguagens de programação, que já é chamada por muitas

pessoas de quinta geração, é baseada em métodos de consulta e utilizam comandos escritos
em linguagens naturais, permitindo uma fácil comunicação com o computador.
Essas linguagens são baseadas nos conceitos de objetos, que agrupam comandos de
programação com dados em objetos que podem ser usados o tempo todo durante a execução
do programa, o que é muito útil em ambientes de execução paralela.
Outra tendência dos ambientes de desenvolvimento de programas é fornecer além
das linguagens de programação, um ambiente de geração automática de código, onde o
programador especifica através de ferramentas visuais as características do programa e a
ferramenta se encarrega de gerar a codificação na linguagem específica. Estas ferramentas são
muito difundidas na programação para Windows, e são também chamados de RAD
(Desenvolvimento Rápido de Aplicativos).
4. Classificação das linguagens de programação em tipos
Um tipo é definido a partir de um conjunto de valores e de operações ao qual está

associado.
O sistema de tipos de uma linguagem de programação (LP) usualmente inclui um
conjunto básico de tipos;
 mecanismos para a associação entre tipos e construções básicas da LP;

11
 regras para a definição de novos tipos;

 regras de compatibilidade e inferência.
A forma como a representação de um tipo de dado é implementada torna-se
transparente, podendo inclusive ser modificada sem afetar o funcionamento do programa.
Toda LP possui um conjunto primitivo de tipos, que geralmente incluem:
 Caracter (char)
 Strings
 Inteiros
 Reais
 Boleanos
Além disso muitas LPs permitem que o usuário defina novos tipos de dados através
de declarações específicas (typedef em C, type em Pascal e Módula 2, etc).
Podemos classificar os tipos compostos disponíveis em LPs nas seguintes categorias:
 Produto cartesiano;
 Conjunto potência;
 Domínios finitos;
 União discriminada;
 Sequências;
 Definição recursiva;
Produto Cartesiano é um produto cartesiano de dois ou mais conjuntos é uma
combinação de valores agregados (tuplas) retirados de cada um dos conjuntos de dados.
Conjunto Potência é um produto que permite definir valores a um subconjunto de um
tipo qualquer. Operações típicas de conjunto potência são: união, interseção e pertence.
Domínios Finito, permitem definir uma associação entre um conjunto finito
(domínio) e valores de um conjunto qualquer (contradomínio). Como principal exemplo desta
categoria temos o array, que é o tipo composto mais comum e mais importante em LPs.
Poucas LPs permitem a comparação (Fortran, Ada) e atribuição direta entre arrays (Java).
Diversas LPs permitem a definição dos limites de um array dinamicamente (Java, Lua).
União Discriminada é um produto que permite a definição concomitante de mais de
um tipo para uma variável. É interessante em situações em que uma variável precisa assumir
valores de mais de um tipo, ou para economia de memória.

12
Seqüências são os produtos que permitem que os dados sejam representados através
de listas. Exemplos são cadeias de caracteres (strings), listas (Lisp, Prolog, Ada) e arquivos
seqüenciais (Pascal). Suportam operações como “primeiro”, “próximo” e “anterior”.
Definições Recursivas são tipos de produtos em que os dados podem crescer de
forma arbitrária, através de referências a outras estruturas do mesmo tipo. Exemplos seriam
estruturas de dados clássicas como listas e árvores.
5. Interpretador e Compilador
Qualquer sistema para processamento de programas – executando-os ou preparando-

os para a execução – é chamado processador de linguagem. Processadores de linguagem
incluem compiladores, interpretadores, e ferramentas auxiliares como editores dirigidos à
sintaxe.
Um compilador transforma o código fonte (da linguagem que você está
programando) em um código em que o computador entenda.
Já um interpretador, transforma um código fonte em código que só ele (o programa
que você está utilizando para escrever o código) entende. Assim, quando um programa
interpretado for iniciado, ele necessita de uma DLL para poder rodar, que irá traduzir esse
código para uma linguagem que o computador entenda.
5.1 Compiladores
Um compilador tem a finalidade de converter uma linguagem – Linguagem Fonte –

de fácil escrita e leitura para os programadores, numa linguagem – Linguagem alvo ou objeto
– que possa ser executada pelas máquinas.
O código executável gerado pelo compilador é dependente do sistema operacional e
da linguagem de máquina para o qual o código fonte foi traduzido.
A enorme variedade de compiladores existentes é bem vinda, visto que existem
milhares de linguagens fonte, e as linguagens alvo são também muito variadas.
Podemos dividir o processo de compilação em duas fases:
 Análise: Parte o programa fonte em peças constituintes e cria uma representação
intermediaria do programa fonte. Esta dividida em: análise léxica; análise sintática;
análise semântica.

13
 Síntese: Constrói o desejado programa alvo (código de máquina) a partir da

representação intermediaria. Se divide em: geração do código e otimização do
código.
Análise Léxica: é o processo de analisar a entrada de linhas de caracteres e produzir
uma seqüência de símbolos chamados “símbolos léxicos” (lexical tokens), ou somente
"símbolos" (tokens), que podem ser manipulados mais facilmente pelo compilador. A análise
léxica é a forma de verificar determinado alfabeto. Quando analisamos uma palavra, podemos
definir através da análise léxica se existe ou não algum caractere que não faz parte do nosso
alfabeto, ou um alfabeto inventado por nós. O analisador léxico é a primeira etapa de um
compilador, logo após virá à análise sintática.
Análise Sintática: é o processo de analisar uma seqüência de entrada para determinar
sua estrutura gramatical segundo uma determinada gramática formal. Essa análise faz parte de
um compilador. A análise sintática transforma um texto na entrada em uma estrutura de
dados, em geral uma árvore, o que é conveniente para processamento posterior e captura a
hierarquia implícita desta entrada. 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. Em termos práticos, pode também ser usada para decompor um texto em unidades
estruturais para serem organizadas dentro de um bloco.
Análise semântica: é a terceira fase da compilação onde se verifica os erros
semânticos, (por exemplo, uma multiplicação entre tipos de dados diferentes) no programa-
fonte (código-fonte) e coleta as informações necessárias para a próxima fase da compilação
que é a geração de programa-objeto (código objeto).

14
Figura 1 - Fases de um compilador
Vantagens Desvantagens
Execução mais rápida Várias etapas de tradução
Permite estruturas de Programação final é maior,
Compiladores programação mais necessitando mais memória
completas para a sua execução
Processo de correcção de
Permite a optimização do
erros e depuração é mais
código fonte.
demorado
Quadro 1- Vantagens e Desvantagens dos Compiladores
5.2 Interpretador
Um interpretador, transforma um código fonte em código que só ele (o programa que

você está utilizando para escrever o código) entende. Assim, quando um programa
interpretado for iniciado, ele necessita de uma DLL para poder rodar, que irá traduzir esse
código para uma linguagem que o computador entenda.
Interpretadores são programas de computador que lêem um código fonte de uma
linguagem de programação e os convertem em código executável. Seu funcionamento pode
variar de acordo com a implementação.
Em muitos casos o interpretador lê linha-a-linha e converte em código objeto à
medida que vai executando o programa. Linguagens interpretadas são mais dinâmicas por não

15
precisarem escrever-compilar-testar-corrigir-compilar-testar- distribuir, e sim escrever-testar-

corrigir-escrever-testar-distribuir.
Mas existem também linguagens que funcionam como interpretadores e
compiladores, como: C, Python, BASIC, entre outros. Exemplo de linguagens interpretadas:
BASIC, Bash, C#, Perl, PHP, Python, Euphoria, Forth, JavaScript, Logo, MUMPS e Ruby.
O interpretador traduz o código linha a linha.
O código fonte não é totalmente traduzido antes de ser executado.
Não existem fases distintas nem se produz código intermediário.
Passa o tempo todo a ler e a traduzir código.
Vantagens Desvantagens
Depuração do programa é Execução do programa é

mais simples mais lenta
Interpretadores Estruturas de dados

Consome menos memória
demasiado simples
Resultado imediato do Necessário fornecer o

programa ou rotina programa fonte ao
desenvolvida utilizador
Quadro 2 – Vantagens e Desvantagens dos interpretadores
6. Programação estruturada
As linguagens concebidas em meados dos anos 60 foram resultado da necessidade da

produção de código de programa de forma clara, aparecendo o conceito de estruturação do
código (endentação, utilização de letras maiúsculas e minúsculas nos identificadores,
eliminação de instruções “problemáticas” como o “go to”, etc...).
O período compreendido entre a década de 60 e a de 80 foi bastante produtivo no que
diz respeito ao surgimento de linguagens de programação, o que permitiu o aparecimento de
uma grande quantidade de linguagens as quais podem ser organizadas da seguinte forma:
 as linguagens de uso geral, as quais podem ser utilizadas para implementação de
programas com as mais diversas características e independente da área de aplicação
considerada; encaixam-se nesta categoria linguagens como Pascal, Modula-2 e C;
 as linguagens especializadas, as quais são orientadas ao desenvolvimento de
aplicações específicas; algumas das linguagens que ilustram esta categoria são
Prolog, Lisp e Forth;

16
 as linguagens orientadas a objeto, que oferecem mecanismos sintáticos e semânticos

de suporte aos conceitos da programação orientada a objetos; alguns exemplos destas
linguagens são Smalltalk, Eiffel, C++ e Delphi.
Aqui um programa pode ser visto como uma seqüência de chamadas de
procedimentos.
Um exemplo de procedimento clássico é o cálculo de uma raiz quadrada. Uma
chamada de procedimento é usada para invocar o procedimento, podendo ser passado alguns
parâmetros (por exemplo, o número cuja raiz quadrada deve ser calculada). Após a seqüência
ser executada, o controle retorna justo após o ponto de chamada do procedimento.
Introduzindo parâmetros tão bem quanto procedimentos de procedimentos (sub-
procedimentos), programas podem ser escritos mais em mais estruturados e livres de erro. Por
exemplo, se um procedimento é correto, toda vez que ele é usado ele produz um resultado
correto. Conseqüentemente, no caso de erros você pode direcionar sua busca àqueles lugares
que não são livres de erros.
Uma das desvantagens da programação estruturada é a tendência em gerar códigos
onde tratamentos de dados são misturados com o comportamento do programa. Além disso,
quando se desejava criar um programa semelhante a um que já tivesse feito, era complicado
pegar determinadas partes deste programa já pronto e trazer para o novo projeto, uma vez que
eram necessárias, na maior parte das vezes, realizar mudanças substanciais no código.
7. Programação Modular
No passar dos anos, a ênfase no projeto de programas passou do projeto de

procedimentos para a organização dos dados, surgindo a programação modular. Nela,
procedimentos relacionados e dados que eles utilizam são agrupados em módulos separados.
Por exemplo, todas as funções de manipulação de uma pilha (empilhar, desempilhar, etc.) e a
pilha em si podem ser agrupadas em um módulo. Um programa, portanto não consiste mais
de apenas uma parte única. Ele é agora composto de várias pequenas partes que interagem
através de chamadas de procedimento. Cada módulo tem seus próprios dados. Isto permite
que cada módulo gerencie um estado interno que é modificado por chamadas a procedimentos
deste módulo.
São programações denominadas de subprogramas, essas permitem a divisão de um
programa em módulos, cada um dos quais pode ser desenvolvido separada e

17
independentemente dos outros, podendo estes módulos, posteriormente, serem integrados

num único programa.
As linguagens de alto nível fornecem dois processos distintos de produzir módulos,
dando um deles origem à criação de funções e o outro à criação de procedimentos.
Um subprograma para ser executado tem de ser integrado num programa.
8. Programação orientada à objetos
Em contraste com as outras técnicas apresentadas, nós agora temos uma malha de
objetos que interagem cada um mantendo seu próprio estado. A essência da programação
orientada a objetos consiste em tratar os dados e os procedimentos que atuam sobre os dados
como um único objeto – uma entidade independente com uma identidade e certas
características próprias. Este paradigma de programação será o objeto de estudo deste curso.
Uma abordagem orientada a objetos identifica as palavras-chaves no problema. Estas
palavras-chaves são descritas então em um diagrama e setas são desenhadas entre estas
palavras-chaves para definir uma hierarquia interna. As palavras-chaves serão os objetos na
implementação e a hierarquia define a relação entre estes objetos. O termo objeto é usado aqui
para descrever uma estrutura bem definida, contendo todas as informações sobre certa
entidade: dados e funções para manipular os dados.
Os objetos introduzem uma maneira diferente de conceber, de programar, de analisar
e de manter as aplicações. Após um longo período de maturação em laboratórios de pesquisa,
as linguagens à objetos começam a invadir os domínios profissionais. É possível hoje em dia
dizer que não se trata de um modo, mas de um processo de mutação. O principal argumento
desses novos produtos inclui as facilidades de reutilização de código e em conseqüência
ganhos de produtividade são alcançados. A reusabilidade depende em muito da modularidade
dos programas.
A POO foi criada para tentar simular o mundo real dentro do computador e para isso
utiliza objetos. Desta forma, fica a cargo do programador modelar objetos e a interação entre
eles. Essa modelagem leva em consideração alguns conceitos, dentre os principais, pode-se
citar:
 Classe: É o molde para criar objetos. Possui todas as especificações de um grupo
deles. Ex.: Os objetos Eddie Vedder e Kurt Cobain, apesar de serem diferentes,
derivam da mesma classe Pessoa.

18
 Atributos: Definem características de objetos, e.g., a classe pessoa tem os atributos

nome, endereço, telefone e sexo.
 Métodos: Definem o comportamento dos objetos, tendo seus nomes normalmente
definidos por verbos. Para a classe Pessoa, por exemplo, podem haver os métodos
comprar, vender e alugar.
 Abstração: É a habilidade de se concentrar nos principais aspectos de um grupo de
objetos, em vez de se preocupar com as suas especificações. Ex.: Para a classe
Pessoa são definidas as principais características comuns à maioria das pessoas, sem
que haja preocupação especial com objetos muito específicos e, por conseguinte,
pouco comuns (e.g., pessoas com dedos a mais ou a menos).
 Encapsulamento: É a habilidade de esconder de outros objetos, as características
intrínsecas de um dado objeto. Toda a comunicação inter objetos deve ser realizada
via métodos. Um objeto não deve ser capaz de acessar, e tampouco alterar, atributos
de outro objeto diretamente.
 Associação: É a habilidade pela qual um objeto utiliza recursos de outro. Por
exemplo:Corda é parte de um Violão.
 Herança: É a capacidade de criar subclasses a partir de uma superclasse. Essas
subclasses herdam, então, todas as características da superclasse. É normalmente
definida como uma associação do tipo "é um", e.g., Cliente é uma Pessoa.
 Polimorfismo: É o princípio pelo qual uma subclasse sobrescreve um comportamento
(método) herdado de sua superclasse. Por exemplo, a classe pessoa implementa o
método Comprar, mas a classe Cliente, derivada da classe Pessoa, precisa de algo
mais específico, envolvendo mais dados. Então a classe cliente sobrescreve o método
comprar, tornando-o mais específico.
Estes são alguns conceitos da POO. Sugiro a leitura da página da Sun, na seção de
leituras recomendadas, no rodapé deste texto, para mais informações sobre eles. No código
abaixo temos implementadas algumas das características da POO, que foram citadas. É um
código bastante simples, sem aplicação direta em problemas reais. Contudo, serve como
exemplo de implementação de Classes, Atributos, Herança, Polimorfismo e instanciação de
objetos.

19
9. Programação Linear
A utilização de programação linear é recomendada para problemas de maior porte,

em que muitas variáveis e restrições devem ser consideradas sem dúvida nenhuma a
Programação Linear é uma das técnicas da Pesquisa Operacional das mais utilizadas em se
tratando de problemas de otimização.
A Programação linear se incube de achar a solução ótima de um problema, uma vez
definida o modelo linear, ou seja, a função objetivo e as restrições lineares.
Quando se esta diante de um problema de PL práticos, que se pretende resolver, ele
pode estar escrito de forma de maximização (ou minimização) de uma função objetivo linear,
que é sujeita a um conjunto de restrições que podem ser expressos sob a forma de inequações
ou equações lineares.
O passo mais importante na formulação de um modelo é a escolha apropriada das
variáveis de decisão. Se as variáveis de decisão forem selecionadas adequadamente, a função
objetivo e as restrições devem ser obtidas sem muita dificuldade. Problemas na determinação
da função objetivo e restrições normalmente são devido a uma escolha incorreta das variáveis
de decisão.
10. Principais linguagens atuais
A evolução das linguagens de programação continua, tanto na indústria quanto na

pesquisa. Algumas das tendências atuais incluem:
 Mecanismos para a adição de segurança e verificação da confiabilidade para a
linguagem: verificação estática prolongada, controle de fluxo de informação, estático
segurança em threads.
 Mecanismos alternativos de modularidade: mixin s, Delegação de programação,
programação orientada a aspectos.
 Desenvolvimento de software orientado a componentes.
 Metaprogramação, Reflexão ou acesso a árvores de sintaxe abstratas.
 Maior ênfase na distribuição e mobilidade.
 Integração com bases de dados, incluindo XML e bancos de dados relacionais.
 Suporte para Unicode de forma que o código-fonte não esteja restrito aos caracteres
contidos no código ASCII; permitindo, por exemplo, o uso de scripts não latinos ou
pontuação estendida.

20
 XML para à interfaces gráficas (XUL, XAML).

Algumas linguagens importantes que foram desenvolvidas durante o período de 1990
à 2008, são: 1990 - Haskell, 1991 - Python, 1991 - Java, 1993 - Ruby, 1993 - Lua, 1994 –
ANSI Common Lisp, 1995 - JavaScript, 1995 - PHP, 2000 - C#, 2008 - JavaFX Script.

21
Conclusão
Levando se em consideração, o que foi visto neste trabalho pode-se concluir que são
muitas as linguagens de programação existentes na área da computação e é fato que cada um
possui características e particularidades, por isso, é necessário estudá-las e conhecê-las para
que, no momento de decidir qual linguagem utilizar na hora de desenvolver um projeto se
faça a melhor escolha.

22
Referências
Lógica de Programação – A Construção de Algoritmos e Estruturas de Dados – São Paulo:

Forbellone, André Luiz Villar - MAKRON, 1993.
Kowaltowski, T. & Lucchesi, C., Conceitos Fundamentais e Teoria da Computação. Anais
do II WEI. Minas Gerais, 1994.
Szwarcfiter, J. L. & Markenzon, Estruturas de Dados e seus Algoritmos. LTC Editora. Rio
de Janeiro, 1994.
Norton, P., Introdução à Informática. Makron Books. Sap Paulo, 1996.
TREMBLAY, Jean-Paul & BUNT, Richard B. – Ciência dos computadores - Uma
abordagem Algorítmica. Mcgraw-Hill, 1983.
http://www.digibarn.com/collections/posters/tongues, acesso em 28 de Outubro de 2014, às
23:00 horas.


Docsity Linguagem de Programacao Trabalho

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

Docsity Linguagem de Programacao Trabalho

Enviado por

Direitos autorais:

Formatos disponíveis

Linguagem de programação

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

João Batista dos Santos Pimentel

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

João Batista dos Santos Pimentel

Projeto de pesquisa apresentado

Prof.(o): Alacy Serrão

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

1. História das Linguagens de Programação...................................................................... 4

2. Primeiras linguagens de programação ............................................................................ 5

3. Classificação das linguagens de programação em gerações ........................................... 6

4. Classificação das linguagens de programação em tipos................................................ 10

5. Interpretador e Compilador .......................................................................................... 12

6. Programação estruturada .............................................................................................. 15

7. Programação Modular ................................................................................................... 16

8. Programação orientada à objetos .................................................................................. 17

9. Programação Linear ...................................................................................................... 19

10. Principais linguagens atuais......................................................................................... 19

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

1. História das Linguagens de Programação

Como muitos "primeiros" na história, a primeira linguagem de programação moderna

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

programadores a escrever a mão economicamente programas em linguagem de montagem

2. Primeiras linguagens de programação

Na década de 1950 as primeiras três linguagens de programação modernas, cujos

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

projetados para serem programados em um subconjunto estendido do Algol, a WFL (Work

3. Classificação das linguagens de programação em gerações

As linguagens de programação podem ser agrupadas em dois grandes grupos:

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

3.1 Linguagens de primeira geração

A primeira geração de linguagens remonta aos dias da codificação em linguagem de

3.2 Linguagens de Segunda Geração

A segunda geração de linguagens de programação foi desenvolvida de 1962 a 1974 e

3.3 Linguagens de Terceira Geração

As linguagens de terceira geração também chamadas de linguagens de programação

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

As linguagens de propósito gerais foram desenvolvidas baseadas principalmente na

3.4 Linguagens de quarta geração

A quarta geração das linguagens de programação foram desenvolvidas a partir de

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

As linguagens de quarta geração podem ser classificadas em três categorias:

3.5 Linguagens de quinta geração

A nova geração das linguagens de programação, que já é chamada por muitas

4. Classificação das linguagens de programação em tipos

Um tipo é definido a partir de um conjunto de valores e de operações ao qual está

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

 regras para a definição de novos tipos;

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

Qualquer sistema para processamento de programas – executando-os ou preparando-

Um compilador tem a finalidade de converter uma linguagem – Linguagem Fonte –

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

 Síntese: Constrói o desejado programa alvo (código de máquina) a partir da

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

Figura 1 - Fases de um compilador

Um interpretador, transforma um código fonte em código que só ele (o programa que

Document shared on https://www.docsity.com/pt/linguagem-de-programacao-trabalho/4896019/

precisarem escrever-compilar-testar-corrigir-compilar-testar- distribuir, e sim escrever-testar-

Depuração do programa é Execução do programa é

Interpretadores Estruturas de dados

Resultado imediato do Necessário fornecer o

As linguagens concebidas em meados dos anos 60 foram resultado da necessidade da