Introdução e Lógica

de Programação

1
 Glossário
Linguagem de baixo nível ou linguagem de máquina: conjunto de instruções representados por
bits(0,1)
Linguagem de programação: Conjunto de códigos para passar instruções para uma máquina
Linguagem de Alto nível: conjunto de instruções em linguagem natural que é convertida por um
interpretador para linguagem de baixo nível para enviar ao computador instruções.
Sistema Operacional: Programa que permite a comunicação entre usuários e Hardware.
Hardware: Parte física de um computador, aquilo que pode ser tocado.
Software: Parte lógica de um computador, aquilo que é intangível.

2
Glossário.....................................................................................................................................................1
História da Computação.............................................................................................................................4
História das Linguagens de Programação.................................................................................................. 5
Lógica de Programação..............................................................................................................................8
Algoritmos..........................................................................................................................................8
Variáveis.....................................................................................................................................9
Operadores.............................................................................................................................. 10
Operadores de Atribuição................................................................................................10
Operadores Aritméticos...................................................................................................10
Operadores Relacionais................................................................................................... 10
Operadores Lógicos..........................................................................................................11
Estruturas de Controle.............................................................................................................11
Desvios Condicionais........................................................................................................11
Laços de Repetição.......................................................................................................... 12

3
 História da Computação

Os modelos que deram origem aos computadores atuais datam do final do século XIX, com a criação
da máquina analítica, Charles Babbage, eram modelos que não chegaram a funcionar, mas foram os
modelos que permitiram a evolução para o que temos em nossas mãos nos dias de hoje. E antes
mesmo de existir um computador surgiu a primeira programadora, Ada Lovelace, que traduziu os
modelos matemáticos para serem “compreendidos” pela máquina analítica de Babbage.

Foi apenas na década de 40, que Alan Turing criou sua tese sobre inteligência artificial, ela ficou
conhecida como Máquina de Turing, e serve como modelo para criação de qualquer computador até
os dias de hoje. Durante esta década estes conceitos foram evoluindo e foram aplicados na segunda
guerra mundial, para quebrar código de comunicação criptografados(código embaralhados para que
somente o destinatário pudesse compreende-los) dos alemães.

Em 1945, foi criado o ENIAC, o primeiro computador criado, ele era gigante fisicamente e em
capacidade de cálculo, em 10 anos de funcionamento ele havia realizado mais cálculos que toda a
humanidade ao longo da história.

Foi apenas em 1977, que a Apple lançou o Apple-II, o computador que revolucionou o mercado de
computadores pessoais, ele ainda só podia ser usado por que possuía um conhecimento avançado
pois era complexo a forma de interagir com estes equipamentos a interface e a linguagem de
programação eram de baixo nível(programadas em linguagem de máquina).

O primeiro computador que poderia ser usado por todos foi criado apenas em 1981, ele possui um
sistema operacional que facilitava o envio de informações para o computadores, ele fazia a tradução
do que o usuário desejava, enviava para o computador processar, e apresentava para o usuário o
resultado do processamento realizado.

O primeiro SO(Sistema Operacional) foi o PC-DOS, que depois ficou conhecido como MS-DOS e
acompanha todos os computadores com SO Windows até os dias de hoje. Era um sistema simples,
voltado para a entrada e saída de textos, com o tempo chegamos aos modernos SO, que possuem
interface gráfica, multi coloridas e diversas maneiras de apresentar os dados.

Os PCs a partir desta época também começaram a evoluir rapidamente, principalmente pela guerra
entra Microsoft, IBM e Apple. Esta evolução nos trouxe até os dias atuais onde temos a disposição
equipamentos para processamento de dados extremamente potentes.
Com a evolução das máquinas começou a se fazer necessários novos sistemas para serem operados,
as pessoas não estavam mais satisfeitas me inserir um comando e ver o resultado deles, elas queriam
podem imprimir os dados, colori-los, criar imagens junto com textos, enviar estas informações para
outras pessoas e ter momentos de laser.

Estas necessidades criaram um mercado que precisava de programas mais específicos, para atender a
necessidades específicas de seus usuários, e a partir da década de 90 houve uma explosão de novos
Software:

 Aplicativos, que poderiam gerar textos, planilhas, ou serem tão específicos a ponto de
controlar o estoque de uma determinada empresa, controlar despesas financeiras entre
outras;
 Games;
 Sistemas operacionais;

4
Cada um destes sistemas era escrito de uma maneira diferente(linguagem), pois cada um precisava
passar para a máquina os seus comandos.

E agora vamos entender como surgiram e se desenvolveram a principais linguagens de programação.

História das Linguagens de Programação

Antes de iniciarmos, cabe aqui ressaltar, que máquinas são equipamento eletrônicos, e como tais
compreendem apenas pulsos elétricos(0s e 1s). Como mencionado no bloco anterior, a primeira
programadora foi Ada Lovelace, que organizou os passos para processamento matemático, esta
primeira linguagem de programação consistia em passar para a máquina os pulsos elétricos
necessários para que ela pudesse calcular algo e retornar na representação de 0s e 1s os resultados
deste processamento. Para tal ela usava cartões perfurados, que deviam ser inseridos na ordem
correta para que pudessem processar os dados, estes cartões perfurados representavam uma
sequencia de 0s e 1s compreendidos pelas máquinas.

Estas linguagens apresentavam alguns problemas facilmente identificáveis, como por exemplo a
necessidade de alto conhecimento técnico, demora para processar os dados pois era necessário
inserir vários cartões para se conseguir um simples cálculo e a principal de todas, na minha opinião, os
resultados só poderiam ser conhecidos por alguém com conhecimento elevado, pois a máquina
apresentava os resultados em linguagem de 0s e 1s, conhecidas como binária.

Pesquisadores investiram tempo e dedicação para evoluir esta forma de calcular, e para isso
começaram a desenvolver compiladores, que eram programas especializados a converter a linguagem
natural em linguagem de máquina e vice-versa. Em 1954, surgiu a primeira linguagem amplamente
utilizada, Fortran. Após o Fortran sugiu o Cobol(1959), linguagem que teve alta aceitação comercial,
existem até hoje programas escritos em Cobol rodando em produção.

As linguagens de programação começaram a se especializar, Cobol foi muito utilizada na área

comercial, Lisp(1957) e Prolog(1972) muito utilizadas para programas na área de pesquisa de
inteligência artificial.

Um marco importante, e muito estudado até os dias de hoje foi o surgimento da orientação a objetos
na história das linguagens de programação. A linguagem Simula(1967) introduziu o conceito de
classes e a linguagem Smalltalk expandiu o conceito de classes e se tornou a primeira linguagem de
programação orientada a objetos. Masfoi a linguagem C++ (originalmente conhecida como C) que
popularizou a orientação a objetos, vamos falar mais dela a frente.

A partir dai muitas linguagens surgiram com aplicação em áreas distintas. Das quais podemos citar:

 C#;
 VB.NET;
 Java;
 Object Pascal;
 Objective-C;
 PHP;
 Python;
 Ruby.

Antes de avançar mais sobre as linguagens de programação, precisamos entender alguns conceitos:

5
1. Programação estruturada: É a maneira de escrever os códigos de maneira estruturada, usando
funções e sub-rotinas. Ela prega que todo programa pode ser reduzido a sequencia, decisão e
repetição. Ela foi sucedida pela programação orientada a objeto(POO), mas ainda é a maneira
como se iniciam os estudos de programação, embora tenha sido superada pela POO.

2. Programação modular: São blocos de código, que são ligados a outros através de uma interface
simples.

3. Programação Orientada a Objetos: É um paradigma que busca a criação de componentes de

software, chamados objetos. Cada objetos é representado por atributos(características) e
métodos(Funções/Ação). Imagine um objeto carro, nele podemos citar como atributos cor,
modelo, ano e como método acelerar, mudar de direção, abrir a porta. Um sistema é composto
por vários objetos que o representam e comunicam-se entre si através de mensagens.
Estudaremos a fundo esta forma de programação e todas as suas características.

Existem algumas formas de classificarmos as linguagens de programação:

 Quanto ao paradigma

 Paradigma procedural: os programas executam uma série de chamas a procedimentos

separados. Exemplo de linguagem: Fortran e Basic.

 Paradigma de estrutura de bloco: marcada pela presença de escopos aninhados,

geralmente programas de bloco único. Exemplo de linguagem: Pascal.

 Paradigma de orientação a objetos: permitem a iteração entre os objetos. Exemplo de

linguagem: C++, Java, Python, Ruby.

 Paradigma de computação distribuída: partes do programa pode ser executado em

máquinas diferentes. Exemplo de linguagem: ADA.

 Quanto a estrutura de tipos

 Forte ou fracamente tipada:

 Fortemente tipada: quando uma variável é criada é necessário determinar o tipo

desta variável e este se mantém imutável. Ex: Java, Ruby e Python.

 Fracamente tipada: quando o tipo da variável muda de acordo com o que é

armazenado nela, uma mesma variável pode armazenar um número em dado
momento e em outro armazenar um texto. Ex: JavaScript, PHP.

 Dinâmica ou estaticamente tipada:

 Dinamicamente: O tipo da variável e definido no momento que o programa esta

sendo executado. Ex: Python, Pearl.

 Estaticamente: O tipo da variável é determinado no momento da compilação. Ex:

Java, C.

Existem outras maneiras de classificar as linguagens de programação, como por exemplo geração,
grau de abstração, etc, mas para este estudo usaremos as apresentadas anteriormente.

Atualmente existem inúmeras linguagens de programação, abaixo estão listadas as 20 linguagens de

programação mais populares, de acordo com pesquisa divulgada pela RedMonk em março de 2021:

1. JavaScript 2. Python

6
3. Java 12. Objective-C
4. PHP 13. Shell
5. C# 14. Scala
6. C++ 15. Go
7. TypeScript 16. PowerShell
8. Ruby 17. Kotlin
9. C 18. Rust
10. Swift 19. Perl
11. R 20. Dart

Assim resumimos a história dos

computadores e das linguagens de
programação. No decorrer dos estudos
voltaremos a falar sobre algumas
diferenças de plataformas e sobre como
escolher uma linguagem de programação,
por ora, vamos partir para aprender a
criar nossos primeiros códigos.

7
 Lógica de Programação

Algoritmos

Algoritmos segundo Szwarcfiter e Markenzon (1994), são definidos como sendo o processo
sistemático para a resolução de um problema. Para Manzano (2015), um algoritmo é um conjunto
lógico de operações predefinidas que resolve um determinado problema de forma intuitiva, já Saliba
(1993), Berg e Figueiró (1998) descrevem algoritmos como sendo uma sequência ordenada de passos
que deve ser seguida para a realização de uma tarefa.

De uma maneira geral, os algoritmos são a forma como resolvemos um problema da melhor maneira
possível.

Veja um exemplo de um algoritmo que fazemos quando queremos cozinhar arroz:

1. Acender o fogo.
2. Refogar os temperos.
3. Colocar o arroz na panela.
4. Colocar a água.
5. Cozinhar o arroz.
6. Abaixar o fogo.
7. Esperar o ponto.
8. Desligar o fogo.
9. Servir o arroz.

Importante observar que um algoritmo não é algo imutável e pode ter outras etapas ou até mesmo
outra ordem de execução, por exemplo poderíamos incrementar etapas neste algoritmo como por
exemplo comprar o arroz, tampar a panela, entre outras etapas que poderiam deixar o algoritmo
ainda mais detalhado. O que nunca muda em um algoritmo é o seu objetivo, um algoritmo escrito
para cozinhar arroz nunca será usado para trocar o pneu de um carro por exemplo.
Um algoritmo é composto por 3 partes: Entrada, Processamento e Saída.

Entrada: São todos os itens que são inseridos em um algoritmo, no nosso exemplo podemos citar o
arroz, temperos, água, etc, em um algoritmo computacional as entradas poderiam ser um arquivo, o
preenchimento de um formulário, uma imagem, entre outros.

Processamento: Esta é a etapa onde a coisa aconteceu, no nosso exemplo é o cozimento do arroz,
durante esta etapa novas entradas podem ser necessárias ou não. Nela estão contidos todos os
tratamento necessário para que cheguemos ao objetivo do nosso algoritmo, em um algoritmo
computacional, o processamento pode envolver cálculos, transformação de textos, entre outros.

8
Saída: Saída é o resultado do da entrada + processamento, no nosso caso arroz cozido é a saída
esperada. A saída pode nem sempre ser a esperada, caso isso aconteça, será necessário uma
avaliação do algoritmo e/ou entradas que foram informadas a ele. Em um algoritmo computacional, a
saída pode ser um gráfico, uma planilha, um cadastro, etc. Caso o resultado do algoritmo não seja
alcançado o mesmo precisa ser revisto e executado novamente. Importante lembrar que para saídas
de qualidade, além do algoritmo ser confiável e correto, as entradas também precisam ser de
qualidade, e o algoritmo pode fazer tratamento para validar se estas entradas estão de acordo com o
que ele precisa para produzir o resultado correto. Ex: Se no processo de cozinhar arroz eu colocar
feijão o resultado não será o mesmo. Em um algoritmo computacional, o mesmo pode ser o mesmo
que colocar um número em um campo que espera um nome.

Para criarmos nossos algoritmos vamos usar a linguagem natural neste primeiro momento, isso para
facilitar o entendimento dos principais conceitos de programação. Para isso vamos usar o PORTUGOL
STUDIO(http://lite.acad.univali.br/portugol/). Além disso nossos algoritmos iniciais irão adotar o
paradigma de programação estruturada, onde eles terão sua execução de forma linear.

Agora que entendemos o que são algoritmos vamos entender como o nosso algoritmo é estruturado.

Variáveis

Variáveis são espaços reservados na memória do computador para guardar um determinado valor
que ainda não sabemos qual é. Elas são identificadas por um nome, que será acessado pelo programa
para armazenar, modificar ou apresentar o seu valor.

Tipos de variáveis mais comuns:

Inteiro: Armazena apenas números inteiros, positivos ou negativos. Ex: 1, 2, -1, -2.

String: Armazena qualquer carácter alfa numérico. Ex: Rio de Janeiro, Brasil.

Decimal: Armazena números com casa decimal. Ex: 10.5.

Boolean: Armazena um estado true/verdadeiro ou false/falso.

Cada linguagem tem as suas próprias maneira de trabalhar e determinar suas variáveis, a frente
entraremos nestes detalhes, por hora vamos estudar os tipos usados no Portugol, abaixo estão as
variáveis que poderemos usar de acordo com o que desejarmos criar:

Cadeia: Variável para armazenar uma quantidade de texto. Ex: João, Maria.

Caracter: Variável que armazena apenas 1(UM) caracter. Ex: A, B, c, 1.

Inteiro: Armazena números inteiros positivos e negativos. Ex: 1, -1.

Logico: Armazena um estado verdadeiro ou falso.

Real: Armazena um número com casas decimais. Ex: 10.2.

Vazio: Armazena um tipo de dado que não pode ser classificado.

9
Operadores

Através dos operadores é que conseguimos realizar a etapa de processamento dos nosso algoritmo,
cada linguagem define seus próprios operadores, e estes são classificados em grupos de acordo com o
seu tipo, vamos estudar abaixo os principais grupos de operadores usados no Portugol, objeto de
estudo deste módulo.

Operadores de Atribuição

Ao criamos uma variável, precisaremos atribuir valores a elas, para isso usamos os operadores de
atribuição, no Portugol usaremos o símbolo =(igual) para atribui um valor a uma variável.

Ex: Variavel = 6
Nome = ‘João’
Sobrenome = ‘Silva’
NomeCompleto = Nome + Sobrenome

A atribuição de valores a uma variável pode ser um dado novo ou o conteúdo de uma outra variável.

Operadores Aritméticos

São os velhos e conhecidos operadores da matemática,alguns destes símbolos mudam na construção

de algoritmos:

Operação Símbolo Prioridade Descrição

Adição + 1 Soma dois ou mais números. Ex: 1 + 1
Subtração - 1 Subtrair um ou mais números. Ex: 10 - 7
Multiplicação * 2 Multiplica dois ou mais números. Ex: 2 * 3
Divisão / 2 Divide dois números. Ex: 6 / 3
Resto % 2 Retorna o resto da divisão entre 2 números. Ex: 5 / 2

A prioridade indica qual será executada primeiro, quando existirem no cálculo mais de uma operação,
quanto mais alta a prioridade significa que este calculo será executado primeiro. Para modificar a
ordem, podemos usar parênteses “(“, sendo que o algoritmo irá executar sempre dos parênteses mais
internos para o externos. A diferença que na computação não usamos chaves e colchetes como na
matemática tradicional.

Operadores Relacionais

São usados para comparar valores.

Operação Símbolo
Maior >
Menor <
Maior ou Igual >=
Menor ou Igual <=
Igual ==
Diferente !=

10
Operadores Lógicos

Operadores lógicos permitem que façamos operações sobre variáveis, semelhante ao que fazemos
com os aritméticos.

Operação Prioridade
ou 1
e 2
nao 3

Estruturas de Controle

Em determinadas situações é necessário executar ações de acordo com os dados fornecidos pelo
usuário ou processados pelo programa. Em alguns casos, pode ser necessário que o programa
execute uma determinada função ou ação repetidas vezes. Sendo assim, controlar e manipular a
ordem com que instruções serão executadas pelo programa torna-se essencial, e para isso usamos as
estruturas de controle. Sem o uso de estruturas de controle, o programa seria executado de cima
para baixo, linha a linha, dificultando assim a resolução de diversos problemas. As estruturas de
controle dividem-se em duas:

Desvios Condicionais

Os desvios condicionais são desvios que o código executa quando determinada situação é encontrada,
por exemplo, para calcular a tabuada quero que o programa pare quando chegar ao numero 10 ou
quando queremos escrever se o aluno foi ou não aprovado em uma matéria de acordo com a nota
que ele obteve.

SE: Esta condição valida se determinado código será ou não executado. Ex: quero que o programa
escreva aprovado se a nota for maior que 70, a sintaxe ficaria igual a que seque abaixo:

SE-SENAO: Esta condição valida terminado código e caso ele não seja atendido ela desvia para o
bloco do senão, no caso do exemplo anterior o programa vai escrever aprovado ou reprovado, a
sintaxe ficaria igual a que segue abaixo:

SE-SENAO SE: Semelhante a estrutura anterior o senão se difere pelo fato de executar no bloco senão
um novo teste, podendo assim ser criada uma estrutura hierárquica de decisão. No exemplo anterior
da nota, o candidato seria aprovado com nota acima de 70, abaixo de 60 estaria na lista de espera, e
abaixo disso eliminado. Para representar esta estrutura de decisão o código ficaria como o que segue
abaixo:

11
Lembrando que no exemplo acima o bloco senão poderia ter sido deixado de fora caso não existisse
uma terceira opção de saída do algoritmo.

Escolha-Caso: Esta estrutura condicional, vai ter uma série de possíveis alternativas e ao entrar na
estrutura o sistema executará apenas uma delas. Seu funcionamento é parecido com o SE e SENAO,
porém ela deixa o código mais organizado e mais fácil de dar manutenção. Abaixo segue um exemplo
de uso da estrutura Escolha-Caso:

Laços de Repetição

Os laços de repetição são utilizados para repetir determinado bloco de código até que certa situação
aconteça. Como citado acima, para calcular a tabuada até 10 será usada além de um desvio
condicional, uma estrutura de repetição para escrever a tabuada. Vamos ver os principais laços do
Portugol.

Laço Para: O laço para repete o bloco de códigos até que a condição seja atendida e desvio o fluxo do
programa. A sintaxe para escrever a tabuada até o 10 seria como a imagem abaixo:

,
O código acima ira repetir a multiplicação de uma tabuada 10 vezes e escrever este resultado na tela.

Laço Enquanto: O laço enquanto repete o código até que a condição que o valida não seja atingido, o
exemplo abaixo vai imprimir o mesmo resultado do laço for anterior.

Laço Faça Enquanto: Faça enquanto difere do enquanto no quesito do momento que ele faz a
validação da condição, no enquanto o código pode chegar a nem ser executado, já o faça enquanto
garante que o bloco de código será executado minimamente uma vez, veja um exemplo do faça
enquanto:

12