Lógica e Organização_ de Computadores

Prévia do material em texto

2016
Lógica e OrganizaçãO 
de cOmputadOres
Prof.a Greisse Moser Badalotti
Copyright © UNIASSELVI 2016
Elaboração:
Prof.a Greisse Moser Badalotti
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:
III
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!
Prof.a Greisse Moser Badalotti
IV
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!
UNI
V
VI
VII
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
sumáriO
VIII
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
IX
2.3 ENTENDENDO FILAS .................................................................................................................. 106
2.4 ENTENDENDO LISTAS LINEARES GERAIS ........................................................................... 109
2.5 ENTENDENDO ÁRVORES .......................................................................................................... 112
2.6 ENTENDENDO GRAFOS ............................................................................................................. 114
LEITURA COMPLEMENTAR .............................................................................................................. 115
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
X
TÓPICO 5 – SUBALGORITMOS E ESCOPO DE IDENTIFICADORES ................................... 173
1 INTRODUÇÃO .................................................................................................................................... 173
2 ESCOPO DE IDENTIFICADORES .................................................................................................. 174
LEITURA COMPLEMENTAR .............................................................................................................. 179
RESUMO DO TÓPICO 5 ....................................................................................................................... 184
AUTOATIVIDADE ................................................................................................................................ 185
REFERÊNCIAS ........................................................................................................................................ 187
1
UNIDADE 1
HISTÓRICO DA COMPUTAÇÃO
OBJETIVOS DE APRENDIZAGEM
PLANO DE ESTUDOS
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.
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
2
3
TÓPICO 1
UNIDADE 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:
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
4
 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 contagemde 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.
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.
UNI
TÓPICO 1 | BREVE HISTÓRICO
5
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.
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
6
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.
TÓPICO 1 | BREVE HISTÓRICO
7
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. 
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
8
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.
TÓPICO 1 | BREVE HISTÓRICO
9
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.
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
10
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>. 
Acesso em: 2 mar. 2016.
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.
TÓPICO 1 | BREVE HISTÓRICO
11
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). 
12
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. 
13
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.
14
15
TÓPICO 2
GERAÇÃO DOS COMPUTADORES
UNIDADE 1
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. 
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
16
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 
TÓPICO 2 | GERAÇÃO DOS COMPUTADORES
17
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/>. 
Acesso em: 2 mar. 2016.
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.
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
18
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.
TÓPICO 2 | GERAÇÃO DOS COMPUTADORES
19
4 TERCEIRA GERAÇÃO: 1965-1970
Os transistores foram um grande avanço para os computadores. No entanto, 
ninguém poderiaprever 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.
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
20
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>. 
Acesso em: 2 mar. 2016.
TÓPICO 2 | GERAÇÃO DOS COMPUTADORES
21
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.
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
22
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.
TÓPICO 2 | GERAÇÃO DOS COMPUTADORES
23
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.
DICAS
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.
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
24
Watson: computador com inteligência artificial que derrotou oponentes humanos 
em um programa de televisão chamado Jeopardy, o qual possui perguntas e respostas.
NOTA
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 linguageme 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.
TÓPICO 2 | GERAÇÃO DOS COMPUTADORES
25
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.
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ô.
DICAS
26
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.
27
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
AUTOATIVIDADE
28
29
TÓPICO 3
TIPOS DE COMPUTADORES E SEUS 
COMPONENTES
UNIDADE 1
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.
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
30
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.
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
31
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. 
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
32
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 ummicrocomputador 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.
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
33
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 
computadores móveis.
• 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.
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
34
• 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 
computadores móveis. 
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.
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
35
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.
36
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
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.
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
37
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.
38
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
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 dedados. 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.
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
39
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.
40
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
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 
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
41
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.
42
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
Os processadoresutilizados 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:
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
43
• 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 
44
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
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 
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
45
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)
46
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
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. 
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
47
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. 
48
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
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 dospais 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. 
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
49
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 
50
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
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 
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
51
slots – um para a impressora e outro para um modem. Ele achava que assim seria 
possível fabricar umamá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. 
52
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
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”.
 
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
53
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. 
54
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
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 soubesseo 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”.
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
55
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”. 
56
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
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, 
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
57
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 pequenasala 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. 
58
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
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. 
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
59
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 
60
UNIDADE 1 | HISTÓRICO DA COMPUTAÇÃO
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! 
TÓPICO 3 | TIPOS DE COMPUTADORES E SEUS COMPONENTES
61
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.
62
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.
63
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.
AUTOATIVIDADE
64
65
UNIDADE 2
CONCEITOS FUNDAMENTAIS DA 
COMPUTAÇÃO
OBJETIVOS DE APRENDIZAGEM
PLANO DE ESTUDOS
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 principaiselementos de um sistema computacional.
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
66
67
TÓPICO 1
SISTEMAS DE NUMERAÇÃO
UNIDADE 2
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).
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
68
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 
TÓPICO 1 | SISTEMAS DE NUMERAÇÃO
69
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 
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
70
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.
TÓPICO 1 | SISTEMAS DE NUMERAÇÃO
71
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.
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
72
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.
TÓPICO 1 | SISTEMAS DE NUMERAÇÃO
73
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).
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
74
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.
TÓPICO 1 | SISTEMAS DE NUMERAÇÃO
75
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.
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
76
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.
TÓPICO 1 | SISTEMAS DE NUMERAÇÃO
77
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 HEXADECIMALPARA DECIMAL
FONTE: A autora
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
78
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.
TÓPICO 1 | SISTEMAS DE NUMERAÇÃO
79
FIGURA 34 – CALCULADORA WINDOWS NO MODO PROGRAMADOR
FONTE: A autora
80
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.
81
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
82
83
TÓPICO 2
BASES COMPUTACIONAIS
UNIDADE 2
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.
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
84
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 
(FOROUZAN; MOSHARRAF, 2011).
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).
TÓPICO 2 | BASES COMPUTACIONAIS
85
3 SOFTWARE
O computador é umsistema 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.
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
86
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.
TÓPICO 2 | BASES COMPUTACIONAIS
87
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>. 
Acesso em: 17 mar. 2016. 
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 
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
88
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>. 
Acesso em: 17 mar. 2016.
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) é 
TÓPICO 2 | BASES COMPUTACIONAIS
89
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, 
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
90
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).
TÓPICO 2 | BASES COMPUTACIONAIS
91
Os sinais podem ser entendidos como ondas que são propagadas através dealgum 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.
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
92
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.
TÓPICO 2 | BASES COMPUTACIONAIS
93
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.
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
94
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ônicascomuns, 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.
TÓPICO 2 | BASES COMPUTACIONAIS
95
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.
96
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.
97
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.
98
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.
99
TÓPICO 3
DADOS
UNIDADE 2
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.
100
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
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:
Neste tópico entenderemos esta estrutura de dados para a implementação 
e discutiremos vários tipos abstratos de dados. 
TÓPICO 3 | DADOS
101
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.
102
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
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
FONTE: Forouzan e Mosharraf (2011, p. 282) 
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
FONTE: Forouzan e Mosharraf (2011, p. 282)
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)
TÓPICO 3 | DADOS
103
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
FONTE: Forouzan e Mosharraf (2011, p. 282)
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
FONTE: Forouzan e Mosharraf (2011, p. 283)
30
78
20
Elemento
do topo
Pilha antes 
da exclusão
pilha_exclui
Operação
30
Dados
eliminados
78
20
Elemento
do topo
Pilha antes 
da exclusão
Elemento
do topo
Elemento
do topo
30
78
20 20
78
30
Dados a serem
inseridos
Operação
pilha_insere
Pilha depois
da inserção
Pilha depois
da inserçã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).
104
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
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.
FONTE: Forouzan e Mosharraf (2011, p. 283)
FIGURA 43 – APLICANDO OPERAÇÃO DE PILHA
FONTE: Forouzan e Mosharraf (2011, p. 284)
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. 
pilha_cria (P)
pilha_insere (P, 10)
se (não pilha_vazia (P) ) pilha_exclui (P, X) 
pilha_insere (P, 12)
pilha_insere (P, 2) P
P
P
P
P10
12
10
2
10
10
TÓPICO 3 | DADOS
105
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
FONTE: Forouzan e Mosharraf (2011, p. 286)
a. TAD
topo
contador topo
S
[n]
[6]
[5]
[4]
[3]
[2]
[1]
S
contador topo
b. Implementação
em vetor
c. Implementação em
lista encadeada
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). 
106
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
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 
(FOROUZAN; MOSHARRAF, 2011). 
FIGURA 45 – REPRESENTAÇÃO DE FILAS
FONTE: Forouzan e Mosharraf (2011, p. 286)
Uma fila de pessoas
exclui
(fila_exclui)
inicio fim
insere
(fila_insere)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
FONTE: Forouzan e Mosharraf (2011, p. 287)
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)
TÓPICO 3 | DADOS
107
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
FONTE: Forouzan e Mosharraf (2011, p. 287)
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
FONTE: Forouzan e Mosharraf (2011, p. 288)
inicio
da fila
fim
da fila
inicio
da fila
fim
da fila
20
20
Operação Fila depoisFila antes
7878 34 34fila_exclui
Dado excluído
Para a verificação de status de fila vazia utilizamos a operação filavazia 
conforme a sintaxe a seguir: 
fila_vazia(nomedafila)
Operação Fila depoisFila antes
inicio
da fila
fim
da fila
inicio
da fila
fim
da fila
fila_insere
Dado a ser inserido
20 2078 78
34
34
OperaçãoFila antes Fila depois
108
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
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).
FIGURA 49 – REPRESENTAÇÃO DE UM ALGORITMO DE FILA
FONTE: Forouzan e Mosharraf (2011, p. 289)
fila_cria (F)
fila_insere (F, 10)
se ( não fila_vazia (F) fila_exclui (F, X)
fila_insere (F, 12)
fila_insere (F, 2)
10 12
10
12 2
12
F
F
F
F
F
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).
Vejamos a seguir a figura com um algoritmo de fila:
TÓPICO 3 | DADOS
109
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.
NOTA
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
FONTE: Forouzan e Mosharraf (2011, p. 291)
Elemento 3Elemento 1 Elemento 2 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.
110
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
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
FONTE: Forouzan e Mosharraf (2011, p. 292)
Lista
(antes da inserção)
elementos
Restante 
dos dados
Lista
(depois da inserção)
Chave
Lista
Elemento
inserido
elementos
20 25
lista_insere (lista, elemento)
10 30
Lista10 20 30
25
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
FONTE: Forouzan e Mosharraf (2011, p. 292)
Lista
(antes da exclusão)
lista_exclui (lista, alvo, elemento)
Elemento a
ser excluído
Lista
(depois da exclusão) Lista
Lista
Restante 
dos dados
Chave
elementos
alvo 25
10 20 30
25
20 2510 30
TÓPICO 3 | DADOS
111
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
FONTE: Forouzan e Mosharraf (2011, p. 293)
Chave
Restante 
dos dados
elemento
Lista
(depois da recuperação)
Lista
(antes da recuperação)
lista_recupera (lista, alvo, elemento)
Elemento a 
ser recuperado
alvo 25
20
25
10
30
25
25
10 20
30
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.
FONTE: Forouzan e Mosharraf (2011, p. 294)
112
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
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
FONTE: Forouzan e Mosharraf (2011, p. 294)
Observando a figura anterior vemos que a terceira operação insere os 
novos dados na posição correta, porquea 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).
lista_cria (L)
lista_insere (L, 10)
lista_insere (L, 5)
se ( não lista_vazia (L) ) lista_exclui (L, 3)
lista_insere (L, 6)
10
6
105
10
5 10
5
L
L
L
L
L
TÓPICO 3 | DADOS
113
FIGURA 55 – NÚMERO DE ARCOS CHEGANDO E SAINDO
FONTE: Forouzan e Mosharraf (2011, p. 296)
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
FONTE: Forouzan e Mosharraf (2011, p. 297)
E
A
I
A: raiz
B e F: nós internos
C, D, E, G, H e I: folhas
HG
F
D
B
C
Nós
114
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
FIGURA 57 – REPRESENTAÇÃO DE SUBÁRVORES
FONTE: Forouzan e Mosharraf (2011, p. 297)
Subárvore B Subárvore F
D
B
C
E
A
IHG
F
Subárvore C
Subárvore E
Subárvore D Subárvore G Subárvore H Subárvore I
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).
TÓPICO 3 | DADOS
115
FIGURA 58 – REPRESENTAÇÃO DE GRAFOS
FONTE: Forouzan e Mosharraf (2011, p. 303)
a. Grafo dirigido b. Grafo não dirigido
A A
D
E
FF
BB
CC D
E
LEITURA COMPLEMENTAR
Á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
116
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
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)
TÓPICO 3 | DADOS
117
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.
118
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
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 1e 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.
TÓPICO 3 | DADOS
119
Á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) :
 if tree == None : return
 printTreePostorder(tree.left)
 printTreePostorder(tree.right)
 print tree.cargo,
120
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
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) :
 if tree == None : return
 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) :
 if tree == None : return
 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:
TÓPICO 3 | DADOS
121
def printTreeIndented(tree, level=0) :
 if tree == None : return
 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:
122
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
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:
TÓPICO 3 | DADOS
123
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.
124
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
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’]
>>> tree = getProduct(tokenList)
>>> printTreePostorder(tree)
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 é:
TÓPICO 3 | DADOS
125
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:
126
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
>>> tokenList = [2, ‘*’, 3, ‘*’, 5 , ‘*’, 7, ‘end’]
>>> tree = getProduct(tokenList)
>>> printTreePostorder(tree)
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)
>>> printTreePostorder(tree)
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:
TÓPICO 3 | DADOS
127
def getNumber(tokenList) :
 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)
>>> printTreePostorder(tree)
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.
def getNumber(tokenList) :
 if getToken(tokenList, ‘(‘) :
 x = getSum(tokenList)
 if not getToken(tokenList, ‘)’):
 raise ‘BadExpressionError’, ‘missing parenthesis’
 return x
 else :
 # the rest of the function omitted
128
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
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
Are you thinking of an animal? y
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
Are you thinking of an animal? y
Can it fly? n
Does it bark? y
Is it a dog? y
I rule!
Are you thinking of an animal? n
TÓPICO 3 | DADOS
129
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:
130
UNIDADE 2 | CONCEITOS FUNDAMENTAIS DA COMPUTAÇÃO
 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.
TÓPICO 3 | DADOS
131
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 antesdos 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.
132
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.
133
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.
134
135
UNIDADE 3
LÓGICA DE PROGRAMAÇÃO
OBJETIVOS DE APRENDIZAGEM
PLANO DE ESTUDOS
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.
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
136
137
TÓPICO 1
FUNDAMENTOS DE LÓGICA DE PROGRAMAÇÃO
UNIDADE 3
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.
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
138
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.
TÓPICO 1 | FUNDAMENTOS DE LÓGICA DE PROGRAMAÇÃO
139
• 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 algoritmosdesenvolvidos 
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.
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
140
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.
TÓPICO 1 | FUNDAMENTOS DE LÓGICA DE PROGRAMAÇÃO
141
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
FONTE: Araújo (2007, p. 79)
Terminal Indica início e fim do fluxo do programa
Seta de fluxo de dados
Indica o sentido do fluxo de 
dados. Serve para conectar os 
blocos existentes.
Entrada de dados
Indica que serão recebidas 
informações através do 
teclado.
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
142
FIGURA 60 – CONTINUAÇÃO FIGURAS UTILIZADAS NOS FLUXOGRAMAS
FONTE: Araújo (2007, p. 80)
Processamento
Indica a realização de cálculos, 
atribuições ou qualquer 
manipulação de dados. 
Exibir da tela Indica que as informações serão exibidas na tela.
Desvio Condicional
Indica tomada de decisão. Divide 
o fluxo do programa em dois 
caminhos.
Conector Serve para identificar o limite de um laço de repetição.
Repetição com variável de 
controle
Usado especificamente para o 
comando de repetição.
Repetição com teste lógico 
no início
Usado para o comando de 
repetição com teste lógico no 
início.
Repetição com teste lógico 
no final
Usado para o comando de 
repetição com teste lógico no 
final
Declaração Usado para as declarações de variáveis, tipos e constantes.
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
143
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.
RESUMO DO TÓPICO 1
144
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.
AUTOATIVIDADE
145
TÓPICO 2
CONSTANTES E VARIÁVEIS
UNIDADE 3
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 percentualdo 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. 
146
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
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
TÓPICO 2 | CONSTANTES E VARIÁVEIS
147
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;
148
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
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.
TÓPICO 2 | CONSTANTES E VARIÁVEIS
149
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.
150
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
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:
TÓPICO 2 | CONSTANTES E VARIÁVEIS
151
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 somade 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.
152
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
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.
153
 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.).
RESUMO DO TÓPICO 2
154
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.
155
TÓPICO 3
ESTRUTURAS DE CONTROLE
UNIDADE 3
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:
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
156
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:
TÓPICO 3 | ESTRUTURAS DE CONTROLE
157
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;
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
158
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çõesmú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>
Caso <rótulo2>: <bloco de comandos>
Caso <rótulo3>: <bloco de comandos>
TÓPICO 3 | ESTRUTURAS DE CONTROLE
159
Senão
 <bloco de comandos>
Fim escolha
Exemplo:
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:
escolha Numero 
 caso 1: escreva(’*’);
 caso 2: escreva(’**’);
 caso 3: escreva(’***’);
senão
 escreva(’Este número está fora da faixa.’);
fim escolha.
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
160
enquanto (<condição>) faça
 Instruções a serem executadas enquanto a condição for verdadeira
fim_enquanto
Agora vamos para o exemplo:
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.
Quantidade = 0;
enquanto (Quantidade <= 5) faça
 início enquanto 
 Quantidade = Quantidade + 1;
 escreva(Quantidade, ’ª execução.’);
fim enquanto;
Algoritmo Enquanto_Faca;
variáveis
 Quantidade : inteiro;
início
 Quantidade = 1;
 enquanto (Quantidade <= 5) faça 
 início enquanto
 escreva(Quantidade, ’ vez.’);
 Quantidade = Quantidade + 1;
 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 
TÓPICO 3 | ESTRUTURAS DE CONTROLE
161
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
 Quantidade : inteiro;
início
 para Quantidade de 1 até 5 faça
 início para 
 escreva(Quantidade, ’ vez.’); 
 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.
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
162
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
 Quantidade = Quantidade + 1;
 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
 Quantidade : inteiro;
início
 Quantidade = 1;
 repita
 escreva(Quantidade, ’ vez.’);
 Quantidade = Quantidade + 1;
 até (Quantidade > 5);
fim.
163
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.
RESUMO DO TÓPICO 3
164
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 dotelefone 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.
165
TÓPICO 4
TIPOS ESTRUTURADOS
UNIDADE 3
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.
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
166
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.
TÓPICO 4 | TIPOS ESTRUTURADOS
167
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.
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
168
É 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.
TÓPICO 4 | TIPOS ESTRUTURADOS
169
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 ’, 
Linha, ’ Linha: ’);
 leia(Matriz[Linha, Coluna].Codigo);
 escreva(’Informe a idade do aluno da ’, Coluna, ’ coluna da ’, 
Linha, ’ Linha: ’);
 leia(Matriz[Linha, Coluna].Idade);
 fim para;
fim para;
fim.
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
170
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 ’, 
Linha, ’ Linha: ’);
 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.
171
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.
172
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.
173
TÓPICO 5
SUBALGORITMOS E ESCOPO DE IDENTIFICADORES
UNIDADE 3
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.
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
174
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.
TÓPICO 5 | SUBALGORITMOS E ESCOPO DE IDENTIFICADORES
175
Algoritmo Calcula;
variáveis
 Primeiro : inteiro;
 Segundo : inteiro;
 Resultado : inteiro;
 subalgoritmo SomaValores(N1, N2 : inteiro);
 início
 Resultado = N1 + N2;
 fim;
início
 escreva(’Informe o primeiro número: ’);
 leia(Primeiro);
 escreva(’Informe o segundo número: ’);
 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;
 subalgoritmo SomaValores(N1, N2 : inteiro);
 variáveis
 inteiro : Soma;
 início
 Soma = N1 + N2;
 fim;
início
 escreva(’Informe o primeiro número: ’);
 leia(Primeiro);
 escreva(’Informe o segundo número: ’);
 leia(Segundo);
 escreva(SomaValores(Primeiro, Segundo));
fim.
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
176
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.
TÓPICO 5 | SUBALGORITMOS E ESCOPO DE IDENTIFICADORES
177
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.
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
178
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 fundamentalentre 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.
TÓPICO 5 | SUBALGORITMOS E ESCOPO DE IDENTIFICADORES
179
LEITURA COMPLEMENTAR
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.
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
180
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:
TÓPICO 5 | SUBALGORITMOS E ESCOPO DE IDENTIFICADORES
181
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.
UNIDADE 3 | LÓGICA DE PROGRAMAÇÃO
182
Obs.: Diferentemente do que fora visto anteriormente, o visualg não utiliza o ; ao 
final de cada instrução.
IMPORTANT
E
Para finalizar, o resultado deste programa é como apresentado pela figura 
a seguir:
TÓPICO 5 | SUBALGORITMOS E ESCOPO DE IDENTIFICADORES
183
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.
184
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.
185
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.
186
187
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>. 
Acesso em: 1 mar. 2016.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.
188
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.
189
ANOTAÇÕES
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________
____________________________________________________________