Lógica e Organização

Lógica e Organização
de Computadores
Prof.a Greisse Moser Badalotti
2016
Copyright © UNIASSELVI 2016
Elaboração:
Revisão, Diagramação e Produção:

Centro Universitário Leonardo da Vinci – UNIASSELVI
Ficha catalográfica elaborada na fonte pela Biblioteca Dante Alighieri

UNIASSELVI – Indaial.
160
B132l Badalotti; Greisse Moser
Lógica e organização de computadores/ Greisse Moser

Badalotti : UNIASSELVI, 2016.
189 p. : il.
ISBN 978-85-7830-967-1
1.Lógica.
I. Centro Universitário Leonardo Da Vinci.
Impresso por:
Apresentação
Prezado(a) Acadêmico(a):
Bem-vindo(a) à disciplina Lógica e Organização de Computadores.

A história da computação, conceitos da computação, lógica de programação,
entre muitos outros temas, farão parte dos seus estudos nesta disciplina.
O estudo desta disciplina é muito importante para ampliar seus

conhecimentos acerca da computação e compreender como a mesma funciona.
Com esta disciplina você entenderá a informática de maneira sistêmica.
Aproveitamos esse momento para destacar que os exercícios deste

caderno não são opcionais, os quais tem por objetivo a fixação de determinado
conceito. É aí que reside a importância da realização de todos. Sugerimos
fortemente que em caso de dúvida em algum exercício você entre em contato
com seu tutor externo ou com a tutoria da Uniasselvi.
Este material foi desenvolvido com o objetivo de disponibilizar a você

acadêmico(a), o pontapé inicial da computação.
Desejo a você sucesso nessa nova busca de informações!
Bons estudos!
III
UNI
Você já me conhece das outras disciplinas? Não? É calouro? Enfim, tanto

para você que está chegando agora à UNIASSELVI quanto para você que já é veterano, há
novidades em nosso material.
Na Educação a Distância, o livro impresso, entregue a todos os acadêmicos desde 2005, é

o material base da disciplina. A partir de 2017, nossos livros estão de visual novo, com um
formato mais prático, que cabe na bolsa e facilita a leitura.
O conteúdo continua na íntegra, mas a estrutura interna foi aperfeiçoada com nova
diagramação no texto, aproveitando ao máximo o espaço da página, o que também
contribui para diminuir a extração de árvores para produção de folhas de papel, por exemplo.
Assim, a UNIASSELVI, preocupando-se com o impacto de nossas ações sobre o ambiente,

apresenta também este livro no formato digital. Assim, você, acadêmico, tem a possibilidade
de estudá-lo com versatilidade nas telas do celular, tablet ou computador.

Eu mesmo, UNI, ganhei um novo layout, você me verá frequentemente e surgirei para
apresentar dicas de vídeos e outras fontes de conhecimento que complementam o assunto
em questão.
Todos esses ajustes foram pensados a partir de relatos que recebemos nas pesquisas
institucionais sobre os materiais impressos, para que você, nossa maior prioridade, possa
continuar seus estudos com um material de qualidade.
Aproveito o momento para convidá-lo para um bate-papo sobre o Exame Nacional de

Desempenho de Estudantes – ENADE.

Bons estudos!
IV
V
VI
Sumário
UNIDADE 1 – HISTÓRICO DA COMPUTAÇÃO ........................................................................... 1
TÓPICO 1 – BREVE HISTÓRICO ........................................................................................................ 3

1 INTRODUÇÃO ..................................................................................................................................... 3
2 HARDWARE .......................................................................................................................................... 3
2.1 DISPOSITIVOS MECÂNICOS ....................................................................................................... 4
2.2 DISPOSITIVOS ELETROMECÂNICOS ....................................................................................... 8
2.3 COMPONENTES ELETRÔNICOS . .............................................................................................. 10
RESUMO DO TÓPICO 1 ....................................................................................................................... 12
AUTOATIVIDADE ................................................................................................................................. 13
TÓPICO 2 – GERAÇÃO DOS COMPUTADORES .......................................................................... 15

1 INTRODUÇÃO ..................................................................................................................................... 15
2 PRIMEIRA GERAÇÃO: 1945-1956 .................................................................................................... 15
3 SEGUNDA GERAÇÃO: 1956-1963 .................................................................................................... 17
4 TERCEIRA GERAÇÃO: 1965-1970 .................................................................................................... 19
5 QUARTA GERAÇÃO: 1971- ATÉ OS DIAS ATUAIS .................................................................... 20
6 UM POUCO DA HISTÓRIA DA APPLE ......................................................................................... 21
7 UM POUCO DE BILL GATES E A MICROSOFT .......................................................................... 22
8 QUINTA GERAÇÃO ............................................................................................................................ 23
8.1 JOGOS ............................................................................................................................................... 23
8.2 REDES NEURAIS ............................................................................................................................ 24
8.3 LINGUAGEM NATURAL . ............................................................................................................ 24
8.4 SISTEMAS ESPECIALISTAS .......................................................................................................... 24
8.5 ROBÓTICA ....................................................................................................................................... 25
RESUMO DO TÓPICO 2 ....................................................................................................................... 26
AUTOATIVIDADE ................................................................................................................................. 27
TÓPICO 3 –TIPOS DE COMPUTADORES E SEUS COMPONENTES ....................................... 29

1 INTRODUÇÃO ..................................................................................................................................... 29
2 SUPERCOMPUTADORES .................................................................................................................. 29
3 COMPUTADORES MAINFRAME ................................................................................................... 30
4 MINICOMPUTADORES .................................................................................................................... 31
5 MICROCOMPUTADORES ................................................................................................................ 32
6 COMPUTADORES MÓVEIS ............................................................................................................. 33
7 FUNÇÕES PRIMÁRIAS DE UM COMPUTADOR ....................................................................... 34
7.1 PROCESSAMENTO DE DADOS .................................................................................................. 35
7.2 ARMAZENAMENTO DE DADOS ............................................................................................... 35
7.3 MOVIMENTAÇÃO DOS DADOS ................................................................................................ 35
7.4 CONTROLE ...................................................................................................................................... 36
8 PRINCIPAIS COMPONENTES ESTRUTURAIS DE UM COMPUTADOR ............................ 36
8.1 CPU .................................................................................................................................................... 37
8.2 ARMAZENAMENTO DE DADOS / MEMÓRIA ....................................................................... 38
VII
8.2.1 Memória principal .................................................................................................................. 38
8.2.2 Armazenamento secundário ................................................................................................. 39
8.3 OS DISPOSITIVOS DE ENTRADA/SAÍDA . ............................................................................... 40
8.4 INTERCONEXÃO DE SUBSISTEMAS . ....................................................................................... 40
9 MICROPROCESSADORES / MICROCONTROLADORES / SISTEMAS EMBARCADOS. 40
10 ARQUITETURA RISC E CISC ......................................................................................................... 42
10.1 CAUSAS PARA UMA ARQUITETURA COMPLEXA . ........................................................... 42
10.2 RISC POR QUE? . ........................................................................................................................... 43
10.3 PIPELINING ................................................................................................................................... 45
LEITURA COMPLEMENTAR ............................................................................................................... 46
RESUMO DO TÓPICO 3 ....................................................................................................................... 62
AUTOATIVIDADE ................................................................................................................................. 63
UNIDADE 2 – CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO ....................................... 65
TÓPICO 1 – SISTEMAS DE NUMERAÇÃO ..................................................................................... 67

1 INTRODUÇÃO ..................................................................................................................................... 67
2 SISTEMA DE NUMERAÇÃO ............................................................................................................ 67
3 SISTEMA DE NUMERAÇÃO DECIMAL ....................................................................................... 68
4 SISTEMA DE NUMERAÇÃO BINÁRIO ......................................................................................... 69
5 SISTEMA DE NUMERAÇÃO OCTAL ............................................................................................. 70
6 SISTEMA DE NUMERAÇÃO HEXADECIMAL ............................................................................ 71
7 CONVERSÕES ENTRE SISTEMAS DE NUMERAÇÃO ............................................................. 71
8 CONVERSÃO DE DECIMAL PARA BINÁRIO ............................................................................. 72
9 CONVERSÃO DE DECIMAL PARA OCTAL ................................................................................. 73
10 CONVERSÃO DE DECIMAL PARA HEXADECIMAL .............................................................. 73
11 CONVERSÃO DE BINÁRIO PARA DECIMAL ........................................................................... 74
12 CONVERSÃO DE OCTAL PARA DECIMAL ............................................................................... 75
13 CONVERSÃO DE HEXADECIMAL PARA DECIMAL .............................................................. 77
14 REGRAS DE FIXAÇÃO ..................................................................................................................... 78
RESUMO DO TÓPICO 1 ....................................................................................................................... 80
AUTOATIVIDADE ................................................................................................................................. 81
TÓPICO 2 – BASES COMPUTACIONAIS ......................................................................................... 83

1 INTRODUÇÃO ..................................................................................................................................... 83
2 ARQUITETURA DE COMPUTADORES ........................................................................................ 84
3 SOFTWARE ............................................................................................................................................ 85
3.1 CATEGORIAS DE SOFTWARE ..................................................................................................... 85
3.1.1 Softwares básicos .................................................................................................................... 85
3.1.2 Softwares utilitários . .............................................................................................................. 87
3.1.3 Softwares aplicativos . ............................................................................................................ 87
3.1.4 Ferramentas de desenvolvimento ........................................................................................ 88
4 REDES DE COMPUTADORES .......................................................................................................... 89
RESUMO DO TÓPICO 2 ....................................................................................................................... 96
AUTOATIVIDADE ................................................................................................................................. 97
TÓPICO 3 – DADOS ............................................................................................................................... 99

1 INTRODUÇÃO ..................................................................................................................................... 99
2 ENTENDENDO O TIPO ABSTRATO DE DADOS ....................................................................... 100
2.1 MODELO PARA UM TAD ............................................................................................................. 100
2.2 ENTENDENDO PILHAS ............................................................................................................... 101
VIII
2.3 ENTENDENDO FILAS ................................................................................................................... 106
2.4 ENTENDENDO LISTAS LINEARES GERAIS ............................................................................ 109
2.5 ENTENDENDO ÁRVORES ........................................................................................................... 112
2.6 ENTENDENDO GRAFOS .............................................................................................................. 114
RESUMO DO TÓPICO 3 ....................................................................................................................... 132
AUTOATIVIDADE ................................................................................................................................. 133
UNIDADE 3 – LÓGICA DE PROGRAMAÇÃO ................................................................................ 135
TÓPICO 1 – FUNDAMENTOS DE LÓGICA DE PROGRAMAÇÃO .......................................... 137

1 INTRODUÇÃO ..................................................................................................................................... 137
2 FUNDAMENTOS DE LÓGICA DE PROGRAMAÇÃO .............................................................. 138
3 LÓGICA .................................................................................................................................................. 139
4 LÓGICA DE PROGRAMAÇÃO ........................................................................................................ 140
RESUMO DO TÓPICO 1 ....................................................................................................................... 143
AUTOATIVIDADE ................................................................................................................................. 144
TÓPICO 2 – CONSTANTES E VARIÁVEIS ....................................................................................... 145

1 INTRODUÇÃO ..................................................................................................................................... 145
2 CONSTANTES ...................................................................................................................................... 145
3 VARIÁVEIS ............................................................................................................................................ 146
4 TIPOS DE DADOS ............................................................................................................................... 147
5 DECLARANDO CONSTANTES E VARIÁVEIS ............................................................................ 147
6 COMANDOS BÁSICOS DE UM ALGORITMO ........................................................................... 149
7 EXPRESSÕES ......................................................................................................................................... 151
RESUMO DO TÓPICO 2 ....................................................................................................................... 153
AUTOATIVIDADE ................................................................................................................................. 154
TÓPICO 3 – ESTRUTURAS DE CONTROLE .................................................................................... 155

1 INTRODUÇÃO ..................................................................................................................................... 155
2 ESTRUTURAS DE CONTROLE SEQUENCIAL ............................................................................ 155
3 ESTRUTURAS DE CONTROLE CONDICIONAL ........................................................................ 156
4 ESTRUTURAS DE CONTROLE DE REPETIÇÃO ........................................................................ 159
4.1 ESTRUTURA DE REPETIÇÃO ENQUANTO-FAÇA ................................................................ 159
4.2 ESTRUTURA DE REPETIÇÃO PARA-FAÇA ............................................................................. 160
4.3 ESTRUTURA DE REPETIÇÃO REPITA_ATÉ ............................................................................. 161
RESUMO DO TÓPICO 3 ....................................................................................................................... 163
AUTOATIVIDADE ................................................................................................................................. 164
TÓPICO 4 – TIPOS ESTRUTURADOS .............................................................................................. 165

1 INTRODUÇÃO ..................................................................................................................................... 165
2 REGISTROS ........................................................................................................................................... 165
3 VETORES ............................................................................................................................................... 166
4 MATRIZES ............................................................................................................................................. 168
RESUMO DO TÓPICO 4 ....................................................................................................................... 171
AUTOATIVIDADE ................................................................................................................................. 172
IX
TÓPICO 5 – SUBALGORITMOS E ESCOPO DE IDENTIFICADORES .................................... 173
1 INTRODUÇÃO ..................................................................................................................................... 173
2 ESCOPO DE IDENTIFICADORES ................................................................................................... 174
RESUMO DO TÓPICO 5 ....................................................................................................................... 184
AUTOATIVIDADE ................................................................................................................................. 185
REFERÊNCIAS ......................................................................................................................................... 187
X
UNIDADE 1
HISTÓRICO DA COMPUTAÇÃO
OBJETIVOS DE APRENDIZAGEM
A partir desta unidade, você será capaz de:
• conhecer os principais fatos históricos da computação;
• compreender os conceitos fundamentais da computação;
• entender a área de informática de maneira sistêmica.
PLANO DE ESTUDOS
Esta unidade de ensino está dividida em três tópicos, sendo que no final de
cada um deles você encontrará atividades que contribuirão para a apropriação
dos conteúdos.
TÓPICO 1 – BREVE HISTÓRICO
TÓPICO 2 – GERAÇÃO DOS COMPUTADORES
TÓPICO 3 – TIPOS DE COMPUTADORES E SEUS COMPONENTES
1
2
UNIDADE 1
TÓPICO 1
BREVE HISTÓRICO
1 INTRODUÇÃO
Embora os recursos tecnológicos disponíveis atualmente possam parecer
extremamente novos e atuais, o processo de desenvolvimento da tecnologia percorreu
um longo caminho para que pudéssemos nos beneficiar de tais tecnologias.
A informática nos permite revolucionar a forma que vivemos e agimos e

conseguimos cada vez mais benefícios com a sua utilização. Os computadores nos
auxiliam nas escolas, escritórios, indústrias, hospitais, casas entre outros lugares,
tornando-se uma ferramenta indipensável para muitas pessoas.
Se a informática nos auxilia em todos os lugares, por que não entendermos

algumas das características da evolução do computador?
Vamos à leitura!
2 HARDWARE
Antes de acompanharmos a evolução do hardware, vamos descrever
hardware. Hardware é a parte física do computador, isto é, tudo o que “pode ser
tocado”, como, gabinete, monitor, teclado, mouse, processadores, memórias, disco
rígido etc.
Sabemos que os computadores estão em constante transformação, por isso

a importância de conhecermos sua história.
Podemos dividir os acontecimentos de forma cronológica e de acordo com

seus componetes básicos. Vejamos a divisão:
3
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
 Dispositivos mecânicos.
 Dispositivos eletromecânicos.
 Dispositivos eletrônicos.
 Computadores com vávulas, com transistores, com circuitos integrados e com
itegração em larga escala.
Agora vamos entender cada etapa desta evolução.
2.1 DISPOSITIVOS MECÂNICOS

Um computador é uma máquina que trabalha com dados e informações
sob a forma de números. O ser humano desde os primórdios da humanidade até
a atualidade, buscam constantemente desenvolver ferramentas que auxiliam no
processo de contagem.
Os homens das cavernas, contavam com as únicas ferramentas de

contagem que conheciam: seus dedos das mãos e pés. Estas foram consideradas as
primeiras ferramentas de contagem. Logo o homem percebeu que outros objetos
poderiam ser usados para fazer a contagem de números maiores. Algumas das
outras ferramentas de contagem que foram utilizadas ao longo do tempo foram as
pedras, os nós em cordas, ossos, paus, entre outros. Essas pessoas utilizavam essas
ferramentas de contagem para contar suas posses e também para a contagem do
tempo, como nossos calendários nos dias de hoje.
É importante distinguir o início dos ábacos, conhecidos como placas de

contagem ou calculadora decimal manual. O ábaco é um pedaço de madeira,
pedra ou metal com sulcos esculpidos ou linhas pintadas entre os quais pérolas,
pedras ou discos de metal são movidos. Tanto o ábaco como a placa de contagem,
são auxiliares mecânicos utilizados para contagem, eles não são calculadoras. A
pessoa que opera o ábaco executa cálculos em sua cabeça e usa o ábaco como um
auxílio físico para manter o controle da contagem.
UNI
O mais velho ábaco é o tablet Salamis (originalmente pensado para ser uma placa
de jogo), usada pelos babilônios por volta de 300 a.C., descoberto em 1846 na ilha de Salamina.
4
TÓPICO 1 | BREVE HISTÓRICO
O ábaco foi inventado há cerca de 4.000 anos atrás, pelos chineses. Foi
a primeira máquina utilizada para contagem e cálculo. É preciso uma grande
quantidade de tempo e prática para aprender a dominar o uso de um ábaco.
FIGURA 1 – MODELO DE ÁBACO
FONTE: Monteiro (2014)
No início do século 17, John Napier, um matemático escocês, inventou

outra ferramenta de cálculo. Ela tinha tiras marcadas de madeira ou osso, lado
a lado, para multiplicar e dividir. Esta ferramenta tornou-se conhecida como
"Ossos de Napier".
Em 1642, com 19 anos de idade, um matemático francês chamado Blaise

Pascal, inventou a Pascaline. A Pascaline é conhecida como a primeira calculadora
mecânica e automática. Pascal inventou a Pascaline para facilitar o trabalho de seu
pai como contador de imposto. A máquina às vezes chamada de La Pascaline ou
máquina de Pascal, nunca se tornou popular, primeiro porque quebrou muitas
vezes e seu inventor era a única pessoa que poderia consertá-la. Em segundo lugar,
era lenta, e em terceiro, os funcionários não a utilizavam porque estavam com
medo de que poderia substituí-los em seus trabalhos.
5
FIGURA 2 – BLASE PASCAL
FONTE: Disponível em: <http://educacao.uol.com.br/biografias/blaise-

pascal.htm>. Acesso em: 2 mar. 2016.
Pascal mais tarde tornou-se famoso em matemática e filosofia, mas ele

ainda é lembrado por seu papel na história do computador. Em sua homenagem,
há uma linguagem de computador chamada Pascal.
Em 1673, o inventor alemão Gottfried Leibniz aperfeiçoou a calculadora

Leibniz. Leibniz entrou em uma universidade com 15 anos de idade e recebeu
seu diploma de bacharel aos 17 anos. Esta máquina também era uma máquina
de calcular, mas muito superior à de Pascal. Essa calculadora fazia mais do que
apenas somar e subtrair. A Calculadora Leibniz também poderia multiplicar,
dividir e encontrar raízes quadradas.
FIGURA 3 – CALCULADORA LEIBNIZ
FONTE: Disponível em: <http://ds-wordpress.haverford.edu/bitbybit/bit-by-bit-

contents/chapter-one/1-8-leibniz-and-the-stepped-reckoner/>. Acesso em: 2 mar.
2016.
6
Em 1801, Jacquard inventou o tear Jacquard. Era uma máquina de tecelagem

que foi controlada por cartões perfurados. Enquanto o tear estava sendo bombeado,
cartões com buracos foram ligados em conjunto de um padrão através do qual cordas
de fios eram alimentados automaticamente.
Sua invenção assustou outros tecelões porque com este tear o pano era
produzido mais rápido e melhor do que com a mão. Por este motivo a casa e tear
Jacquard foi incendiada.
Anos depois, variações sobre cartões perfurados de Jacquard foram utilizados

em vários tipos de máquinas, incluindo a representação da música em pianos
automáticos, bem como o armazenamento de programas para computadores.
FIGURA 4 – TEAR DE JACQUARD
FONTE: Disponível em: <http://addiator.blogspot.com.br/2011/10/jacquards-loom-

and-stored-programme.html>. Acesso em: 2 mar. 2016.
No início da década de 1820, o matemático Inglês Charles Babbage, projetou

uma máquina de computação chamada de máquina de diferenças. Esta máquina
era usada no cálculo e impressão de tabelas de matemática simples. Na década
de 1830, ele projetou uma segunda máquina de computação chamada Máquina
Analítica. Esta máquina era utilizada no cálculo dos problemas complicados,
seguindo um conjunto de instruções.
A Máquina Analítica era um computador mecânico que resolvia qualquer

problema matemático.
7
Mesmo a máquina analítica sendo totalmente mecânica, possuía os mesmos

componentes de um computador atual, tais como: memória, processador e saída
para um perfurador de cartões (MONTEIRO, 2014).
FIGURA 5 – MÁQUINA ANALÍTICA
FONTE: Disponível em: <http://history-computer.com/Babbage/AnalyticalEngine.html>.

Acesso em: 2 mar. 2016.
2.2 DISPOSITIVOS ELETROMECÂNICOS

A partir da invenção do motor elétrico surgiu uma grande quantidade de
máquinas de somar acionadas por motores elétricos baseados nos princípios do
funcionamento da máquina de Pascal.
Em 1890, 50 anos após a morte de Charles Babbage, Herman Hollerith

inventou uma máquina chamada de máquina de tabulação, usando notas que
foram deixadas por Babbage.
8
Antes desta invenção, demorava quase oito anos para levantar as

informações do censo nos Estados Unidos. A máquina Tabuladora usava cartões
perfurados para registrar e classificar dados ou informações. Cada buraco
perfurado significava algo. Aproximadamente 65 cartões poderiam ser passados
através deste computador em um minuto, e em 1890 foram necessários apenas 2,5
anos para completar o Censo EUA.
Hollerith não parou com este invento. Ele começou uma empresa com o
nome de Tabulating Machine Company. Eventualmente, esta empresa mudou seu
nome para International Business Machines (IBM) - uma das maiores empresas de
informática do mundo.
FIGURA 6 – MÁQUINA TABULADORA
FONTE: Disponível em: <http://www.officemuseum.com/data_processing_machines.

htm>. Acesso em: 2 mar. 2016.
9
2.3 COMPONENTES ELETRÔNICOS

Em 1930, Vannevar Bush lançou o primeiro "computador" eletrônico nos
Estados Unidos. Era um dispositivo analógico, isto é, poderia medir quantidades
que mudavam de forma contínua, tais como a temperatura e a pressão do ar. Eram
utilizados tubos a vácuo para alternar sinais elétricos que executavam cálculos.
A máquina de Bush poderia fazer 25 cálculos em poucos minutos. Para mostrar
os resultados, uma caneta fixa acima de uma mesa de desenho foi usada para
desenhar uma curva em um gráfico.
O Analisador Diferencial pesava 100 toneladas, utilizava 2000 tubos a

vácuo, milhares de relés, motores, e cerca de 200 milhas de arame.
FIGURA 7 – MÁQUINA DE BUSH
FONTE: Disponível em: <http://www.kerryr.net/pioneers/gallery/ns_bush5.htm>.

A próxima grande invenção na história da computação começou em 1937.

Naquele ano, Howard Aiken delineou um plano para uma máquina que poderia
executar problemas matemáticos envolvendo números muito grandes. Era um
dispositivo digital ao invés de analógico.
Em 1944, a IBM pagou engenheiros para construir a máquina de Aiken.

Chamado Mark I, foi composto por 78 máquinas de somar e calculadoras de mesa
que foram ligadas por quase 500 milhas de fios. Em um segundo, o Mark I poderia
adicionar três números de oito dígitos e podia imprimir os seus resultados em
cartões perfurados ou em uma máquina de escrever elétrica.
10
A máquina tinha alguns inconvenientes como: era enorme – 51 pés de

comprimento e 8 pés de altura. Seus 3.000 interruptores elétricos faziam um
barulho terrível. O Mark I era caro e complicado para construir. Afinal, ele tinha
um milhão de peças e pesava cerca de 5 toneladas.
Um dos principais programadores para o Mark I era uma mulher, Grace

Hopper. Hopper encontrou o primeiro "bug" de computador: uma mariposa
morta que tinha entrado no Mark II e cujas asas estavam bloqueando a leitura dos
buracos na fita de papel. A palavra "bug" foi usada para descrever um defeito, pelo
menos desde 1889, mas Hopper é creditada por inventar a palavra "depuração"
para descrever o trabalho para eliminar as falhas do programa (DECATUR CITY
SCHOOLS, 2008).
11
RESUMO DO TÓPICO 1
Maravilha! Conseguimos um avanço fantástico ao cumprirmos mais esta
tarefa. Você é a pessoa mais interessada em rever um pouco mais daquilo que
discutimos neste tópico.
• Neste tópico pudemos rever o conceito de hardware.
• Vimos também que em função da necessidade de tornar as operações

matemáticas cada vez mais rápidas e precisas surgiram os primeiros dispositivos
de automação de cálculos, como o ábaco e seus similares. A partir da invenção
do ábaco estava plantada a pedra fundamental sobre a qual se desenvolveria
todo o restante da história da informática.
• Um dos primeiros projetos de calculadoras de que há registros foi materializado

por Blaise Pascal numa calculadora mecânica com capacidade apenas para
somar e subtrair.
• A partir desta iniciativa, novos pesquisadores se interessaram pelo assunto e

inicia-se uma trajetória para a evolução.
• Charles Babbage com seu fatástico projeto cria a máquina analítica.
• Não podemos nos esquecer da primeira programadora da história.
• Através das máquinas tabuladoras nasce a IBM.
• E para completar a evolução daquele período, surgiram os primeiros

componentes eletrônicos.
12
AUTOATIVIDADE
1 Os primeiros ábacos eram feitos com fios verticais paralelos pelos quais o
operador podia fazer deslizar sementes secas. Quem foram os inventores
do ábaco?
a) Chineses
b) Incas
c) Romanos
d) Índios
2 A calculadora mecânica desenvolvida por Blaise Pascal é considerada um

marco no processo de criação e evolução de dispositivos de automação de
cálculos. Porém, a calculadora de Pascal, denominada Pascalina, permitia
realizar apenas as operações de soma e subtração. Algum tempo depois,
outro pesquisador contruiu uma calculadora que efetuava também as
operações de divisão e multiplicação. Qual o nome deste pesquisador?
3 Descreva o significado da palavra bug, para a área da computação.
13
14
UNIDADE 1
TÓPICO 2
GERAÇÃO DOS COMPUTADORES
1 INTRODUÇÃO
Em 1946, pequenas vias eletrônicas chamadas circuitos começaram a
realizar a contagem que antes era feita por engrenagens e outras peças mecânicas.
Com cada nova geração, o circuito tornou-se menor e mais avançado do que a
geração anterior. Como resultado da miniaturização, a velocidade, potência e
memória dos computadores aumentaram proporcionalmente. Novas descobertas
estão sendo constantemente desenvolvidas, as quais afetam a maneira como
vivemos, trabalhamos e nos divertirmos.
2 PRIMEIRA GERAÇÃO: 1945-1956

Os computadores da primeira geração eram enormes, lentos, caros e muitas
vezes pouco confiáveis. Em 1946, dois americanos, Presper Eckert e John Mauchly
construiram o ENIAC (Electronic Numerical Integrator and Computer) computador
eletrônico que utilizou tubos de vácuo em vez dos interruptores mecânicos. O ENIAC
usou milhares de tubos de vácuo, que ocupava muito de espaço e emitia uma grande
quantidade de calor. O ENIAC levou à construção de outros tipos de computadores,
como do tipo de tubo a vácuo, como o EDVAC (Electronic Discrete Variable Automatic
Computer) e o UNIVAC I (Universal Automatic Computer). O tubo de vácuo foi um
passo extremamente importante no avanço dos computadores. Os tubos de vácuo
foram inventados ao mesmo tempo em que a lâmpada foi inventada por Thomas
Edison e os tubos trabalhavam de forma semelhante às lâmpadas. O objetivo era de
agir como um amplificador e um interruptor. Sem partes móveis, os tubos a vácuo
podiam levar sinais fracos e ampliar o sinal. Os tubos a vácuo também podiam parar
e iniciar o fluxo de eletricidade instantaneamente (switch). Essas duas propriedades
fizeram o computador ENIAC possível. O ENIAC exalava tanto calor que teve que
ser arrefecido por condicionadores de ar gigantescos. No entanto, mesmo com estes
enormes refrigeradores, os tubos a vácuo ainda superaqueciam regularmente.
15
Ao contrário das ferramentas de contagem anteriores, o ENIAC não tinha

peças mecânicas e engrenagens. Baseava-se exclusivamente em tubos a vácuo.
Cada tubo a vácuo continha um circuito eletrônico, um pequeno caminho que
levava a eletricidade. Cada circuito podia ligar e desligar de maneira parecida
como uma lâmpada faz.
O ENIAC operava 1000 vezes mais rápido do que Mark I. Ele podia fazer
5000 adições por segundo e 300 multiplicações. Esta máquina custava cerca de 3
milhões de dólares.
No entanto, o ENIAC tinha inúmeros problemas. Os 19.000 tubos a vácuo

ocupavam tanto espaço que exigia uma sala medindo aproximadamente 75 m²!
Os tubos também produziam uma grande quantidade de calor e estavam sempre
queimando. Em média, 50 tubos queimavam a cada dia.
FIGURA 8 – ENIAC
FONTE: Disponível em: <http://www.hnf.de/en/museum/die-erfindung-des-computers/eniac-life-

size-model-of-the-first-vacuum-tube-computer.html>. Acesso em: 2 mar. 2016.
Em 1946, um matemático chamado John von Neumann propôs duas

alterações no projeto do computador; 1º) as instruções da máquina, deveriam ser
armazenadas dentro do computador. 2º) uma vez que os circuitos eletrônicos são
ligados ou desligados, ele sugeriu que as pessoas usassem uma série de 0 ou 1 para
16
TÓPICO 2 | GERAÇÃO DOS COMPUTADORES
codificar todas as informações que eles colocassem no computador. Um zero estaria

desligado (sem sinal) e um estaria ligado (com sinal). Este código é chamado de código
binário e é usado ainda hoje. Mais adiante aprofundaremos o código binário.
Em 1951, Eckert e Mauchly concebeu outro computador chamado de

UNIVAC (Universal Automatic Computer). Foi o primeiro computador a ser
vendido para as empresas. UNIVAC continha 5.400 tubos a vácuo e utilizava fitas
magnéticas para dar instruções ao computador. O UNIVAC foi utilizado para
prever a eleição presidencial de Dwight Eisenhower.
FIGURA 9 - UNIVIAC
FONTE: Disponível em: <http://blogs.loc.gov/loc/2008/04/my-first-bloggiversary/univac/>.

3 SEGUNDA GERAÇÃO: 1956-1963

O computador transistor não durou tanto quanto o computador de tubo a
vácuo, mas não era menos importante no avanço da tecnologia dos computadores.
Em 1947 três cientistas, John Bardeen, William Shockley e Walter Brattain que
trabalham na AT & T Bell Labs inventaram o que iria substituir o tubo a vácuo
para sempre. Esta invenção foi o transistor que funcionava como um tubo a vácuo,
em que ele podia ser usado para transmitir e comutar sinais eletrônicos.
17
Houve diferenças óbvias entre o transistor e o tubo a vácuo. O transistor

foi mais rápido, mais confiável, menor, e muito mais barato de construir do que
um tubo a vácuo. Um transistor substituiu o equivalente a 40 tubos a vácuo. Estes
transistores eram feitos de material sólido, alguns dos quais eram de silício, um
elemento abundante encontrado na areia da praia, e vidro. Portanto, eles foram
muito mais baratos para produzir. Transistores foram inventados para conduzir
eletricidade mais rápida e melhor do que os tubos a vácuo. Eles também foram muito
menores e exalavam praticamente nenhum calor em comparação com os tubos a
vácuo. Seu uso marcou um novo começo para o computador. Sem essa invenção,
as viagens espaciais na década de 1960 não teriam sido possíveis. No entanto, uma
nova invenção iria avançar ainda mais nossa capacidade de usar computadores.
FIGURA 10 – TRANSISTOR
FONTE: Disponível em: <http://www.electronics-lab.com/happy-birthday-transistor-16-

dec-1947/>. Acesso em: 2 mar. 2016.
18
4 TERCEIRA GERAÇÃO: 1965-1970

Os transistores foram um grande avanço para os computadores. No entanto,
ninguém poderia prever que milhares até milhões de transistores (circuitos) podiam
ser compactados em um espaço tão pequeno. Robert Noyce da Fairchild Corporation
e Jack Kilby da Texas Instruments descobriram que colocando grande número
de transistores em um único chip aumentava imensamente o poder de um único
computador e baixava consideravelmente seu custo.
Com a invenção de circuitos integrados, o número de transistores que

poderia ser colocado em um único chip dobrava de dois em dois anos, diminuindo
o tamanho e o custo dos computadores e ainda aumentando a sua potência.
Estes computadores de terceira geração podiam executar instruções em

bilionésimos de segundo. O tamanho destas máquinas caiu para o tamanho
de armários de arquivo pequenos. No entanto, o grande avanço na era dos
computadores ainda estava por vir.
FIGURA 11 – CIRCUITOS INTEGRADOS
FONTE: Disponível em: <http://buvenes.blogspot.com.br/2012/01/computer-history-and-

generations.html>. Acesso em: 2 mar. 2016.
19
5 QUARTA GERAÇÃO: 1971- ATÉ OS DIAS ATUAIS

Esta geração pode ser caracterizada pelo o grande avanço de circuitos
integrados monolíticos (milhões de transistores colocados sobre uma pastilha de
circuito integrado) e a invenção do microprocessador (um único chip que podia
fazer todo o processamento de um computador de grande escala).
No entanto, o que realmente provocou o enorme crescimento dos

computadores e seu impacto significativo em nossas vidas foi a invenção do
microprocessador. Ted Hoff, contratado pela Intel (nova empresa Robert Noyce)
inventou um chip quase do tamanho da borracha que fica na ponta do lápis que
poderia fazer toda a computação e lógica de trabalho de um computador. O
microprocessador foi feito para ser usado em calculadoras, não computadores. Ele
conduziu, no entanto, a invenção de computadores pessoais, ou microcomputadores.
Na década de 1970 as pessoas começaram a comprar computadores para

uso pessoal. Um dos primeiros computadores pessoais foi o kit de computador
Altair 8800. Em 1975, você poderia comprar este kit e colocá-lo em conjunto para
fazer o seu próprio computador pessoal. Em 1977, o Apple II foi vendido ao público
e, em 1981, a IBM entrou no mercado de PC (computador pessoal).
FIGURA 12 – PRIMEIROS MICROPROCESSADORES
FONTE: Disponível em: <https://delphinemeow.files.wordpress.com/2014/04/ibm-pc.jpg>.

20
6 UM POUCO DA HISTÓRIA DA APPLE

Steven Paul Jobs e Stephen Wozniak eram adolescentes quando o
microcomputador foi inventado. Eles cresceram no Vale do Silício, uma área perto
de Palo Alto, Califórnia, conhecida por computadores e indústrias eletrônicas.
Mais tarde, eles conseguiram emprego lá como engenheiros. Interessados em
computadores, eles se juntaram ao Homebrew Computer Club e começaram a
trabalhar sério com os computadores.
Em 1976, Wozniak, que tinha interesse em computadores desde a quarta

série, decidiu construir um pequeno computador que seria fácil de usar. Seus
amigos ficaram impressionados com ele, e Jobs queria vendê-lo. Os dois começaram
seus negócios, Apple Computer Inc., com os US$ 1.300 que receberam com a venda
de um ônibus Volkswagen e calculadora científica de Wozniak.
O primeiro Apple II, recebeu este nome, em memória aos verões em que
Jobs passou colhendo maçãs no Noroeste, foi um enorme sucesso. Desde então, a
Apple tem feito muitos computadores, incluindo o Apple II Plus, Apple IIe, Apple
II, a Apple IIGS, Macintosh, iMac, iPod e iPhone (DECATUR CITY SCHOOLS, 2008).
FIGURA 13 – STEVE JOBS
FONTE: Disponível em: <http://lounge.obviousmag.org/advibe/2014/05/jobs.html>. Acesso em: 2

mar. 2016.
21
7 UM POUCO DE BILL GATES E A MICROSOFT

Em dezembro de 1974, Paul Allen estava em seu caminho para visitar
Gates, quando ao longo do caminho ele parou para ver as revistas atuais. O que
ele viu mudou Bill Gates para sempre. Na capa da Popular Electronics foi uma
imagem do Altair 8080 e a manchete "Kit primeiro microcomputador do mundo
para rivalizar Modelos Comerciais." Ambos reconheceram isso como sua grande
oportunidade. Os dois sabiam que o mercado de computadores domésticos
estava prestes a explodir e que alguém precisaria desenvolver os softwares para
as novas máquinas. Dentro de alguns dias, Gates havia chamado a MITS (Micro
Instrumentation and Telemetry Systems), os fabricantes da Altair. Contou à empresa
que ele e Allen tinham desenvolvido um programa básico que podia ser utilizado
no Altair. Esta foi uma mentira. Eles ainda não tinham escrito uma linha de código
sequer. Eles não tinham nem um Altair nem o chip que funcionava o computador.
A empresa MITS não sabia disso e estava muito interessada em ver o programa.
Assim, Gates e Allen começaram a trabalhar febrilmente sobre o programa que
haviam prometido. O código para o programa foi deixado em sua maioria para
Bill Gates, enquanto Paul Allen começou a trabalhar em uma maneira de simular
a Altair com as escolas PDP-10. Oito semanas depois, os dois sentiram que seu
programa estava pronto. Allen foi para MITS mostrar sua criação. Um dia depois
que Allen chegou a MITS, é que foram testar seu programa. Se a simulação do
Altair não funcionasse ou se qualquer código de Gates estivesse com defeito, a
demonstração provavelmente teria terminado em fracasso. Este não era o caso, e
o programa funcionou perfeitamente na primeira vez. Gates estava convencido
de que o mercado de software tinha nascido. Dentro de um ano, Bill Gates havia
abandonado Harvard e a Microsoft foi criada (DECATUR CITY SCHOOLS, 2008).
FIGURA 14 – PAUL ALEN E BILL GATES
FONTE: Disponível em: <http://www.blog.shops.kharkov.ua/microsoft/>. Acesso em: 2 mar.

2016.
22
DICAS
Assista ao filme Piratas do Vale do Silício para saber mais sobre a história das
principais empresas que contribuíram para o atual estado da tecnologia da informação.
8 QUINTA GERAÇÃO
A quinta geração da computação é chamada de "inteligência artificial", e é
o objetivo de cientistas e programadores de computador criarem computadores
mais espertos. Todas as linguagens de alto nível como C e C ++, Java, .Net etc.,
são utilizadas nesta geração.
A inteligência artificial pode ser dividida em cinco categorias distintas:

os jogos, robótica, sistemas especialistas, redes neurais e de linguagem natural.
Cada uma destas categorias está sendo desenvolvida independente uma da
outra. Por exemplo, jogos têm tido grande sucesso ao longo dos últimos 15
anos, enquanto linguagem natural levou mais tempo para o seu pleno e perfeito
desenvolvimento (TECHIWAREHOUSE, 2011).
8.1 JOGOS
Um dos maiores avanços da inteligência artificial foi em 1997, quando
um computador da IBM derrotou com sucesso o campeão mundial de xadrez
em seu próprio jogo. Foi a primeira vez que um computador tinha batido um
ser humano.
Em 2011, a IBM introduziu "Watson" para os telespectadores Jeopardy

nos Estados Unidos. O evento foi concebido como um teste para a sua mais nova
tecnologia artificial que pôde interpretar a linguagem humana, bem como usar
a lógica para encontrar as respostas e perguntas comuns e triviais. Sua mais
recente incursão em inteligência artificial tinha alguns pequenos erros ao ouvir
a interpretação das perguntas, mas ainda assim conseguiu vencer todos os seus
adversários no jogo, mesmo o campeão de mais longa duração, Ken Jennings.
23
NOTA
Watson: computador com inteligência artificial que derrotou oponentes humanos

em um programa de televisão chamado Jeopardy, o qual possui perguntas e respostas.
8.2 REDES NEURAIS

Uma rede neural tenta reproduzir os pensamentos e ligações físicas de
cérebros humanos ou animais, e é uma das áreas mais testadas na quinta geração
de computação. Este é, de fato, o segredo para Watson da IBM: deram-lhe um
cérebro humano que pudesse entender em grande parte a linguagem e fazer
pesquisas para responder as perguntas.
Estas redes neurais também estão se tornando importantes em aplicações

muito menores, como o recurso de reconhecimento de voz em muitos computadores
pessoais atuais e telefones celulares.
8.3 LINGUAGEM NATURAL

Este é muitas vezes considerado um dos "Santos Graal" da inteligência
artificial. Atualmente, o tipo de reconhecimento de voz que está disponível para
os consumidores cai mais na categoria de "ditado" do que "conversa". Isso porque
o computador pode ouvir as palavras e transcrevê-las em texto, mas ele realmente
não têm a capacidade de compreender o seu significado ou o seu contexto.
Da mesma forma, a linguagem natural está atualmente limitada a um tom

de voz, e dispositivos de computação de inteligência mais artificial e não pode
distinguir entre uma frase de voz suave, e uma sentença de raiva.
8.4 SISTEMAS ESPECIALISTAS

Já fomos vítimas do chamado "erro humano", seja no consultório médico,
no banco, ou até mesmo enquanto nós estávamos dirigindo o nosso carro para um
destes lugares. Cada vez mais, os investigadores estão olhando para a inteligência
artificial como uma espécie de caminho à prova de falhas de diagnóstico de
pacientes e para fazer as tarefas humanas diárias.
24
Esses chamados sistemas especialistas podem ajudar as pessoas a tomar

a decisão certa em um ambiente difícil. Sistemas especialistas são capazes de
armazenar muito mais informações do que o cérebro humano, bem como tê-las
mais facilmente disponíveis.
8.5 ROBÓTICA
Esta pode ser a área mais popular da inteligência artificial entre aqueles
que não estão familiarizados com conceitos mais avançados, como "redes neurais"
ou "sistemas epecilalistas". Mas estes não são robôs típicos de limpeza. O campo
da robótica da inteligência artificial é sobre a criação de robôs que podem
experimentar, e reagir a estímulos externos, tal como os seus homólogos humanos.
Isso significa que esses robôs serão capazes de levar uma vida semiautônoma,
conscientes de seu entorno e capazes de modificar de forma independente o seu
comportamento com base no seu ambiente. É uma das áreas mais promissoras e
mais difíceis da inteligência artificial.
DICAS
Para conhecer um pouco mais da Inteligência Artificial, assista aos filmes:
• Uma Odisseia no Espaço;

• O ano em que faremos contato;
• Inteligência Artificial;
• Eu, Robô.
25
RESUMO DO TÓPICO 2
Caro(a) acadêmico(a), neste capítulo você estudou que:
• Existem no total cinco gerações de computador conhecidas até a data. Cada

geração tem sido discutida em detalhe, juntamente com o seu período de tempo
e características.
• A primeira geração é marcada pelos tubos a vácuo.
• A segunda geração é marcada pelo transistor.
• A terceira geração é marcada pelos circuitos integrados.
• A quarta geração é marcada pelo microprocessador.
• A quinta geração é marcada pelos estudos da inteligência artificial.
• Uma das empresas mais significativas dos últimos tempos na área da computação
é a Apple, fundada por Steve Jobs e Steve Wosniak.
• A evolução também foi marcada por Bill Gates e Microsoft.
26
AUTOATIVIDADE
1 O que diferencia os computadores de primeira geração dos da segunda?
2 Por que a quarta geração ficou conhecida como a geração dos

microprocessadores?
3 Computadores da quinta geração são baseados em:
a) ( ) Tubos a vácuo
b) ( ) Circuitos integrados
c) ( ) Microprocessadores
d) ( ) Inteligência artificial
4 Como vimos, na primeira geração de computadores encontravam-se muitos

problemas. Analise as afirmativas abaixo e assinale as sentenças corretas:
I. Os computadores desta geração eram enormes;

II. Os computadores desta geração eram caros;
III. Os computadores desta geração transmitiam grande quantidade de calor.
a) ( ) As alternativas I e II estão corretas.

b) ( ) As alternativas II e III estão corretas.
c) ( ) Apenas a alternativa I está correta.
d) ( ) Todas as alternativas estão corretas.
5 Esta invenção foi 1.000 vezes mais rápida do que qualquer máquina construída
antes dela. Era tão grande que poderia preencher uma casa. Assinale a opção
correta:
a) Apple I
b) ENIAC
c) Windows
d) Z3
27
28
UNIDADE 1
TÓPICO 3
TIPOS DE COMPUTADORES E SEUS

COMPONENTES
1 INTRODUÇÃO
Quando as pessoas pensam em computadores, geralmente relacionam
a um laptop ou desktop. Os computadores são, na verdade, tudo que nos rodeia,
e podem ser divididos em categorias distintas dependendo do seu tamanho e
poder de processamento. Algumas definições mudaram ao longo do tempo com
os avanços rápidos na tecnologia, temos computadores que cabem na palma de
nossas mãos e que têm poder de processamento imenso. Ainda assim, a maior
parte das qualificações gerais para cada categoria são as mesmas, juntamente com
as diversas subcategorias que podem se encaixar.
Então, quais são essas categorias de tipos de computador? Há cinco principais:

supercomputadores, mainframes, minicomputadores, microcomputadores e
computadores móveis.
Além disso, computadores possuem componetes essenciais para seu

funcionamento. Neste tópico, vamos ver os detalhes de cada um.
2 SUPERCOMPUTADORES
Supercomputador é um termo usado para descrever computadores que têm
o poder de processamento mais rápido. Os supercomputadores executam centenas
de milhares de processamentos, capazes de quatrilhões de cálculos de computação
em apenas alguns nanossegundos. Você provavelmente não vai precisar deste
tipo de capacidade para acessar o Facebook. Na verdade, os supercomputadores
são usados em ciência computacional para calcular e realizar uma infinidade de
tarefas complexas. Modelagem de estruturas moleculares, previsão do tempo, e no
campo da mecânica quântica, entre outros.
29
FIGURA 15 – SUPERCOMPUTADORES
FONTE: Disponível em: <http://www.peimag.com/top-10-most-powerful-supercomputers-in-the-

world/>. Acesso em: 2 mar. 2016.
3 COMPUTADORES MAINFRAME
Como os supercomputadores, os computadores mainframe são enormes,
elevando-se máquinas com lotes de poder de processamento. Mainframes são usados
principalmente por empresas, agências governamentais e bancos e organizações que
precisam de uma maneira de armazenar grandes quantidades de informação, tais
como a Receita Federal do Brasil. A capacidade de processamento de computadores
de grande porte é medida em MIPS, ou milhões de instruções por segundo.
Supercomputadores, por outro lado, são medidos em FLOPS, ou operações de ponto
flutuante por segundo.
30
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
FIGURA 16 – MAINFRAME
FONTE: Disponível em: <https://tegrupo7.wordpress.com/>. Acesso em: 2 mar 2016.
4 MINICOMPUTADORES
Um minicomputador é uma máquina de multiprocessamento que trabalha
com cerca de 200 usuários ao mesmo tempo. É como um computador mainframe
menos poderoso, e possui o tamanho parecido com de uma geladeira. Um servidor
pode ser um exemplo de um minicomputador, mas nem todos os servidores
são minicomputadores. Apesar do seu nome, um minicomputador não é um
computador pessoal como a máquina desktop que você pode ter em casa ou no
trabalho. Eles são muito maiores do que isso.
31
5 MICROCOMPUTADORES
Microcomputadores são os que as pessoas estão mais familiarizadas na
sua vida diária, não profissional, mas é claro que isso não significa que eles são
exclusivos para a casa. Microcomputadores são pequenos computadores que
rodam em microprocessadores em suas unidades de processamento central.
Eles são muito mais baratos do que os supercomputadores, computadores de
grande porte e até mesmo minicomputadores, porque eles foram feitos para usos
diários que são mais práticos do que profissional. A gama de capacidades para
microcomputadores é vasta. Um editor de filme poderia usar um microcomputador
para executar muitos programas de edição intensivos de uma só vez, enquanto
que um aluno pode usar um microcomputador para digitar um texto.
A maioria das pessoas usa o que chamamos de computadores pessoais, e

até mesmo dentro desta definição existem diversas variações. Estas incluem:
• Computadores desktop: também conhecidos por computadores de mesa, são

populares, pois os usuários podem personalizá-los, substituir peças e corrigi-los
com muito mais facilidade do que seria um laptop. É também mais conveniente
por ser capaz de se conectar a periféricos como telas, teclados e mouses. Neste
sentido, computadores de mesa podem ser usados no escritório para tarefas
profissionais, ou em casa. Computadores de mesa podem ser especializados
para jogos, bem como, equipados com placas gráficas e mais memória RAM.
• Consoles de video game: algumas pessoas não pensam consoles de videogame

como computadores, mas eles são. Eles têm muitos dos mesmos componentes
de hardware como computadores, mas geralmente são menos avançados, razão
pela qual eles são capazes de custar muito menos do que um computador de
jogos de alto nível.
• Diversos: outros exemplos de microcomputadores incluem TVs inteligentes.
32
FIGURA 17 – MICROCOMPUTADORES
FONTE: A autora.
6 COMPUTADORES MÓVEIS
Estes são exatamente computadores pequenos e móveis. Você pode
argumentar que um computador de mesa é móvel, mas computadores móveis
são os que se destinam a serem transportados e levados de um lugar para outro.
Se um computador desktop é um microcomputador, em seguida, um laptop é
um computador móvel. Há muitos tipos diferentes de computadores móveis,
a seguir está uma lista de dispositivos que poderiam ser classificados como
• Laptops: computadores portáteis destinados a serem transportados de um lugar

para outro. Todos os seus componentes estão contidos dentro de um painel, que
funciona também como teclado, e podem ser dobrados. Devido ao seu tamanho
e conveniência, estes são alguns dos computadores mais populares para o uso
diário.
• Netbooks: laptops muito menores.
• Tablet: tela que possui a funcionalidade touch-screen para navegação e uso.
33
• Console de jogos portátil: Dispositivos como o Game Boy, Game Boy Color,
Game Boy Advance, Sega Nomad, PlayStation Portable (PSP) e PlayStation Vita são
consoles de jogos portáteis. Assim como consoles regulares, estes são pequenos
computadores que permitem que as pessoas joguem jogos em movimento.
• Calculadoras: são computadores que executam tarefas mais básicas dos

computadores - cálculos! Existem muitos tipos diferentes de calculadoras,
calculadoras básicas, calculadoras gráficas, calculadoras científicas, calculadoras
programáveis e calculadoras utilizadas para outros fins financeiros e de
contabilidade.
• Players portáteis: também conhecidos como leitores de MP3, MP4, MP5. Um

iPod, por exemplo, é um computador móvel também.
• Celulares e smartphones: smartphones como o iPhone e o Samsung Galaxy,

entre outros, são exemplos de poderosos smartphones que também são
FIGURA 18 – COMPUTADORES MÓVEIS
FONTE: A autora.
7 FUNÇÕES PRIMÁRIAS DE UM COMPUTADOR

Todos os computadores, desde os primeiros mainframes até os desktops,
laptops e PCs de hoje, executam as mesmas operações gerais sobre os dados. O
que muda ao longo do tempo é o dado manipulado, como ele é tratado, quanto é
movido, e quanto sua forma é rápida e eficiente.
34
As funções básicas que um computador pode executar são:
• Processamento de dados;
• Armazenamentode de dados;
• Movimentação dos dados, e
• Controle.
7.1 PROCESSAMENTO DE DADOS

Quando você pensa sobre um computador e o que ele faz, você naturalmente
pensa: “sua função é calcular”. E esta é realmente uma parte de seu trabalho.
O computador gasta grande quantidade de seu tempo realizando operações
matemáticas, e traduzindo os dados de uma forma para outra.
7.2 ARMAZENAMENTO DE DADOS

O sistema de computador armazena diferentes tipos de dados de
diferentes maneiras, dependendo do que os dados são e a quantidade de espaço de
armazenamento que eles exigem, e quão rapidamente eles precisam ser acessados.
Estes dados são armazenados em memórias.
A memória principal do sistema do computador, também chamada de

armazenamento primário, contém dados que você ou o computador estão trabalhando
naquele instante. Esta é a "memória a curto prazo" do computador, e é projetada para
ser capaz de alimentar dados para o processador de alta velocidade de modo que o
processador não atrase demais enquanto espera por isso. No entanto, essa memória de
curto prazo desaparece quando o computador está desligado.
Armazenamento a longo prazo, também chamado de armazenamento

secundário, consiste em discos rígidos, cartões de memória, pendrives, HDs externos, nos
quais os dados são armazenados permanentemente na forma de arquivos, prontos para
você abrir quando precisar deles.
7.3 MOVIMENTAÇÃO DOS DADOS

O computador também controla a movimentação dos dados de um
lugar para outro. Ele lê os dados que você digita no teclado, move na memória e,
eventualmente, exibe na tela. Esse movimento é chamado de entrada/saída ou E/S e
é a forma como o computador conversa com dispositivos que estão conectados a ele.
35
Movendo dados entre máquinas também é uma parte importante da

computação. O computador usa componentes de rede, modems e cabos para
permitir que ele se comunique com outras máquinas.
7.4 CONTROLE
O sistema de computador deve controlar as três funções acima citadas.
Dentro do computador, uma unidade de controle dirige e coordena a operação
de todos os outros componentes do computador, proporcionando sinais de
temporização e de controle e execução das instruções de um programa.
8 PRINCIPAIS COMPONENTES ESTRUTURAIS DE UM

COMPUTADOR
Os principais elementos de um computador são:
• Unidade Central de Processamento (CPU);

• Memória principal (armazenamento primário);
• Armazenamento Secundário;
• Dispositivos de entrada/saída;
• Interconexão de subsistemas.
FIGURA 19 – SISTEMA DE HARDWARE DE UM MICROPROCESSADOR
FONTE: A autora.
36
8.1 CPU
A Unidade Central de Processamento (CPU) é o componente central do PC.
Este componente é o responsável vital para o funcionamento de cada coisa no PC.
Os princípios subjacentes a todos os processadores de computador são

os mesmos. Fundamentalmente, todas eles têm sinais na forma de 0s e 1s (sinais
binários), manipulados de acordo com um conjunto de instruções, e produzem
uma saída na forma de 0s e 1s.
A CPU possui três unidades principais:
• Lógica e aritmética (ULA): realiza operações aritméticas e lógicas. Por exemplo,

pode adicionar em conjunto dois números binários da memória ou de alguns
dos registros da CPU.
• Unidade de Controle: controla a ação dos outros componentes do computador,
para que as instruções sejam executadas na sequência correta.
• Registos: armazenamento temporário dentro da CPU.
FIGURA 20 – CPU
FONTE: A autora.
37
8.2 ARMAZENAMENTO DE DADOS / MEMÓRIA

O processador é o cérebro do computador. Todos componentes fundamentais
para o computador têm lugar no processador. Outros componentes contribuem
para o cálculo, mas o processador é onde a ação fundamental tem lugar.
No computador possuímos dois tipos fundamentais de memória:
A memória principal usada para armazenar informações para acesso

imediato pela CPU. Também chamamos a memória principal de armazenamento
primário. Algumas funções da memória são:
• Estreitamente ligadas ao processador.

• Os conteúdos são mudados rapidamente e facilmente.
• Detém os programas e dados que o processador está trabalhando ativamente.
• Interage com os milhões de processamento por segundo.
Armazenamento secundário: dispositivos fornecem armazenamento

permanente de grandes quantidades de dados. O armazenamento secundário
também é chamado de memória secundária, memória externa, armazenamento de
backup ou armazenamento auxiliar.
Este pode consistir de armazenamento de disco rígido, pendrive, HD

externo. Algumas de suas características são:
• Ligado à memória principal através de um controlador.

• O conteúdo é facilmente alterado.
• Utilizado para a armazenagem a longo prazo de programas e de dados.
8.2.1 Memória principal

A memória principal é onde os programas e os dados são mantidos quando
o processador está ativo. Quando os programas e os dados tornam-se ativos, eles
são copiados da memória secundária para a memória principal, onde o processador
pode interagir com eles. Uma cópia permanece na memória secundária.
A memória principal pode ser visualizada como um conjunto de ranhuras

marcadas chamadas locais de memória ou células de memória. Cada posição da
memória guarda uma palavra de dados e é designada um endereço único. Os
endereços são palavras binárias que são interpretadas como números começando
do número 0 e indo para cada local de memória sucessiva. Locais de memória
podem ser usados para armazenar os dados, tais como caracteres e números, e
instruções de programa.
38
A CPU pode acessar diretamente os dados armazenados na memória

principal. Quando uma posição de memória é lida o conteúdo da localização da
memória permanece inalterado (uma cópia exata do conteúdo da localização é
feita para o processamento pela CPU). Quando uma nova informação é colocada
em uma posição da memória, os dados existentes são substituídos pelos novos
dados. Os dados são armazenados em binário (1 e 0).
Os tipos de memória principais são:
• Memória de acesso aleatório (RAM);

• Memória só leitura (ROM).
A memória de acesso aleatório (RAM) é uma área no sistema do computador

que armazena dados temporariamente antes ou depois de ser processado. A RAM
pode ser escrita e lida. Por exemplo, quando você entra em um documento, os
caracteres digitados geralmente não são processados imediatamente. Eles são
mantidos na RAM até que você diga ao computador para realizar um processo como
impressão. Mas RAM é volátil, ou seja, quando o computador é desligado todos
os dados armazenados na memória RAM são destruídos. O termo acesso aleatório
refere-se à capacidade de acesso a qualquer posição e em qualquer momento.
Memória só de leitura (ROM) armazena dados e é fixa e não pode ser alterada.
Ela é usada para armazenar dados de referência e programas que serão necessários
para a aplicação do computador. Por exemplo, quando um computador é ligado,
um conjunto de instruções armazenadas na ROM chamado BIOS ROM (Basic Input
Output System) diz ao computador como acessar seus drives de disco como o sistema
operacional. Então, o computador pode copiar esses arquivos para a RAM.
8.2.2 Armazenamento secundário

A maioria dos sistemas de computador têm dispositivos de armazenamento
secundário que são utilizados para proporcionar uma capacidade adicional de
armazenamento de dados. O armazenamento secundário fornece armazenamento
permanente para os programas e dados que não estejam sendo utilizados.
Os dados na memória secundária não são diretamente acessados pela CPU,

mas podem ser transferidos para a memória principal antes de serem processados.
O armazenamento secundário é consideravelmente menos caro do que a memória
principal, mas requer tempo de acesso significativamente mais longo. Exemplos
de armazenamento secundário incluem discos rígidos, CD-ROM, pendrive. Na
história da computação o disco rígido sempre apresentou uma capacidade de
armazenamento muito superior a da memória principal, contudo, a velocidade de
processamento do disco rígido é muito menor.
39
Mas você deve estar se perguntando por que ter dois tipos de armazenamento.
A razão para ter dois tipos de armazenamento é dividir as tarefas, enquanto:
• a memória primária é: rápida, com baixa capacidade e possui conexão direta ao

processador;
• a memória secundária: é lenta, barata, com grande capacidade e não conecta

diretamente com o processador.
8.3 OS DISPOSITIVOS DE ENTRADA/SAÍDA

Dispositivos de entrada/saída fornecem uma interface entre o computador
e o usuário. Devendo existir, pelo menos, um dispositivo de entrada (por exemplo
teclado, mouse) e, pelo menos, um dispositivo de saída (por exemplo, impressora, tela).
Os dispositivos de entrada e saída, como teclados e impressoras, em conjunto com os
dispositivos de armazenamento externos, são referidos como periféricos.
8.4 INTERCONEXÃO DE SUBSISTEMAS

O sistema de computador requer interligações entre os vários
componentes. Quando estes caminhos de dados transportam mais do que um bit
simultaneamente a partir de um número de componentes diferentes, é referido
como um barramento de dados.
Conforme Forouzan e Mosharraf (2011), para essa comunicação há três

tipos de barramentos distintos:
• Barramento de dados: responsável pela transmissão dos dados entre as unidades;
• Barramento de endereços: responsável por conduzir endereços, indicando a

origem ou destino dos dados a serem transmitidos;
• Barramento de controle: responsável por realizar a sincronização dos demais

barramentos, habilitando ou desabilitando o fluxo de dados.
9 MICROPROCESSADORES / MICROCONTROLADORES /
SISTEMAS EMBARCADOS
Um microprocessador é uma Unidade Central de Processamento (CPU)
em um único chip. O microprocessador contém a aritmética, lógica e circuitos
de controle necessários para interpretar e executar instruções de um sistema de
40
computador. Um microprocessador por si só não é um computador, quando

combinado com outros componentes que proporcionam o armazenamento de
dados e programas, frequentemente com uma única base de semicondutores, para
formar um chip, o microprocessador torna-se o coração de um computador.
Um microcontrolador é um sistema de computador completo, numa única

pastilha de circuito integrado, otimizado para aplicações de controle. Ele consiste
em um microprocessador, memórias (RAM, Random Access Memory e ROM, Read
Only Memory), portas, entrada/saída, e, possivelmente, outras características, tais
como temporizadores. Sendo o controlador completo em um único chip permite
o desenho de hardware para ser simples e muito barato. Os microcontroladores
são cada vez mais utilizados, em produtos variados, como aplicações industriais,
eletrodomésticos e brinquedos.
Sistemas de computadores se dividem em duas categorias distintas:
• Os computadores de uso geral;
• Sistemas Embarcados.
O primeiro e mais óbvio, é o computador de uso geral (isto é, os PCs). Os

programas de aplicação determinam a funcionalidade do sistema de computador.
Para que o computador possa cumprir um novo papel, tudo o que é necessário é
um novo aplicativo ser carregado.
Em contraste com computadores de uso geral temos o sistema embarcado.

Sistemas embarcados são sistemas que são dedicados para executar funções
específicas, com o hardware e software que estão sendo utilizados diretamente para
o aplicativo. Eles diferem dos sistemas de computador convencionais na medida
em que não são necessários para ser de uso geral. Sua operação em tempo real
também é frequentemente muito importante para sistemas embarcados. Alguns
exemplos de sistemas embarcados são fornos de microondas, CD players, câmeras
de vídeo, controles remotos, jogos de vídeo, impressoras a laser, máquinas de
fax, fotocopiadoras, controle automotivo, controle de temperatura nos edifícios,
aeronaves e veículos espaciais, sintetizadores de música, controladores de tráfego-
luz e caixas registradoras.
Todos estes sistemas têm um microprocessador, uma memória e os

dispositivos de entrada e saída. Cada um deles é executado através de software
específico para controlar a sua aplicação.
41
Os processadores utilizados em PCs compõem apenas uma pequena

percentagem do número total de processadores vendidos. A maioria dos
processadores feitos são utilizados em aplicações incorporadas. Aplicações
embarcadas geralmente exigem que o processador (e/ou sistema) tenham alta
integração (isto é, ser muito compacto), baixo consumo de energia, resposta rápida
e alto desempenho. Sistemas embarcados não têm a capacidade de executar software
diferente, como é possível em um computador de uso geral.
10 ARQUITETURA RISC E CISC

Arquiteturas de computadores, em geral, têm evoluído progressivamente
com maior complexidade, como maiores conjuntos de instruções, mais modos de
endereçamento, muito mais poder computacional das instruções individuais, mais
registros especializados, e assim por diante. Máquinas recentes que abrangem tais
tendências são denominadas de computador com conjunto de intruções complexas
(Complex Instruction Set Computer - CISC). No entanto, pode-se chegar a um ponto
em que a adição de um complexo de instruções a um conjunto de instruções afeta a
eficiência e o custo do processador. Os efeitos de tal instrução devem ser avaliados
antes de ser adicionada ao conjunto de instruções.
O senso comum nos diz que as instruções inúteis (ou pouco utilizadas)
não devem ser adicionadas ao conjunto de instruções. Este conceito básico de não
adicionar instruções inúteis para o conjunto de instruções invocou um interesse
crescente em uma abordagem inovadora para a arquitetura de computador, o
computador com conjunto reduzido de instruções (Reduced Instruction Set Computer
- RISC). A filosofia da arquitetura RISC diz para adicionar o mínimo de instruções
para que façam o mínimo possível de operações, na qual resultam em um grande
ganho de desempenho. Sistemas RISC foram definidos e desenhados por diferentes
grupos em uma variedade de formas. A primeira máquina RISC foi construída
em 1982 pela IBM. As características comuns compartilhadas pela maioria destes
projetos são um conjunto limitado de instruções e simples, um grande número
de registros, um compilador para maximizar a utilização de registos e, assim,
minimizar os acessos à memória principal e a ênfase na otimização do pipelining.
Mais adiante você entenderá o que é pipelining.
10.1 CAUSAS PARA UMA ARQUITETURA COMPLEXA

Existem várias razões para a tendência em direção progressiva para a
complexidade. Estas incluem suporte para linguagens de alto nível, a migração
de funções de software em hardware e compatibilidade. Cada um desses fatores é
explicado a seguir:
42
• Suporte para linguagens de alto nível: ao longo dos anos o ambiente de

programação mudou de programação em linguagem assembly (baixo nível)
para a programação em linguagens de alto nível, de modo que os fabricantes
começaram a fornecer instruções mais poderosas para apoiar a implementação
eficaz dos programas de linguagem de alto nível.
• Migração de funções de software em hardware: a única instrução realizada no

hardware terá um desempenho melhor do que um realizado por uma sequência
de várias instruções mais simples devido ao maior número de acessos à memória
e a disparidade entre as velocidades de CPU e memória. Para aumentar a
velocidade de processamento dos computadores, observa-se o fenômeno da
migração de funções de software para o firmware e de firmware para hardware.
(Firmware é uma sequência de microinstruções.) Esta migração de funções do
domínio de software para o domínio de hardware irá naturalmente aumentar o
tamanho do conjunto de instruções, o que resulta no aumento da complexidade
global do computador.
• Compatibilidade: a compatibilidade é frequentemente utilizada pelos

fabricantes como uma estratégia de marketing, a fim de projetar seus
computadores como sendo melhor do que outros modelos existentes. Como
resultado desta estratégia de marketing, por vezes, os fabricantes aumentam
o número de instruções e o seu poder aumenta, independentemente da
utilização real deste conjunto de instruções complexas. Compatibilidade é
uma maneira de melhorar um projeto adicionando novos e geralmente mais
complexos recursos (isto é, um novo computador deve ter todas as capacidades
funcionais de seus antecessores e algo mais). Como resultado, o novo conjunto
de instruções é um superconjunto de um antigo.
10.2 RISC POR QUE?

Projetistas de computadores têm diferentes pontos de vista, mas os dois
critérios seguintes são universalmente aceitos para todos os sistemas:
1. Maximizar a velocidade de operação ou minimizar o tempo de execução;

2. Minimizar o custo de desenvolvimento e preço de venda.
Uma maneira de realizar o primeiro objetivo é melhorar a tecnologia dos

componentes, conseguindo assim o funcionamento de frequências mais elevadas.
O aumento da velocidade pode ser conseguido através da minimização do número
médio de ciclos do relógio por instrução e/ou execução de várias instruções,
simultaneamente. Para realizar ambos os objetivos, os designers originais do RISC
focaram no aspecto da criação de um circuito integrado combinando-se milhões
43
de transistores em um único chip, este circuito chama-se Very Large Scale Integration
– VLSI. Como um resultado de menos instruções, modos de endereçamento e
formatos de instrução, obteve-se um pequeno e simples circuito para a unidade de
controle. Esta redução relativa do tamanho e da complexidade provocada por chips
VLSI produz alguns resultados desejáveis para CISC, que são discutidos a seguir.
A principal finalidade da tecnologia VLSI é realizar o processamento em um

só chip, permitindo reduzir de forma significativa o maior atraso de transmissão
de um sinal a partir de um chip para outro. Arquiteturas com maior complexidade
(maior conjunto de instruções, mais modos de endereçamento, formatos de
instrução variáveis, e assim por diante) precisam ter um meio complexo de
buscar, decodificar e executar a lógica. Se o processador está microprogramado,
esta lógica é colocada em microprogramas complexos, resultando em um maior
armazenamento de microcódigo. Como resultado, se um CISC é desenvolvido
utilizando a tecnologia VLSI, uma parte substancial da área pode ser consumida
na realização do armazenamento de microcódigo. A quantidade de área que
determinada unidade de controle de uma arquitetura CISC pode variar é de
40% a 60%, enquanto que apenas cerca de 10% da área do chip é consumida no
caso de uma arquitetura RISC. Esta área restante numa arquitetura RISC pode
ser utilizada para outros componentes, tais como caches e arquivos de registro
maiores pelos quais o desempenho do processador pode ser melhorado. Com a
tecnologia VLSI isso é melhorado, o RISC é sempre um passo à frente em relação
à CISC. Por exemplo, se um CISC é realizado em um único chip, então RISC pode
ter algo a mais (ou seja, mais registros, cache etc.), e quando CISC tem bastante
registros e cache no chip, RISC irá ter mais do que uma unidade de processamento,
e assim por diante.
Diversas vantagens estão envolvidas quando se discute RISC como

velocidade de computação, confiabilidade e suporte à linguagem de alto nível.
Quanto à velocidade de computação, o projeto RISC é adequado à abordagem
pipelining. Um pipelining permite várias instruções serem processadas ao mesmo
tempo. O processo de uma instrução é dividido em uma série de fases, tal como
busca de instrução, decodificação de instrução, busca de operação e execução.
Enquanto uma instrução está na fase de esforço, outra instrução está em fase de
descodificação, e assim por diante.
VLSI relaciona-se com o fato de a unidade de controle RISC ser implementada

no hardware.
Por causa do progresso na tecnologia VLSI, muitos microprocessadores

comerciais têm o seu próprio cache no chip. Esse cache é tipicamente menor do que
o cache onboard, e serve como o primeiro nível de caches. O cache onboard, que fica
ao lado do chip do processador, serve como o segundo nível de caches. Geralmente,
estes dois níveis de caches melhoram o desempenho quando comparados com um
nível de cache. Além disso, o cache em cada nível pode realmente ser organizado
como uma hierarquia de caches. Por exemplo, o processador Intel P6 contém dois
níveis de caches no chip. Finalmente, às vezes cada cache em níveis mais elevados
é dividido em dois caches: cache de instruções e cache de dados. Processadores
44
que têm caches separados (ou armazenamento) para obter instruções e os dados
são às vezes chamados arquiteturas baseadas em Harvard. O uso de dois caches,
um para instruções e outro para dados, em contraste com um único cache pode
melhorar consideravelmente o tempo de acesso e, consequentemente, melhorar
o desempenho de um processador, especialmente um que faz uso extensivo de
canalização, como o processador RISC.
Outra vantagem do RISC é que requer um período mais curto de criação.

O tempo necessário para a concepção de uma nova arquitetura depende da
complexidade da arquitetura. Naturalmente, o tempo de design é mais longo para
arquiteturas complexas (CISC), que exigem a depuração do projeto e remoção
de erros da unidade de controle microprogramada complexa. No caso de RISC,
o tempo necessário para testar e depurar a resultante hardware é menor porque a
microprogramação não está envolvida e o tamanho da unidade de controle é pequeno.
Um tempo de design mais curto diminui a chance de que o produto final possa se
tornar obsoleto antes da conclusão. A menos complexa unidade de arquitetura tem
menos chance de erro de projeto e, portanto, maior confiabilidade. Assim, o projeto
RISC reduz os custos do projeto e aumenta a confiabilidade de design.
10.3 PIPELINING
O computador utiliza três etapas para o pipelining: busca, decodificação
e execução para cada instrução. Nos primeiros computadores essas fases eram
realizadas em série para cada instrução. Os computadores atuais utilizam uma
técnica chamada pipelining para melhorar o throughput (número total de instruções
realizadas em cada período de tempo). Se a unidade de controle pode realizar duas
ou três dessas fases simultaneamente, a próxima instrução pode começar antes que
a anterior seja concluída (FOROUZAN; MOSHARRAF, 2011).
FIGURA 21 – FUNCIONAMENTO COM E SEM PIPELINING
FONTE: Forouzan e Mosharraf (2011)
45
LEITURA COMPLEMENTAR
O Apple II
No início de 1976, tínhamos vendido cerca de 150 computadores. Não

apenas pela Byte Shop, mas através de outras pequenas lojas que vinham surgindo
por todo o país. Steve e eu dirigíamos pela Califórnia, entrávamos em uma loja e
perguntávamos se eles queriam ter o Apple I. Vendemos alguns dessa forma.
Mas isso não era nada, porque outras companhias estavam surgindo na
região do Vale do Silício naquela época. Uma delas, chamada Processor Technology,
supostamente vendia mais de mil unidades por mês de seu computador SOL-20,
um sucesso no mundo da computação de uso doméstico. Além disso, era um
computador que tinha um teclado (que era a forma como eles passaram a ser
concebidos após eu mostrar o Apple I em uma reunião do Homebrew). O Apple I
deu início a essa tendência.
Lee Felsenstein, o mediador dos encontros no Homebrew, projetou o SOL.

E Gordon French trabalhava na Processor Technology. Então estávamos sempre a
par das últimas novidades na área.
Para mim, o computador SOL, da Processor Technology, não era tão

impressionante assim. Steve e eu tínhamos certeza de poder vender mais do que
eles. Na época, tínhamos o protótipo do próximo computador da Apple, o Apple
II, que era dez vezes melhor que o Apple I.
Com o novo computador, tínhamos certeza de que se tivéssemos o dinheiro

necessário para fabricá-lo, poderíamos facilmente vender tantos computadores quanto
a Processor Technology.
O Apple II, no qual comecei a trabalhar quase ao mesmo tempo em que o

Apple I foi concluído, foi um fantástico aperfeiçoamento de meu projeto anterior.
Eu queria um computador que processasse cores. E embora tivesse concebido o
Apple I para poder adicionar cores a ele, pois tinha usado chips que trabalhavam
nas frequências necessárias para gerar cores em uma televisão americana, decidi
que em vez disso seria melhor projetar um novo computador.
Adicionar cores não era apenas uma questão de comprar mais chips, mas
de eficiência e de elegância de projeto. Eu queria projetar as cores desde o início,
não apenas acrescentá-las em um computador já existente. Dessa forma, o Apple II
seria concebido desde o início com tal característica.
Outro aperfeiçoamento que pensei em inserir no Apple II foi projetar todo

o novo computador em torno de textos e gráficos, com tudo vindo da própria
memória do sistema.
46
Portanto, em vez de ter todo um terminal em separado para fazer coisas na

tela e outra memória para as outras computações, decidi combinar toda a memória em
um único banco de dados – uma seção da DRAM. Assim, uma porção da DRAM que
o microprocessador utilizava poderia também ser continuamente aproveitada para
qualquer coisa que fosse preciso exibir na tela.
Trabalhando dessa forma, eu sabia que economizaria alguns chips. De fato,

no final, o Apple II acabou ficando com metade dos chips utilizados pelo Apple I.
Além de ser bem mais rápido.
Lembra-se de que mencionei como o Apple I precisava constantemente

manter os conteúdos da memória DRAM vivos através de atualizações? Bem, na
época do Apple II, eu tinha chips DRAM bem mais rápidos para utilizar. Dessa
forma, em vez de o microprocessador ser capaz de acessar (desenvolver ou ler) a
RAM a cada milionésimo de segundo, os novos chips que eu estava utilizando na
época podiam fazê-lo duas vezes a cada microssegundo.
De fato, o Apple II até conseguia que o microprocessador acessasse a

memória RAM na metade de um microssegundo (milionésimo de segundo),
enquanto os circuitos que atualizavam a RAM podiam acessá-la na outra metade
do tempo. É por isso que ele rodava mais rápido. Além de ser menor e mais barato.
O que sempre foi um objetivo meu.
O Apple II possuía inúmeros aperfeiçoamentos em relação ao Apple I.

Algumas pessoas consideram o Apple II um segundo projeto elaborado a partir do
Apple I, mas quero frisar que não é assim. De jeito nenhum.
O Apple I não foi um computador projetado do zero, mas uma ligeira

extensão de meu terminal ARPANET para um microprocessador, com praticamente
nenhuma inovação eletrônica com exceção da memória DRAM.
O Apple II, por sua vez, foi projetado e teve sua engenharia concebida a partir
do zero. Também somente por mim. Olhando para trás, eu poderia ter projetado o
Apple II primeiro – com cores e tudo –, mas escolhi avançar com um projeto que eu
pudesse desenvolver mais rapidamente.
É verdade que ambas as máquinas trouxeram incríveis avanços para o

mundo da informática. O Apple I fez história ao ser o primeiro computador pessoal
a trabalhar com um teclado e uma tela. Mas o Apple II trouxe cores, gráficos em
alta resolução, som, e a possibilidade de anexar controles de jogos. Foi o primeiro
computador que, ao ser ligado, já estava pronto para uso, com o BASIC inserido
na memória ROM.
Outros computadores chegaram perto do Apple II, mas levaram anos para
se equiparar ao que eu tinha feito. No final, cada um deles precisaria fornecer a
mesma lista de características.
47
O Apple II foi o primeiro computador de baixo custo que, de forma notável,

podia ser usado por pessoas comuns – ninguém precisava ser um geek para utilizá-lo.
Mas àquela altura, ninguém havia visto o Apple II. Eu ainda estava
finalizando-o, e naquele momento, ainda trabalhávamos em nossas casas: eu
trabalhava em meu apartamento e Steve trabalhava pelo telefone de seu dormitório
na faculdade. Ainda testávamos computadores na garagem da casa dos pais dele. E
eu ainda estava montando calculadoras na HP e pensando que a Apple era apenas
um hobby. Eu ainda planejava trabalhar na HP para sempre.
Mas não demorou muito para eu ter um Apple II funcionando logo após a
entrega das placas do Apple I para Paul Terrell. E como eu disse antes: o Apple II
não era apenas duas vezes melhor. Era algo como dez vezes melhor.
Concluí a placa, que era o núcleo do Apple II, em agosto de 1976. Lembro-
me disso muito bem porque foi nesse mesmo mês que Steve e eu viajamos para a
mostra PC’ 76, em Atlantic City.
Pegamos o avião em San Jose e sentamos juntos, levando o Apple I e o

Apple II conosco a bordo. O aspecto engraçado dessa viagem foi que um bando
de pessoas que conhecíamos do Homebrew e que agora trabalhavam nas várias
pequenas empresas de informática concorrentes da Apple estavam naquele
mesmo voo. Pudemos ouvi-las falando sobre o avanço dos negócios: falavam
sobre propostas e utilizavam terminologias que nunca havíamos escutado antes.
Sentimo-nos muito distantes de todas aquelas discussões.
Mas dentro de nós sabíamos que tínhamos um segredo. Um grande segredo.

Talvez não fizéssemos parte daqueles grupos de empresários, mas sabíamos que
possuíamos um computador melhor. Na verdade, possuíamos os dois melhores
computadores disponíveis no mercado da época. O Apple I e o Apple II. E ninguém
no mundo sabia ainda do Apple II.
Quando a exposição começou em Atlantic City, tive sorte porque não

precisei empurrar o Apple I em nosso estande. Não tenho perfil de vendedor.
Steve Jobs e Dan Kottke é que fizeram isso. Fiquei no andar de cima terminando as
últimas sequências do BASIC.
A exposição estava cheia de empresas jovens e mal financiadas como a

Apple. Os proprietários eram parecidos conosco. Isto é, não eram executivos bem
vestidos, empresários ou gerentes de empresa participando da mostra. Mas um
grupo de pessoas bastante desleixado.
Eles atuavam no mesmo ramo de negócio que o nosso, e muitos eram

nossos concorrentes diretos. Apesar de sermos todos amigos, ainda assim éramos
concorrentes.
48
Embora não tenhamos mostrado o Apple II para ninguém durante a

exposição em Atlantic City, um sujeito que não estava associado a nenhuma
companhia ou negócio de informática o viu. Ele estava lá preparando um projetor
de TV para as palestras. Eu e Steve nos apresentamos na primeira noite, e depois
que todos haviam ido embora, nos encontramos com o tal técnico do projetor.
Acho que tínhamos pedido para ele ficar. Era provavelmente 9 horas da noite.
Com o Apple II eu tinha criado um método diferente de gerar cores e ainda estava
espantado com a quantidade de TVs em que ele funcionava. Mas então imaginei
que um projetor pudesse ter circuitos diferentes para cores capazes de obstruir
meu método. Assim, queria ver se o Apple II funcionaria com ele.
Então conectei o protótipo do Apple II ao projetor daquele sujeito e ele

funcionou perfeitamente. O técnico, que estava vendo todos os computadores de
baixo custo do mundo à medida que preparava o equipamento para as palestras, me
disse que de todos os computadores que ele vira na exposição, o Apple II seria o único
que ele compraria. Apenas sorri. O Apple II não tinha sido sequer anunciado ainda.
Depois da exposição, o maior e mais sensacional momento Eureka que já

tive foi o dia em que fiz o Breakout (o jogo da Atari) funcionar no Apple II.
Eu tinha inserido capacidade suficiente no BASIC para que o computador

pudesse ler onde estavam as raquetes do jogo. Ele podia soar nos alto-falantes
quando necessário e organizar as cores na tela. Portanto, eu estava pronto.
Sentei um dia com aquela pequena placa em branco com chips na parte de
cima e todos os pequenos fios enrolados em azul e vermelho soldados por baixo e
a conectei, através de alguns fios e transformadores, à minha TV colorida.
Sentei-me e comecei a digitar comandos em BASIC. Eu precisava criar uma

fileira de tijolos – exatamente como no jogo da Atari – e funcionou! Eu tinha uma
fileira de tijolos. Experimentei várias combinações de cores até chegar à cor de
tijolo que ficasse melhor.
Dispus lado a lado oito fileiras de tijolos. Equacionei as cores corretas e

estabeleci como os tijolos deveriam aparecer para ficar mais real. Fileiras pares e
ímpares. Depois comecei a programar a raquete. Fiz a raquete subir e descer na
tela com o botão de controle do jogo. Depois coloquei a bola. Então comecei a dar
movimento à bola. Em seguida, passei a dizer para a bola quando ela batia nos
tijolos como ela deveria se livrar deles, bater e voltar. Quando ela atingia a raquete,
programei como ela rebateria e mudaria de direção na vertical e na horizontal.
Depois brinquei com todos esses parâmetros, e isso tudo levou apenas
meia hora. Testei dezenas e dezenas de variações diferentes dos componentes até o
Breakout funcionar por completo no Apple II, mostrando a pontuação e tudo mais.
Chamei Steve Jobs para ver. Não podia acreditar que havia conseguido
fazer aquilo tudo; foi fantástico. Pedi a Steve que sentasse e mostrei a ele como o
49
jogo aparecia com a raquete e os tijolos. Depois disse: “Veja isto”. E digitei alguns
comandos BASIC e mudei a cor da raquete, a cor dos tijolos e local onde ficava a
pontuação na tela.
Então disse: “Se tivesse feito toda essa variedade de opções embutidas no
equipamento da forma que sempre foi feito, eu teria levado dez anos. Agora que
os jogos estão no software, o mundo inteiro vai mudar”.
E naquele exato momento foi que me dei conta. Os jogos em software serão
incrivelmente avançados se comparados com os jogos em hardware – isto é, jogos
que estão embutidos nos equipamentos tipo fliperama e em sistemas semelhantes.
Atualmente, os gráficos nos jogos são excelentes. Eles ficaram incrivelmente

complicados e grandes. Se precisassem ser feitos em hardware, não haveria tempo
suficiente no universo para concebê-los.
Pensei: Nossa! Ninguém no clube vai acreditar que um jogo de fliperama

pôde ser escrito em BASIC. O Breakout foi o primeiro no mundo. Inseri também
um segredo naquele jogo para o Apple II: ao digitar CTRL + Z no teclado, o jogo
passava para um modo em que a raquete iria sempre se movimentar, mas nunca
erraria a bola.
Que recurso fantástico! Ele enganava as pessoas fazendo-as pensar que

tinham muita sorte em atingir a bola. A raquete ficava tão instável e movimentava-
se tanto que uma pessoa nunca poderia dizer que tal feito não era por sua habilidade
e que seus próprios movimentos é que estavam acertando a bola.
Um dia me sentei com John Draper (o Capitão Crunch, lembra?). Estávamos

no Homebrew logo depois do principal segmento da reunião, quando as pessoas
podiam fazer suas demonstrações.
John nunca havia brincado em um jogo de fliperama antes.
Eu disse: “Veja, jogue este”. Então mostrei a ele como virar o botão para
que a raquete se movimentasse para cima e para baixo. Ele sentou e começou a
jogar. Todos na sala ficaram olhando para ele por aproximadamente 15 minutos. A
bola estava muito rápida, e ele, embora não soubesse realmente o que fazer com o
controle, continuava acertando. As pessoas simplesmente pensaram que John era
um jogador excepcional.
Passados cerca de 15 minutos, ele finalmente venceu o jogo. E todos o

cumprimentaram como se ele fosse o melhor jogador do mundo. Acho que John
nunca soube que o jogo já estava configurado para ganhar.
Na primavera de 1976, quando ainda estava trabalhando no Apple II, Steve

e eu tivemos nossa primeira discussão. Ele não achava que o Apple II devesse
ter 8 slots, ou seja, conectores para encaixar novas placas de circuito no caso de o
usuário querer expandir a funcionalidade do computador. Steve queria somente 2
50
slots – um para a impressora e outro para um modem. Ele achava que assim seria
possível fabricar uma máquina menor e mais barata – e que fosse boa o suficiente
para as tarefas diárias.
Mas eu queria mais slots; 8 deles. Porque tinha na cabeça a ideia de

que as pessoas iriam querer muitas coisas no futuro, e que de forma alguma
deveríamos limitá-las.
Normalmente, sou uma pessoa fácil de se relacionar, mas daquela vez disse
para Steve: “Se é o que quer, vá conseguir outro computador para você”. Eu não
conseguiria economizar um único chip reduzindo o número de slots de 8 para 2, e
eu sabia que pessoas iguais a mim poderiam eventualmente descobrir coisas para
adicionar a qualquer computador.
Na época, eu estava em posição de agir assim. O que não aconteceria

sempre. Alguns anos mais tarde, a Apple prosseguiu com o projeto do Apple III,
que foi simplesmente um desastre – e a máquina tinha menos slots.
Mas em 1976, ganhei a discussão, e o Apple II foi fabricado e no final saiu

da maneira que eu queria.
Lembro-me de um dia chegar à HP – onde ainda estava trabalhando

– e mostrar o Apple II para os outros engenheiros. Demonstrei-o fazendo um
redemoinho de cores. E os outros engenheiros se aproximavam para dizer que
aquele era o melhor produto que já tinham visto. E a HP ainda não havia encontrado
uma maneira de executar corretamente aquele tipo de projeto.
Um dia, meu chefe, Pete Dickinson, disse que algumas pessoas em minha
divisão de calculadoras haviam criado um novo projeto, que seguiu para a aprovação
da diretoria, um projeto para desenvolver uma pequena máquina de mesa com um
microprocessador, memória DRAM, uma pequena tela de vídeo e um teclado. E até
já tinham designado cinco pessoas para desenvolver o BASIC para ela.
O horrível de tudo aquilo é que eles sabiam o que eu havia feito com o
Apple I – e mesmo com o Apple II. Mas mesmo assim começaram o tal projeto sem
mim! Por quê? Não sei. Acho que perceberam que o projeto deles era igual ao que
eu já havia feito.
Mas mesmo assim fui falar com o gerente do projeto, Kent Stockwell.
Embora tivesse criado computadores como o Apple I e o Apple II, eu queria tanto
trabalhar em um computador na HP que faria qualquer coisa para isso. Eu poderia
ser um mero engenheiro da interface da impressora. Algo pequeno.
Então disse a Kent: “Todo meu interesse na vida tem sido os computadores.
Não as calculadoras”.
Após alguns dias, fui recusado novamente.
51
Ainda acho que a HP cometeu um enorme erro em não me deixar participar

do projeto de computadores. Eu era muito leal à empresa. Queria trabalhar lá para
sempre. Quando se tem um funcionário que diz que está cansado de calculadoras
e que é realmente produtivo em computadores, deve-se colocá-lo onde ele é
produtivo. Onde ele trabalha feliz. A única explicação que posso imaginar é que
havia gerentes e subgerentes naquele projeto de computador que se sentiram
ameaçados. Eu já havia feito um computador inteiro sozinho. Talvez por isso eles
tenham me ignorado. Não sei dizer o que estavam pensando.
Mas deveriam ter dito para si mesmos: “Como fazer para trazer Steve
Wozniak a bordo? Vamos colocá-lo como engenheiro da pequena interface com a
impressora”. Eu teria ficado muito feliz se isso tivesse acontecido, mas ninguém se
preocupou em me colocar onde eu mais gostava.
Como disse antes, precisávamos de dinheiro.
Assim, no verão de 1976, começamos a falar sobre a Apple com pessoas

potencialmente endinheiradas, mostrando-lhes o Apple II funcionando com cores
na garagem de Steve.
Uma das primeiras pessoas para quem mostramos o novo computador foi
Chuck Peddle. Lembra-se dele? O sujeito da MOS Technologies que me vendeu
na mostra da WESCON o processador 6502, em torno do qual projetei o Apple I
no ano anterior.
Naquele momento, Chuck estava trabalhando na Commodore, empresa de

eletroeletrônicos que dizia estar em busca de um computador pessoal para vender
em suas lojas. Lembro-me de que estava muito emocionado em encontrá-lo depois
do papel que seu chip (MOS 6502) desempenhara no Apple I. Então abrimos a
garagem de Steve naquele dia e, contra a luz do sol, Chuck veio caminhando até
nós vestindo um terno e um chapéu de caubói. Eu estava muito feliz em vê-lo e não
podia esperar para mostrar o Apple II para ele. Em minha cabeça, Chuck era uma
pessoa muito importante.
Digitei alguns programas em BASIC, mostrei-lhe algumas espirais coloridas

na tela, o total de chips que o computador possuía e como funcionavam, e todos
os outros detalhes técnicos. Apenas para mostrar a ele o que estávamos fazendo.
Durante toda a reunião Chuck ria e sorria, demonstrando estar de bom humor.
Então nos disse para elaborarmos uma apresentação para os figurões da empresa,
o que fizemos algumas semanas mais tarde.
Nunca esquecerei como naquela sala de reuniões Steve Jobs fez o que eu
achava ser uma afirmação das mais ridículas. Ele disse: “Vocês poderão comprar
este produto por apenas algumas centenas de milhares de dólares”.
52
Eu estava quase envergonhado. Quer dizer: lá estávamos nós, sem dinheiro,

tendo ainda de provar para alguém que era possível faturar com aquele produto.
Então Steve acrescentou: “Algumas centenas de milhares de dólares mais os
empregos para trabalhar neste projeto”.
Fomos embora e recebemos a resposta da Commodore algumas semanas

depois: eles haviam decidido montar a própria máquina, pois seria mais barato. E
não precisavam de coisas extravagantes como cor, som e gráficos (todos os recursos
legais que possuíamos). Na garagem, Chuck Peddle nos disse que pensava ser
possível que eles tivessem o próprio computador em quatro meses. Eu não via
como alguém conseguiria aquilo, mas acho que após ver o Apple II, seria muito
mais fácil projetar algo como o que eles queriam.
A propósito, vi o PET da Commodore (o computador que eles lançaram

tão rapidamente) alguns meses depois na West Coast Computer, uma feira de
informática e tecnologia. Ele me deixou um pouco doente, pois estavam tentando
fazer algo parecido com o que havíamos mostrado para Chuck na garagem de
Steve, com um monitor, programação e teclado, mas terminaram com um produto
muito ruim ao projetá-lo tão rápido. Eles poderiam ter tido o Apple, sabe? Poderiam
ter tido ele todo, se tivessem tido a visão correta. Péssima decisão.
É engraçado. Pensando novamente sobre tudo isso agora, o Apple II acabou

sendo um dos produtos de maior sucesso de todos os tempos. Mas não tínhamos
direitos de propriedade ou patentes naquela época. Sem segredos. Estávamos
simplesmente mostrando-o para todo mundo.
Após a recusa da Commodore, fomos à casa de Al Alcorn, um dos

fundadores da Atari com Nolan Bushnell, e quem contratou Steve Jobs para fazer
videogames lá dois anos antes.
Eu sabia que Al me conhecia. E ele sabia que eu havia projetado o Breakout, a

versão do Pong para um único jogador. Lembro-me de que quando fomos à casa dele
fiquei impressionado porque ele tinha um projetor de TV colorido. Em 1976, ele deve
ter sido uma das primeiras pessoas a possuir um projetor daqueles. Muito legal.
Mas Al nos disse depois que a Atari estava muito ocupada com o mercado
de videogames para embarcar em um projeto de computador.
Alguns dias depois, começaram a aparecer alguns investidores que Steve

havia contatado. Um deles foi Don Valentine, da Sequoia, que ridicularizou a
maneira como conversamos sobre a fabricação do Apple II.
– Qual é o mercado? – ele perguntou.
– Cerca de um milhão – eu respondi.
– Como você sabe?
Então disse a ele que o mercado de radioamador tinha um milhão de

usuários e que o nosso poderia ser pelo menos desse tamanho.
53
Bem, ele também recusou, mas nos colocou em contato com um sujeito
chamado Mike Markulla. Don nos disse que Mike tinha apenas 30 anos de idade,
mas que já havia se aposentado pela Intel. Ele nos contou também que Mike se
interessava por equipamentos eletrônicos. E que por isso talvez soubesse o que
fazer conosco.
A primeira vez que encontrei Mike, achei-o a pessoa mais legal que já tinha
conhecido. Era um rapaz jovem com uma bela casa nas colinas com vista para as
luzes de Cupertino. Ele tinha uma vista deslumbrante, uma esposa maravilhosa,
todo o pacote.
E ainda melhor: ele realmente adorou nosso computador! E não conversou

conosco como se estivesse escondendo coisas e pensando em como nos enganar.
Ele foi verdadeiro, o que ficou óbvio desde o início. E que, de fato, fazíamos algo
muito importante.
Mike estava verdadeiramente interessado no Apple II. Ele nos perguntou

quem éramos, qual era nossa formação, quais eram nossos objetivos com a Apple,
e até onde achávamos que ela poderia chegar. Ele deu indicações de que teria
algum interesse em nos financiar: falava em cerca de 250 mil dólares ou algo assim
para fabricar mil unidades.
Mike demonstrava bom senso, falando normalmente em termos de qual

poderia ser o futuro de uma nova indústria de computadores de uso doméstico.
Porém, eu sempre pensara que o Apple II seria algo como o hobby de pessoas que
quisessem simular uma situação do trabalho ou jogar videogame.
Mas Mike falava de algo diferente. Ele falava em introduzir o computador

na vida de pessoas normais, em casas normais, fazendo em casa atividades como
procurar a receita favorita ou conferir o saldo bancário. “Isso é o que vem vindo”,
ele disse. Ele tinha a visão do Apple II como um verdadeiro computador residencial.
Claro que Steve e eu já vínhamos atuando um pouco em torno de tal ideia.

Isto é, Paul Terrell da Byte Shop já tinha nos pedido algo inovador e pronto para
usar. E nós planejávamos seguir naquela direção, além de utilizar gabinetes de
plástico. Tínhamos até planejado contratar um amigo de Steve, Rod Holt, para
criar uma fonte de alimentação com comutação muito mais eficiente que a fonte
anteriormente disponível – e sabíamos que isso geraria menos calor, fator necessário
para colocarmos a placa e nossa fonte de alimentação em um gabinete de plástico.
Mas quando Mike concordou em assinar ele nos disse: “Seremos uma
empresa da Fortune 500* em dois anos. Este é o início de uma indústria. E acontece
uma vez em cada década”.
54
Quer saber? Acreditei nele somente por causa de sua reputação e posição
na vida. Ele era o tipo de pessoa que, se fazia tal afirmação – e era possível ver
sinceridade nele –, era porque realmente acreditava no que estava dizendo. Porém,
achei que a Fortune 500 estaria fora de nosso alcance. Quer dizer: uma empresa de 5
milhões de dólares seria imensa e inacreditável.
Se alguém sabe fazer certos julgamentos melhor que eu, não tento usar
minha lógica e meu raciocínio para desafiá-lo. Posso ser cético, mas se alguém
realmente sabe sobre o que está falando, então deve receber um voto de confiança.
Acontece que mesmo Mike estava subestimando nosso sucesso. Mas estou
me adiantando nos acontecimentos.
Depois que Mike concordou em fazer nosso plano de negócios – depois de

começar a trabalhar nele –, ele pediu para conversar comigo. Ele disse: “OK, Steve.
Você sabe que precisa sair da Hewlett-Packard”.
Então perguntei: “Por quê? ”. Afinal, o tempo inteiro em que projetei o

Apple I e o Apple II trabalhei na HP. E durante todo o tempo que trabalhei nas
duas coisas montei as interfaces, criei as cores e os gráficos, desenvolvi o BASIC,
simplesmente fiz tudo. Perguntei novamente: “Por que não posso continuar
fazendo isso em paralelo e ter a HP como meu emprego seguro para a vida toda? ”.
E Mike respondeu: “Não, você precisa deixar a HP”. Não me deu nenhum
motivo. Disse-me apenas que eu precisava decidir até terça-feira.
Então pensei, pensei e pensei. Percebi que me divertia muito projetando

computadores e mostrando-os nas reuniões do Homebrew. Divertia-me
desenvolvendo os softwares e jogando com o computador. Percebi que poderia
fazer tudo aquilo pelo resto da vida. Não precisava ter minha própria empresa.
Além disso, sentia-me muito inseguro em começar uma empresa onde

haveria a expectativa de que eu ficasse forçando as pessoas, dirigisse suas tarefas e
controlasse o que faziam. Não tenho um perfil administrativo. Já disse isso antes:
decidi há muito tempo que nunca me tornaria um chefe autoritário.
Então decidi que, afinal, não ficaria somente na Apple. Ficaria na HP, em
meu emprego de tempo integral, e projetaria computadores por diversão.
Fui até a cabana – Mike tinha uma cabana em sua propriedade – e disse
para Mike e Steve o que havia decidido. Disse-lhes que minha resposta era não.
Pensei a respeito e cheguei à conclusão de que não sairia da HP.
Lembro-me de que Mike reagiu friamente ao meu comunicado. Ele apenas

deu de ombros e disse: “OK. Tudo bem”. Ele realmente foi muito conciso. Como se
estivesse pensando: “OK, tudo bem, vou procurar alguma outra pessoa para dar à
Apple o que ela precisa”.
55
Mas Steve ficou chateado. Ele estava convencido de que o Apple II era o
computador com o qual deveriam seguir adiante.
Em poucos dias, meu telefone começou a tocar. Passei a receber telefonemas

no trabalho e em casa de meu pai, minha mãe, meu irmão e de vários amigos. Um
telefonema após outro. Todos dizendo que eu estava tomando a decisão errada. Que
eu deveria seguir com a Apple porque, afinal, 250 mil dólares era muito dinheiro.
Foi Steve quem pediu a todos eles que me telefonassem. Aparentemente,

ele achou que alguém precisava intervir.
Mas não adiantou nada; eu ainda continuaria na HP.
Então Allen Baum ligou e disse: “Sabe, Steve, você realmente precisa seguir
adiante e fazer isso. Pense a respeito. Você pode ser um engenheiro, se tornar
um administrador e ficar rico, ou você pode ser um engenheiro, permanecer um
engenheiro e ficar rico”. Ele me disse que achava ser perfeitamente possível começar
uma empresa e permanecer um engenheiro. Também mencionou que eu poderia
fazê-lo sem nunca precisar lidar com aspectos da administração da empresa.
Aquilo era exatamente o que eu precisava ouvir: alguém me dizendo

que eu poderia permanecer na parte inferior do organograma da empresa, como
engenheiro, e não virar um administrador. Telefonei imediatamente para Steve
Jobs para contar-lhe as novidades. Ele ficou emocionado.
No dia seguinte, cheguei cedo à HP, caminhei em direção a alguns amigos

e lhes disse: “É isso aí. Vou sair da HP e começar a trabalhar na Apple”.
Depois me dei conta: Ih, é sempre melhor falar com o chefe primeiro. Então
fui rapidamente falar com ele, mas ele não estava em sua mesa. Esperei, esperei,
e às 4 horas da tarde ele ainda não havia aparecido. Enquanto eu esperava, todos
chegavam perto de mim e diziam: “Ei, ouvi falar que você está saindo”, e eu não
queria que meu chefe ouvisse aquilo de outra pessoa.
Por fim, meu chefe apareceu quase no fim do dia. Então disse a ele que
estava saindo para começar meu próprio negócio. Ele me perguntou quando eu
gostaria de ir. Respondi: “Imediatamente”. Então ele me levou até o departamento
de recursos humanos, eles me entrevistaram e, de repente, eu estava fora. Foi tudo
muito rápido.
Nunca duvidei de minha decisão. Isto é, eu havia tomado minha decisão. A

Apple seria a principal coisa para mim dali em diante.
Um pouco antes de conhecer Mike, Steve e eu havíamos planejado mudar

a Apple da casa dele e de meu apartamento para um escritório de verdade.
Possuíamos algo como 10 mil dólares no banco pelas vendas do Apple I, portanto,
56
poderíamos fazer tal mudança. O escritório ficava na Stevens Creek Boulevard, em

Cupertino, poucas quadras distante de onde, no final, acabaria se localizando o
enorme campus da Apple em Bandley Drive.
Mais tarde, quando Mike se incorporou ao projeto, passamos a ter ainda

mais dinheiro em conta. Então mudamos para nosso pequeno escritório, com
cinco ou seis mesas ao redor e uma pequena sala para instalar uma bancada de
laboratório para testes e consertos de bugs. Na verdade, era uma grande bancada de
laboratório. Toda nossa equipe principal estava a postos. Steve, eu, Mike Markulla,
Rod Holt e, agora, um sujeito chamado Mike Scott.
Contratamos Mike Scott para ser presidente um pouco antes de Mike

Markulla chegar (portanto, agora tínhamos dois Steves e dois Mikes). Mike, ou
“Scotty”, como o chamávamos, era um sujeito com experiência em administração.
Ele veio da National Semiconductor, onde havia sido diretor.
Acho que muitas pessoas se esqueceram dele, mas Mike foi presidente e
líder da Apple por quatro anos – ele abriu nosso capital para o mercado quatro
anos mais tarde.
Àquela altura, tínhamos a ideia de anunciar e mostrar o Apple II na West

Coast Computer, feira de informática que ocorreria dali a quatro meses. Essa
feira, criada por Jim Warren (outro membro do Homebrew), aconteceria em São
Francisco, em janeiro de 1977.
Portanto, eu teria quatro meses para finalizar o projeto do Apple II. Naquele
momento, eu estava completando a codificação de 8 Kbytes que precisávamos
liberar para a Synertek, empresa que faria os chips de memória ROM para nós. Tais
chips seriam os responsáveis por fazer o Apple II rodar o BASIC.
Depois havia o projeto em torno do gabinete de plástico. Seríamos o

primeiro computador da época a ter um gabinete assim. Graças a Deus, eu não
tinha nada a ver com aquilo. Foi um projeto difícil. Steve Jobs, Rod Holt e Mike
Scott cuidaram de tudo. Eles contrataram um sujeito em Palo Alto para fazer os
tais gabinetes. O processo todo foi laborioso e consumiu muito tempo – além do
quê, havia um limite para o que o sujeito em Palo Alto conseguiria fazer. Ele estava
usando um determinado processo para fabricar os gabinetes, mas só conseguia
fazer um número realmente pequeno por dia.
Estávamos a apenas três dias do início da West Coast Computer quando

recebemos nossos três primeiros gabinetes de plástico como amostra. Então
montamos o computador completo com a placa dentro. Ele ficou com a cara do
que viria a ser o Apple II e agora poderíamos mostrá-lo na feira.
Finalmente, nos dias anteriores à feira, Mike Markulla explicou como

deveríamos nos vestir, como deveria ser nossa aparência e como deveríamos agir.
Ele coordenou até mesmo a maneira como deveríamos falar com as pessoas e
mostrar-lhes o equipamento.
57
Claro que, paralelamente, comecei a pensar em como poderia aprontar

uma brincadeira na exposição. Primeiro escrevi um pequeno programa de
piadas no qual contaria piadas sobre a etnia das pessoas. Depois pensei em uma
enorme brincadeira que exigiria um pouco mais de esforço que apenas uma piada
normal. Pensei em brincar com a grande empresa que começou tudo para mim. A
companhia que criou o Altair: a MITS Corporation.
Tínhamos uma lista de todos os expositores de computadores e equipamentos

na West Coast Computer e achei muito estranho o fato de a MITS não participar.
Pensei: Que grande oportunidade para aprontar uma brincadeira com eles!
Minha ideia tinha a ver com algo que li nos Papéis do Pentágono sobre
fraudes políticas e um sujeito chamado Dick Tuck, que executou truques sujos
(pequenos truques psicológicos), como divulgar falsos memorandos e notícias falsas
para alarmar as pessoas, escritos de tal maneira que não poderiam ser vistos como
mentirosos. Então decidi divulgar um falso memorando preparado por mim – um
anúncio falso, como um folheto, para um produto falso da MITS. Depois de ouvir
Mike Markulla dizer que distribuiríamos 20 mil brochuras sobre o Apple II, percebi
que seria possível conseguir milhares e milhares de anúncios falsos por fora.
A primeira coisa que fiz foi chamar Adam Schoolski, um hacker de telefone
que conheci alguns anos antes, quando ele tinha 13 anos de idade. Ele agia sob o nome
Johnny Bagel. Contei-lhe que queria pregar uma peça, mas que não poderia ser perto
da região da Baía de São Francisco. Na época, eu já tinha uma boa experiência em
aprontar brincadeiras como aquela, e sabia que não seria pego se tomasse algumas
precauções, como não fazer as coisas perto de minha casa ou trabalho, e manter um
certo nível de sigilo. Eu disse para Adam que a tal brincadeira seria enorme, porque
queria imprimir 8 mil folhetos para distribuição. Consegui juntar os 400 dólares de
que precisava para imprimir as tais 8 mil cópias em diferentes cores de papel.
Adam e eu fizemos tudo juntos. Batizamos o produto que inventamos de

Zaltair. Havia uma nova empresa na época, chamada Zilog, que estava fabricando um
chip compatível com o Intel 8080. Era o Z-80, e na época havia muitos computadores
de uso exclusivamente recreativo sendo lançados com aquele chip. Eram os chamados
Z-isso ou Z-aquilo. Todas aquelas empresas estavam sempre utilizando palavras com
Z. Então criei o Zaltair, um computador que também usaria o Z-80.
Inventei também todo tipo de palavras tolas de computação com Z. Como

Bazic. E Perzonalidade. Em seguida, eu precisava de um modelo para o folheto.
Procurei em uma revista de informática, chamada Byte, um anúncio que fosse o
pior possível. E encontrei. Era de uma empresa chamada Sphere. Dizia coisas idiotas
como: “Imagine isso. Imagine aquilo. Imagine alguma outra coisa”. Então copiei a
estrutura do anúncio com estes dizeres: “Imagine um carro de corrida com cinco
rodas”. Inventei as coisas mais estúpidas das quais qualquer imbecil riria, mas se
fossem vistas em um folheto benfeito, com letras bonitas, todos iriam pensar se tratar
de algo real. Imagine algo mais rápido que a velocidade da luz. Imagine um banjo
com seis cordas. Pensei nas coisas mais estúpidas para colocar no anúncio.
58
Também brinquei com o que era chamado de barramento S-100, conexão

que o Altair utilizava para conectar placas de expansão. Dei o nome Z-150 para
o equivalente de barramento no Zaltair. Escrevi: “Nós temos 150 slots. Nós o
chamamos de barramento Z-150”. Disse ainda que ele era compatível com o
barramento S-100, mas com 50 pinos a mais. Se pensar a respeito, verá que são
afirmações idiotas, mas eu sabia que as pessoas leriam aquelas coisas como se
fossem avanços fantásticos, apenas porque nosso folheto pareceria ter sido criado
de forma bastante profissional.
Então decidi fazer que a brincadeira com a MITS Corporation parecesse

ter sido preparada pela Processor Technology. Afinal, eles desenvolveram um
computador concorrente do Altair, o SOL. Tive essa ideia ao me lembrar do que
fizera na Universidade do Colorado, quando consegui fazer parecer que outro
sujeito havia causado interferência nas TVs da classe. Duas brincadeiras pelo preço
de uma! E a maneira que encontrei para fazê-lo foi criar uma citação totalmente
falsa, que faria todos se espantarem. As pessoas diriam: “Nossa! Que diabos ele
está dizendo?”. E eu a atribuí ao presidente da MITS, Ed Roberts, e coloquei-a no
alto do folheto, em itálico.
A citação não tinha sentido algum: “Previsível refinamento ou computador

estável sempre sugere outros recursos. Toda elite computacional hoje necessita
ostentar lógica opção garantidora. Yes!”.* Percebeu? A primeira letra de cada
palavra nas duas frases forma Processor Technology!
Em seguida, na parte de trás do papel, coloquei um quadro comparativo,

igual aos quadros que revistas como a Byte usavam para comparar computadores.
Qual é sua rapidez? Qual é o seu tamanho? Quanto eles possuem de memória RAM?
Que processador utilizam? Em meu quadro, inventei as categorias mais estúpidas.
Por exemplo: eu tinha uma categoria simplesmente chamada genericamente
“hardware”. Um computador poderia ter pontuação de 1 a 10. Depois, “software”.
Avaliei os computadores em termos de exclusividade, personalidade, e em outros
termos genéricos e estúpidos nos quais ninguém jamais viu um computador sendo
avaliado. Para o Zaltair, coloquei 1 em todas as categorias, claro, e sempre fiz o Altair
vir em segundo lugar. Depois, todos os computadores que na verdade eram melhores
que o Altair vinham avaliados abaixo dele. Dessa forma, parecia que eles não valiam
nada em comparação, embora todos naquela feira provavelmente soubessem que os
concorrentes eram muito melhores. É óbvio que incluí o Apple II.
Seja como for, eu esperava que parecesse que a MITS estava mentindo em
seu quadro comparativo.
Então percebi que tudo aquilo era muito grande e que não havia jeito
de eu ser pego. Não deixaria isso acontecer. Eu tinha dois jovens amigos, Chris
Espinoza e Randy Wiggington, que sabiam sobre o que eu estava fazendo – eles
eram adolescentes na época. Disse a cada um deles que não importava o que
59
acontecesse: eles não poderiam contar nada daquilo para ninguém. Mesmo se
fossem chamados pela polícia e esta lhes dissesse que o parceiro deles contou tudo,
ainda assim deveriam continuar negando. “Nós vamos esconder isso”, disse a eles,
“e nunca admitir para ninguém”.
Adam Schoolski vivia em Los Angeles, mas veio para a feira. Quando nós
quatro chegamos com os 8 mil folhetos, vimos aquelas mesas enormes onde todas
as empresas estavam colocando suas brochuras e propagandas. Trouxemos 2 mil
de início e simplesmente colocamos em uma das mesas como se estivéssemos
fazendo algo normal. Depois fomos dar uma volta pela feira e gargalhar um pouco.
Mas Adam me procurou uma hora depois dizendo que todos os folhetos
haviam sumido. Com a caixa de papelão e tudo.
Fomos então para nosso hotel e pegamos outra caixa com 2 mil folhetos e
os deixamos na mesa. Ficamos por ali em volta observando, até que no final um
sujeito se aproximou, olhou um dos folhetos, pegou toda a caixa e levou embora.
Um representante da MITS estava interceptando os folhetos!
Voltamos novamente para o hotel e pegamos mais folhetos, mas não os

colocamos apenas sobre a mesa. Em vez disso, os escondemos sob os casacos e nas
mochilas e distribuímos pacotes pelos cantos, nos telefones públicos, nas mesas,
em todo lugar. Em toda a feira. Encontrávamos pilhas de folhetos – outros folhetos
reais de empresas – e colocávamos alguns dos nossos por baixo. Assim, se alguém
desse uma olhada rapidamente, não perceberia que nossos folhetos estavam lá no
meio. Uma vez, duas vezes, e não fomos pegos.
Graças a Deus Steve e Mike não descobriram nada. Mike, pelo menos,
teria dito: “Não, Steve, não faça brincadeiras. Não faça piadas. Elas geram uma
imagem errada da empresa”. Isso é o que qualquer tipo mais profissional teria
dito. Mas espera aí! Eles estão lidando com Steve Wozniak. Eu levo o trabalho a
sério – projetei um produto fantástico e todos sabiam disso – e fui sério ao fundar
uma empresa e ao introduzir um produto novo no mercado. Mas para mim, tudo
isso caminha junto com me divertir e fazer piadas. Passei toda a vida agindo assim.
E se pensar a respeito, boa parte da personalidade do computador Apple reside na
diversão. E tudo o que aconteceu só aconteceu de fato porque meu estilo era esse:
diversão. As piadas fazem as coisas valer a pena.
Não consegui parar de rir no dia seguinte na Apple, quando Steve viu o quadro
comparativo e começou a falar positivamente sobre o fato de nosso desempenho não
estar tão ruim em comparação. Claro que estávamos muito ruins, como todos os
demais, exceto meu Zaltair inventado, mas ele disse: “Ei, não fizemos muito feio,
afinal; tivemos melhor classificação do que alguns outros”. Ai, meu Deus! Randy
Wiggington precisou sair da sala porque chorava de tanto rir!
60
Na noite seguinte, noite do encontro regular do Homebrew às quartas-

feiras, eu não podia esperar para ver se o pessoal do clube havia pegado o folheto.
Com certeza: uma pessoa levantou a propaganda no ar e começou a falar sobre o
Zaltair, dizendo que ligou para a empresa para perguntar a respeito do computador
e descobriu que era falso. Tudo não passara de um trote.
Acontece que cerca de um terço das pessoas, umas duas centenas, haviam
pegado o folheto. Portanto, ele circulou.
Uma semana depois, Gordon French, que começou a Homebrew e que

naquela época havia deixado seu emprego na Processor Technology, deu uma
passada na Apple para ver se haveria algum trabalho de consultoria que ele
poderia realizar para nós. Lembro-me de ter pensado que ele era um sujeito legal,
agradável, tranquilo.
Aproveitei a oportunidade e perguntei para ele, mal segurando o riso:

“Você já ouviu falar desse Zaltair que foi lançado? ”.
“É verdade”, ele disse. “Aquele trote. Eu sei quem fez. ” Imediatamente,

Randy e eu ficamos mais interessados. Então perguntei: “Quem? ”.
Gordon respondeu: “Foi Gary Ingram, da Processor Technology. Ele tem

um estranho senso de humor”.
Aquilo era exatamente o que eu esperava! Outra pessoa levando a culpa – e

o outro alguém era nosso rival, a Processor Technology. Portanto, foi um sucesso.
Eu disse a Gordon: “Você sabe, ouvi falar que existe um tipo de código
no folheto”. Então peguei a brochura e olhei para as letras como se estivesse
descobrindo aquilo pela primeira vez. “P... R... O... C...”.
Tenho certeza de que por anos a fio todos pensaram que a Processor Technology
é que havia feito o folheto. Eu não havia admitido nada para ninguém até muitos anos
mais tarde, quando estava em uma festa de aniversário de Steve Jobs.
Foi lá que apresentei para ele uma cópia emoldurada do folheto. Assim que a
viu, ele começou a gargalhar. Steve jamais suspeitara que eu estivesse por trás de tudo!
FONTE: WOANIAK, Steve. Iwoz: a verdadeira história da Apple segundo seu cofudador. São
Paulo: Évora, 2011, p. 198- 221.
61
RESUMO DO TÓPICO 3
Neste tópico vimos os tipos de computadores e suas características.
• Vimos que as funções primárias de um computador são processar, armazenar,

movimentar e controlar dados.
• As partes que compõem um computador podem ser divididas em CPU,

memória principal, armazenamento secundário, dispositivos de entrada e saída
e interconexão de subsistemas.
• A unidade lógica aritmética (ULA) desempenha operações lógicas, de

deslocamento e aritmética sobre dados.
• A memória principal é um conjunto de localizações de memória, cada um com

identificador único. Dois tipos de memória estão disponíveis: memória de acesso
aleatório (RAM) e memória somente para leitura (ROM).
• Os dispositivos de entrada e saída permitem que um computador se comunique

com o ambiente externo.
• A interconexão dos subsistemas de um computador representa um papel

importante, porque existem informações que precisam ser trocadas entre os
subsistemas.
• Você viu a importância dos microprocessadores, microcontroladores e sistemas

embarcados.
• A arquitetura e organização dos computadores passaram por muitas mudanças.

Podemos dividir a arquitetura de computadores em duas categorias: CISC e RISC.
• Computadores atuais utilizam uma técnica chamada pipelining para melhorar o

throughput. Sua função é permitir que a unidade de controle realize duas ou três
fases simultaneamente.
62
AUTOATIVIDADE
1 Quais as funções primárias de um computador?
2 Qual a função da memória principal?
3 Em nossos estudos vimos que podemos ter vários componentes de entrada

e saída para o computador fazer a comunicação com o mundo externo.
Assinale a alternativa que identifica um dispositivo de entrada ou saída.
a) ( ) Unidade central de processamento.

b) ( ) Memória dinâmica.
c) ( ) Roteador.
d) ( ) Teclado.
4 Analise e descreva as diferenças entre a arquitetura CISC com a arquitetura

RISC.
63
64
UNIDADE 2
CONCEITOS FUNDAMENTAIS DA
COMPUTAÇÃO
Ao final desta unidade você será capaz de:
• compreender os conteúdos fundamentais da computação;
• entender a área da informática de maneira sistêmica;
• compreender os sistemas de numeração e sua importância;
• conhecer os principais elementos de um sistema computacional.
PLANO DE ESTUDOS
Esta unidade de ensino está dividida em três tópicos, sendo que no final de
cada um deles você encontrará atividades que contribuirão para a apropria-
ção dos conteúdos.
TÓPICO 1 – SISTEMAS DE NUMERAÇÃO
TÓPICO 2 – BASES COMPUTACIONAIS
TÓPICO 3 – DADOS
65
66
UNIDADE 2
TÓPICO 1
SISTEMAS DE NUMERAÇÃO
1 INTRODUÇÃO
Através dos estudos realizados foi possível perceber que a área da
computação possui raízes no campo da matemática e que seu desenvolvimento
não ocorreu de forma repentina.
A matemática é a razão pela existência da computação, pois os dispositivos

computacionais nasceram da necessidade de realizar cálculos a partir de máquinas.
Num dado momento da história, percebeu-se que computadores

poderiam ser utilizados para realizar atividades que vão muito além de
cálculos. Porém, numa visão mais clínica do que está sendo computado, pode-
se perceber que o processamento realizado está baseado em lógica e resolução
de expressões, praticamente idênticas às expressões matemáticas, apenas
utilizando outros elementos.
Diante disso, entender com maior propriedade os sistemas de numeração é

fundamental para melhor entender a área da computação. Neste sentido, a presente
unidade apresenta os principais sistemas de numeração envolvidos na computação
e também os cálculos para realização das conversões entre estes sistemas.
2 SISTEMA DE NUMERAÇÃO
Na antiguidade, diversos sistemas de numeração foram utilizados, como
os sistemas de numeração de base dois, três, cinco e vinte (BOYER, 1996). Para
representação numérica, diversas simbologias foram utilizadas. Isso implica em
podermos classificar os sistemas de numeração em dois grupos: os sistemas de
numeração não posicionais e os sistemas de numeração posicionais (FOROUZAN;
MOSHARRAF, 2011).
67
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
Num sistema de numeração não posicional, cada símbolo possui um

valor fixo. Isso significa que o valor daquele símbolo não se altera em função
da posição que ele ocupa na composição do número e que normalmente não
tem relação com o valor da posição. O exemplo mais popular são os números
romanos, pois ainda são utilizados em relógios, eventos esportivos e outras
aplicações (FOROUZAN; MOSHARRAF, 2011). No conjunto de símbolos dos
numerais romanos temos I, V, X, L, C, D e M. Observe no quadro a seguir os
símbolos com seus respectivos valores.
QUADRO 1 – EXEMPLO DE ALGARISMOS ROMANOS

Valor 1 5 10 50 100 500 1000
Símbolo I V X L C D M
FONTE: A autora
O quadro a seguir apresenta alguns exemplos de números romanos e seus

respectivos valores na base decimal, para melhor entendimento dos sistemas de
numeração não posicionais.
QUADRO 2 – EXEMPLOS DE ALGARISMOS ROMANOS
III 3
IV 4
VIII 8
XIX 19
LXXII 72
CI 101
MMVII 2007
FONTE: A autora
Num sistema de numeração posicional, o local em que um algarismo

ocupa na representação do valor numérico determina o valor que ele representa
(FOROUZAN; MOSHARRAF, 2011). Para nosso entendimento, pensar em
unidade, dezena e centena, por exemplo, facilita a compreensão do princípio
destes sistemas de numeração. Já nos sistemas de numeração não posicionais, o
valor representado por um algarismo não se altera em função do local em que
ele está posicionado na representação. Um exemplo simples desse grupo são os
algarismos romanos.
3 SISTEMA DE NUMERAÇÃO DECIMAL

O sistema de numeração decimal, ou de base 10 (dez), foi criado na
antiguidade, motivado pelo fato dos seres humanos possuírem dez dedos (BOYER,
1996). Pelo fato de não haver dispositivos de auxílio aos cálculos, as pessoas se
68
TÓPICO 1 | SISTEMAS DE NUMERAÇÃO
valiam dos dedos para realizar contagens. Se analisarmos o comportamento dos

seres humanos contemporâneos, veremos que ainda fazemos isso, talvez por
instinto ou herança genética.
O sistema de numeração decimal utiliza 10 (dez) algarismos em sua

representação. Os algarismos são: 0, 1, 2, 3, 4, 5, 6, 7, 8 e 9. Os algarismos utilizados
neste sistema de numeração também são tipicamente chamados de dígitos decimais
ou apenas de dígitos (FOROUZAN; MOSHARRAF, 2011).
A formação dos números de base decimal segue o princípio posicional.

A formação dos números baseada no princípio posicional se dá pela potência da
posição elevada pela base, iniciando da direita para a esquerda a partir da potência
zero. Isso significa dizer que a unidade é formada pelo algarismo multiplicado
pela base elevada à potência zero. Utilizando como exemplo o algarismo 7 (sete),
teremos a unidade sete formada da seguinte maneira: 7 x 100 = 7. O resultado
da base 10 (dez) elevada à potência 0 (zero) será 1 (um), pois qualquer número
elevado à potência 0 (zero) resulta no valor 1 (um). Então, o valor 7 (sete) será
multiplicado por 1 (um), resultando no próprio 7 (sete).
4 SISTEMA DE NUMERAÇÃO BINÁRIO

O sistema de numeração binário, ou de base 2 (dois), utiliza apenas os
algarismos 0 (zero) e 1 (um) na sua representação. Neste sistema de numeração, os
algarismos são tipicamente chamados de dígitos binários ou apenas de bits, que é
a abreviação de dígito binário na língua inglesa, ou seja, binary digit (FOROUZAN;
MOSHARRAF, 2011).
Partindo do princípio matemático de formação dos números, podemos

criar a seguinte relação:
FIGURA 22 – PARALELO DE VALORES BINÁRIOS E DECIMAIS
Binário Decimal
000 = 0
001 = 1
010 = 2
011 = 3
100 = 4
FONTE: A autora
É importante observar que, da mesma forma como os símbolos são repetidos

na quantidade de vezes relativa à sua posição na representação decimal, no sistema
binário ocorre a mesma coisa. Observe na figura anterior que na coluna mais da
69
direita os símbolos variam de 1 (um) em 1 (um). Já na segunda coluna da direita

para a esquerda, eles variam de 2 (dois) em 2 (dois). Na terceira coluna os símbolos
variam de 4 (quatro) em 4 (quatro) e assim ocorrerá sucessivamente para os demais.
A quantidade de vezes que um símbolo se repete é resultante da base

elevada à potência da posição ocupada pelo símbolo na representação numérica.
Para melhor entender este conceito, vamos calcular quantas vezes o símbolo que
está na terceira coluna deve ser repetido. Para chegar a este valor é só elevar a base
2 (dois) à respectiva potência da terceira coluna que é 2 (dois), ficando da seguinte
forma: 2² = 4.
5 SISTEMA DE NUMERAÇÃO OCTAL

O sistema de numeração octal, ou de base 8 (oito), utiliza os algarismos (0,
1, 2, 3, 4, 5, 6 e 7) para sua representação. Observe que a quantidade de algarismos
é 8 (oito), mas o maior símbolo é o 7 (sete), pois inicia de 0 (zero).
Exemplo de codificação octal:
FIGURA 23 – PARALELO DE VALORES OCTAIS E DECIMAIS
Octal Decimal
12 = 10
23 = 19
35 = 29
FONTE: A autora
O sistema de numeração octal é uma notação abreviada em que cada dígito

representa um conjunto de 3 (três) dígitos binários. Este sistema de numeração
é utilizado para mostrar o equivalente do sistema binário fora do computador
(FOROUZAN; MOSHARRAF, 2011).
A utilização do sistema de numeração octal na computação se deu

efetivamente em função dessa característica, pois é muito mais simples para nós
humanos tratarmos com abreviações de binários do que com todo o conjunto
de binários envolvidos numa representação de dados. O sistema de numeração
octal foi, portanto, utilizado por profissionais da área de computação/
informática como uma importante ferramenta para a abreviação do conjunto
de bits sendo manipulados.
70
6 SISTEMA DE NUMERAÇÃO HEXADECIMAL

O sistema de numeração hexadecimal, ou de base 16, utiliza 16 (dezesseis)
algarismos para sua representação. São eles (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E,
F). Os algarismos A, B, C, D, E e F representam, respectivamente, os valores 10,
11, 12, 13, 14 e 15. Forouzan e Mosharraf (2011) relatam que o nome do sistema de
numeração hexadecimal possui raízes no grego e no latim, pois é derivado da raiz
grega hex (seis) e da raiz latina decem (dez).
Exemplo de codificação hexadecimal:
FIGURA 24 – PARALELO DE VALORES HEXADECIMAIS E DECIMAIS
Hexadecimal Decimal
47 = 71
68 = 104
75 = 117
FONTE: A autora
Da mesma forma como o sistema de numeração octal, o hexadecimal é

utilizado como uma notação abreviada para representar um conjunto de 4 (quatro)
dígitos binários. Isso ocorre pelo fato do sistema de armazenamento utilizado nos
computadores não ter relação direta com o sistema decimal. Os computadores
utilizam dígitos binários, porém para os humanos poderem ler tais dígitos pode
ser excessivamente extenso na maioria dos casos, logo utiliza-se o hexadecimal.
O hexadecimal possui uma relação com o binário, pois é resultante da potência 4
(quatro) sobre a base 2 (dois), ou seja, 24 = 16.
Atualmente a forma abreviada do binário mais utilizada é o hexadecimal.

Isso se dá pelo fato da maioria dos sistemas computacionais não utilizarem mais 8
bits em seus circuitos. A grande maioria utiliza 16, 32 e 64 bits nos circuitos, logo, o
sistema hexadecimal se mostra bastante conveniente.
7 CONVERSÕES ENTRE SISTEMAS DE NUMERAÇÃO

A necessidade de conversão de valores entre os sistemas de numeração
tornou-se uma consequência natural. Nós humanos entendemos com naturalidade
apenas o sistema de numeração decimal, porém os computadores trabalham
com o sistema binário. Para permitir que humanos utilizem valores decimais e
computadores utilizem valores binários é necessário que o valor seja convertido de
um sistema de numeração para outro.
Em função dessa necessidade e da importância do entendimento deste

conteúdo, estudaremos as formas de conversões entre os sistemas de numeração
decimal, binário, octal e hexadecimal.
71
Iniciaremos convertendo do sistema de numeração decimal para os

demais sistemas (binário, octal e hexadecimal). Em seguida você aprenderá como
converter de outros sistemas de numeração para o decimal e também entre os
demais sistemas.
8 CONVERSÃO DE DECIMAL PARA BINÁRIO

A conversão de números representados no sistema decimal para o sistema
de numeração binário é efetuada através de divisões sucessivas do número decimal
pela base binária (2), até que se obtenha o quociente 0. Os restos das divisões
tomados da direita para a esquerda é que formarão o número binário resultante.
Divisões sucessivas:
FIGURA 25 – EXEMPLO DE CONVERSÃO DE DECIMAL PARA BINÁRIO
FONTE: A autora
O exemplo apresentado na figura anterior demonstra que o valor inicial

14 é primeiramente dividido por dois, obtendo-se como quociente o valor 7. O
valor 7 multiplicado pela base 2 resulta em 14. Subtraindo-se 14 do valor inicial o
resultado será resto = 0. É esse zero com os demais restos obtidos no processo de
conversão que formarão o número binário resultante.
72
9 CONVERSÃO DE DECIMAL PARA OCTAL

Da mesma forma como a conversão para binário, a conversão de números
representados no sistema decimal para o sistema de numeração octal pode ser
efetuada através do método de divisões sucessivas.
FIGURA 26 – EXEMPLO DE CONVERSÃO DE DECIMAL PARA OCTAL
FONTE: A autora
A diferença neste caso resulta apenas no fato da divisão estar sendo

realizada pela base em uso atualmente, ou seja, a base octal (8). Neste caso, os
valores dos possíveis restos variam de 0 até 7. Perceba que o algarismo 0 (zero)
tem muita importância na computação. A importância é muito maior daquela que
talvez você imaginaria que um simples 0 (zero) pudesse ter.
10 CONVERSÃO DE DECIMAL PARA HEXADECIMAL

A conversão de números representados no sistema decimal para o sistema
de numeração hexadecimal pode ser efetuada através de divisões sucessivas pelo
valor da base, ou seja, 16 (dezesseis).
73
FIGURA 27 – EXEMPLO DE CONVERSÃO DE DECIMAL PARA

HEXADECIMAL
FONTE: A autora
O processo de divisões sucessivas do número 175 resultou em dois restos.

O primeiro resto obtido foi o valor 15 e o segundo o valor 10. Porém, quando
se está tratando de um algarismo que deve representar o valor de uma posição
num sistema de numeração posicional, não é possível que sejam utilizados dois
algarismos para tal propósito. É justamente por este motivo que a partir do valor
10 (dez) o sistema de numeração hexadecimal utiliza os algarismos A, B, C, D, E e
F na sua representação. Com base nisso, o valor resultante da conversão realizada
na Figura 27 é AF. O A se refere ao valor 10 (dez) do segundo resto obtido e o F se
refere ao valor 15 (quinze) do primeiro resto obtido.
Parece estranho para você um sistema de numeração que utiliza letras

em sua representação? Realmente, é estranho. Parece que voltamos ao passado
anterior à popularidade do sistema de representação hindu-arábico, quando se
utilizavam letras para representar valores. Estranho ou não, o importante é que
o sistema hexadecimal é extremamente útil para os profissionais da computação.
11 CONVERSÃO DE BINÁRIO PARA DECIMAL

A conversão de números representados no sistema octal para o sistema de
numeração decimal pode ser efetuada utilizando-se o método da soma dos termos,
conforme demonstrado na figura a seguir.
74
FIGURA 28 – EXEMPLO DE CONVERSÃO DE BINÁRIO PARA DECIMAL
FONTE: A autora
O cálculo também pode ser efetuado utilizando-se o método denominado

valores de posições. Este método consiste em multiplicar cada um dos dígitos pelo
valor da sua posição. Veja na figura a seguir um exemplo de uso deste método.
FIGURA 29 – EXEMPLO DE CONVERSÃO DE BINÁRIO PARA DECIMAL
FONTE: A autora
Este método dispensa a necessidade de detalhar tanto o cálculo, pois

sempre que houver um dígito zero, o valor resultante será zero. Isso implica no
fato de que interessam para fins de cálculo apenas as posições em que houver
valor 1 (um). Multiplicando-se os valores 1 pelo respectivo valor de sua posição e
somando-os, se obterá o valor correspondente na base 10.
12 CONVERSÃO DE OCTAL PARA DECIMAL

A conversão de números representados no sistema octal para o sistema de
numeração decimal pode ser efetuada utilizando-se o método da soma dos termos,
conforme demonstrado na figura a seguir.
75
FIGURA 30 – EXEMPLO DE CONVERSÃO DE OCTAL PARA DECIMAL
FONTE: A autora
Esta conversão também pode ser efetuada utilizando-se o método de

operações sucessivas e alternadas de multiplicação e adição. Veja na figura a seguir
a demonstração de como proceder.
FIGURA 31 – EXEMPLO DE CONVERSÃO DE OCTAL PARA

DECIMAL
FONTE: A autora
O método de operações sucessivas e alternadas de multiplicação e adição

permite que o valor octal possa ser facilmente convertido para a base decimal. Este
método consiste na multiplicação do primeiro algarismo octal da esquerda pela
base 8 (oito) e em seguida somando o valor do algarismo seguinte. No caso do
exemplo, o valor 4 foi multiplicado por 8, resultando em 32. A estes 32 foi somado
o valor do próximo dígito, que é 5.
76
O resultado da soma de 32 e 5 foi novamente multiplicado por 8 e o dígito

seguinte somado. Este processo deve ser repetido até que todos os números de
origem tenham sido utilizados. Chegando-se ao cálculo que envolveu o último dos
números, chegou-se também ao resultado da conversão.
Esta conversão também pode ser efetuada através do método de operações

sucessivas e alternadas de multiplicação e adição.
13 CONVERSÃO DE HEXADECIMAL PARA DECIMAL

A conversão de números representados no sistema hexadecimal para o
sistema de numeração decimal pode ser efetuada através do método da soma dos
termos, conforme apresentado na figura a seguir.
FIGURA 32 – EXEMPLO DE CONVERSÃO DE HEXADECIMAL PARA DECIMAL
FONTE: A autora
Esta conversão também pode ser efetuada através do método de operações

sucessivas e alternadas de multiplicação e adição.
FIGURA 33 – EXEMPLO DE CONVERSÃO DE HEXADECIMAL

PARA DECIMAL
FONTE: A autora
77
Da mesma forma como na conversão de octal para decimal, na conversão

de hexadecimal para decimal pode-se utilizar o método de operações sucessivas e
alternadas de multiplicação e adição. Na conversão de hexadecimal para decimal, o
uso deste método faz ainda mais sentido, caso o profissional não disponha de uma
calculadora que realize as conversões.
14 REGRAS DE FIXAÇÃO
Após ter estudado estes métodos de conversão, pode-se perceber que as
conversões podem ser divididas em duas categorias. A primeira categoria é a das
conversões de valores do sistema de numeração decimal para outros sistemas de
numeração. E a segunda categoria, a das conversões de valores de outros sistemas
de numeração para o decimal. Poderíamos argumentar ainda que há uma terceira
categoria, que seria a das conversões entre sistemas de numeração que não envolvem
o sistema decimal, porém, se considerarmos que todas as conversões podem ser
realizadas convertendo-se primeiramente para o decimal e em seguida para o sistema
de numeração destino, podemos considerar a existência de apenas duas categorias.
Ao convertermos um número da base decimal para outra base qualquer,

utilizamos a operação de divisão. Para obter-se o equivalente ao valor decimal
na base para a qual se deseja converter, realiza-se divisões sucessivas do valor
decimal tantas vezes quantas possíveis. Após esta sucessão de divisões, agrupam-
se os restos das divisões tomados da direita para a esquerda, transcrevendo-os. A
reunião dos restos das divisões é que formará o valor convertido na base destino.
Estas regras de fixação são importantes para que você não esqueça a forma
de realização das conversões entre sistemas de numeração. Porém, no seu dia a dia
profissional é muito provável que utilize calculadoras científicas, as quais realizam
estas operações de forma simples e rápida.
78
FIGURA 34 – CALCULADORA WINDOWS NO MODO PROGRAMADOR
FONTE: A autora
79
RESUMO DO TÓPICO 1
Mais uma etapa foi cumprida! Nesse tópico você estudou que:
• Os sistemas de numeração são divididos em dois grupos: os sistemas de

numeração não posicionais e os sistemas de numeração posicionais.
• Nos sistemas de numeração não posicionais, os valores dos símbolos ou

algarismos utilizados não se alteram em função da posição que eles ocupam na
composição do valor. Isso significa que o valor de um determinado símbolo será
sempre o mesmo, independentemente da posição que ele ocupar na formação
do número.
• Os sistemas de numeração posicionais, como é o caso do sistema de numeração

decimal, são ligeiramente diferentes. Neles, a posição do símbolo ou algarismo
na formação do número é que indica o seu valor. Isso significa que um algarismo
7 na posição mais à direita do número terá valor de unidade e que uma posição
à esquerda terá valor de dezena, centena, milhar e assim por diante.
• Para converter um número decimal para binário, octal ou hexadecimal é utilizada

uma sucessão de divisões e subtrações pelo valor da respectiva base, obtendo-
se os restos destas operações. Os restos das operações sucessivas de divisões
e subtrações, tomados da direita para a esquerda, é que formarão o número
resultante na base binária, octal ou hexadecimal.
• Para converter um número de binário, octal ou hexadecimal para decimal é

utilizada uma sucessão de multiplicações pela respectiva base e somas.
80
AUTOATIVIDADE
Agora vamos praticar:
1 Converta os números binários para decimal:
a) (101)2
b) (100111)2
2 Converta os números abaixo de decimais para a base binária:
a) 10110
b) 4010
3 Converta os números abaixo de decimais para a base octal:
a) 14410
b) 4310
81
82
UNIDADE 2 TÓPICO 2
BASES COMPUTACIONAIS
1 INTRODUÇÃO
Um sistema computacional é formado por diversos elementos que devem
funcionar harmoniosamente. Estes elementos são formados tanto por dispositivos
físicos, denominados de hardware (já estudado na Unidade 1), quanto de dispositivos
virtuais, denominados de software.
A base de um sistema computacional é formada por dois elementos

fundamentais. O primeiro se refere aos equipamentos físicos, sem os quais não
existiria um sistema computacional. Estes equipamentos sofrem constante
evolução e atualização.
O segundo importante elemento que forma a base de um sistema

computacional é o sistema operacional. Não é incomum ver profissionais da
área de computação discutindo fragilidades de seus sistemas computacionais,
comparando-os segundo os sistemas operacionais utilizados.
Da mesma forma como a tendência de utilização de dispositivos cada vez

menores e móveis, os sistemas operacionais tendem a prover recursos para atender
às novas demandas de uso da sociedade. Os sistemas operacionais precisam ter
capacidade para suportar novas e diferentes funcionalidades de maneira cada vez
mais rápida e eficiente.
Para potencializar estes elementos existem as redes de computadores, as

quais permitem o uso adequado dos dispositivos para realização das comunicações
e obtenção e compartilhamento de informações. As redes de computadores
possuem diferentes abrangências e finalidades, que serão estudadas neste tópico.
83
2 ARQUITETURA DE COMPUTADORES
Relembrando um pouco da Unidade 1, a arquitetura de computadores também
é tipicamente referenciada por arquitetura e organização de computadores, pois trata
da forma como os elementos físicos de um sistema computacional estão dispostos ou
organizados. Em relação à organização, os computadores podem ser divididos em três
categorias ou subsistemas: a Unidade Central de Processamento, a memória principal
e o subsistema de entrada e saída (FOROUZAN; MOSHARRAF, 2011).
A Unidade Central de Processamento, também referenciada por UCP ou

CPU (Central Process Unit), é o dispositivo destinado à realização de operações sobre
dados. Tipicamente, a CPU está organizada em três partes: unidade de aritmética e
lógica, unidade de controle e os registradores (FOROUZAN; MOSHARRAF, 2011).
A unidade de aritmética e lógica, também conhecida pela sigla ULA, é

responsável pelas atividades que envolvem operações lógicas, por exemplo, as
operações AND (e), OR (ou), NOT (não) e XOR (ou exclusivo). Esta unidade
também realiza operações de deslocamento e operações aritméticas sobre os
dados. A unidade de controle é quem realiza o controle do funcionamento
de cada subsistema. Já os registradores são localizações que armazenam os
dados temporariamente para a realização de operações sobre eles. Os três tipos
de registradores comumente encontrados nas arquiteturas modernas são os
registradores de dados, os registradores de instrução e o contador de programa
A memória principal é a área para a qual são carregados dados e programas.

Ela consiste de um conjunto de localizações únicas denominadas endereços. As
memórias podem ser organizadas com base em diferentes grupos de bits. Esta
quantidade de bits é denominada de palavra. Nos atuais computadores são
encontradas palavras formadas por grupos de 8, 16, 32 ou 64 bits (FOROUZAN;
MOSHARRAF, 2011).
O subsistema de entrada/saída é responsável pela comunicação do

computador com o mundo externo e pelo armazenamento de programas e dados. Este
subsistema pode ser dividido em duas categorias: dispositivos de armazenamento
e dispositivos sem armazenamento. Os dispositivos de armazenamento, também
chamados de dispositivos de armazenamento auxiliar, permitem armazenamento de
grandes quantidades de dados para posterior utilização. É o conjunto de dispositivos
que utilizamos para guardar os dados de forma permanente. Já os dispositivos sem
armazenamento são utilizados para a comunicação do computador com outros
dispositivos, porém não realizam o armazenamento de dados (FOROUZAN;
MOSHARRAF, 2011).
84
TÓPICO 2 | BASES COMPUTACIONAIS
3 SOFTWARE
O computador é um sistema composto por duas partes importantes:
hardware e software (FOROUZAN; MOSHARRAF, 2011). O hardware é composto
pelos equipamentos físicos, ou seja, pelas máquinas e demais equipamentos
ligados ao computador. Já o software é composto pelo conjunto de programas que
são executados neste hardware.
3.1 CATEGORIAS DE SOFTWARE

Um computador para realizar uma tarefa específica, precisa ser instruído
passo a passo para realizar a tarefa. Ele necessita ser projetado com a capacidade
de realizar, ou seja, interpretar e executar um determinado conjunto de operações,
cada uma sendo constituída de uma instrução específica, a qual chamamos de
instrução de máquina. Este conjunto de instruções ou comandos organizados
em uma certa sequência para obter um resultado compõe o que denominamos
programa de computador (MONTEIRO, 2014).
O conjunto de softwares existentes pode ser dividido em categorias. As

principais categorias de software existentes são conhecidas como softwares básicos,
softwares utilitários, softwares aplicativos e ferramentas de desenvolvimento.
3.1.1 Softwares básicos

Na categoria de softwares básicos estão principalmente os sistemas
operacionais.
Sistema Operacional é um software ou um conjunto de programas cuja

função é servir de interface entre um computador e o usuário. É comum utilizar-se
a abreviatura SO (em português) ou OS (do inglês Operating System).
Um Sistema Operacional é complexo e em função disso é complexo também

defini-lo.
Forouzan e Mosharraf (2011) sugerem algumas definições comuns:
• Interface entre o hardware e o usuário;
• Programa que facilita a execução dos programas;
• Gerenciador que supervisiona as atividades dos componentes do sistema

computacional.
85
Um sistema operacional pode ser visto como um programa de grande

complexidade que é responsável por todo o funcionamento de uma máquina,
desde o software a todo hardware instalado na máquina. Todos os processos de
um computador estão por detrás de uma programação complexa que comanda
todas a funções que um utilizador impõe à máquina. Existem vários sistemas
operativos; entre eles, os mais utilizados no dia a dia, normalmente utilizados
em computadores domésticos, são o Windows, Linux e Mac OS X.
Um computador com o sistema operativo instalado poderá não dar acesso

a todo o seu conteúdo dependendo do utilizador. Com um sistema operativo,
podemos estabelecer permissões a vários utilizadores que trabalham com este.
Existem dois tipos de contas que podem ser criadas num sistema operativo, as
contas de Administrador e as contas limitadas. A conta Administrador é uma
conta que oferece todo o acesso à máquina, desde a gestão de pastas, fichários
e software de trabalho ou entretenimento ao controle de todo o seu Hardware
instalado. A conta Limitada é uma conta que não tem permissões para aceder
a algumas pastas ou instalar software que seja instalado na raiz do sistema ou
então que tenha ligação com algum Hardware que altere o seu funcionamento
normal ou personalizado pelo Administrador. Para que este tipo de conta possa
ter acesso a outros conteúdos do disco ou de software, o administrador poderá
personalizar a conta oferecendo permissões a algumas funções do sistema como
também poderá retirar acessos a certas áreas do sistema.
O sistema operativo funciona com a iniciação de processos que este irá

precisar para funcionar corretamente. Esses processos poderão ser fichários
que necessitam ser frequentemente atualizados, ou fichários que processam
dados úteis para o sistema. Poderemos ter acesso a vários processos do sistema
operativo a partir do gestor de tarefas, onde se encontram todos os processos
que estão em funcionamento desde o arranque do sistema operativo até a sua
utilização atual. Pode-se também visualizar a utilização da memória por cada
processo, no caso de o sistema operativo começar a mostrar erros ou falhas de
acesso a programas tornando-se lento, pode-se verificar no gestor de tarefas
qual dos processos estará bloqueado ou com elevado número de processamento
que está afetando o funcionamento normal da memória.
Um sistema operacional possui as seguintes funções: (i) gerenciamento

de processos; (ii) gerenciamento de memória; (iii) sistema de arquivos; (iv)
entrada e saída de dados.
O sistema operacional multitarefa é preparado para dar ao usuário a

ilusão de que o número de processos em execução simultânea no computador
é maior que o número de processadores instalados. Cada processo recebe uma
fatia do tempo e a alternância entre vários processos é tão rápida que o usuário
pensa que sua execução é simultânea.
86
São utilizados algoritmos para determinar qual processo será executado

em determinado momento e por quanto tempo.
Os processos podem comunicar-se — isto é conhecido como IPC (Inter-

Process Communication) — e, em geral, os mecanismos utilizados são: sinais, pipes,
named pipes, memória compartilhada, soquetes (sockets), semáforos, trocas de
mensagens.
O sistema operacional, normalmente, deve suportar multiprocessamento

(SMP ou NUMA). Neste caso, processos diferentes e threads podem ser executados
em diferentes processadores. Para que um sistema operacional suporte este
tipo de sistema, ele deve ser amplamente modificado para ser reentrante e
interruptível, o que significa que ele pode ser interrompido no meio da execução
de uma tarefa.
O sistema operacional tem acesso completo à memória do sistema e

deve permitir que os processos dos usuários tenham acesso seguro à memória
quando o requisitam.
Vários sistemas operacionais usam memória virtual, que possui três

funções básicas: (i) assegurar que cada processo tenha seu próprio espaço de
endereçamento, começando em zero — problema de relocação (TANENBAUM,
1999); (ii) proteção de memória, para impedir que um processo utilize um
endereço de memória que não lhe pertença; (iii) possibilitar que uma aplicação
utilize mais memória do que a fisicamente existente (essa é a função mais óbvia).
FONTE: Disponível em: <http://aa-cienciasdacomputacao.wikidot.com/sistema-operacional>.

3.1.2 Softwares utilitários

Utilitários são programas utilizados para suprir deficiências dos sistemas
operacionais ou como ferramentas auxiliares aos mesmos. Sua utilização poderá
depender de licenças pagas, mas existem vários utilitários livres. Podemos incluir
nos utilitários programas para compactação de dados, aumento de desempenho de
máquinas, overclock, limpeza de discos rígidos, acesso à internet, compartilhamento
de conexões, entre outros.
3.1.3 Softwares aplicativos

Software aplicativo (ou aplicativo ou ainda aplicação) é um programa de
computador que tem por objetivo o desempenho de tarefas de índole prática,
em geral ligadas ao processamento de dados, como o trabalho em escritório
ou empresarial. A sua natureza é, portanto, diferente da de outros tipos de
87
software, como sistemas operacionais e ferramentas a eles ligadas, jogos e

outros softwares lúdicos, entre outros.
FONTE: Disponível em: <http://www.ldsystem.com.br/servicos.aspx>.
Aplicativos, portanto, podem ser utilizados em diversas áreas de

negócios. No cálculo de estruturas, planejamento e controle de projetos, pesquisas
operacionais, problemas de engenharia de software. Na automação industrial,
programação e controle de máquinas e equipamentos, controle de processos e
calibração. Na automação comercial com reserva de passagens, contas correntes,
pontos de venda, caixas automáticos. No apoio educacional como assistência a
instruções e ensino auxiliado pelo computador. Em situações especiais e científicas
como teleprocessamento, comunicações, militares, pesquisas espaciais, pesquisas
meteorológicas. No ramo artístico em composição de imagens, sons, músicas,
vídeos. No entretenimento com a execução de jogos, entre outros.
3.1.4 Ferramentas de desenvolvimento

As ferramentas de desenvolvimento são uma categoria especial de software,
pois são utilizadas para produzir novos softwares. Ferramentas de desenvolvimento
podem compreender diversos softwares para as mais diversas atividades do
desenvolvimento. Em geral as ferramentas de desenvolvimento que mais são
consideradas são os softwares conhecidos como compiladores.
Quando se quer converter uma linguagem de máquina, um programa escrito

em linguagem de mais alto nível, então o método utilizado se chama compilação.
Compilação é o processo de análise de um programa escrito em linguagem

de alto nível, o programa fonte ou código-fonte e sua conversão, ou seja, tradução
em um programa equivalente, porém descrito em linguagem binária de máquina.
O programa que realiza esta tarefa é denominado compilador.
A compilação é um processo que analisa o programa fonte, cria tabelas

auxiliares e gera o código-objeto final em linguagem de máquina. Durante a compilação
o código-fonte é analisado, comando por comando, o programa compilador realiza
várias tarefas, dependendo do tipo de comando que ele esteja analisando.
Após a análise é gerado um código intermediário e são construídas várias

tabelas, como a tabela de símbolos que auxiliará a realização da segunda fase, que
é a fase de efetiva criação do código binário de máquina. Nesta segunda fase, o
módulo responsável do compilador aloca memória para as variáveis e realiza a
atribuição dos registradores a serem utilizados, além da geração do código-objeto
final (MONTEIRO, 2014).
Para facilitar o trabalho dos desenvolvedores foram criadas as IDEs. A IDE

(Integrated Development Environment – Ambiente de Desenvolvimento Integrado) é
88
um programa de computador que reúne características e ferramentas de apoio ao

desenvolvimento de software com o objetivo de agilizar este processo.
Geralmente as IDEs unem a técnica de RAD (Rapid Application Development),

que consiste em permitir que os desenvolvedores obtenham um aproveitamento
maior, desenvolvendo código com maior rapidez. As características e ferramentas
mais comuns encontradas nas IDEs são editor, compilador, montador, depurador,
modelagem, gerador de código e distribuição.
O editor permite editar o código-fonte do programa na(s) linguagem(ns)

suportada(s) pela IDE. O compilador (compiler) permite compilar o código-fonte
do programa, editado em uma linguagem específica e a transforma em linguagem
de máquina. O montador (linker) organiza as várias partes do código-fonte,
compiladas em linguagem de máquina, em um programa executável que pode
ser rodado ou executado em um computador ou outro dispositivo computacional.
O depurador (debuger) auxilia no processo de encontrar e corrigir erros (bugs) no
código-fonte do programa, na tentativa de aprimorar a qualidade do software.
A modelagem (modeling) permite a criação do modelo de classes, objetos,

interfaces, associações e interações dos artefatos envolvidos no software com
o objetivo de solucionar as necessidades do software. A geração de código é a
característica mais explorada em ferramentas CASE. A geração de código também
é encontrada em IDEs, contudo com um escopo mais direcionado a modelos de
código comumente utilizados para solucionar problemas rotineiros. Todavia, em
conjunto com ferramentas de modelagem, a geração de código pode gerar todo
ou praticamente todo o código-fonte do programa com base no modelo proposto,
tornando muito mais rápido o processo de desenvolvimento e distribuição do
software. A distribuição (deploy) auxilia no processo de criação do instalador
do software, ou outra forma de distribuição, seja via discos ou via internet. As
ferramentas de testes automatizados (automated tests) realizam testes no software
com base em scripts ou programas de testes previamente especificados, gerando
um relatório dos mesmos, assim auxiliando na análise do impacto das alterações
no código-fonte. Ferramentas deste tipo mais comuns no mercado são chamadas
robôs de testes. A refatoração (refactoring) consiste na melhoria constante do
código-fonte do software, seja na construção de código mais otimizado, mais
limpo e/ou com melhor entendimento pelos envolvidos no desenvolvimento
do software. A refatoração, em conjunto com os testes automatizados, é uma
poderosa ferramenta no processo de erradicação de bugs, tendo em vista que
os testes visam garantir o mesmo comportamento externo do software ou da
característica sendo reconstruída.
4 REDES DE COMPUTADORES
Na sociedade contemporânea a confiabilidade e qualidade da informação
são fatores de importância fundamental. Mais e mais informações têm sido geradas
e utilizadas na tomada de decisões, tanto em nível pessoal quanto profissional,
89
definindo muitas vezes o sucesso de uma organização ou mesmo de toda uma nação.
Toda essa informação armazenada serve como uma grande base de conhecimento
que pode ser atualizada, consultada e utilizada para as mais diversas finalidades,
objetivando a melhoria da qualidade de vida de toda a sociedade.
O valor da informação demonstra a importância do papel que as

telecomunicações e a informática têm na sociedade atual. Esta estrutura permite que
as pessoas se comuniquem de forma mais rápida e confiável e, em consequência,
impulsionando o crescimento econômico do mundo como um todo. Esta
característica faz com que a dependência dos sistemas de comunicação também se
torne maior, o que exige também que estes sistemas se tornem mais eficientes, de
forma a permitir que as empresas produzam e vendam mais e, consequentemente,
gerem mais empregos e renda.
Devido ao fato da quantidade de informação ser muito grande, é importante

também a criação de mecanismos que permitam selecionar entre toda informação
disponível o que realmente é importante para a finalidade em que se está focado.
Isto nos leva à situação em que, tão importante quanto o armazenamento e
transmissão de informações, é a sua interpretação e compreensão. Para que haja
a devida transmissão e recepção de informação de forma que a mesma possa ser
corretamente interpretada e compreendida, é necessário que seja seguido um
conjunto de símbolos e regras previamente estabelecidos utilizados como meio
de codificação para o transporte desta informação. Este conjunto de códigos e
regras previamente estabelecidos é o que podemos entender como uma espécie de
protocolo de comunicação.
Os meios de comunicação, assim como a informática, evoluíram muito nas

últimas décadas e ainda continuam em franco desenvolvimento. Equipamentos
e tecnologias têm sido substituídos cada vez com mais frequência por outros de
menor custo e maiores capacidades.
Em paralelo, existem maiores possibilidades de utilização de

equipamentos de diferentes fabricantes na mesma base de infraestrutura,
permitindo que o crescimento seja mais flexível e econômico.
Num esquema de comunicação em que há um emissor e um receptor, pode-

se ter tanto pessoas quanto equipamentos utilizando uma linguagem conhecida de
ambos, permitindo o entendimento das mensagens transmitidas. Num processo
de comunicação existem quatro elementos básicos que devem ser considerados.
Estes elementos são o emissor, a informação, o meio através do qual a informação
é transmitida e o destinatário. Em algumas situações pode ser necessária ainda a
utilização de uma interface para facilitar o processo.
Para que a transmissão de dados ocorra é necessário que haja passagem

de sinais através de meios físicos de comunicação, os quais compõem o que
denominamos de redes. As questões de tecnologia que influenciam no projeto e
construção de redes têm certa relação com as propriedades físicas dos meios de
transmissão e também das características dos sinais transmitidos (SOARES, 1995).
90
Os sinais podem ser entendidos como ondas que são propagadas através de
algum meio físico, o qual pode ser um cabo, o ar ou outros meios disponíveis. Para
que o processo de transmissão de informação ocorra, há necessidade da execução
de uma sucessão de processos, os quais são relacionados a seguir:
• A geração de um conteúdo a ser transmitido;

• A codificação deste conteúdo em um conjunto bem definido de símbolos;
• Esta codificação do conteúdo deve atender aos critérios necessários para que
possa ser transmitido adequadamente através do meio físico utilizado;
• A realização da transmissão do conteúdo;
• A decodificação do conteúdo transmitido e a reprodução do mesmo;
• A recriação do conteúdo que foi transmitido, mesmo que haja certo grau de
degradação da qualidade do conteúdo para o entendimento do destinatário.
Na transmissão de dados em redes, podemos classificar os sinais em dois

tipos: sinais analógicos e sinais digitais. A Figura 35 representa a forma de variação
de um determinado sinal analógico. A Figura 36 representa a forma de variação
de um determinado sinal digital. Na transmissão de dados os tipos de sinais
mais comumente utilizados são o analógico e o digital. A denominação do sinal
analógico está associada à característica do sinal de ter uma variação contínua no
tempo. Já a denominação do sinal digital está associada à característica do sinal de
ter uma variação denominada discreta, ou seja, com variações em forma de pulsos.
FIGURA 35 – REPRESENTAÇÃO DE UM SINAL ANALÓGICO
FONTE: Disponível em: <http://cgrbrasil.com.br/artigos/diferenca-entre-sinal-

digital-e-analogico/>. Acesso em: 30 mar. 2016.
Ambos os termos são bastante utilizados quando a transmissão de dados é

o assunto em pauta. Estas definições permitem qualificar a natureza da informação
quanto à característica dos sinais utilizados para a transmissão através dos meios
físicos disponíveis.
91
FIGURA 36 – REPRESENTAÇÃO DE UM SINAL DIGITAL
FONTE: Disponível em: <http://cgrbrasil.com.br/artigos/diferenca-entre-sinal-

digital-e-analogico/>. Acesso em: 30 mar. 2016.
Para deixar mais clara a definição de analógico e digital, são apresentados

dois exemplos. Equipamentos como computadores armazenam, processam e
codificam dados em bits. Os bits permitem representar apenas os valores lógicos 0
ou 1 (zero ou um). A esta característica dos bits de representarem apenas os valores
0 ou 1 é atribuído o termo digital.
Equipamentos para emissão de som, por exemplo, representam sinais cuja

variação tem continuidade ao longo de um determinado espaço de tempo.
É importante observar que o tipo de informação a ser transmitida não

depende do tipo de sinal utilizado. Podem-se transmitir dados ou informações
que naturalmente são analógicos por meios digitais, da mesma forma que dados
naturalmente digitais podem ser transmitidos através de sinais analógicos.
Certamente, nesta situação há necessidade de conversão dos sinais de forma
adequada para que a transmissão possa ocorrer. Após a transmissão, este sinal deve
novamente ser convertido para retornar ao formato em que naturalmente é utilizado.
As redes de computadores estão cada vez mais presentes no dia a dia das
pessoas e instituições, através de diversos tipos de estruturas de organização.
Ao longo do desenvolvimento das redes de computadores foram empregadas
muitas teorias, modelos e técnicas para que se chegasse aos modelos disponíveis
atualmente. Além da aplicação das teorias, modelos e técnicas, também foi
necessário que muitos experimentos fossem realizados para provar a efetividade
de determinadas teorias, modelos e técnicas.
O crescimento das redes de computadores, e principalmente das redes de

longa distância, se dá pela importância que elas representam para as organizações
e pela quantidade de aplicações que dependem da comunicação de dados a longas
distâncias. Exemplos podem ser transações bancárias, compras de produtos e serviços,
bem como no campo do relacionamento humano, seja através da disponibilização
de informações, pelo ensino remoto ou pela comunicação escrita ou falada.
92
As tecnologias atuais de redes de computadores, em geral, são classificadas

em três grandes categorias. O parâmetro utilizado para esta classificação está
associado ao tamanho da rede referenciada. Neste sentido, as redes podem ser locais,
metropolitanas ou de longa distância.
A figura a seguir ilustra a interligação destas redes.
FIGURA 37 – INTERLIGAÇÃO ENTRE REDES LOCAIS, METROPOLITANAS E DE LONGA DISTÂNCIA
FONTE: Senger (2016, p. 20)
As redes locais, também conhecidas como LAN (Local Area Network), são
redes que podem abranger um ou mais edifícios que estejam fisicamente próximos.
Delimitar uma rede local em uma distância máxima específica é relativamente
complicado, pois pode haver grandes organizações que tenham quilômetros de
extensão e mesmo assim a rede ser classificada como uma rede local (COMER, 2001).
A segunda categoria de redes, as metropolitanas, também referenciadas

por MAN (Metropolitan Area Network), são redes que em geral cobrem a área física
de uma cidade ou de uma região metropolitana (COMER, 2001).
Finalmente, as redes de longa distância, também referenciadas por WAN (Wide

Area Network), são redes que podem abranger múltiplas cidades, países ou continentes
(COMER, 2001).
Em relação à abrangência, as redes podem ser classificadas em intranet,

internet e extranet. A intranet é uma rede privada de uma organização que se
vale da tecnologia da internet e que permite prover uma série de serviços que em
geral facilitam o dia a dia dos usuários. A tecnologia da intranet está baseada nos
mesmos dispositivos, serviços e protocolos utilizados pela internet, possibilitando
melhorar a comunicação dentro da organização, além de melhorar a produtividade
dos profissionais.
93
Dentre as principais ferramentas que podem ser utilizadas na intranet está

o navegador (browser) e o banco de dados. A utilização do navegador facilita em
muito a questão de atualização de software e dispensa a necessidade de instalação
de softwares em todos os equipamentos em que o mesmo será utilizado. A utilização
do banco de dados proporciona acesso imediato a todas as informações necessárias,
além de permitir o registro de novas informações a qualquer momento.
Já a internet pode ser definida do ponto de vista dos componentes de

hardware software que a formam ou como uma infraestrutura de rede que fornece
serviços de forma distribuída (KUROSE, 2003). A internet do ponto de vista dos
componentes que a formam é uma rede de computadores de abrangência mundial,
que conecta uma quantidade incalculável de equipamentos de computação. A maior
parte dos componentes que formam esta gigantesca rede são microcomputadores,
servidores de rede, servidores de e-mail, servidores de aplicação, dentre outros
dispositivos de rede necessários para a comunicação.
A internet está baseada na infraestrutura das telecomunicações, no entanto,

existe uma diferenciação entre redes telefônicas e a internet. A internet provê serviços
através da comutação de pacotes, ou seja, sem necessidade de conexão fim-a-fim; já
os serviços telefônicos utilizam comutação por circuito na qual a conexão deve ser
estabelecida antes que a chamada telefônica possa ser iniciada.
Uma parte dos recursos da rede é reservada para a chamada, de modo que
nenhuma outra chamada possa utilizar aqueles recursos antes que a conexão seja
encerrada. A maior vantagem do uso da comutação de pacotes é o fato de permitir
que pacotes de diferentes fontes possam utilizar a mesma linha, permitindo
otimizar o uso dos recursos instalados.
O conjunto de redes que formam a internet é interligado por redes de alta

capacidade, denominadas backbone. Os backbones são canais de comunicação com
largura de banda bastante expressiva, permitindo o tráfego de grande volume
de dados. Além dos backbones, são utilizadas linhas telefônicas comuns, linhas
de comunicação privadas, satélites, cabos submarinos e diversos outros meios
de comunicação e telecomunicação, com o objetivo de estabelecer a troca de
informações e serviços.
A internet permite unir entidades de pesquisa, órgãos culturais, usuários

particulares, órgãos governamentais, bibliotecas e empresas. O controle da internet
é descentralizado, utilizando os protocolos TCP/IP como estrutura básica para
comunicação e serviços de rede.
Isto é devido ao fato da arquitetura TCP/IP fornecer não somente os

protocolos que habilitam a comunicação de dados entre redes, mas também possuir
uma série de características que contribuem para a eficiência da arquitetura.
94
Entre os serviços mais conhecidos da internet estão o correio eletrônico

(protocolos SMTP, POP), a transferência de arquivos (FTP), a emulação de terminal
remoto (Telnet) e acesso de informação em hipertexto (HTTP).
A extranet é uma extensão da intranet de uma organização. Através da

extranet é possível realizar atividades da intranet a partir de qualquer local que
tenha acesso à internet. As atividades que antes estavam disponíveis apenas na
intranet corporativa, agora podem ser realizadas a partir de qualquer lugar por
qualquer pessoa que tenha os direitos de acesso. O salto qualitativo em termos
de valor agregado aos negócios das organizações é praticamente incalculável, se
considerarmos a quantidade quase que ilimitada de diferentes oportunidades que
podem ser geradas pelo uso desta tecnologia.
A intranet, embora possa ser utilizada por uma grande quantidade de

usuários de uma corporação e abranger uma área geográfica considerável dentro
da mesma, é uma rede local que utiliza a tecnologia da internet. A internet é a rede
mundial de computadores que possibilita o compartilhamento de informações
entre as pessoas conectadas à ela. A internet é a maior rede de longa distância
existente na atualidade. Já a extranet é a fusão da intranet com a internet.
A evolução dos meios de comunicação tem tornado a extranet uma

importante ferramenta para os mais variados tipos de atividades profissionais. A
aceitação da extranet por parte dos usuários é facilitada pelo fato de utilizar a
mesma tecnologia da internet e esta ser de utilização relativamente comum pela
maioria dos profissionais atualmente.
Dentre as vantagens da utilização de uma extranet podem ser destacadas

a agilidade e facilidade na tramitação de informações entre parceiros, clientes e
fornecedores, facilidade no arquivamento digital de documentos, além da redução
no consumo de papel.
95
RESUMO DO TÓPICO 2
Chegamos ao final do Tópico 2. Neste tópico você estudou que:
• O Sistema Operacional é o principal software de qualquer computador, pois é ele

quem oferece uma interface entre o hardware e os demais softwares executados
no mesmo. Pode-se dizer que um computador sem Sistema Operacional é inútil,
pois não servirá mais do que de elemento de decoração.
• A comunicação é elemento essencial na sociedade contemporânea e grande parte

da comunicação é provida através das redes de computadores. É praticamente
impossível pensar numa organização que não tenha seus dados num servidor
de arquivos ou compartilhados entre diversas máquinas através de uma rede.
96
AUTOATIVIDADE
1 O software é composto pelo conjunto de programas executados pelo hardware.

Com relação à funcionalidade de cada software, associe os itens, utilizando o
código a seguir:
I- Software básico.
II- Software utilitário.
III- Software aplicativo.
( ) São softwares específicos para atividades como trabalho em escritórios,

empresas, entre outros.
( ) São softwares com função de gerenciar o computador, ou seja, são os
sistemas operacionais.
( ) São softwares auxiliares ao sistema operacional.
Agora, assinale a alternativa que apresenta a sequência CORRETA:
a) ( ) III - I - II.
b) ( ) I - II - III.
c) ( ) II - I - III.
d) ( ) III - II - I.
2 O trabalho dos desenvolvedores é facilitado com um programa que reúne

ferramentas de apoio de desenvolvimento de software. Com relação às
ferramentas de desenvolvimento de software, associe os itens, utilizando o
código a seguir:
I- Editor.
II- Compilador.
III- Montador.
IV- Depurador.
( ) Auxilia no processo de encontrar e corrigir erros.

( ) Permite editar o código-fonte.
( ) Organiza as várias partes do código-fonte.
( ) Edita a linguagem específica e a transforma em linguagem de máquina.
Agora, assinale a alternativa que apresenta a sequência CORRETA:
a) ( ) IV - I - III - II.
b) ( ) I - II - IV - III.
c) ( ) III - IV - II - I.
d) ( ) II - III - I - IV.
97
3 Para trabalharmos com o computador, precisamos de softwares. Os softwares
são divididos em quatro categorias: básicos, utilitários, aplicativos e
ferramentas de desenvolvimento. Descreva os softwares utilitários.
98
UNIDADE 2
TÓPICO 3
DADOS
1 INTRODUÇÃO
Para gerenciar a complexidade dos problemas e o processo de resolução
de problemas, os cientistas da computação usam abstrações, que lhes permitem
concentrar-se em uma “grande figura”, sem se perderem nos detalhes. Com a
criação de modelos de domínio do problema, somos capazes de utilizar um melhor
e mais eficiente processo de resolução de problemas. Esses modelos permitem
descrever os dados dos algoritmos de manipularão de uma forma mais consistente
no que diz respeito ao problema em si.
Um tipo de dado abstrato, por vezes abreviado TAD, é uma descrição

lógica de como podemos ver os dados e as operações que são permitidas sem
levar em conta a forma como eles serão implementados. Isto significa que estamos
preocupados apenas como os dados são representados e não com a forma como ele
acabará por ser construído. Ao fornecer este nível de abstração, estamos criando
um encapsulamento em torno dos dados. A ideia é que, ao encapsular os detalhes
da implementação, estamos escondendo-os de vista do usuário. Isso é chamado de
ocultação de informação.
A implementação de um tipo de dado abstrato, muitas vezes referida como

uma estrutura de dados, vai exigir que nós forneçamos uma visão física dos dados
usando alguma coleção de construções de programação e tipos de dados primitivos.
A separação entre essas duas perspectivas nos permitirá definir os modelos de
dados complexos para nossos problemas sem dar qualquer indicação sobre os
detalhes de como o modelo vai realmente ser construído. Isso proporciona uma
visão independente da implementação dos dados. Normalmente haverá muitas
maneiras diferentes de implementar um tipo de dado abstrato, esta independência
de implementação permite que o programador mude os detalhes da implementação
sem alterar a maneira como o usuário interage com ele. O usuário pode manter o
foco sobre o processo de resolução de problemas.
99
Neste tópico entenderemos esta estrutura de dados para a implementação

e discutiremos vários tipos abstratos de dados.
2 ENTENDENDO O TIPO ABSTRATO DE DADOS

Processamos dados para resolver problemas de computador e para isso
acontecer é necessário definir o tipo de dado e a operação a ser realizada com ele.
Esta definição do tipo de dados e da operação a ser aplicada aos dados é parte de
um tipo abstrato de dados (TAD). O usuário de um TAD apenas necessita saber
que um conjunto de operações está disponível para o tipo de dados, mas não como
elas são realizadas.
Podemos classificar os TADs como simples e complexos.
Os TADs simples são parte integrante de muitas linguagens de programação.

Podemos ter como referência um elemento com domínio e conjunto de operações
predefinido. Como exemplo podemos citar a linguagem C que estabelece um TAD
simples, chamado inteiro, que define números inteiros com alcances predefinidos.
Outros exemplos de TADs simples que podemos citar são os números reais,
caractere, ponteiro, entre outros.
O que acontece com os TADs simples não acontece com muitos TADS
complexos e úteis. Precisamos de um TAD para lista, outro para pilha, outro para fila
e assim por diante. Os TADs para terem eficiência devem ser criados e armazenados
na biblioteca do computador que os utilizará. Novamente, o usuário precisa apenas
saber se a operação está disponível para a lista e não como ela é realizada.
Sendo assim, o TAD consiste em um conjunto de definições que permite aos

programadores utilizarem sua operação enquanto a implementação permanece
oculta. Isso é conhecido como abstração.
2.1 MODELO PARA UM TAD

Vejamos a figura a seguir:
100
TÓPICO 3 | DADOS
FIGURA 38 – MODELO DE TAD
FONTE: Forouzan e Mosharraf (2011, p. 281)
Entendendo a figura, podemos destacar que a área do contorno irregular

representa o TAD. Dentro dele estão as duas partes diferentes do modelo. A
estrutura de dados e as operações públicas e privadas. O programa de aplicação
apenas pode acessar as operações públicas por meio da interface. As operações
privativas são destinadas ao uso interno pelo TAD. As estruturas de dados, como o
vetor, os registros e as listas encadeadas estão dentro da TAD e são utilizadas pelas
operações públicas e privadas.
As operações públicas e a interface devem ser independentes da

implementação, já as operações privativas são dependentes das estruturas de
dados escolhidas durante a implementação do TAD. As linguagens de computador
não oferecem pacotes de TADs, por isso para ser utilizado precisa primeiro ser
implementado e mantido em uma biblioteca (FOROUZAN; MOSHARRAF, 2011).
2.2 ENTENDENDO PILHAS

Pilha é uma lista linear restrita, onde todas as adições e exclusões são
efetuadas em uma extremidade, chamada topo. Se inserirmos uma série de itens
de dados em uma pilha e removermos, a ordem delas é invertida. Por exemplo
se a entrada de dados fosse 25, 30, 35, 40 seria removida como 40, 35, 30, 25. Este
atributo de inversão torna as pilhas estrutura de dados chamada LIFO (last in, first
out), traduzindo, último a entrar, primeiro a sair.
101
Em nosso dia a dia utilizamos muitos e diferentes tipos de pilhas. O que

nos é mais comum são pilhas de moedas ou de livros. Qualquer situação que
podemos adicionar ou remover um objeto do topo caracteriza uma pilha. Caso
queira remover um objeto diferente daquele que está no topo, primeiro devemos
remover todos os objetos acima dele (FOROUZAN; MOSHARRAF, 2011).
FIGURA 39 – REPRESENTAÇÃO DE PILHAS
Existem muitas operações com pilha, mas na computação existem quatro

básicas: pilha cria, pilha_insere, pilha exclui e pilha_vazia.
Para criarmos uma pilha vazia temos a seguinte sintaxe:
pilha_cria (nomedapilha)
nomedapilha é o nome da pilha a ser criada. Essa operação apresenta como

resultado uma pilha vazia (FOROUZAN; MOSHARRAF, 2011).
FIGURA 40 – REPRESENTAÇÃO DE CRIAÇÃO DE UMA PILHA
pilha_cria
Operação pilha_vazia
A operação inserção na fila insere um item no topo da fila. Veja a sintaxe:
pilha_isere(nomedapilha, itemdedados)
102
TÓPICO 3 | DADOS
nomedapilha é o nome da pilha e item de dados se refere aos dados a

serem inseridos no topo da pilha. Depois da operação de inserção, o novo item
se torna o topo.
FIGURA 41 – REPRESENTAÇÃO DA OPERAÇÃO INSERÇÃO

Dados a serem
inseridos
30 Elemento
30 do topo
Elemento
do topo
78 78
pilha_insere
20 Operação 20
Pilha depois Pilha depois

da inserção da inserção
A operação exclusão da fila exclui o item no topo da fila. Veja a sintaxe:
pilha_exclui(nomedapilha, itemdedados)
nomedapilha é o nome da pilha e item de dados se refere aos dados a serem

excluídos da pilha.
FIGURA 42 – REPRESENTAÇÃO DE OPERAÇÃO DE EXCLUSÃO

Dados
eliminados
Elemento
30 30
do topo
Elemento
78 78 do topo
pilha_exclui
20 Operação 20
Pilha antes Pilha antes

da exclusão da exclusão
O item excluído pode ser utilizado pelo programa da aplicação ou ser

descartado. Depois que o item é excluído, o item que estava abaixo do elemento do
topo antes da exclusão passa ser o do topo. Isto resulta em uma nova pilha com um
elemento a menos (FOROUZAN; MOSHARRAF, 2011).
103
A operação pilha vazia verifica o status da pilha. Veja a sintaxe:
pilha_vazia(nomedapilha)
nomedapilha é o nome da pilha. Esta operação resulta em verdadeiro se a

pilha estiver vazia, senão resulta em falso.
Para definirmos uma pilha como um TAD utilizamos conforme segue:
TAD de pilhas
Definição: uma lista de itens de dados que somente pode ser acessada
em uma extremidade, chamada topo da pilha.
Operações: pilha_cria: cria uma pilha vazia.

pilha_insere: insere um elemento no topo.
pilha_exclui: exclui um elemento no topo.
pilha_vazia: verifica o status da pilha.
FIGURA 43 – APLICANDO OPERAÇÃO DE PILHA
pilha_cria (P) P
pilha_insere (P, 10) 10 P
12
pilha_insere (P, 12) P
10
se (não pilha_vazia (P) ) pilha_exclui (P, X) 10 P
2
pilha_insere (P, 2) P
10
Analisando a Figura 43, o algoritmo aplica as operações definidas

anteriormente em uma pilha P. Na operação ela verifica o status da pilha antes
de tentar eliminar o elemento do topo. O valor deste elemento é armazenado na
variável x. Porém, não utilizamos este valor, ele será descartado automaticamente
no final do segmento do algoritmo.
104
TÓPICO 3 | DADOS
Classificamos as aplicações de pilhas em inversão de dados, emparelhamento

de dados, adiamento do uso de dados e rastreamento de caminho.
A inversão de dados é uma categoria que exige um determinado conjunto

de itens de dados reordenado, de modo que o primeiro e o último troquem de
posição entre si, e que todas as posições entre o primeiro e último item, também
sejam trocadas relativamente.
Ainda quando falamos de implementação de pilhas, precisamos escolher

uma estrutura de dados para implementá-los. Os TADs de pilhas podem ser
implementados utilizando um vetor ou uma lista encadeada (FOROUZAN;
MOSHARRAF, 2011).
FIGURA 44 – EXEMPLO DE UMA IMPLEMENTAÇÃO DE PILHAS
contador topo
[n]
S
contador topo [6]

[5]
S [4]
topo
[3]
[2]
[1]
b. Implementação c. Implementação em
em vetor lista encadeada
a. TAD
Na figura anterior temos a implementação em um vetor com o registro

com dois campos. O primeiro pode ser utilizado para armazenar informações
sobre o vetor utilizando um campo de contagem chamado contador, o qual a cada
momento mostra o número de itens de dados na pilha. O segundo é um número
inteiro que mantém o índice do elemento do topo. O vetor é mostrado do último
(topo) para o primeiro para corresponder a implementação em lista encadeada. A
implementação em lista encadeada é similar onde temos um nó extra cujo nome
é o da pilha. Esse nó também tem dois campos, um contador e um ponteiro que
aponta o elemento do topo (FOROUZAN; MOSHARRAF, 2011).
105
2.3 ENTENDENDO FILAS

Filas são listas lineares nas quais os dados podem ser inseridos somente
em uma extremidade, chamada fim da fila. Essas restrições asseguram que os
dados sejam processados por intermédio da fila na ordem em que são recebidos. A
estrutura de uma fila é chamada de FIFO (first in, first out), traduzindo, primeiro a
entrar e primeiro a sair.
Utilizamos filas em nosso cotidiano, fila de pessoas esperando o ônibus,

uma relação de chamadas colocadas em espera para serem respondidas por uma
telefonista, uma lista de tarefas em espera a serem executadas por um computador
FIGURA 45 – REPRESENTAÇÃO DE FILAS
exclui insere
(fila_exclui) (fila_insere)
Uma fila de pessoas inicio fim

Uma fila no computador
Como pilhas, filas também possuem muitas operações, vamos ver as quatro
básicas: fila_cria, fila_insere, fila_exclui e fila_vazia.
Para a criação de uma fila vazia utiliza-se a sintaxe a seguir:
fila_cria(nomedafila)
nomedafila é o nome a ser criado, e esta operação apresenta como resultado

uma fila vazia (FOROUZAN; MOSHARRAF, 2011).
FIGURA 46 – REPRESENTAÇÃO DE CRIAÇÃO DE FILA
fila_cria
Operação Fila vazia
Para operação de inserção de um item na fila utiliza-se a sintaxe a seguir:
fila_insere(nomedafila, itemdedados)
106
TÓPICO 3 | DADOS
nomedafila é o nome a ser criado, e o itemdedados refere-se aos dados a

serem inseridos no fim da fila. Após inserção, o novo item passa a ser o último da
fila. Isto apresenta como resultado a nova fila com o itemdedados inserido no fim
dela (FOROUZAN; MOSHARRAF, 2011).
FIGURA 47 – REPRESENTAÇÃO DE OPERAÇÃO DE INSERÇÃO

Dado a ser inserido
inicio fim 34 inicio fim

da fila da fila da fila da fila
20 78 fila_insere 20 78 34
Fila antes Operação Fila
Filadepois
depois
Para operação de exclusão de um item na fila utiliza-se a sintaxe a seguir:
fila_exclui(nomedafila, itemdedados)
nomedafila é o nome a ser criado, e o itemdedados refere-se aos dados

a serem excluídos da fila. Como na fila depois da operação de exclusão, o item
seguinte ao elemento do início da fila passa a ocupar sua posição. Esta operação
apresenta como resultado a nova fila, com um elemento a menos (FOROUZAN;
MOSHARRAF, 2011).
FIGURA 48 – REPRESENTAÇÃO DE OPERAÇÃO DE EXCLUSÃO
Dado excluído
inicio fim
20 inicio fim
da fila da fila da fila da fila
20 78 34 fila_exclui 78 34
Fila antes Operação Fila depois
Para a verificação de status de fila vazia utilizamos a operação filavazia

conforme a sintaxe a seguir:
fila_vazia(nomedafila)
107
nomedafila é seu nome. Esta operação resulta verdadeiro se a fila estiver

vazia, e se não estiver retorna falso (FOROUZAN; MOSHARRAF, 2011).
TAD de filas
Definição: uma lista de itens de dados na qual um item pode ser excluído
de uma extremidade, chamada início da fila ou pode ser inserido na outra,
chamada fim da fila.
Operações: fila_cria: cria uma fila vazia.

fila_insere: insere um elemento no fim da fila.
fila_exclui: exclui um elemento no início da fila.
fila_vazia: verifica o status da fila.
FONTE: Forouzan e Mosharraf (2011, p. 288).
Vejamos a seguir a figura com um algoritmo de fila:
FIGURA 49 – REPRESENTAÇÃO DE UM ALGORITMO DE FILA
fila_cria (F) F
fila_insere (F, 10) F 10
fila_insere (F, 12) F 10 12
se ( não fila_vazia (F) fila_exclui (F, X) F 12
fila_insere (F, 2) F 12 2
A figura nos demonstra um algoritmo em uma fila F. A condição se verifica

o status da fila antes de tentar excluir o elemento inicial. O valor deste elemento
é armazenado na variável x, porém não utilizamos este valor, ele será descartado
automaticamente ao final do algoritmo.
As filas são uma das estruturas mais comuns de processamento de dados.

Encontramos filas nos sistemas operacionais, redes, sistemas de spool de impressão,
organizar banco de dados, entre outros (FOROUZAN; MOSHARRAF, 2011).
108
TÓPICO 3 | DADOS
NOTA
Spool de impressão é um espaço na memória do seu computador (no HD) onde

ficam armazenados em fila (essa fila depende das prioridades dos usuários que enviaram o
arquivo ou da ordem de chegada) os arquivos para impressão.
2.4 ENTENDENDO LISTAS LINEARES GERAIS

As pilhas e filas são listas lineares restritas. Listas lineares gerais são aquelas
nas quais as operações como inserção e exclusão podem ser efetuadas em qualquer
parte da lista, ou seja, no início, meio ou fim (FOROUZAN; MOSHARRAF, 2011).
FIGURA 50 – REPRESENTAÇÃO LISTA LINEAR GERAL
Elemento 1 Elemento 2 Elemento 3 Elemento n
Uma lista linear geral é um conjunto de elementos que possuem as seguintes

propriedades:
• São do mesmo tipo;

• São organizados em sequência;
• Cada elemento, exceto o primeiro, tem um único predecessor;
• Cada elemento é um registro chamado de chave;
• Os elementos são ordenados conforme o valor da chave.
Nas listas também temos muitas operações, porém visualizaremos apenas

seis operações comuns: lista_cria, lista_insere, lista_exclui, lista_recupera, lista_
atravessa e lista_vazia.
Na operação de criação cria-se uma lista vazia. A sintaxe utilizada é:
lista_cria(nomedalista)
nomedalista é o nome a ser criado, e o resultado desta operação é uma

lista vazia.
109
Os dados de uma lista linear geral são ordenados, portanto a inserção

precisa ser feita de forma a manter esta ordenação. Para isso determinamos onde o
elemento deve ser colocado. Vejamos a sintaxe:
lista_isere(nomedalista,elemento)
FIGURA 51 – REPRESENTAÇÃO INSERÇÃO DE UMA LISTA

Restante
Lista dos dados
10 20 30 Lista
(antes da inserção)
elementos
elementos 25 lista_insere (lista, elemento)

Chave
Lista
(depois da inserção) 10 20 25 30 Lista
Elemento
inserido
Na exclusão também é necessário que seja feita a busca na lista para localizar
os itens a serem excluídos. Depois que a localização dos dados é definida, a exclusão
pode ser efetuada. Vejamos a sintaxe (FOROUZAN; MOSHARRAF, 2011):
lista_exclui(nomedalista, alvo, elemento)
Nesta sintaxe alvo é um valor de dados do mesmo tipo da chave dos

elementos na lista.
FIGURA 52 – REPRESENTAÇÃO DA EXCLUSÃO DE UMA LISTA

Elemento a
ser excluído
Lista
(antes da exclusão) 10 20 25 30 Lista
Restante
alvo 25 lista_exclui (lista, alvo, elemento) 25 dos dados
elementos
Lista
(depois da exclusão)
10 20 30 Lista
Chave
110
TÓPICO 3 | DADOS
A operação de recuperação refere-se a acessar um único elemento. Como

na inserção e na exclusão, a busca ocorre primeiro na lista geral, e se os dados
forem encontrados eles podem ser recuperados (FOROUZAN; MOSHARRAF,
2011). Vejamos abaixo a sintaxe:
lista_recupera(nomedalista, alvo, elemento)
FIGURA 53 – REPRESENTAÇÃO DA RECUPERAÇÃO DE UM ITEM NA LISTA

Elemento a
Restante
ser recuperado
dos dados
Lista
10 20 25 30
(antes da recuperação)
elemento
alvo 25 lista_recupera (lista, alvo, elemento) 25

Chave
Lista
10 20 25 30
(depois da recuperação)
Cada uma das operações anteriores envolve um único elemento na lista,

com acesso aleatório a ela. Já na operação de travessia envolve o acesso sequencial.
Nesta operação os elementos na lista são processados um a um (FOROUZAN;
MOSHARRAF, 2011). Vejamos abaixo a sintaxe:
lista_atravessa (nomedalista, ação)
Alguns exemplos desta operação são imprimir dados, aplicar alguma

operação matemática aos dados, entre outros.
A operação lista vazia verifica o status da lista. Para esta operação utilizamos
a seguinte sintaxe:
lista_vazia(nomedalista)
TAD da lista linear
Definição: uma lista de itens de dados ordenados; todos do mesmo tipo.
Operações: lista_cria: cria uma lista vazia;

lista_insere: insere um elemento na lista;
lista_exclui: exclui um elemento da lista;
lista_recupera: recupera um elemento da lista;
lista_atravessa: percorre a lista sequencialmente;
lista_vazia: verifica o status da lista.
111
Vejamos na figura a seguir um segmento de um algoritmo que aplica

operações definidas a uma lista L.
FIGURA 54 – REPRESENTAÇÃO DE UM ALGORITMO DE LISTA
lista_cria (L) L
lista_insere (L, 10) 10 L
lista_insere (L, 5) 5 10 L
5
se ( não lista_vazia (L) ) lista_exclui (L, 3) 10
L
lista_insere (L, 6) 5 6 10 L
Observando a figura anterior vemos que a terceira operação insere os

novos dados na posição correta, porque a operação de inserção aciona o algoritmo
de busca no nível da implementação para descobrir onde os novos dados devem
ser inseridos. Na quarta operação é excluído o item de dados 3 da lista, porém
antes ele verifica se a lista realmente está vazia. E na última operação insere 6 no
local apropriado.
As listas lineares são utilizadas em situações nas quais os elementos são

acessados aleatoriamente ou sequencialmente, como em uma faculdade, uma
lista linear pode ser utilizada para armazenar informações sobre os alunos que se
matriculam a cada semestre.
2.5 ENTENDENDO ÁRVORES

Árvore consiste em um conjunto finito de elementos chamados nós, mas
também conhecidos como vértices, e de um conjunto finito de linhas direcionadas,
chamadas arcos, que conectam pares de nós. Se a árvore não estiver vazia, um dos
nós, chamado raiz, não tem arcos chegando. Os outros nós de uma árvore podem
ser alcançados a partir da raiz, seguindo um caminho único, que é uma sequência de
arcos consecutivos. As estruturas de árvores normalmente são desenhadas de cabeça
para baixo, com a raiz voltada para cima. Podemos dividir os vértices de uma árvore
em três categorias: raiz, folhas e nós internos (FOROUZAN; MOSHARRAF, 2011).
112
TÓPICO 3 | DADOS
FIGURA 55 – NÚMERO DE ARCOS CHEGANDO E SAINDO

Tipo de nó Arco chegando Arco saindo
raiz 0 0 ou mais
folha 1 0
interno 1 1 ou mais
Um nó que é diretamente acessível, por meio de um arco simples, a partir

de determinado nó, é chamado filho: o nó a partir do qual o filho é diretamente
acessível é chamado pai. Nós com os pais em comum são chamados irmãos. Os
descendentes de um nó são todos os nós que podem ser alcançados a partir deste,
e em um nó a partir do qual todos os descendentes podem ser alcançados são
chamados de ancestrais.
Cada nó de uma árvore pode ser uma subárvore, que inclui um de seus
filhos e todos os descendentes deste filho. (FOROUZAN; MOSHARRAF, 2011).
FIGURA 56 – REPRESENTAÇÃO DE UMA ÁRVORE
A: raiz
B e F: nós internos
A C, D, E, G, H e I: folhas
Nós
B E F
C D G H I
113
FIGURA 57 – REPRESENTAÇÃO DE SUBÁRVORES
E
Subárvore E
B F
C D G H I
Subárvore C Subárvore D Subárvore G Subárvore H Subárvore I
Subárvore B Subárvore F
As árvores possuem muitas aplicações na computação como por exemplo

arquivos de índices.
2.6 ENTENDENDO GRAFOS

Grafo é um TAD composto de um conjunto de nós, chamados vértices,
e de um conjunto de linhas conectando os vértices, chamadas arestas ou arcos.
Enquanto uma árvore define uma estrutura hierárquica na qual um nó pode ter
somente um único pai, cada nó em um grafo pode ter um ou mais pais. Os grafos
podem ser dirigidos ou não dirigidos. Em um grafo dirigido, ou dígrafo, cada arco,
que conecta dois vértices, tem uma direção de um vértice a outro. Em um grafo
não dirigido, não existe direção.
Os vértices de um grafo podem representar objetos ou conceitos, e as

arestas ou arcos podem representar uma relação entre esses objetos ou conceitos.
Um exemplo de grafo não dirigido pode ser um mapa de cidades e

estradas conectando as cidades entre si. As cidades são os vértices, e as arestas não
direcionadas são as estradas que as conectam.
Outra aplicação de grafos é em redes de computadores. Os vértices

podem representar os nós, ou hubs, e as arestas os caminhos (FOROUZAN;
MOSHARRAF, 2011).
114
TÓPICO 3 | DADOS
FIGURA 58 – REPRESENTAÇÃO DE GRAFOS
A A
B E B E
F F
C D C D
a. Grafo dirigido b. Grafo não dirigido

ÁRVORES
Nota: confira o glossário no fim do texto.
Como listas ligadas, árvores são constituídas de células. Uma espécie

comum de árvores é a árvore binária, em que cada célula contém referências a duas
outras células (possivelmente nulas). Tais referências são chamadas de subárvore
esquerda e direita. Como as células de listas ligadas, as células de árvores também
contêm uma carga. Um diagrama de estados para uma árvore pode aparecer assim:
FIGURA 1
115
Para evitar a sobrecarga da figura, nós frequentemente omitimos os Nones.
O topo da árvore (a célula à qual o apontador tree se refere) é chamada de

raiz. Seguindo a metáfora das árvores, as outras células são chamadas de galhos e
as células nas pontas contendo as referências vazias são chamadas de folhas. Pode
parecer estranho que desenhamos a figura com a raiz em cima e as folhas embaixo,
mas isto nem será a coisa mais estranha.
Para piorar as coisas, cientistas da computação misturam outra metáfora

além da metáfora biológica - a árvore genealógica. Uma célula superior pode ser
chamada de pai e as células a que ela se refere são chamadas de filhos. Células com
o mesmo pai são chamadas de irmãos.
Finalmente, existe também o vocabulário geométrico para falar de árvores.

Já mencionamos esquerda e direita, mas existem também as direções “para cima”
(na direção da raiz) e “para baixo” (na direção dos filhos/folhas). Ainda nesta
terminologia, todas as células situadas à mesma distância da raiz constituem um
nível da árvore.
Provavelmente não precisamos de três metáforas para falar de árvores, mas

aí elas estão.
Como listas ligadas, árvores são estruturas de dados recursivas já que elas
são definidas recursivamente:
Uma árvore é:
• a árvore vazia, representada por None, ou

• uma célula que contém uma referência a um objeto (a carga da célula) e duas
referências a árvores.
1 CONSTRUINDO ÁRVORES
O processo de montar uma árvore é similar ao processo de montar uma

lista ligada. Cada invocação do construtor cria uma célula.
class Tree :
def __init__(self, cargo, left=None, right=None) :
self.cargo = cargo
self.left = left
self.right = right
def __str__(self) :
return str(self.cargo)
116
TÓPICO 3 | DADOS
A carga pode ser de qualquer tipo, mas os parâmetros left e right devem ser
células. left e right são opcionais; o valor default é None.
Para imprimir uma célula, imprimimos apenas a sua carga.
Uma forma de construir uma árvore é de baixo para cima. Aloque os filhos
primeiro:
left = Tree(2)
right = Tree(3)
Em seguida, crie a célula pai e ligue ela a seus filhos:
tree = Tree(1, left, right);
Podemos escrever este código mais concisamente encaixando as invocações

do construtor:
>>> tree = Tree(1, Tree(2), Tree(3))
De qualquer forma, o resultado é a árvore que apareceu no início do

capítulo.
2 PERCORRENDO ÁRVORES
Cada vez que você vê uma nova estrutura de dados, sua primeira pergunta
deveria ser “Como eu percorro esta estrutura? ”. A forma mais natural de percorrer
uma árvore é fazer o percurso recursivamente. Por exemplo, se a árvore contém
inteiros na carga, a função abaixo retorna a soma das cargas:
def total(tree) :
if tree == None : return 0
return total(tree.left) + total(tree.right) + tree.cargo
O caso base é a árvore vazia, que não contém nenhuma carga, logo a
soma das cargas é 0. O passo recursivo faz duas chamadas recursivas para achar
a soma das cargas das subárvores dos filhos. Ao finalizar a chamada recursiva,
adicionamos a carga do pai e devolvemos o valor total.
117
3 ÁRVORES DE EXPRESSÕES
Uma árvore é uma forma natural para representar a estrutura de uma

expressão. Ao contrário de outras notações, a árvore pode representar a computação
de forma não ambígua. Por exemplo, a expressão infixa 1 + 2 * 3 é ambígua, a
menos que saibamos que a multiplicação é feita antes da adição.
A árvore de expressão seguinte representa a mesma computação:
FIGURA 2
As células de uma árvore de expressão podem ser operandos como 1 e 2 ou

operações como + e *. As células contendo operandos são folhas; aquelas contendo
operações devem ter referências aos seus operandos. (Todos os nossos operandos
são binários, significando que eles têm exatamente dois operandos).
Podemos construir árvores assim:
>>> tree = Tree(‘+’, Tree(1), Tree(‘*’, Tree(2), Tree(3)))
Examinando a figura, não há dúvida quanto à ordem das operações; a

multiplicação é feita primeiro para calcular o segundo operando da adição.
118
TÓPICO 3 | DADOS
Árvores de expressão tem muitos usos. O exemplo neste capítulo usa

árvores para traduzir expressões para as notações pósfixa, prefixa e infixa. Árvores
similares são usadas em compiladores para analisar sintaticamente, otimizar e
traduzir programas.
4 PERCURSO DE ÁRVORES
Podemos percorrer uma árvore de expressão e imprimir o seu conteúdo

como segue:
def printTree(tree) :
if tree == None : return
print tree.cargo,
printTree(tree.left)
printTree(tree.right)
Em outras palavras, para imprimir uma árvore, imprima primeiro o

conteúdo da raiz, em seguida imprima toda a subárvore esquerda e finalmente
imprima toda a subárvore direita. Esta forma de percorrer uma árvore é chamada
de préordem, porque o conteúdo da raiz aparece antes dos conteúdos dos filhos.
Para o exemplo anterior, a saída é:
>>> tree = Tree(‘+’, Tree(1), Tree(‘*’, Tree(2), Tree(3)))

>>> printTree(tree)
+ 1 * 2 3
Esta notação é diferente tanto da notação pósfixa quanto da infixa; é

uma notação chamada de prefixa, em que os operadores aparecem antes dos
seus operandos.
Você pode suspeitar que se você percorre a árvore numa ordem diferente,
você produzirá expressões numa notação diferente. Por exemplo, se você imprime
subárvores primeiro e depois a raiz, você terá:
def printTreePostorder(tree) :
printTreePostorder(tree.left)
printTreePostorder(tree.right)
print tree.cargo,
119
O resultado 1 2 3 * + está na notação pósfixa! Esta ordem de percurso é

chamada de pósordem.
Finalmente, para percorrer uma árvore em inordem, você imprime a

subárvore esquerda, depois a raiz e depois a subárvore direita:
def printTreeInorder(tree) :
printTreeInorder(tree.left)
print tree.cargo,
printTreeInorder(tree.right)
O resultado é 1 + 2 * 3, que é a expressão na notação infixa.
Para sermos justos, devemos lembrar que acabamos de omitir uma

complicação importante. Algumas vezes quando escrevemos expressões na
notação infixa, devemos usar parênteses para prescrever a ordem das operações.
Ou seja, um percurso em inordem não é suficiente para gerar a expressão infixa.
Ainda assim, com alguns aperfeiçoamentos, a árvore de expressão e os

três modos recursivos de percurso resultam em algoritmos para transformar
expressões de uma notação para outra.
Como um exercício, modifique `printTreeInorder` de modo que ele coloque

parênteses em volta de cada operador e par de operandos. A saída é correta e não ambígua?
Os parênteses são sempre necessários?
Se percorrermos uma árvore em inordem e acompanharmos em qual nível

na árvore estamos, podemos gerar uma representação gráfica da árvore:
def printTreeIndented(tree, level=0) :

printTreeIndented(tree.right, level+1)
print ‘ ‘*level + str(tree.cargo)
printTreeIndented(tree.left, level+1)
O parâmetro level registra aonde estamos na árvore. Por ‘default’, o nível

inicialmente é zero. A cada chamada recursiva repassamos level+1 porque o nível
do filho é sempre um a mais do que o nível do pai. Cada item é indentado dois
espaços por nível. Para o nosso exemplo obtemos:
120
TÓPICO 3 | DADOS
def printTreeIndented(tree, level=0) :

printTreeIndented(tree.right, level+1)
print ‘ ‘*level + str(tree.cargo)
printTreeIndented(tree.left, level+1)
O parâmetro level registra aonde estamos na árvore. Por ‘default’, o nível

inicialmente é zero. A cada chamada recursiva repassamos level+1 porque o nível
do filho é sempre um a mais do que o nível do pai. Cada item é indentado dois
espaços por nível. Para o nosso exemplo obtemos:
>>> printTreeIndented(tree)
3
*
2
+
1
Se você deitar a saída acima você enxerga uma versão simplificada da

figura original.
5 CONSTRUINDO UMA ÁRVORE DE EXPRESSÃO
Nesta seção analisamos expressões infixas e construímos as árvores de

expressão correspondentes. Por exemplo, para a expressão (3+7)*9 resultará a
seguinte árvore:
121
FIGURA 3
Note que simplificamos o diagrama omitindo os nomes dos campos.
O analisador que escreveremos aceitará expressões que incluam números,

parênteses e as operações + e *. Vamos supor que a cadeia de entrada já foi
tokenizada numa lista do Python. A lista de tokens para a expressão (3+7)*9 é:
[‘(‘, 3, ‘+’, 7, ‘)’, ‘*’, 9, ‘end’]
O token final end é prático para prevenir que o analisador tente buscar
mais dados após o término da lista.
A título de um exercício, escreva uma função que recebe uma expressão na forma
de uma cadeia e devolve a lista de tokens.
A primeira função que escreveremos é getToken que recebe como parâmetros

uma lista de tokens e um token esperado. Ela compara o token esperado com o
primeiro token da lista: se eles batem a função remove o token da lista e devolve
um valor verdadeiro, caso contrário a função devolve um valor falso:
122
TÓPICO 3 | DADOS
def getToken(tokenList, expected) :

if tokenList[0] == expected :
tokenList[0:1] = [] # remove the token
return 1
else :
return 0
Já que tokenList refere a um objeto mutável, as alterações feitas aqui são

visíveis para qualquer outra variável que se refira ao mesmo objeto.
A próxima função, getNumber, trata de operandos. Se o primeiro token na

tokenList for um número então getNumber o remove da lista e devolve uma célula
folha contendo o número; caso contrário ele devolve None.
def getNumber(tokenList) :
x = tokenList[0]
if type(x) != type(0) : return None
del tokenList[0]
return Tree(x, None, None)
Antes de continuar, convém testar getNumber isoladamente. Atribuímos

uma lista de números a tokenList, extraímos o primeiro, imprimimos o resultado e
imprimimos o que resta na lista de tokens:
>>> tokenList = [9, 11, ‘end’]

>>> x = getNumber(tokenList)
>>> printTreePostorder(x)
9
>>> print tokenList
[11, ‘end’]
Em seguida precisaremos da função getProduct, que constrói uma árvore

de expressão para produtos. Os dois operandos de um produto simples são
números, como em 3 * 7.
Segue uma versão de getProduct que trata de produtos simples.
123
def getProduct(tokenList) :
a = getNumber(tokenList)
if getToken(tokenList, ‘*’) :
b = getNumber(tokenList)
return Tree(‘*’, a, b)
else :
return a
Supondo que a chamada de getNumber seja bem-sucedida e devolva

uma árvore de uma só célula atribuímos o primeiro operando a “a”. Se o
próximo caractere for *, vamos buscar o segundo número e construir a árvore
com a, b e o operador.
Se o caractere seguinte for qualquer outra coisa, então simplesmente

devolvemos uma célula folha com a. Seguem dois exemplos:
>>> tokenList = [9, ‘*’, 11, ‘end’]

>>> tree = getProduct(tokenList)
>>> printTreePostorder(tree)
9 11 *
>>> tokenList = [9, ‘+’, 11, ‘end’]

9
O segundo exemplo sugere que nós consideremos um operando unitário

como uma espécie de produto. Esta definição de “produto” talvez não seja intuitiva,
mas ela será útil.
Agora tratamos produtos compostos, como 3 * 5 * 13. Encaramos esta

expressão como um produto de produtos, mais precisamente como 3 * (5 * 13).
A árvore resultante é:
124
TÓPICO 3 | DADOS
FIGURA 4
Com uma pequena alteração em getProduct, podemos acomodar produtos

arbitrariamente longos:
def getProduct(tokenList) :
a = getNumber(tokenList)
if getToken(tokenList, ‘*’) :
b = getProduct(tokenList) # this line changed
return Tree(‘*’, a, b)
else :
return a
Em outras palavras, um produto pode ser um singleton ou uma árvore

com * na raiz, que tem um número como filho esquerdo e um produto como filho
direito. Este tipo de definição recursiva devia começar a ficar familiar.
Testemos a nova versão com um produto composto:
125
>>> tokenList = [2, ‘*’, 3, ‘*’, 5 , ‘*’, 7, ‘end’]

2 3 5 7 * * *
A seguir adicionamos o tratamento de somas. De novo, usamos uma

definição de “soma” que é ligeiramente não intuitiva. Para nós, uma soma pode ser
uma árvore com + na raiz, que tem um produto como filho esquerdo e uma soma
como filho direito. Ou, uma soma pode ser simplesmente um produto.
Se você está disposto a brincar com esta definição, ela tem uma propriedade
interessante: podemos representar qualquer expressão (sem parênteses) como uma
soma de produtos. Esta propriedade é a base do nosso algoritmo de análise sintática.
getSum tenta construir a árvore com um produto à esquerda e uma soma

à direita. Mas, se ele não encontra uma +, ele simplesmente constrói um produto.
def getSum(tokenList) :
a = getProduct(tokenList)
if getToken(tokenList, ‘+’) :
b = getSum(tokenList)
return Tree(‘+’, a, b)
else :
return a
Vamos testar o algoritmo com 9 * 11 + 5 * 7:
>>> tokenList = [9, ‘*’, 11, ‘+’, 5, ‘*’, 7, ‘end’]

>>> tree = getSum(tokenList)
9 11 * 5 7 * +
Quase terminamos, mas ainda temos que tratar dos parênteses. Em

qualquer lugar numa expressão onde podemos ter um número, podemos também
ter uma soma inteira envolvida entre parênteses. Precisamos, apenas, modificar
getNumber para que ela possa tratar de subexpressões:
126
TÓPICO 3 | DADOS
if getToken(tokenList, ‘(‘) :
x = getSum(tokenList) # get subexpression
getToken(tokenList, ‘)’) # eat the closing
parenthesis
return x
else :
x = tokenList[0]
if type(x) != type(0) : return None
tokenList[0:1] = [] # remove the token
return Tree(x, None, None) # return a leaf with the
number
Testemos este código com 9 * (11 + 5) * 7:
>>> tokenList = [9, ‘*’, ‘(‘, 11, ‘+’, 5, ‘)’, ‘*’, 7,

‘end’]
>>> tree = getSum(tokenList)
9 11 5 + 7 * *
O analisador tratou os parênteses corretamente; a adição é feita antes da

multiplicação.
Na versão final do programa, seria uma boa ideia dar a getNumber um

nome mais descritivo do seu novo papel.
6 MANIPULANDO ERROS
Ao longo do analisador sintático tínhamos suposto que as expressões

(de entrada) são bem formadas. Por exemplo, quando atingimos o fim de uma
subexpressão, supomos que o próximo caractere é um fecha parênteses. Caso haja
um erro e o próximo caractere seja algo diferente, devemos tratar disto.
if getToken(tokenList, ‘(‘) :
x = getSum(tokenList)
if not getToken(tokenList, ‘)’):
raise ‘BadExpressionError’, ‘missing parenthesis’
return x
else :
# the rest of the function omitted
127
O comando raise cria uma exceção; neste caso criamos um novo tipo de
exceção, chamada de BadExpressionError. Se a função que chamou getNumber,
ou uma das outras funções no traceback, manipular a exceção, então o programa
pode continuar. Caso contrário Python vai imprimir uma mensagem de erro e
terminará o processamento em seguida.
A título de exercício, encontre outros locais nas funções criadas onde erros
possam ocorrer e adicione comandos ``raise`` apropriados. Teste seu código com expressões
malformadas.
7 A ÁRVORE DOS ANIMAIS
Nesta seção, desenvolvemos um pequeno programa que usa uma árvore

para representar uma base de conhecimento.
O programa interage com o usuário para criar uma árvore de perguntas e

de nomes de animais. Segue uma amostra da funcionalidade:
Are you thinking of an animal? y

Is it a bird? n
What is the animals name? dog
What question would distinguish a dog from a bird? Can it
fly
If the animal were dog the answer would be? n

Can it fly? n
Is it a dog? n
What is the animals name? cat
What question would distinguish a cat from a dog? Does it
bark
If the animal were cat the answer would be? n

Can it fly? n
Does it bark? y
Is it a dog? y
I rule!
Are you thinking of an animal? n
128
TÓPICO 3 | DADOS
Aqui está a árvore que este diálogo constrói:
FIGURA 5
No começo de cada rodada, o programa parte do topo da árvore e faz a

primeira pergunta. Dependendo da resposta, ele segue pelo filho esquerdo ou
direito e continua até chegar numa folha. Neste ponto ele arrisca um palpite. Se o
palpite não for correto, ele pergunta ao usuário o nome de um novo animal e uma
pergunta que distingue o palpite errado do novo animal. A seguir, adiciona uma
célula à árvore contendo a nova pergunta e o novo animal.
Aqui está o código:
def animal() :
# start with a singleton
root = Tree(“bird”)
# loop until the user quits

while 1 :
print
if not yes(“Are you thinking of an animal? “) : break
# walk the tree

tree = root
while tree.getLeft() != None :
prompt = tree.getCargo() + “? “
if yes(prompt):
tree = tree.getRight()
else:
129
tree = tree.getLeft()
# make a guess
guess = tree.getCargo()
prompt = “Is it a “ + guess + “? “
if yes(prompt) :
print “I rule!”
continue
# get new information

prompt = “What is the animal\’s name? “
animal = raw_input(prompt)
prompt = “What question would distinguish a %s from
a %s? “
question = raw_input(prompt % (animal,guess))
# add new information to the tree
tree.setCargo(question)
prompt = “If the animal were %s the answer would be?“
if yes(prompt % animal) :
tree.setLeft(Tree(guess))
tree.setRight(Tree(animal))
else :
tree.setLeft(Tree(animal))
tree.setRight(Tree(guess))
A função yes é um auxiliar; ele imprime um prompt e em seguida solicita

do usuário uma entrada. Se a resposta começar com y ou Y, a função devolve um
valor verdadeiro:
def yes(ques) :
from string import lower
ans = lower(raw_input(ques))
return (ans[0:1] == ‘y’)
A condição do laço externo é 1`, que significa que ele continuará até a
execução de um comando break, caso o usuário não pense num animal.
O laço while interno caminha na árvore de cima para baixo, guiado pelas
respostas do usuário.
130
TÓPICO 3 | DADOS
Quando uma nova célula é adicionada à árvore, a nova pergunta substitui

a carga e os dois filhos são o novo animal e a carga original.
Uma falha do programa é que ao sair ele esquece tudo que lhe foi
cuidadosamente ensinado!
A título de exercício, pense de vários jeitos para salvar a árvore do conhecimento

acumulado num arquivo. Implemente aquele que você pensa ser o mais fácil.
8 GLOSSÁRIO
árvore binária (binary tree): uma árvore em que cada célula tem zero, um ou dois
descendentes.
raiz (root): a célula mais alta de uma árvore, a (única) célula de uma árvore que não
tem pai.
folha (leaf): uma célula mais baixa numa árvore; uma célula que não tem
descendentes.
pai (parent): a célula que aponta para uma célula dada.
filho (child): uma célula apontada por uma célula dada.
irmãos (siebling): células que têm o mesmo pai.
nível (level): um conjunto de células equidistantes da raiz.
operador binário (binary operator): um operador sobre dois operandos.
subexpressão (subexpression): uma expressão entre parênteses que se comporta
como um operando simples numa expressão maior.
pré-ordem (preorder): uma forma de percorrer uma árvore visitando cada célula
antes dos seus filhos.
notação prefixa (prefix notation): uma forma de escrever uma expressão matemática
em que cada operador aparece antes dos seus operandos.
pós-ordem (postorder): uma forma de percorrer uma árvore visitando os filhos de
cada célula antes da própria célula.
in-ordem (inorder): uma forma de percorrer uma árvore visitando a subárvore
esquerda, seguida da raiz e finalmente da subárvore direita.
FONTE: Disponível em: <https://aprendendo-computacao-com-python.readthedocs.org/en/

latest/capitulo_20.html>. Acesso em: 22 mar. 2016.
131
RESUMO DO TÓPICO 3
Chegamos ao final de mais uma unidade. Neste tópico vimos que:
• Um TAD é um pacote que define um novo tipo de dados, operações sobre ele e
encapsula os dados e as operações.
• Pilha é uma lista linear restrita na qual todas as inserções e exclusões são feitas
através do topo.
• As pilhas têm estrutura do tipo LIFO, ou seja, último a entrar, primeiro a sair.
• Fila é uma lista linear na qual os dados podem ser inseridos apenas no fim da fila.
• A fila possui estrutura do tipo FIFO, ou seja, primeiro a entrar, primeiro a sair.
• Lista linear geral é aquela na qual as operações, como inserção e exclusão, podem
ser feitas em qualquer local da lista, ou seja, no início, meio ou fim.
• Que a árvore consiste em um conjunto finito de elementos chamado nós e um

conjunto finito de linhas direcionadas, chamadas arcos.
• Grafo é um TAD composto de um conjunto de nós, chamados vértices, e um

conjunto de linhas que conectam os vértices, chamado de arestas.
132
AUTOATIVIDADE
1 Um dos tipos de dados estudados são as pilhas. O que é uma pilha? Quais
são as quatro operações básicas com pilhas?
2 Qual a estrutura de dados baseada no princípio FIFO (first in, first out), em
que os elementos que foram inseridos no início são os primeiros a serem
removidos?
a) ( ) Pilha
b) ( ) Árvore
c) ( ) Lista
d) ( ) Fila
e) ( ) Lista Encadeada
3 Se A é o primeiro elemento de dados inserido em uma pilha, seguido por B,

C e D. Qual é o primeiro elemento a ser removido?
a) ( ) A
b) ( ) B
c) ( ) C
d) ( ) D
4 Descreva o que é um grafo dirigido e um grafo não dirigido.
133
134
UNIDADE 3
LÓGICA DE PROGRAMAÇÃO
A partir desta unidade você será capaz de:
• compreender os fundamentos de lógica de programação;
• entender as estruturas de controle;
• conhecer os tipos estruturados;
• compreender subalgoritmos e escopo de identificadores.
PLANO DE ESTUDOS
Esta unidade está dividida em cinco tópicos, sendo que no final de cada um
deles você encontrará atividades que contribuirão para a apropriação dos
conteúdos.
TÓPICO 1 – FUNDAMENTOS DE LÓGICA DE PROGRAMAÇÃO
TÓPICO 2 – CONSTANTES E VARIÁVEIS
TÓPICO 3 – ESTRUTURAS DE CONTROLE
TÓPICO 4 – TIPOS ESTRUTURADOS
TÓPICO 5 – SUBALGORITMOS E ESCOPO DE IDENTIFICADORES
135
136
UNIDADE 3
TÓPICO 1
FUNDAMENTOS DE LÓGICA DE PROGRAMAÇÃO
1 INTRODUÇÃO
O dia a dia de pessoas e instituições tem sido facilitado pelo uso de softwares
das mais variadas naturezas. Seu uso crescente requer que mais e melhores softwares
sejam desenvolvidos para atender diversas áreas de aplicação.
O desenvolvimento de software, porém, ainda é uma tarefa árdua e requer

profissionais altamente qualificados para sua execução. A maturidade lógica do
profissional de programação é um elemento essencial para o sucesso do software
que será construído por ele.
Estes profissionais devem ter em mente que grande parte do sucesso

de um software depende de uma definição clara das regras de negócio a serem
implementadas nele.
Deve-se desenvolver estas regras de negócio visando alto desempenho e

eficiência nos resultados obtidos.
Embora seja altamente sistemático, o desenvolvimento de software não

deve ser encarado como uma atividade puramente técnica. O profissional de
desenvolvimento deve levar em consideração o fato de que geralmente softwares são
criados para o atendimento de necessidades de pessoas. Quem pontua a qualidade
do software são as pessoas que os utilizam.
Tão importante quanto o bom desempenho e eficiência é o atendimento das

necessidades dos usuários. Neste sentido, os fatores ergonômicos são relevantes e
também devem ser considerados.
137
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
2 FUNDAMENTOS DE LÓGICA DE PROGRAMAÇÃO

Para tornar esta unidade mais clara e produtiva, neste tópico são descritos
alguns conceitos que auxiliarão no aprendizado e entendimento do conteúdo dos
demais tópicos. Vejamos:
• Programa: é uma unidade de software destinada à execução de determinada

tarefa. Geralmente atribui-se esta denominação a uma unidade de software que
tenha um conjunto reduzido de funcionalidades.
• Sistema: para fins computacionais, sistema pode ser definido como um conjunto
inter-relacionado de programas. Um sistema geralmente permite a execução
de um número maior de funcionalidades. Estas funcionalidades podem estar
organizadas em programas diferentes. Um exemplo é o sistema operacional. Ele
possui uma série de pequenos programas que auxiliam no seu funcionamento e
na execução das tarefas.
• Rotina: é uma pequena unidade dentro de um programa que geralmente executa

uma tarefa bastante específica. Um exemplo pode ser a rotina de cálculo de
média. Este trecho de programa é denominado rotina, pois executa uma tarefa
específica e que sempre ocorre e é tratada da mesma maneira. Nas linguagens
de programação as rotinas geralmente são implementadas na forma de funções
ou procedimentos.
• Sub-rotina: é um trecho bastante particular do software que geralmente auxilia

uma rotina. Pode-se dizer que uma sub-rotina é o refinamento de uma rotina.
Nas linguagens de programação, tanto as rotinas quanto as sub-rotinas podem
ser encontradas na forma de funções (function) ou procedimentos (procedure).
• Comando: é uma palavra ou símbolo que indica uma ordem para execução de
uma ação. Os comandos são imperativos. Por exemplo: leia, escreva, escolha,
entre outros.
• Instrução: é uma das tarefas que devem ser executadas para a obtenção do
resultado desejado através do software. Esta tarefa pode ser um cálculo, uma
atribuição, uma chamada de sub-rotina, entre outras.
• Linguagem de Programação: são softwares destinados ao desenvolvimento

de novos softwares. É através delas que são escritos códigos de programação
entendidos e executados pelos computadores.
• Sintaxe: é a forma de organização das instruções para que seja obtido o resultado
desejado, seguindo-se as regras da linguagem utilizada. É o conjunto de regras
que indicam o formato de escrita das instruções. Considera também a sequência
em que as instruções devem ser escritas para atender aos requisitos da linguagem
utilizada, pois não basta apenas a escrita estar correta, é necessário que haja
coerência na instrução.
138
TÓPICO 1 | FUNDAMENTOS DE LÓGICA DE PROGRAMAÇÃO
• Semântica: refere-se ao significado das instruções, ou o que um conjunto de

instruções quer informar. Na semântica, um conjunto de instruções deve ser
escrito de forma que elas possam ser correta e coerentemente executadas.
• Teste de Mesa: é uma técnica de validação de algoritmos que visa testar os

resultados obtidos em relação ao objetivo para o qual o algoritmo foi construído.
O teste de mesa consiste na definição de um conjunto de dados de entrada e
resultados esperados, após o processamento destes dados. Submissão destes
dados às instruções do algoritmo e a obtenção do resultado deste processamento.
Caso o resultado do teste de mesa seja o mesmo que o resultado esperado,
há grande possibilidade de o algoritmo estar correto. Num teste de mesa é
fundamental validar todas as situações previstas no algoritmo.
• Comentário: é uma informação agregada ao algoritmo que informa ao

programador algo importante e que deve ser considerado no momento de
interpretar ou alterar o algoritmo. É aconselhável que junto à declaração de
variáveis e procedimentos sejam acrescentados comentários descrevendo seus
significados e finalidades. Regras de negócios também podem ser descritas em
comentários, facilitando futuras manutenções. Nos algoritmos desenvolvidos
neste livro serão utilizadas chaves { } para delimitar o início e fim de comentários.
• Endentação: é o alinhamento das instruções de forma a simplificar a identificação

da subordinação dos blocos de instruções. A endentação também é chamada de
indentação ou identação na área de programação. É altamente recomendável
que os algoritmos, assim como os programas, sejam endentados, pois facilita o
entendimento. Para a maioria das linguagens de programação a endentação não
exerce influência. Nestes casos, quem é beneficiado pela endentação é a pessoa
que precisa ler e entender o código escrito.
3 LÓGICA
Pessoas utilizam lógica em seu cotidiano sem perceber, chegam a citá-la
sem entender direito seu significado.
Lógica é a ciência das formas do pensamento, além de estudar a correção

do raciocínio, visto que ela é a forma mais complexa do pensamento. Pode-se
dizer ainda que a lógica visa à ordem da razão, que nossa razão pode funcionar
desordenadamente e que ela estuda e ensina a colocar ordem no pensamento
(ARAÚJO, 2007).
Para entendermos melhor a lógica vejamos o exemplo a seguir:

O número 4 é menor que o número 6.
O número 8 é maior que o número 6.
Logo, o número 4 é menor que os números 6 e 8.
139
Este exemplo mostra lógica ordenada, porém, muitas vezes nosso raciocínio
funciona desordenadamente.
Veja se seria possível retirar uma mercadoria no correio na sequência

descrita abaixo:
1. Sair do correio;
2. Entrar na fila;
3. Entrar no correio;
4. Informar seus dados ao atendente;
5. Procurar a fila;
6. Pegar a mercadoria;
7. Conferir a mercadoria.
Você conseguiria retirar a mercadoria? Não, pois mesmo que as ações estão
corretas, a sequência não está. Temos como primeira ação sair do correio. Como
retiramos a mercadoria estando fora dele? Vamos ver como ficariam as mesmas
ações, mas na ordem correta.
1. Entrar no correio;
2. Procurar a fila;
3. Entrar na fila;
4. Informar seus dados ao atendente;
5. Pegar a mercadoria;
6. Conferir a mercadoria;
7. Sair do correio.
4 LÓGICA DE PROGRAMAÇÃO
Quando falamos de lógica de programação estamos apenas contextualizando
a lógica em programação de computadores, onde, como na lógica, temos uma
sequência de ações para solucionar um problema.
Essa sequência de ações chama-se algoritmos. Algoritmo é um conjunto finito

de instruções que devem ser executadas para a obtenção de um resultado desejado.
Por exemplo, ligar um computador é uma instrução.
140
TÓPICO 1 | FUNDAMENTOS DE LÓGICA DE PROGRAMAÇÃO
No exemplo acima, podemos observar que, ao objeto computador no

estado inicial desligado, é aplicado a instrução ligar, levando ao estado final
computador ligado.
Algoritmos podem ser representados de forma gráfica ou textual. Na

forma gráfica geralmente utiliza-se o fluxograma ou o diagrama estruturado. Já
na representação textual utiliza-se um conjunto padronizado de palavras para
representar as instruções que podem ser facilmente entendidas e traduzidas para
uma linguagem de programação.
Num algoritmo, os elementos fundamentais são as instruções e os dados

manipulados.
Ainda falando sobre a representação de algoritmos, podemos representá-

los através de pseudocódigo, fluxograma ou diagrama de Chapin.
Pseudocódigo são comandos escritos de forma estruturada em português,

também conhecido como portugol.
Vejamos a sintaxe do pseudocódigo:
inicio
comando 1
comando 2
comando 3
fim
Fluxogramas utilizam-se de formas geométricas para a representação de

comandos e instruções.
Vejamos as figuras geométricas e suas representações:
FIGURA 59 – FIGURAS UTILIZADAS NOS FLUXOGRAMAS
Indica início e fim do fluxo do

Terminal
programa
Indica o sentido do fluxo de
Seta de fluxo de dados dados. Serve para conectar os
blocos existentes.
Indica que serão recebidas
Entrada de dados informações através do
teclado.
FONTE: Araújo (2007, p. 79)
141
FIGURA 60 – CONTINUAÇÃO FIGURAS UTILIZADAS NOS FLUXOGRAMAS
Indica a realização de cálculos,

Processamento atribuições ou qualquer
manipulação de dados.
Indica que as informações serão

Exibir da tela
exibidas na tela.
Indica tomada de decisão. Divide

Desvio Condicional o fluxo do programa em dois
caminhos.
Serve para identificar o limite de

Conector
um laço de repetição.
Repetição com variável de Usado especificamente para o

controle comando de repetição.
Usado para o comando de

Repetição com teste lógico
repetição com teste lógico no
no início
início.
Usado para o comando de
Repetição com teste lógico
repetição com teste lógico no
no final
final
Usado para as declarações de

Declaração
variáveis, tipos e constantes.
FONTE: Araújo (2007, p. 80)
O diagrama de Chapin criado por Ned Chapin, nasceu a partir de trabalhos

de Nassi-Schneiderman para a substituição dos fluxogramas. Este tipo de
representação utiliza quadrados e retângulos para descrever as ações. A vantagem
de utilizar este tipo de estrutura é que possui um ponto de entrada e um ponto de
saída e são compostas por estruturas básicas de controle de sequência, seleção e
repartição (ARAÚJO, 2007). Veja a sintaxe a seguir:
Comando 1
Comando 2
Comando 3
142
RESUMO DO TÓPICO 1
Caro acadêmico, neste tópico você estudou que:
• A sintaxe de um programa se refere à escrita correta das instruções que deverão

ser executadas. Tipicamente se entende a sintaxe como sendo o conjunto de
palavras reservadas de uma linguagem de programação. Já a semântica se refere
ao significado que um conjunto de instruções irá gerar.
• A lógica é a forma de ordenar e corrigir pensamentos ou ações voltadas para a

solução de problemas.
• O algoritmo é a descrição de um conjunto de ações, que quando obedecido

resulta em uma sucessão finita de passos.
• Podemos representar o algoritmo através de pseudocódigo, fluxograma e

diagrama de Chapin.
• A estrutura de pseudocódigo representa o algoritmo com comandos escritos na

língua portuguesa.
• O diagrama de Chapin utiliza quadrados para descrever as ações.
• O fluxograma utiliza figuras geométricas para representar o fluxo dos dados e

dos comandos.
143
AUTOATIVIDADE
Agora vamos praticar:
1 Monte um algoritmo com a sequência correta de uma pessoa que vai de táxi
a uma reunião.
a) Entrar no prédio da reunião;

b) Sair do táxi;
c) Acenar para que o táxi pare;
d) Perguntar o preço da corrida;
e) Informar o destino ao motorista;
f) Esperar o táxi;
g) Pagar a corrida;
h) Entrar no táxi.
2 Monte um algoritmo para a troca de uma lâmpada queimada. Para essa

troca você tem disponível uma escada e uma lâmpada nova testada.
3 Utilize a estrutura pseudocódigo para representar o algoritmo do cálculo

matemático 5 + 6, feito em uma calculadora comum. Use termos como
“Aperte a tecla xx” nas ações.
144
UNIDADE 3
TÓPICO 2
CONSTANTES E VARIÁVEIS
1 INTRODUÇÃO
Conforme estudos realizados no tópico anterior, vimos que o raciocínio
lógico é a base para fazermos um algoritmo, além disso vimos suas estruturas de
representação.
Porém, para termos um algoritmo por completo necessitamos seguir

algumas regras básicas de programação, como: constantes e variáveis, declaração de
variáveis, comentar algoritmos, atribuir valores às variáveis, construir expressões
aritméticas, literais, relacionais e lógicas e os comandos ler e escrever.
2 CONSTANTES
Constantes como o próprio nome diz, é tudo que é fixo, estável, inalterável,
imutável, contínuo, incessante, invariável, de valor fixo e que é aplicado em
diversos pontos de vista. Assim, constante é uma grandeza numérica fixa utilizada
normalmente em uma expressão aritmética ou matemática, a qual define um valor
que será inalterado na expressão, independentemente das variáveis envolvidas na
operação a ser realizada (MANZANO; OLIVEIRA, 2014).
Como exemplo de uso de uma constante podemos utilizar um algoritmo

para calcular o imposto de uma nota fiscal, neste algoritmo poderá ser declarada
uma constante que irá armazenar o valor percentual do imposto. Caso a legislação
mude, basta alterar o valor da constante, assim todos os locais onde ela está sendo
utilizada serão automaticamente atualizados com o novo valor.
145
3 VARIÁVEIS
Variável é tudo que está sujeito a variação, que é incerto, estável ou inconstante.
Os dados a serem processados em computadores são bastante variáveis.
Para todo dado a ser armazenado em um computador é necessário saber o

tipo de dado para depois fazer seu armazenamento adequado. Após armazenado
o dado ele pode ser utilizado e processado a qualquer momento.
Para compreender o conceito de variável, imagine que a memória principal

de um computador é um arquivo com muitas gavetas, e cada uma delas pode
armazenar um valor por vez, e como em um arquivo, essas gavetas devem
estar identificadas por uma etiqueta com um nome. Portanto, uma variável é
utilizada para sua identificação e representação em um programa de computador
(MANZANO; OLIVEIRA, 2014).
FIGURA 61 – REPRESENTAÇÃO DA MEMÓRIA DE UM COMPUTADOR COM VARIÁVEIS
FONTE: Manzano e Oliveira (2014, p. 43)
O nome da variável pode ser formado por um ou mais caracteres e deve estar
sempre em letras maiúsculas. O primeiro caractere deve ser obrigatoriamente uma letra e
os caracteres seguintes podem ser letras ou números. Não é permitido o uso de símbolos,
sinais gráficos e de pontuação. Alguns exemplos de identificadores permitidos: NOME
IDADE END1 NOME_DO_ALUNO
146
TÓPICO 2 | CONSTANTES E VARIÁVEIS
4 TIPOS DE DADOS
O tipo de dado define o conjunto de valores que um identificador pode
assumir ou armazenar. Nas linguagens de programação estão disponíveis vários
tipos de dados. Para fins de desenvolvimento de algoritmos utilizam-se os tipos
de dados primitivos, pois as variações de tipos são definidas conforme os recursos
disponibilizados pela linguagem de programação e a necessidade de representação
ou armazenamento.
Os tipos de dados primitivos são: inteiro, real, caractere e lógico.
• Inteiro: armazena números positivos e negativos pertencentes ao conjunto

de números inteiros, excluindo qualquer valor fracionário. Exemplos de tipo
inteiro: 2, 0, 501, -7, -88, entre outros.
• Real: números positivos e negativos que pertencem ao conjunto de números

inteiros, incluindo todos os valores fracionários e inteiros. Exemplo: 36, 0, -57,
-2, 5, 55.
• Caractere: são delimitados pelo símbolo aspas (“ ”), e são representados por
letras de A até Z, números de 0 até 9 e símbolos. Exemplos: “Maria”; “Rua 296”;
greisse@uniasselvi.com.br, entre outros.
• Lógico: armazena valores do tipo sim e não, verdadeiro e falso. O tipo de dado
lógico também é conhecido como booleano.
5 DECLARANDO CONSTANTES E VARIÁVEIS

A sintaxe do portugol para declaração de variáveis é a seguinte:
variável: tipo de dado;
Por exemplo, a variável Cidade armazena somente caracteres:
cidade: caractere;
Podemos declarar mais variáveis ao mesmo tempo para cada tipo. Vejamos
a sintaxe:
variavel1, variavel2, variavel3: inteiro;
147
Vejamos o exemplo:
peso, altura, idade: inteiro;
Para declararmos as constantes não precisamos identificar o tipo de dado,

pois quando a declaramos já atribuímos o valor correspondente, sendo que este
valor será o mesmo do início até o fim do algoritmo. Vejamos a sintaxe:
constante = valor;
Exemplos práticos:
salario_minino = 750,00;
aliquota: 7,5;
Você observou que ao término de cada instrução temos um ponto e vírgula

(;)? Isto indica que a instrução acabou. O ponto e vírgula tem a função de identificar
onde termina e começa outra instrução.
Veja agora como fica a declaração da constante e da variável em um

algoritmo.
Algoritmo declaração;
Constantes
Percentual = 8,5
Reajuste = 6;
Variáveis
Sexo: caractere;
Quantidade: inteiro;
Peso, valor: real;
Início
<instruções>
Fim.
As instruções do algoritmo sempre acontecem após as declarações entre os

comandos início e fim.
148
6 COMANDOS BÁSICOS DE UM ALGORITMO

Os comandos básicos são instruções elementares utilizadas na maioria dos
softwares. Estas instruções são atribuição, leitura, escrita e comentário.
• Atribuição: o comando de atribuição permite atribuir conteúdo a um determinado

identificador. Este conteúdo pode ser um dado que está armazenado em outro
identificador, o resultado de um cálculo, o retorno de uma sub-rotina (função),
entre outros. É importante observar que à esquerda do símbolo de atribuição
deve haver apenas um identificador.
A atribuição deve levar em consideração a compatibilidade do conteúdo com

o tipo do identificador. A atribuição de conteúdo incompatível ao suportado pelo
tipo de dado pode causar erros de compilação ou de execução. Em consequência
desta incompatibilidade, o programa pode terminar de forma brusca ou gerar
resultados inconsistentes. Na maioria das linguagens de programação, a atribuição
é representada por = (igual) ou := (dois pontos e igual).
Exemplo(s):
Continuar = verdadeiro;
Aluna = “Maria”;
Quantidade = 7;
Total_Bruto = A + B;
• Leitura: o comando de leitura permite a obtenção de dados do meio externo para

o programa. Em algoritmos, esta entrada de dados geralmente é feita através do
teclado. A leitura pode se referir ainda à obtenção de conteúdos de um arquivo,
de um banco de dados, de uma porta de comunicação, entre outros.
A sintaxe deste comando é leia (identificador). O identificador utilizado

neste comando indica onde o dado deve ser armazenado.
Exemplo(s):
leia(Continuar);
leia(Total_Bruto);
leia(Idade);
leia(Nome);
leia(Prosseguir);
• Escrita: o comando de escrita permite interagir com o usuário do software

através da apresentação do resultado de um processamento ou a solicitação de
uma nova entrada de dados. A escrita pode se referir ainda ao armazenamento
de dados num arquivo, num banco de dados, no envio de conteúdo para uma
impressora, entre outros.
149
A representação é escreva ( [identificador, conteúdo] ). Os parâmetros

deste comando podem ser um ou mais identificadores, que podem ser combinados
com um ou mais conteúdos predeterminados (caracteres, textos, números e outros
identificadores).
Exemplo(s):
Escreva(“Primeiro Algoritmo.”);
Escreva(“Total: “, Total_Bruto);
Escreva(“Sua idade é: “, Idade);
Escreva(“Deseja prosseguir? (S/N): “);
Escreva(“Informe seu nome: “);
• Comentários: para que um algoritmo seja entendido e executado facilmente são

necessárias informações adicionais chamadas de comentários. Os comentários
são delimitados por chaves aberta e fechada ({ }), sendo que o que estiver escrito
entre estes comandos será interpretado como comentário e não haverá alguma
ação por parte do programa.
Exemplo:
Algoritmo comentário
var {Exemplo de comentário}

pessoa: caractere; {Variável para armazenar o nome}
idade: inteiro; {Variável para armazenar a idade}
Inicio
<comandos>
Fim.
Agora que vimos os comandos básicos vamos construir nosso primeiro

algoritmo. Nosso algoritmo fará a leitura de dois números, a soma deles e mostrará
o valor na tela. Vejamos como ficaria:
150
Algoritmo Soma
{Definição de variáveis}
Var
{Declara três variáveis para armazenar valores do tipo real}
valor1, valor2, soma: real;
inicio
{Solicita e armazena os dois valores que o usuário deseja somar}
Escreva (“Informe o primeiro valor:”);

Leia(valor1);
Escreva (“Informe o segundo valor:”);
Leia(valor2);
{Agora faremos a soma dos valores e armazenaremos o

resultado na variável soma}
soma = valor1 + valor2;
{Agora que temos o valor armazenado vamos exibir na tela para o
usuário}
Escreva (“A soma de”, Valor1, “+”, Valor2, “é”, soma);

Fim.
Supondo que o usuário informou o número 5 para o valor1 e o número 3

para o valor2, o conteúdo de soma será o número 8. Assim, o resultado exibido
pelo comando Escreva (“A soma de”, Valor1, “+”, Valor2, “é”, soma); será:
A soma de 5 + 3 é 8
7 EXPRESSÕES
No exemplo de nosso primeiro algoritmo utilizamos a expressão somar,
para calcularmos a soma dos dois números informados pelo usuário. A seguir
você irá conhecer outros tipos de expressões, seus operadores e suas descrições.
• Operadores Aritméticos: são utilizados para a realização de operações

matemáticas. Os operadores estão relacionados no quadro a seguir.
151
QUADRO 3 – OPERADORES ARITMÉTICOS
Operador Função
+ Adição e concatenação
- Subtração
* Multiplicação
/ Divisão de valores reais
div Divisão de valores inteiros
Mod Resto da divisão de valores inteiros
FONTE: A autora
• Operadores Lógicos: são utilizados para o tratamento de relações lógicas. O

resultado obtido destas operações é sempre o valor verdadeiro ou falso. No
quadro a seguir estão relacionados os operadores lógicos.
QUADRO 4 – OPERADORES LÓGICOS
Operador Função
e Conjunção
ou Disjunção
não Negação
FONTE: A autora
• Operadores Relacionais: são utilizados para a realização de comparações entre

dois elementos do mesmo tipo de dado. O resultado obtido a partir de operações
com estes operadores é sempre o valor verdadeiro ou falso. Tais operadores
estão relacionados no quadro a seguir.
QUADRO 5 – OPERADORES RELACIONAIS
Operador Função
= Igual
> Maior
>= Maior igual
< Menor
<= Menor igual
<> Diferente
FONTE: A autora
Dependendo da situação, os operadores poderão ser utilizados de forma

combinada, permitindo resolver operações mais complexas. Estas operações
poderão ser aritméticas, lógicas, relacionais ou combinações entre elas.
152
RESUMO DO TÓPICO 2
Chegamos ao final do Tópico 2. Neste tópico você estudou que:
• As variáveis são o conjunto de memórias auxiliares que ajudam o programador

na realização das operações necessárias nos programas. A declaração de
variáveis deve seguir uma regra para que os identificadores delas sejam aceitos
pelas linguagens de programação. Esta regra diz que uma variável deve iniciar
com uma letra ou sublinha (_), conter nos demais elementos letras, números e/
ou sublinha.
• Constantes são valores inseridos em cada parte da memória do computador e

que permanecem do início ao fim do algoritmo.
• Os tipos de dados são o conjunto de valores que um determinado identificador

daquele tipo poderá assumir. Também pode-se entender que é o conjunto de
valores que ele poderá representar. O conjunto de valores se refere tanto ao
formato (caractere, inteiro, real etc.) quanto ao tamanho do conjunto que pode
ser representado (0..255, -32768..32767 etc.).
153
AUTOATIVIDADE
1 Defina o tipo de dado mais adequado para as variáveis segundo o conteúdo

a ser armazenado (inteiro, real, caractere ou lógico):
a) Metros
b) Peso
c) Valor_da_compra
d) CPF
e) Endereço
f) Ok
g) Estado_civil
2 Assinale o tipo de operador utilizado em cada expressão, considerando que

uma expressão pode conter mais de um operador:
a) 198 + 12
( ) Aritmético
( ) Aritmético e Lógico
( ) Relacional e Aritmético
b) (Parar = Sim) ou (Sinal = ‘Vermelho’)
( ) Aritmético e Lógico
( ) Aritmético e Relacional
( ) Lógico e Relacional
3 Desenvolva os algoritmos propostos a seguir.
a) Faça um algoritmo que leia quatro notas de um aluno e escreva a média

obtida.
b) Faça um algoritmo para determinar o consumo médio de um automóvel

sendo fornecida a distância total percorrida pelo automóvel e o total de
combustível gasto.
154
UNIDADE 3
TÓPICO 3
ESTRUTURAS DE CONTROLE
1 INTRODUÇÃO
As estruturas de controle permitem determinar como um conjunto de
instruções deverá ser executado para a realização das tarefas desejadas. Esta
determinação pode ser a ordem em que as instruções deverão ser executadas, a
submissão a determinadas condições ou o refinamento do processamento.
É importante observar que não existe uma regra de subordinação básica ou

única para a utilização das estruturas de controle. Pode-se utilizar as estruturas de
controle em qualquer combinação de subordinação.
2 ESTRUTURAS DE CONTROLE SEQUENCIAL

Esta estrutura de controle permite a definição da sequência em que as
instruções deverão ser executadas. A finalidade desta estrutura é definir a ordem
em que as instruções devem ser executadas. Uma inversão na ordem de execução
das instruções pode modificar significativamente o resultado.
Exemplo:
155
Algoritmo Calcula;
var
Primeiro, Segundo, Resultado : inteiro;
Início
Primeiro = 0;
Segundo = 0;
escreva (“Informe o primeiro número:”’);
leia(Primeiro);
escreva (’Informe o segundo número: ’);
leia(Segundo);
Resultado = (Primeiro * 3) + Segundo;
escreva(Resultado);
fim.
Neste algoritmo são solicitados dois números; em seguida, o primeiro

número é multiplicado por três e somado ao segundo número.
3 ESTRUTURAS DE CONTROLE CONDICIONAL

Para tomar uma decisão em lógica, você deve utilizar a estrutura de
controle condicional, também conhecida como estrutura de controle decisória
ou de decisão ou estrutura de controle alternativa. Essa estrutura executa um ou
vários comandos desde que seja satisfeita uma condição, ou várias, representada
por uma expressão lógica. A estrutura de controle condicional se classifica em
simples ou composta (XAVIER, 2004).
Na estrutura de controle condicional simples utiliza-se os comandos se,

então e fim_se na construção da instrução. Nesta instrução se a condição definida
entre os comandos se e então for verdadeira, serão executadas todas as instruções
subordinadas e definidas dentro do bloco adjacente entre os comandos se...então
e fim_se. Após a execução ocorre automaticamente a execução das eventuais
instruções existentes após o comando fim_se. Se a condição for falsa, serão
executadas apenas as eventuais instruções que estiverem após o comando fim_
se.Veja a sintaxe:
se (<condição>) então
instruções executadas após condição ser verdadeira
fim_se
instruções executadas após condição ser falsa ou após executar instruções
Exemplos:
156
TÓPICO 3 | ESTRUTURAS DE CONTROLE
se (A > 10) então

se (Prosseguir = verdadeiro) então
se (Nome <> ’ ’) então
se ((A > 10) e (A < 20)) então
se não Terminou então
A estrutura de controle condicional simples possibilita a execução de

comandos somente se a condição for verdadeira. Se a condição for falsa, não pode
executar qualquer comando dentro desta estrutura. Para isso existe a estrutura
condicional composta formada pela mesma estrutura da condicional simples, mas
acrescida do comando senão.
Se a condição definida entre os comandos se e então for verdadeira, são

executadas todas as ações subordinadas do bloco entre os comandos se...então e
senão. Caso a condição seja falsa, são executadas todas as instruções subordinadas
do bloco entre os comandos senão e fim_se. Vejamos a sintaxe:
se (<condição>) então
instruções executadas após condição ser verdadeira
senão
instruções executadas após condição ser falsa
fim_se
instruções executadas após condição ser falsa ou após executar instruções
Exemplo:
se (A > 10) então

início se
escreva(A, “ é maior que 10.”);
fim se
senão
início senão
escreva(A, “ é menor que 10.”);
fim senão;
157
No exemplo anterior, verificamos apenas duas condições. Porém no dia

a dia precisaremos muitas vezes fazer vários testes ou comparações, com vários
comandos se. Para isso utilizamos o encadeamento de comandos, inserindo um
dentro do outro, para aplicar e verificar todas as soluções possíveis.
A seleção encadeada é resolvida com a utilização do comando se então

subordinado a outro se então. Esta subordinação ou encadeamento pode ter vários
elementos envolvidos.
Exemplo:
se ((A >= 10) e (A <= 20)) então

início se
se (A <= 15) então

início se
escreva(A, ’ está entre 10 e 15’);

fim se
senão
início senão
escreva(A, ’ está entre 16 e 20’);
fim senão;
fim se
senão
início senão
escreva(A, ’ não está entre 10 e 20’);
fim senão;
fim_se;
Para a resolução de seleções múltiplas utiliza-se o comando escolha caso.

Para a construção da instrução utiliza-se os comandos caso, seja, faça, senão e
fim_caso.
Vejamos a sintaxe:
Escolha (expressão)
Caso <rótulo1>: <bloco de comandos>
158
Senão
<bloco de comandos>
Fim escolha
Exemplo:
escolha Numero
caso 1: escreva(’*’);
caso 2: escreva(’**’);
caso 3: escreva(’***’);
senão
escreva(’Este número está fora da faixa.’);
fim escolha.
4 ESTRUTURAS DE CONTROLE DE REPETIÇÃO

Às vezes é necessário repetir a mesma tarefa para se chegar a um resultado
final. Por exemplo, para encher uma caixa, você coloca dentro dela um objeto e
verifica. Se constatar que a caixa ainda não está cheia, coloca mais um objeto. A ação
se repetirá até você atingir o objetivo: encher a caixa. Quando isso acontecer, você vai
parar de colocar objetos nela (XAVIER, 2004).
Para repetir tarefas no algoritmo, evitando escrever várias vezes a mesma

coisa, você pode utilizar a estrutura de controle de repetição.
4.1 ESTRUTURA DE REPETIÇÃO ENQUANTO-FAÇA

O comando enquanto faça é o mais adequado para situações em que a
condição de término da repetição deve ser testada antes da execução das instruções
subordinadas à estrutura de controle.
Os comandos enquanto, faça e fim_enquanto são utilizados para a

construção da instrução enquanto...faça/fim_enquanto. Neste trecho de instruções
são executadas as instruções subordinadas ao bloco entre os comandos enquanto_
faça e fim_enquanto, no período em que o resultado lógico da condição permanecer
verdadeiro entre os comandos enquanto e faça. No momento em que o resultado
lógico for falso são executadas as instruções que estiverem após o comando fim_
enquanto. Vejamos a sintaxe:
159
enquanto (<condição>) faça

Instruções a serem executadas enquanto a condição for verdadeira
fim_enquanto
Agora vamos para o exemplo:
Quantidade = 0;
enquanto (Quantidade <= 5) faça
início enquanto
Quantidade = Quantidade + 1;
escreva(Quantidade, ’ª execução.’);
fim enquanto;
Vamos a mais um exemplo. Algoritmo que executa cinco vezes e em cada

vez escreve o número da execução utilizando o comando enquanto faça.
Algoritmo Enquanto_Faca;
variáveis
Quantidade : inteiro;
início
Quantidade = 1;
enquanto (Quantidade <= 5) faça
início enquanto
escreva(Quantidade, ’ vez.’);
fim enquanto;
fim.
4.2 ESTRUTURA DE REPETIÇÃO PARA-FAÇA

A utilização do comando para faça é recomendada para situações em que
se conhece previamente a quantidade de vezes que o conjunto de instruções deve
ser executado. Esta quantidade de vezes também é conhecida como limite inferior
e limite superior.
Para essa estrutura utiliza-se os comandos para, de, até, passo, faça e fim_
para para realizar a construção da instrução desta estrutura. Pode-se executar um
determinado conjunto de instruções subordinadas a um bloco até determinado
160
número de vezes. No momento que o valor da variável de controle atingir o valor

definido no segmento de fim de contagem, serão executadas as eventuais instruções
que estiverem após o comando fim_para. Vejamos a sintaxe:
Para <variável> de <início> até <fim> passo <incremento> faça

<Instruções>
Fim_para
Vejamos o exemplo:
para Quantidade de 1 até 5 faça

início para
escreva(Quantidade, execução.’);
fim para;
Vejamos mais um exemplo. Algoritmo que executa cinco vezes e em cada

vez escreve o número da execução utilizando o comando para faça.
Algoritmo Para_Faca;
variáveis
início
para Quantidade de 1 até 5 faça
início para
fim para;
fim.
4.3 ESTRUTURA DE REPETIÇÃO REPITA_ATÉ

O comando repita até é mais adequado para situações em que as instruções
subordinadas à estrutura de controle deverão ser executadas pelo menos uma vez,
antes do teste da condição de término. Em algumas linguagens de programação
o comando repita até pode ser encontrado como uma variante do enquanto faça.
161
Na estrutura repita até são executadas instruções entre os comandos repita

e até_que durante o período em que o resultado lógico da condição permanecer
falso. No momento em que o resultado for verdadeiro, executam-se as eventuais
instruções que estiverem após o comando até_que. Vejamos a sintaxe:
Repita
<instruções>
Até_que
Vejamos o exemplo:
Quantidade = 0;
repita
escreva(Quantidade, ’ª execução.’);
até (Quantidade >= 5);
Vejamos mais um exemplo. Algoritmo que executa cinco vezes e em cada

vez escreve o número da execução utilizando o comando repita até.
Algoritmo Repita_Ate;
variáveis
início
Quantidade = 1;
repita
até (Quantidade > 5);
fim.
162
RESUMO DO TÓPICO 3
Chegamos ao final de mais um tópico. Neste tópico vimos que:
• Os algoritmos são baseados quase em sua totalidade nas estruturas. As estruturas

são sequência, seleção e repetição. Com isso, quem aprender a utilizar bem estas
estruturas poderá programar grande parte dos softwares existentes atualmente.
Exceção pode se dar em casos que utilizem tecnologias mais avançadas.
• A estrutura de sequência define a ordem em que as instruções devem ser

executadas para que o resultado definido para o algoritmo seja atingido. Caso
a estrutura de sequência não seja obedecida, os resultados obtidos por tal
algoritmo são imprevisíveis, pois as instruções dependentes podem estar sendo
executadas antes daquelas que as deveriam preceder.
• A estrutura de seleção permite a definição de desvios condicionados às condições

definidas na expressão do comando de seleção definido. A estrutura de seleção
pode ser subdividida nos tipos: simples, composta, encadeada e múltipla. Na
seleção simples, composta e encadeada é utilizado o comando se e na seleção
encadeada é utilizado o comando escolha caso.
• A estrutura de repetição visa permitir a execução de um conjunto de instruções

na quantidade de vezes necessárias de acordo com a condição estabelecida na
expressão de controle do laço. As estruturas de seleção são: enquanto faça, para
faça e repita até.
• É importante observar que as estruturas de seleção e repetição utilizam

expressões como forma de definir o que deve ser executado. Estas expressões
demonstram o quanto a computação tem suas raízes na área da matemática.
Portanto, conhecimentos e habilidades com lógica são muito importantes para
profissionais da área de computação.
163
AUTOATIVIDADE
Caro acadêmico, como forma de fixar o conteúdo estudado, realize a

autoatividade proposta a seguir:
1 Desenvolva os algoritmos propostos a seguir.
a) Elabore um algoritmo onde será lido o valor de vários itens de compra e ao

final escreva o valor a ser pago. O algoritmo deverá continuar lendo itens
enquanto o valor digitado for diferente de zero.
b) Uma loja deseja saber quantos clientes compram 1 = à vista, 2 = 30 dias e 3

= 60 dias. Desenvolva um algoritmo que leia uma quantidade ilimitada de
clientes. Ao informar zero, o algoritmo será finalizado e deverá apresentar
quantos clientes foram digitados em cada condição.
c) Construa um algoritmo para calcular e escrever o IMC (Índice de Massa

Corporal) de uma pessoa. São fornecidos o nome da pessoa, o peso e a altura.
A fórmula para calcular o IMC é o peso dividido pela altura ao quadrado.
Com base no resultado do cálculo do IMC, escreva o resultado conforme as
seguintes faixas:
até 20,0 (inclusive) = abaixo do peso

acima de 20,0 e abaixo de 25,0 = peso normal
entre 25,0 e abaixo de 30,0 = sobrepeso
entre 30,0 e abaixo de 40,0 = obeso
40,0 e acima = obeso mórbido
O algoritmo deverá ser executado até que seja informado “FIM” no
nome da pessoa.
d) Faça um algoritmo que leia o nome de uma pessoa e várias ligações

telefônicas (número do telefone e valor da ligação), enquanto o número do
telefone informado for diferente de zero. Ao final escreva o nome do cliente
e o valor da conta telefônica.
e) No controle de qualidade de uma empresa são classificadas as mercadorias

como de primeira, de segunda e refugo. Elabore um algoritmo para ler 100
peças e no final escreva quantas são de primeira, quantas são de segunda e
quantas são refugo.
164
UNIDADE 3
TÓPICO 4
TIPOS ESTRUTURADOS
1 INTRODUÇÃO
A partir do momento em que se passa a construir algoritmos mais
sofisticados, aumenta proporcionalmente a necessidade de elementos que deem
suporte a esta construção.
Utilizando apenas os tipos de dados primitivos, os algoritmos podem ser

bastante restritos e limitados. Felizmente, os tipos estruturados permitem romper as
barreiras desta limitação.
Tipos estruturados são tipos de dados construídos a partir de outros

tipos de dados. Os tipos de dados utilizados como base para a criação dos tipos
estruturados podem ser tipos primitivos ou tipos estruturados que já tenham sido
previamente definidos.
2 REGISTROS
Registros permitem a criação de tipos de dados heterogêneos. Os elementos
que compõem o registro são chamados de campos. Estes campos devem ter nomes
(identificadores) diferentes e podem ter o mesmo tipo de dado ou tipos de dados
diferentes, conforme a necessidade.
Em algumas linguagens de programação a construção do tipo registro pode

ser encontrada com o nome estrutura (struct) (KOCHANSKI; ANDRIETTI, 2005).
O algoritmo a seguir contém um registro que armazena o código, o nome e

o endereço de uma pessoa.
165
Algoritmo Registro;
tipo
TCadastroPessoas = registro
Codigo : inteiro;
Nome : caracter;
Endereco : caracter;
fim registro;
variaveis
CadastroPessoas : TCadastroPessoas;
início
escreva(’Informe o código: ’);
leia(CadastroPessoas.codigo);
escreva(’Informe o nome: ’);
leia(CadastroPessoas.nome);
escreva(’Informe o endereço: ’);
leia(CadastroPessoas.endereco);
fim.
3 VETORES
Vetor é o nome atribuído a um tipo estruturado que armazena um conjunto
unidimensional de elementos homogêneos. Os vetores são conjuntos homogêneos,
pois todos os elementos que o compõem são do mesmo tipo.
Os vetores podem ser classificados em simples e estruturado.
Um vetor simples é composto por elementos com apenas um campo. Este

conjunto poderá ter vários elementos e em cada elemento poderá ser armazenado
apenas um valor (KOCHANSKI; ANDRIETTI, 2005).
Vejamos a sintaxe:
Variável: conjunto[ ] de <tipo de dado>
Exemplo: O algoritmo a seguir implementa um vetor com capacidade para

armazenar 10 números do tipo inteiro.
166
TÓPICO 4 | TIPOS ESTRUTURADOS
Algoritmo VetorSimples;
tipo
TNumeros = Vetor[1..10] de inteiro;
variáveis
VetorNumeros : TNumeros;
Contador : inteiro;
início
para Contador de 1 até 10 faça
início para
escreva(’Informe um número: ’);
leia(VetorNumeros[Contador]);
fim para;
fim.
Um vetor estruturado é composto por elementos cujo tipo de dado utilizado

é derivado de outros tipos de dados. Um vetor estruturado também é conhecido
como um vetor de registros (KOCHANSKI; ANDRIETTI, 2005).
Exemplo:
Este algoritmo armazena o código e a idade de 10 alunos em um vetor

homogêneo estruturado com registro de apenas um tipo de dado.
Algoritmo VetorEstruturadoUm;
tipo
TCadastroAluno = registro
Codigo : inteiro;
Idade : inteiro;
Fim registro;
TAlunos = Vetor[1..10] de TCadastroAluno;
variáveis
VetCadAlu : TAlunos;
Contador : inteiro;
início
para Contador de 1 até 10 faça
início para
escreva(’Informe o código do aluno: ’);
leia(VetCadAlu[Contador].Codigo);
escreva(’Informe a idade do aluno: ’);
leia(VetCadAlu[Contador].Idade);
fim para;
fim.
167
É importante observar que para criar um vetor homogêneo estruturado

deve-se, primeiro, criar um registro com os dados necessários. O passo seguinte
é criar um vetor que usará o tipo de dado criado no registro e então declarar uma
variável do tipo do vetor. O registro pode ter um ou vários tipos de dados.
4 MATRIZES
Matriz é o nome atribuído a um tipo estruturado que armazena um conjunto
bidimensional de elementos homogêneos. As matrizes são conjuntos homogêneos,
pois todos os elementos que a compõem são do mesmo tipo.
Nas matrizes, além do limite inferior e superior do eixo X, há também

o limite inferior e superior do eixo Y. Assim como nos vetores, as matrizes
também podem ser compostas por elementos baseados em tipos de dados
primitivos ou estruturados.
Uma matriz simples é composta por elementos com apenas um campo.

Este conjunto poderá ter vários elementos em cada dimensão e em cada elemento
poderá ser armazenado apenas um valor (KOCHANSKI; ANDRIETTI, 2005).
Exemplo: este algoritmo tem capacidade de armazenar nove números do

tipo inteiro.
Algoritmo MatrizSimples;
tipo
TMatriz = Vetor[1..3, 1..3] de inteiro;
variáveis
Matriz : TMatriz;
Linha : inteiro;
Coluna : inteiro;
início
para Linha de 1 até 3 faça
início para
para Coluna de 1 até 3 faça
início para
escreva(’Informe um número para a ’, Coluna, ’ coluna da ’,
Linha, ’ Linha: ’);
leia(Matriz[Linha, Coluna]);
fim para;
fim para;
fim.
168
TÓPICO 4 | TIPOS ESTRUTURADOS
Neste exemplo a matriz de 3 X 3 com tipo de dado inteiro foi carregada

com números na seguinte ordem:
• primeira coluna da primeira linha;

• segunda coluna da primeira linha;
• terceira coluna da primeira linha;
• primeira coluna da segunda linha;
• segunda coluna da segunda linha;
• terceira coluna da segunda linha;
• primeira coluna da terceira linha;
• segunda coluna da terceira linha; e
• terceira coluna da terceira linha.
Uma matriz estruturada é composta por elementos cujo tipo de dado utilizado
é derivado de outros tipos de dados. Uma matriz estruturada também é conhecida
como uma matriz de registros.
Exemplo: este algoritmo armazena os dados de 25 alunos em uma matriz

de registros onde cada célula da matriz recebe o código e a idade de um aluno.
Algoritmo MatrizEstruturadaUm;
constantes
MaxLin = 5;
MaxCol = 5;
tipo
TAlu = registro
Codigo : inteiro;
Idade : inteiro;
fim registro;
TMatAlu = Vetor[1..MaxLin, 1..MaxCol] de TAlu;
variaveis
Matriz : TMatAlu;
Linha : inteiro;
Coluna : inteiro;
início
para Linha de 1 até MaxLin faça
início para
para Coluna de 1 até MaxCol faça
início para
escreva(’Informe o código do aluno da ’, Coluna, ’ coluna da ’,
leia(Matriz[Linha, Coluna].Codigo);
escreva(’Informe a idade do aluno da ’, Coluna, ’ coluna da ’,
leia(Matriz[Linha, Coluna].Idade);
fim para;
fim para;
fim.
169
Vejamos mais um exemplo: neste algoritmo é possível armazenar os dados

de 50 pessoas em uma matriz de registros onde cada célula da matriz recebe o
código, o nome, o endereço e a renda de uma pessoa.
Algoritmo MatrizEstruturadaDois;
constantes
MaxLin = 10;
MaxCol = 5;
tipo
TCadPes = registro
Codigo : inteiro;
Nome : caracter;
Endereco : caracter;
Renda : real;
fim registro;
TCad = Vetor[1..MaxLin, 1..MaxCol] de TCadPes;
variáveis
{Declaração da variável do tipo TCad}
Cad : TCad;
Linha : inteiro;
Coluna : inteiro;
início
para Linha de 1 até MaxLin faça
início para
para Coluna de 1 até MaxCol faça
início para
escreva(’Informe o codigo da pessoa da ’, Coluna, ’ coluna da ’,
Linha, ’Linha: ’);
leia(Cad[Linha, Coluna].Codigo);
escreva(’Informe o nome da pessoa da ’, Coluna, ’ coluna da ’,
leia(Cad[Linha, Coluna].Nome);
escreva(’Informe o endereço da pessoa da ’, Coluna, ’ coluna da
’,Linha, ’ Linha: ’);
leia(Cad[Linha, Coluna].Endereco);
escreva(’Informe a renda mensal da pessoa da ’, Coluna, ’ coluna da
’,Linha, ’ Linha: ’);
leia(Cad[Linha, Coluna].Renda);
fim para;
fim para;
fim.
170
RESUMO DO TÓPICO 4
Caro(a) acadêmico(a), neste tópico você estudou que:
• Os tipos estruturados ou estruturas de dados estáticas são arranjos de dados

que permitem o armazenamento e navegação no conjunto de dados de modo
simples e rápido.
• Os registros são estruturas nas quais são definidos conjuntos de dados que
podem ser utilizados em vetores, matrizes ou mesmo em listas dinamicamente
alocadas na memória. Este conjunto de dados pode conter diferentes tipos de
dados, pois o registro é uma nova definição de tipo de dado.
• Vetores são estruturas homogêneas que permitem a rápida navegação pelos

elementos. Os vetores com os quais lidamos neste Caderno de Estudos
são estruturas estáticas, ou seja, o seu tamanho deve ser definido em tempo
de programação e a alocação é feita uma única vez na carga do programa.
Vetores são especialmente úteis para tratamento de dados intermediários cuja
quantidade seja pequena e previamente conhecida. Vetores estáticos não são
muito aconselháveis em situações em que não se conhece a quantidade de
elementos ou esta quantidade seja grande.
• Matrizes são estruturas homogêneas cuja diferença dos vetores é a possibilidade

de definir quantidade de linhas superior a uma. Os vetores permitem a definição
da quantidade de colunas, porém a quantidade de linhas é sempre uma. As
matrizes são especialmente úteis em situações em que é necessário armazenar e
navegar em um conjunto de dados bidimensional.
171
AUTOATIVIDADE
Elabore os algoritmos propostos a seguir.
a) Elabore um algoritmo que implemente uma matriz de 15 X 12 onde as linhas

são os produtos em estoque e as colunas são as quantidades incluídas em
cada mês do ano. Ao terminar a inclusão dos dados, liste a matriz.
b) Faça um algoritmo que leia uma matriz de 5 X 5 e multiplique cada um dos

seus elementos por um número qualquer. Carregue uma segunda matriz
com os valores multiplicados. Ao final, liste a matriz original e a matriz com
os números multiplicados.
c) Construa um algoritmo que leia duas matrizes de 3 X 3 e ao final mostre as

matrizes e uma terceira matriz com a soma das duas.
172
UNIDADE 3
TÓPICO 5
SUBALGORITMOS E ESCOPO DE IDENTIFICADORES
1 INTRODUÇÃO
Os subalgoritmos são uma forma de organização que visa especializar
um conjunto de instruções e tornar ainda mais clara a descrição de cada parte da
solução.
Quando a quantidade de instruções torna-se muito elevada e principalmente

quando um mesmo bloco de instruções precisa ser utilizado várias vezes, é
aconselhável o uso de subalgoritmos. A estrutura básica de um subalgoritmo
compreende as seguintes partes:
Cabeçalho do subalgoritmo
Definição de constantes
Definição de tipos de dados
Definição de variáveis
Início do subalgoritmo
Corpo principal do subalgoritmo
Fim do subalgoritmo.
Conforme se pode perceber na estrutura de um subalgoritmo, ele segue o

mesmo princípio estrutural de um algoritmo.
Um subalgoritmo pode ser chamado a partir do corpo principal do

algoritmo ou de outro subalgoritmo.
Exemplo: este algoritmo demonstra a utilização de um subalgoritmo.
173
Algoritmo Soma;
variáveis
Primeiro : inteiro;
Segundo : inteiro;
subalgoritmo SomaValores(N1, N2 : inteiro);
início
SomaValores = N1 + N2;
fim;
início
Primeiro = 0;
Segundo = 0;
escreva(’Informe o primeiro número: ’);
leia(Primeiro);
escreva(’Informe o segundo número: ’);
leia(Segundo);
escreva(SomaValores(Primeiro, Segundo));
fim.
2 ESCOPO DE IDENTIFICADORES
O escopo de identificadores (constantes, tipos e variáveis) define a
abrangência de utilização dos mesmos. O escopo define onde um identificador
pode ser utilizado. Os elementos declarados no cabeçalho podem ser utilizados em
qualquer ponto do algoritmo. Este tipo de declaração é conhecido como declaração
global (KOCHANSKI; ANDRIETTI, 2005).
Exemplo:
Variáveis do tipo Global (Primeiro, Segundo e Resultado) podem ser

vistas por todo o algoritmo. Vejamos o subalgoritmo com uso de variáveis globais
(Primeiro, Segundo e Resultado), as quais podem ser vistas por todo o algoritmo.
174
TÓPICO 5 | SUBALGORITMOS E ESCOPO DE IDENTIFICADORES
Algoritmo Calcula;
variáveis
Primeiro : inteiro;
Segundo : inteiro;
Resultado : inteiro;
início
Resultado = N1 + N2;
fim;
início
leia(Primeiro);
leia(Segundo);
SomaValores(Primeiro, Segundo);
escreva(Resultado);
fim.
Já as declarações feitas no cabeçalho de um subalgoritmo podem ser

utilizadas apenas no corpo do subalgoritmo. Fora do subalgoritmo estas declarações
não são conhecidas. Este tipo de declaração é chamado local.
Exemplo(s):
Variáveis do tipo local (Soma) só podem ser vistas por quem a declarou.
Algoritmo Calcula;
variáveis
Primeiro : inteiro;
Segundo : inteiro;
Resultado : inteiro;
variáveis
inteiro : Soma;
início
Soma = N1 + N2;
fim;
início
leia(Primeiro);
leia(Segundo);
escreva(SomaValores(Primeiro, Segundo));
fim.
175
Um subalgoritmo, além de processar, pode receber e devolver dados.

O recebimento de dados é utilizado em situações em que é necessário fornecer
valores específicos para serem manipulados no subalgoritmo. Para isso chamamos
de passagem de parâmetros (KOCHANSKI; ANDRIETTI, 2005).
A passagem de parâmetros permite generalizar a solução através da

indicação de comportamentos específicos passados nos parâmetros.
Exemplo: neste algoritmo são passadas por parâmetro duas notas lidas e o
subalgoritmo carrega a variável global “Media” com a média do aluno.
Algoritmo Media;
variáveis
inteiro : Nota1;
inteiro : Nota2;
real : Media;
subalgoritmo CalculaMedia(N1, N2 : inteiro);
início
Media = (N1 + N2) / 2;
fim;
início
escreva(’Informe a primeira nota: ’);
leia(Nota1);
escreva(’Informe a segunda nota: ’);
leia(Nota2);
CalculaMedia(Nota1, Nota2);
escreva(Media);
fim.
Na maioria das linguagens de programação a passagem de parâmetros

pode ser efetuada de duas formas: por cópia e por referência.
Na passagem de parâmetros por cópia, uma cópia do conteúdo da variável

informada no parâmetro é fornecida ao subalgoritmo. Após copiado, o conteúdo
pode ser manipulado no subalgoritmo sem que a variável de origem seja afetada
ou alterada.
Exemplo: Algoritmo com passagem de parâmetros por cópia.
176
Algoritmo Emprestimo;
variáveis
ValorInicial : real;
ValorFinal : real;
Taxa : inteiro;
subalgoritmo CalculaJuros(Valor : real; Tx : inteiro): real;
início
CalculaJuros = (Valor * Tx) / 100;
fim;
início
escreva(’Informe o valor a emprestar: ’);
leia(ValorInicial);
escreva(’Informe a taxa de juros: ’);
leia(Taxa);
escreva(‘O valor dos juros é ‘,
CalculaJuros(ValorInicial, Taxa));
ValorFinal = ValorInicial + CalculaJuros(ValorInicial, Taxa);
escreva(‘O valor a pagar é ‘, ValorFinal);
fim.
Na passagem de parâmetros por referência não é feita uma cópia do

conteúdo. Neste caso é passada uma referência à variável de origem e as alterações
realizadas refletem diretamente sobre esta variável.
Exemplo: algoritmo com passagem de parâmetros por referência.
177
Algoritmo Juros;
variáveis
ValorInicial : real;
ValorFinal : real;
Taxa : inteiro;
subalgoritmo CalculaJuros(Valor : real;
Taxa : inteiro;
ValorFin : variaveis real): real;
início
ValorFin = Valor + (Valor * Taxa);
CalculaJuros = Valor * Taxa;
fim;
início
escreva(’Informe o valor a emprestar: ’);
leia(ValorInicial);
escreva(’Informe a taxa de juros: ’);
leia(Taxa);
escreva(‘O valor dos juros é ‘,
CalculaJuros(ValorInicial, Taxa, ValorFinal));
escreva(‘O valor valor a pagar é ‘, ValorFinal);
fim.
A diferença fundamental entre estas formas de passagem de parâmetros é

que na primeira os dados de origem não são afetados e, na segunda, são os dados
de origem que estão sendo alterados.
É importante que se conheça as consequências do uso de ambos para

utilizar cada forma nas situações que forem mais adequadas, evitando eventuais
falhas na execução por problemas na lógica empregada.
178
QUER APRENDER PROGRAMAÇÃO? SAIBA QUAL A MELHOR

LINGUAGEM!
A pergunta que é feita por todo mundo que está aprendendo a programar
é: que linguagem de programação devo aprender? A resposta é óbvia: uma
linguagem de programação para iniciantes!
Antes de mais nada, você deve ter consciência de que ao longo da sua
carreira como programador, você sempre terá que aprender uma linguagem de
programação nova. Pois todas têm suas vantagens e desvantagens. Uma dica
interessante é: não seja fanático por uma linguagem específica! Muitas pessoas
defendem com unhas e dentes a linguagem de programação que têm mais
afinidade. Mas isso não é bom! Para cada projeto, cada trabalho, uma linguagem
é mais indicada ou não. Você deve decidir qual usar não com base no seu gosto
pessoal, mas nas vantagens que a linguagem oferece para o projeto.
QUAL A MELHOR LINGUAGEM PARA APRENDER PROGRAMAÇÃO?
Se você é iniciante, procure uma linguagem de programação que te ajude

a aprender lógica de programação! Só depois de aprender o básico que você deve
aprender uma outra linguagem mais profissional. Muitas pessoas já começam
aprendendo lógica de programação com linguagens profissionais, por exemplo
java, C, python, C# etc. É totalmente válido e muitos conseguem de fato aprender,
mas algumas pessoas podem ter dificuldade de assimilar os conceitos básicos com
essas linguagens. Então, para quem nunca programou antes, indico fortemente
que comece com uma linguagem que o ajude aprender a programar.
179
Para mim foi difícil entender isso quando ensinava pessoas a programar,
queria logo que elas aprendessem java, ou C# etc. Mas a dificuldade dos iniciantes
era conseguir aprender lógica de programação tendo que “decorar” as restrições
exigidas pela linguagem. Por isso, nos artigos voltados para iniciante aqui no {
Dicas de Programação }, vamos escrever algoritmos em português (pseudocódigos)
e utilizar uma linguagem simples para transmitir os conceitos, pois o objetivo é
ensinar o básico.
VISUALG, IMPLEMENTANDO ALGORITMOS EM PORTUGUÊS!
Na minha opinião esta é a melhor ferramenta para iniciantes em programação

implementarem seus algoritmos. O Visualg foi criado por um brasileiro (Claudio
Morgado de Souza), é fácil de ser usado e compila pseudocódigos escritos em
português, também conhecidos como “Portugol”.
O Visualg foi desenvolvido para Windows. Para instalar faça o download

do instalador (versão 2.5) na página: <http://www.dicasdeprogramacao.com.br/
download-visualg/>.
A instalação é muito simples, basta executar o instalador e acionar os botões

“Avançar”, a famosa instalação “Next, next, next …”. Quando abrimos o software,
vimos uma tela com o esqueleto de um algoritmo já criado, como a imagem a seguir:
180
CRIANDO O PRIMEIRO PROGRAMA COM O VISUALG
Para batizar o Visualg vamos criar agora um programa básico. Digite o

algoritmo abaixo no visualg (as linhas que iniciam com “//” são comentários e não
são interpretadas):
Para executarmos o programa, utilize o botão indicado na figura ou

pressione F9.
181
E
IMPORTANT
Obs.: Diferentemente do que fora visto anteriormente, o visualg não utiliza o ; ao

final de cada instrução.
Para finalizar, o resultado deste programa é como apresentado pela figura

a seguir:
182
Outra coisa muito interessante no Visualg é a documentação de referência.

É tudo em português! Se você tiver dúvida de uma palavra-chave ou comando,
basta acessar a documentação através do menu ajuda. Eu mesmo já acessei muito
essas referências para ver como os comandos básicos deveriam ser escritos. Use-a!
É uma documentação bem simples e didática, com certeza ela pode te ajudar a
aprender programação.
Como pôde ser visto, programar utilizando o Visualg é muito fácil!

Por utilizar uma linguagem em português, ele torna-se um grande aliado para
iniciantes em programação. Evidentemente, não se cria softwares profissionais com
esta ferramenta, o seu grande objetivo é ajudar no ensino de lógica de programação.
E com certeza cumpre o seu papel.
FONTE: Disponível em: <http://www.dicasdeprogramacao.com.br/linguagem-de-programacao-

para-iniciantes/>. Acesso em: 25 abr. 2016.
183
RESUMO DO TÓPICO 5
Caro acadêmico, neste tópico você estudou que:
• Os subalgoritmos são estruturas de programação que possuem praticamente

todas as características e potencialidades de algoritmos. Eles permitem que seja
definido um novo tipo de dado, declaradas constantes, declaradas variáveis
e em algumas linguagens de programação, até que se definam subalgoritmos
deles.
• É importante observar que os tipos de dados, constantes e variáveis declarados

num subalgoritmo possuem escopo de utilização apenas no subalgoritmo. As
variáveis, por exemplo, são chamadas de variáveis locais. Isso significa que elas
possuem “vida” apenas dentro do subalgoritmo, não estando disponíveis para
uso por outras partes do algoritmo/programa.
• A passagem de parâmetros é um recurso bastante útil nos subalgoritmos. A

maioria das linguagens de programação permite que se utilize duas formas de
passagem de parâmetros: por cópia e por referência.
• Na passagem de parâmetros por cópia, os dados são copiados para o subalgoritmo

para o qual estão sendo passados e utilizados em seu escopo. Isso significa que
os dados passam para o subalgoritmo e podem ser alterados em seu interior,
sem que os dados a partir dos quais foram copiados sejam alterados.
• Na passagem de parâmetros por referência, o endereço da variável é levado

para dentro do subalgoritmo, de forma que quaisquer alterações no conteúdo
da variável são realizadas diretamente nela, com base no seu endereço. Isso
significa que é necessária muita atenção ao utilizar passagem de parâmetros
por referência, pois ao final da execução do subalgoritmo as variáveis passadas
poderão ter os valores alterados.
184
AUTOATIVIDADE
1 Elabore um algoritmo que leia 30 números inteiros utilizando um

subalgoritmo que recebe como parâmetro se deve mostrar os números pares
ou ímpares. Ao final, mostre os números pares e depois os números ímpares.
2 Em uma competição de agilidade são cadastrados 20 cães. Construa um

algoritmo que leia o nome, a raça e a pontuação do cão. Ao final, utilize um
subalgoritmo para mostrar os dados em ordem crescente de pontuação.
185
186
REFERÊNCIAS
ARAÚJO, Everton Coimbra. Algoritmos fundamentos e prática. Florianópolis:
Visual Books, 2007.
BOYER, Carl B. História da matemática. São Paulo: Edgard Blücher, 1996.
COMER, Douglas E. Redes de computadores e Internet. Porto Alegre: Bookman,

2001.
FOROUZAN, Behrouz; MOSHARRAF, Firouz. Fundamentos da ciência da

computação. São Paulo: Cengage, 2011
FOROUZAN, Behrouz; MOSHARRAF, Firouz. Fundamentos da computação.

São Paulo: Cengage Learning, 2011.
KOCHANSKI, Djone; ANDRIETTI, Odilon Jose. Algoritmos. Indaial: Asselvi,

2005.
KUROSE, James S. Redes de computadores e a internet: uma nova abordagem.

São Paulo: Addison Wesley, 2003.
MANZANO, José Augusto N. G; OLIVEIRA, Jayr Figueiredo de. Algoritmos:

lógica para desenvolvimento de programação de computadores. São Paulo: Érica/
Saraiva, 2014.
MONTEIRO, Mario A. Introdução à organização de computadores. Rio de

Janeiro: LTC, 2014.
SENGER, Hermes. Redes locais, metropolitanas e de longa distância. Disponível

em: <www-usr.inf.ufsm.br/~candia/aulas/espec/Aula_2_LAN_MAN_WAN.pdf>.
SOARES, Luiz Fernando Gomes. Redes de computadores: das LANs, MANs e

WANs às redes ATM. Rio de Janeiro: Campus, 1995.
TANENBAUM, Andrew S. Organização estruturada de computadores. São

Paulo: Pearson, 2009.
TECHIWAREHOUSE. Fifth Generation of Computers. 2011. Disponível

em: <http://www.techiwarehouse.com/engine/0ee1987d/Fifth-Generation-of-
Computers>. Acesso em: 26 fev. 2016.
187
THE HISTORY OF COMPUTERS. 2008. Disponível em: <http://www.ptc.dcs.edu/
Moody/comphistory/comphistory_print.html>. Acesso em: 25 fev. 2016.
XAVIER, Gley Fabiano Cardoso. Lógica de Programação. São Paulo: Senac, 2004.
188
ANOTAÇÕES
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
189

Lógica e Organização - de Computadores

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

Lógica e Organização - de Computadores

Enviado por

Direitos autorais:

Formatos disponíveis

Prof.a Greisse Moser Badalotti

Revisão, Diagramação e Produção:

Ficha catalográfica elaborada na fonte pela Biblioteca Dante Alighieri

Lógica e organização de computadores/ Greisse Moser

Bem-vindo(a) à disciplina Lógica e Organização de Computadores.

O estudo desta disciplina é muito importante para ampliar seus

Com esta disciplina você entenderá a informática de maneira sistêmica.

Aproveitamos esse momento para destacar que os exercícios deste

Este material foi desenvolvido com o objetivo de disponibilizar a você

Desejo a você sucesso nessa nova busca de informações!

Prof.a Greisse Moser Badalotti

Você já me conhece das outras disciplinas? Não? É calouro? Enfim, tanto

Na Educação a Distância, o livro impresso, entregue a todos os acadêmicos desde 2005, é

Assim, a UNIASSELVI, preocupando-se com o impacto de nossas ações sobre o ambiente,

Aproveito o momento para convidá-lo para um bate-papo sobre o Exame Nacional de

TÓPICO 1 – BREVE HISTÓRICO ........................................................................................................ 3

TÓPICO 2 – GERAÇÃO DOS COMPUTADORES .......................................................................... 15

TÓPICO 3 –TIPOS DE COMPUTADORES E SEUS COMPONENTES ....................................... 29

UNIDADE 2 – CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO ....................................... 65

TÓPICO 1 – SISTEMAS DE NUMERAÇÃO ..................................................................................... 67

TÓPICO 2 – BASES COMPUTACIONAIS ......................................................................................... 83

TÓPICO 3 – DADOS ............................................................................................................................... 99

UNIDADE 3 – LÓGICA DE PROGRAMAÇÃO ................................................................................ 135

TÓPICO 1 – FUNDAMENTOS DE LÓGICA DE PROGRAMAÇÃO .......................................... 137

TÓPICO 2 – CONSTANTES E VARIÁVEIS ....................................................................................... 145

TÓPICO 3 – ESTRUTURAS DE CONTROLE .................................................................................... 155

TÓPICO 4 – TIPOS ESTRUTURADOS .............................................................................................. 165

REFERÊNCIAS ......................................................................................................................................... 187

• conhecer os principais fatos históricos da computação;

• compreender os conceitos fundamentais da computação;

• entender a área de informática de maneira sistêmica.

TÓPICO 1 – BREVE HISTÓRICO

TÓPICO 2 – GERAÇÃO DOS COMPUTADORES

TÓPICO 3 – TIPOS DE COMPUTADORES E SEUS COMPONENTES

A informática nos permite revolucionar a forma que vivemos e agimos e

Se a informática nos auxilia em todos os lugares, por que não entendermos

Sabemos que os computadores estão em constante transformação, por isso

Podemos dividir os acontecimentos de forma cronológica e de acordo com

Agora vamos entender cada etapa desta evolução.

2.1 DISPOSITIVOS MECÂNICOS

Os homens das cavernas, contavam com as únicas ferramentas de

É importante distinguir o início dos ábacos, conhecidos como placas de

FIGURA 1 – MODELO DE ÁBACO

FONTE: Monteiro (2014)

No início do século 17, John Napier, um matemático escocês, inventou

Em 1642, com 19 anos de idade, um matemático francês chamado Blaise

FIGURA 2 – BLASE PASCAL

FONTE: Disponível em: <http://educacao.uol.com.br/biografias/blaise-

Pascal mais tarde tornou-se famoso em matemática e filosofia, mas ele

Em 1673, o inventor alemão Gottfried Leibniz aperfeiçoou a calculadora

FIGURA 3 – CALCULADORA LEIBNIZ

FONTE: Disponível em: <http://ds-wordpress.haverford.edu/bitbybit/bit-by-bit-

Em 1801, Jacquard inventou o tear Jacquard. Era uma máquina de tecelagem

Anos depois, variações sobre cartões perfurados de Jacquard foram utilizados

FIGURA 4 – TEAR DE JACQUARD

FONTE: Disponível em: <http://addiator.blogspot.com.br/2011/10/jacquards-loom-

No início da década de 1820, o matemático Inglês Charles Babbage, projetou

A Máquina Analítica era um computador mecânico que resolvia qualquer

Mesmo a máquina analítica sendo totalmente mecânica, possuía os mesmos

FIGURA 5 – MÁQUINA ANALÍTICA

FONTE: Disponível em: <http://history-computer.com/Babbage/AnalyticalEngine.html>.

2.2 DISPOSITIVOS ELETROMECÂNICOS