Universidade Rovuma

Licenciatura em Informática

Maldine Ossifo Muhamade Bormuda

Tipos de linguagens de programação e seus níveis

Universidade Rovuma
Nampula
2021
 2

Maldine Ossifo Muhamade Bormuda

Tipos de linguagens de programação e seus níveis

Trabalho individual da cadeira de

Programação Funcional apresentado à
.
Universidade Rovuma Lecionado pelo
docente:
dr Isidro Jorge

Universidade Rovuma
Nampula
2021
 ii

Índice

Introdução..................................................................................................................................3

A história das linguagens de programação.................................................................................5

Os principais tipos de linguagens de programação....................................................................5

Java.............................................................................................................................................6

JavaScript...................................................................................................................................6

Python........................................................................................................................................6

Linguagem C..............................................................................................................................7

PHP............................................................................................................................................7

SQL............................................................................................................................................7

Ruby...........................................................................................................................................8

Historial da linguagem Haskel...................................................................................................8

1930 – O Cálculo Lambda (λ-Calculus)....................................................................................8

1956 – As Primeiras Linguagens Funcionais.............................................................................9

1978 – A Grande Crítica!...........................................................................................................9

1980 – Acensão da Programação Funcional............................................................................10

1987 – Só uma Linguagem!.....................................................................................................10

Álgebra de boleana...................................................................................................................11

Citações de George Boole........................................................................................................12

Conclusão.................................................................................................................................15

Referências Bibliográficas.......................................................................................................16
 3

Introdução

O presente trabalho é sobre Tipos de linguagens de programação e seus níveis, ao

realizar o trabalho percebi que A história das linguagens de programação é bastante longa e
teve seu início há muitas décadas e também não é nossa intenção contá-la minuciosamente
nesta oportunidade. Porém, é interessante conhecer um breve panorama dos primeiros passos
da humanidade no contato com a tecnologia para entender seu propósito e que primeiramente,
vale ressaltar que sua história está diretamente relacionada ao surgimento das primeiras
máquinas inteligentes: por meio delas, o intuito sempre foi transformar as sequências lógicas
em resoluções para problemas. Isso nos leva ao francês Joseph-Mariae Jacquard, que criou
um tear capaz de substituir o homem em seu processo de produção.
As primeiras linguagens de programação antecedem o computador moderno. No
início, as línguas eram códigos.
A máquina de tear de Jacquard,criada em 1801, usava furos em cartões perfurados
para representar os movimentos de um braço da máquina de tricô, com o objetivo de gerar
automaticamente padrões decorativos.
Durante um período de nove meses entre 1842 e 1843, Ada Lovelace traduziu as
memórias do matemático italiano Luigi Menabrea sobre a nova máquina proposta por Charles
Babbage,o Analytical Engine. Com esses escritos, ela adicionou algumas notas nas quais ela
especificou em detalhes um método para calcular os números de Bernoulli com esta máquina.
Herman Hollerith percebeu que poderia codificar as informações em cartões de
perfuração quando observou motoristas de trem identificando passageiros com base no
buraco que fizeram em seu respectivo bilhete. Em 1890 Hollerith cocodificou dados
censitários em cartões perfurados.
Os primeiros códigos de computador eram especializados de acordo com seus
aplicativos. Nas primeiras décadas do século XX, os cálculos numéricos foram baseados em
números decimais. Com o passar do tempo, eles perceberam que a lógica poderia ser
representada com números, não apenas palavras. Por exemplo, a Igreja Alonzo foi capaz de
expressar o cálculo lambda através de fórmulas. A máquina de Turing estabeleceu as bases
para armazenar programas como dados na arquitetura von Neuman de um computador. No
entanto, ao contrário do cálculo lambda, o código de Turing não serviria satisfatoriamente
como base para linguagens de nível superior – seu principal uso está em análise rigorosa na
complexidade algorítmica.
 4

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

é difícil de identificar. Desde o início, as restrições de hardware definiram o idioma. As cartas
de perfuração permitiam 80 colunas, mas algumas delas seriam usadas para uma classificação
de cada carta. A FORTRAN incluiu algumas palavras reservadas do inglês, como "IF",
"GOTO" e "CONTINUE". O uso do tambor magnético para memória significava que os
programas de computador tinham que ser intercalados com rotações de tambores. Portanto, os
programas eram muito dependentes do hardware.
Para algumas pessoas, o que seria a primeira linguagem de programação moderna
depende de quanto poder humano e legibilidade era necessário antes do status de "linguagem
de programação" ser concedido. Tanto o tear de Jacquard quanto a Máquina Diferencial de
Babbage tinham linguagens muito simples e extremamente limitadas para descrever as ações
que essas máquinas realizavam. Buracos perfurados em rolos de pianola podem até ser
considerados uma linguagem limitada específica do domínio,apesar de não ter sido projetada
para consumo humano.
 5

A história das linguagens de programação

A história das linguagens de programação é bastante longa e teve seu início há muitas
décadas — e também não é nossa intenção contá-la minuciosamente nesta oportunidade.
Porém, é interessante conhecer um breve panorama dos primeiros passos da humanidade no
contato com a tecnologia para entender seu propósito.
Primeiramente, vale ressaltar que sua história está diretamente relacionada ao
surgimento das primeiras máquinas inteligentes: por meio delas, o intuito sempre foi
transformar as sequências lógicas em resoluções para problemas. Isso nos leva ao francês
Joseph-Mariae Jacquard, que criou um tear capaz de substituir o homem em seu processo de
produção.
Foi observando essa máquina que Ada Lovelace criou algoritmos interpretados pelo
primeiro computador da história (desenvolvido por Charles Babbage). Assim, iniciava-se o
conceito de linguagem de programação e, aos poucos, os estudiosos da área perceberam que
seriam necessárias várias delas para resolver diferentes problemas.
Como você deve ter visto no filme O Jogo da Imitação, Alan Turing também foi
muito importante na compreensão da importância das máquinas inteligentes, dando ainda
mais base para o computador funcional que conhecemos hoje. Nessa época, as linguagens
trabalhavam com códigos de 0 e 1, o que tornava a vida dos profissionais complicada.
Nos anos 1950, surgiu o Assembly, a linguagem que mais se aproxima das máquinas,
mas que, ainda assim, já facilitava a compreensão das pessoas. Sua criação despertou o
interesse desses estudiosos, que viram a oportunidade de humanizar ainda esses códigos.
Logo, vieram a Fortran, a Lisp e o Cobol.
Já na década de 1970, foram criadas algumas linguagens que são usadas até hoje, a
exemplo do C (que vamos conhecer mais adiante). A partir desse ponto, muitas outras se
derivaram do C, abrindo caminho para a evolução tecnológica que tornou possível a Indústria
4.0 que vivemos hoje.

Os principais tipos de linguagens de programação

Agora que você já entende um pouco mais sobre o surgimento das linguagens de
programação, chegou o momento de conhecer quais são as principais que se encontram no
mercado atualmente. Fique atento, pois o profissional do futuro deve saber ao menos uma
delas.
 6

Java

Essa linguagem orientada a objeto apareceu por volta de 1995, prometendo ser rápida,
segura, confiável e multiplataforma. Isso porque os programas criados em Java não ficam em
código nativo da plataforma. Em vez disso, são compilados para uma forma intermediária
chamada de bytecode e são executados por meio de uma máquina virtual.
Dessa forma, um programador que desenvolve um sistema em Java faz esse processo
uma só vez, podendo executá-lo posteriormente em qualquer plataforma que ofereça suporte
para a linguagem.
Quando você precisa acessar a sua conta virtual de um banco em um computador ou
mesmo alguns aplicativos da Receita Federal do Brasil, está em contato com os maiores
exemplos da aplicação dessa tecnologia.
Um mito que circula bastante no mercado da tecnologia é que essa linguagem de
programação é difícil de aprender. Porém, a dificuldade muitas vezes surge devido aos
conceitos de orientação a objetos, que podem não ficar claros para os profissionais.
Entendendo essa particularidade, o céu é o limite para o profissional.

JavaScript

De acordo com uma pesquisa da Stack Overflow, JavaScript é a linguagem de

programação mais usada pelos programadores da amostra, passando dos 69%. Com ela, é
possível fazer com que todas as funções desenvolvidas criem vida diante dos usuários — ou
seja, trata de todas as interações visuais com a plataforma ou sistema.
Sabe quando você abre algum álbum de fotografia e consegue interagir com as
páginas, como se estivesse manuseando um livro? Ou, então, quando você navega em um
mapa, ampliando-o ou expandindo-o para ter acesso a melhores imagens? Esses são
exemplos referenciais do JavaScript.

Python

Apesar de existir há décadas, o Python ganhou popularidade de uns anos para cá. Essa
linguagem tem como principal objetivo favorecer a legibilidade e a produtividade do sistema,
com códigos de fácil manutenção e baixa quantidade de caracteres especiais.
Se você sonha em trabalhar no Google um dia, saiba que programar em Python é um
requisito primordial — na Nasa também, por curiosidade. Além de ser uma linguagem de alto
nível, conta com uma biblioteca imensa e bons frameworks, facilitando a vida do
profissional.
 7

Linguagem C

Se você já começou algum curso de tecnologia, certamente teve contato com o C. Ele
é bastante comum no ambiente acadêmico, uma vez que dá origem a diversas linguagens de
programação, como C++ e C#. É com ele que o estudante aprende a lógica de criação de
algoritmos, por ser intuitivo e de fácil aprendizado. Não é necessário montar um ambiente
local na máquina para executá-lo — afinal, a maioria dos sistemas operacionais já o utilizam
como base.
Muitos dizem que é possível fazer quase tudo em C, apesar de não ser a linguagem
ideal para algumas aplicações. Uma de suas características é a modularidade: são diversos
blocos em que as funções não estão interligadas. O exemplos mais conhecido de uso é o
sistema operacional Linux.

PHP

Quando falamos em websites, PHP é certamente uma das linguagens mais pedidas. Já
ouviu falar do Facebook e do WordPress, não é mesmo? São os melhores exemplos que se
encontram no mercado hoje de suas aplicações. Por ter o código aberto, muitos profissionais
já contribuíram para aprimorá-lo.
O PHP também é rico em frameworks, que auxiliam no desenvolvimento dos
softwares, de modo a simplificá-los. Entre os mais utilizados no mercado estão:
 Laravel;
 Symphony;
 Zend;
 Phalcon;
 CakePHP;
 Yii;
 CodeIgniter.

SQL

A Structured Query Language (mais conhecida como SQL) tem como função
principal manipular bancos de dados de um modo ágil e descomplicado. O que acontece é
que cada um desses bancos tem uma sintaxe padrão, que é aumentada por cada programador
em seu benefício. Por essa razão, a portabilidade é um pouco mais difícil. Mesmo assim, é
bastante usada pelos profissionais.
A SQL tem alguns subtópicos:
 8

 DML: para acessar e manipular as informações dos bancos de dados, são comumente
utilizados os comandos SELECT, INSERT, DELETE e UPDATE;
 DDL: a fim de alterar as estruturas em que os dados estão inseridos, o profissional
responsável pelo sistema de banco de dados (conhecido como DBA) utiliza dos
comandos CREATE, ALTER e DROP;
 DCL: nesse caso, GRANT e REVOKE são os comandos usados para atribuir ou
revogar privilégios de acesso aos usuários.

Ruby

Precisa de uma linguagem que tem foco na simplicidade e na produtividade? O Ruby

surgiu com essa proposta. Além disso, busca proporcionar flexibilidade aos programadores,
que podem alterar diversas partes do código — seja acrescentando ou removendo algum
fragmento.
Por usar símbolos (a exemplo de @ e $) e não precisar de declarações de variáveis, os
profissionais conseguem identificar facilmente o papel de cada função. O resultado é uma
linguagem cuja leitura é bastante natural, e a escrita, simplificada.
O framework Ruby on Rails é bastante querido pelos programadores. Inclusive, reúne
diversas profissionais nos Rails Girls: eventos com objetivo de incentivar mulheres de
diferentes idades a aprender tecnologia.

Historial da linguagem Haskel

1930 – O Cálculo Lambda (λ-Calculus)

As teorias e fundamentos matemáticos por trás da Programação Funcional tiveram

início na década de 1930 com o Cálculo Lambda – criado por Alonzo Church.
É considerado a primeira linguagem programação funcional – porém, não foi
projetada para ser executada em computadores, sendo apenas um modelo matemático que
descreve relações entre funções.
Alonzo Church consegui criar um modelo que permitia construir funções mais
complexas através de relações entre funções mais simples. Essas relações possibilitavam
modelar comportamentos de forma bastante ampla.
Atualmente, o Cálculo Lambda se mostrou extremamente útil em diversos tipos
computações. Por essa razão, algumas linguagens imperativas começaram a incorporá-lo
parcialmente. É o caso da linguagem Java, que em sua versão 8, e de muitas outras
linguagens.
 9

1956 – As Primeiras Linguagens Funcionais

Lisp foi a primeira linguagem de programação funcional (na prática); foi criada em
1956 por John McCarthy, logo após a criação do FORTRAN. Isso faz de Lisp a segunda
linguagem de programação do mundo!
Muitas outras linguagens funcionais foram criadas desde então – várias delas foram
derivadas de Lisp (os também chamados dialetos do Lisp). Entre as quais cito Scheme (do
MIT) e Clojure (que roda na JVM).
Em 1996, Lisp foi padronizada e passou a chamar-se Common Lisp.

Bem, até hoje, Lisp possui diversos admiradores e, até mesmo, fanáticos!
Dê uma olhada no site Lispers.org e confira os nomes de alguns famosos que são
usuários da linguagem.
Vários sistemas ainda são produzidos em Lisp; ela está fortemente presente em
sistemas de IA e no mundo do software livre  – basta lembrar que o GIMP é feito em
Scheme e aceita plugins feitos em Lisp; o veterano Emacs é feito em Elisp (mais um
dialeto); etc.
Infelizmente, Lisp nunca foi uma linguagem puramente funcional; ela agrega
componentes de linguagens imperativas, tais como: mudanças de estado, efeitos colaterais,
comandos de controle de fluxo, etc.

1978 – A Grande Crítica!

Em 1978, John Backus (pai do FORTRAN, do BNF, etc.) publicou o artigo “Can
Programming Be Liberated from the vonNeumann Style?” (A Programação Pode Ser Livre
do Estilo von Neumann?) no Turing Award.
Este artigo atacava severamente a arquitetura de hardware baseada no modelo de von
Neumann e seus efeitos negativos sobre as linguagens de programação que seguiam esse
estilo. Ou seja, ele criticou o hardware atual e as linguagens de programação do Paradigma
Imperativo!
Ele demostrou que as novas gerações de linguagens herdavam falhas de projeto das
linguagens antigas e adicionavam novas falhas; estas, por sua vez, seriam herdadas pelas
próximas gerações. Assim, essas linguagens apenas cresciam de tamanho (ou, segundo ele,
apenas engordavam), porém, não aumentavam seu poder.
 10

Backus afirmava que as pesquisas envolvendo novas linguagens de programação não

focavam novas ideias, mas sim, a criação de linguagens acomodadas a um modelo já
existente.

Mas, nesse artigo, Backus exaltou a Programação Funcional!

Ele apresentou a Programação Funcional como uma prática ferramenta de

programação, deixando claro que não se tratava de uma curiosidade matemática –
porém, ela possui este estigma até os dias de hoje.

1980 – Acensão da Programação Funcional

Já na metade da década de 1980, a comunidade de Programação Funcional estava em

plena movimentação – entre pesquisas, reuniões e conferências.
Várias técnicas enovadoras foram propostas, como por exemplo: avaliação
preguiçosa (lazy evaluation).
Em meio a tantas ideias e teorias, diversos cientistas individualmente propuseram e
implementaram suas próprias soluções computacionais; o que gerou uma avalanche de
linguagens de programação e de documentação científica.
Somente para exemplificar, segue a lista de algumas linguagens funcionais que
surgiram nesse período: Miranda, LML (Lazy ML), Orwell, Alfl, Id, Clean, Ponder e Daisy.

1987 – Só uma Linguagem!

Das linguagens criadas nesse período, somente a linguagem Miranda era comercial,
madura, tinha um bom projeto e já era usada em produção. As demais, eram esforços
individuais dos cientistas – e não possuíam um bom projeto.
Porém, de uma forma geral, todas possuíam ideias muito interessantes – não era fácil
provar que uma linguagem era melhor que outra.
Pois bem, havia um número enorme de linguagens e isso gerou desconforto na
comunidade de Programação Funcional. Então, surgiu a ideia de se criar uma única
linguagem que englobasse todas as melhores práticas de projeto de linguagem, além de
implementar as técnicas funcionais que estavam sendo discutidas na época. Esperava-se que
isso trouxesse benefícios para toda a comunidade.
Em Setembro de 1987, houve uma reunião, na conferência de Linguagens de
Programação Funcionais e Arquitetura de Computadores, em Portland – Oregon, para discutir
essa questão. Então, foi decidido que uma comissão deveria ser formada para projetar a tal
linguagem.
 11

Eles tinham em mente algumas diretrizes para essa nova linguagem, são elas:
 Proporcionar comunicação mais rápida de novas idéias;
 Ser uma fundação estável para o desenvolvimento de aplicações reais;
 Ser um meio, através do qual, a Programação Funcional seria encorajada.
Essa comissão decidiu não começar do zero e elegeu uma linguagem como base para
o projeto. Bem, a linguagem Miranda era a mais amadurecida e bem projetada – entre as
demais. Sendo assim, ela foi escolhida como ponto de partida.
A nova linguagem foi batizada de Haskell. Isso foi uma homenagem ao matemático
Haskell Brooks Curry – que contribuir com teorias fundamentais para a Programação
Funcional.
A versão 1.0 de Haskell foi liberada em 1990. Em 1999, a linguagem e as bibliotecas
básicas foram padronizadas sob o nome Haskell 98. E, por fim, atualmente encontra-se no
padrão Haskell 2010.

Álgebra de boleana

O conceito de Álgebra Booleana foi formulado pelo matemático inglês George

Boole em 1850. foi um matemático e filósofo britânico, criador da Álgebra Booleana, base da
atual aritmética computacional. Suas teorias têm implicações no desenvolvimento do
computador, baseado em dígitos binários. Nascimento: 2 de novembro de 1815 em Lincoln,
Lincolnshire, Inglaterra Faleceu: 8 de dezembro de 1864 em Ballintemple, County Cork,
Irlanda
Nasce em Lincoln, em família pobre, e estuda por conta própria, dedicando-se ao
latim e ao grego. Aos 16 anos, começa a trabalhar como professor de escolas elementares.
Quatro anos depois, fundou um colégio particular, que dirigio por vários anos. Interessa-se
por matemática e, depois de ler obras de franceses como Laplace e Legendre, passa a redigir
artigos para o Jornal de Matemática da Universidade de Cambridge.
Em 1847, no artigo Análise Matemática da Lógica, introduz o uso de símbolos para expressar
processos lógicos que podem então ser lidos com o mesmo rigor de uma equação algébrica.
Com isso, dá origem à lógica moderna. É condecorado pela Royal Society, em 1844, por suas
contribuições ao desenvolvimento da análise matemática. Em 1848 publica Os Cálculos da
Lógica e, em 1854, Uma Investigação das Leis do Pensamento. George Boole aproximou a
lógica em uma nova forma de reduzi-la a uma Álgebra simples, incorporando a lógica em
matemática. Ele também trabalhou em equações diferenciais, cálculo de diferenças finitas e
métodos gerais de probabilidade.
 12

Citações de George Boole

Não importa como corrigir um teorema matemático pode parecer ser, um nunca
deveria estar convencido de que não havia algo imperfeito sobre isso até que ele também dá a
impressão de ser bonito.
Citado em D MacHale, secções Comic (Dublin 1993)
Presumo que poucos que têm dado atenção à história da análise matemática, vai
duvidar que tem sido desenvolvido em uma determinada ordem, ou que a ordem tem sido, em
grande medida, necessária - a ser determinado, quer por etapas de dedução lógica, ou pela
introdução sucessiva de novas idéias e concepções, quando o prazo para a sua evolução havia
chegado.
Das muitas formas de falsa cultura, uma prematura convence com abstrações, é talvez a
maior probabilidade de ser fatal para o crescimento de um vigor masculino do intelecto.
Preface to A treatise on differential equations (1859) Prefácio a um tratado sobre equações
diferenciais (1859)
Probabilidade é a expectativa fundada no conhecimento parcial. Um conhecimento
perfeito com todas as circunstâncias que afetam a ocorrência de um evento, mudar a
expectativa em segurança, e deixar espaço nem inferiores a procura de uma teoria das
probabilidades.
An Investigation of the Law of Thought (New York, 1951). Uma investigação da lei do
pensamento (Nova Iorque, 1951).
Para desdobrar as leis secretas e as relações dessas faculdades alta de pensamento
pelo qual todos além do conhecimento meramente perceptivo do mundo e de nós mesmos é
atingido ou amadurecido, é um objeto que não se encontra em necessidade de recomendação
para uma mente racional.
Não é da essência da matemática para estar familiarizado com as idéias de número e
quantidade. An investigation of the laws of thought (New York, 1951). Uma investigação das
leis do pensamento (Nova Iorque, 1951).
 13

Expressões booleanas e ÁLGEBRA BOOLEANA

A lógica booleana para criar instruções de validação/substituição. A expressão de
lógica booleana é uma estrutura lógica que pode ser verdadeira ou falsa. As expressões
podem ser ligadas através de operadores (como AND, OR e NOR) para possibilitar a criação
de expressões complexas.
A lógica booleana usa tabelas verdade (TRUE ou FALSE) para determinar o valor
verdade (TRUE ou FALSE) das expressões. Uma tabela verdade atribui o valor T (TRUE) ou
F (FALSE) a cada parte de uma expressão complexa e, em seguida, determina se a expressão
combinada é verdadeira ou falsa.
A figura a seguir utiliza uma tabela verdade para o operador AND (conjunção) para
determinar se um valor deve ser substituído.
Simplificando a Lógica Booleana 
x, y e z são variáveis que podem ser True ou False (Verdadeiro ou Falso)
"!" significa "Not" (Não)
"|" significa "Or" (Ou)
"&" significa "And" (E)
"==" significa "Igual"
!(!x) == x
x | x == x
x | !x == true
!x | !y == !(x & y) - DeMorgan's Theorem
!x & !y == !(x | y) - DeMorgan's Theorem
x & x == x
x & !x == false
x | y == y | x - Commutative Law
x & y == y & x - Commutative Law
(x | y) | z == x | (y | x) - Associative Law
(x & y) & z == x & (y & z) - Associative Law
x & y | x & z == x & (y | z) - Distributive Law
(x | y) & (x | x) == x | (y & z) - Distributive Law
x | x & y == x
x & y | x & !y == x
(x & y) | (!x & z) | (y & z) == (x & y) | (!x & z)
 14

(x | y) & (!x | z) & (y | z) == (x | y) & (!x | z)

x & (x | y) == x
(x | y) & (x | !y) == x

Um processador é composto de transistores que realizam funções sob sinais digitais.

Esses transistores, montados entre eles, formam os componentes que realizam funções muito
simples. A partir desses elementos, é possível criar circuitos realizando operações bem
complexas. A álgebra booleana (do nome do matemático inglês George Boole) é um meio
para criar tais circuitos.
Uma álgebra Booleana pode ser definida com um conjunto de operadores e um
conjunto de axiomas, que são assumidos verdadeiros sem necessidade de prova. Em 1854,
George Boole introduziu o formalismo que até hoje se usa para o tratamento sistemático da
lógica, que é a chamada Álgebra Booleana.
O propósito da álgebra booleana é descrever o processamento de sinais, em forma de
expressão algébrica. Em linguajar matemático, a álgebra booleana é composta por um
conjunto de operadores e de axiomas que são entendidos como verdadeiros mesmo sem
provas. Vale conhecer um pouco sobre ela, pois é essa lógica que baseia o funcionamento dos
computadores.
A álgebra booleana traduz os sinais em expressões matemáticas. Para isso, é preciso
definir cada sinal elementar por variáveis lógicas e seu processamento por funções lógicas.
Certos métodos permitem definir operações que queremos realizar e traduzir o resultado em
uma expressão algébrica. Graças às chamadas leis de composição, as expressões podem ser
simplificadas. Isso permitirá representar um circuito lógico, ou seja, um circuito que
esquematiza o arranjo dos componentes básicos (nível lógico), sem considerar a realização
através dos transistores (nível físico).
Um computador só manipula dados binários. Assim, chamamos variável
lógica um dado binário, ou seja, um dado com apenas dois estados possíveis: 0 ou
1.
 15

Conclusão

A história das linguagens de programação abrange desde a documentação dos

primeiros computadores mecânicos até ferramentas modernas para o desenvolvimento de
software. As primeiras linguagens de programação eram altamente especializadas, contando
com notação matemática e sintaxe igualmente obscura. Ao longo do século XX, pesquisas na
teoria do compilador levaram à criação de linguagens de programação de alto nível, que usam
uma sintaxe mais acessível para comunicar instruções.
A primeira linguagem de programação de alto nível foi Plankalkül, criada por Konrad
Zuse entre 1942 e 1945. A primeira língua de alto nível a ter um compilador associado foi
criada por Corrado Böhm em 1951, para sua tese de doutorado. A primeira língua
comercialmente disponível foi FORTRAN (FORmula TRANslation), desenvolvido em 1956
(primeiro manual apareceu em 1956, mas foi desenvolvido pela primeira vez em 1954) por
uma equipe liderada por John Backus na IBM.
Entretanto, A primeira linguagem de programação foi um algoritmo que foi criado por
Ada Lovelace em 1883. Ada Lovelace criou este algoritmo para o motor analítico de Charles
Babbage. O objetivo deste algoritmo era calcular os números de Bernoulli.
Em 1936, a primeira vez, os códigos de computador foram especializados por Alonzo
Church e Alan Turing. Igreja expressou cálculo lambda de uma forma formulada.
 16

Referências Bibliográficas

https://br.ccm.net/faq/2995-algebra-booleana

https://blog.eseg.edu.br/linguagens-de-programacao/

https://www.google.com/search?
client=opera&q=Tipos+de+linguagens+de+programação+e+seus+níveis&sourceid=o
pera&ie=UTF-8&oe=UTF-8

Introdução ao Haskell.