Lógica e OrganizaçãO de cOmputadOres

2016

Lógica e OrganizaçãO de cOmputadOres

Prof.a Greisse Moser Badalotti

Copyright © UNIASSELVI 2016

Elaboração:


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

Centro Universitário Leonardo da Vinci – UNIASSELVI

Ficha catalográfica elaborada na fonte pela Biblioteca Dante Alighieri

UNIASSELVI – Indaial.

160B132l 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!


IV

Você já me conhece das outras disciplinas? Não? É calouro? Enfi m, 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

Olá acadêmico! Para melhorar a qualidade dos materiais ofertados a você e dinamizar ainda mais os seus estudos, a Uniasselvi disponibiliza materiais que possuem o código QR Code, que é um código que permite que você acesse um conteúdo interativo relacionado ao tema que você está estudando. Para utilizar essa ferramenta, acesse as lojas de aplicativos e baixe um leitor de QR Code. Depois, é só aproveitar mais essa facilidade para aprimorar seus estudos!

UNI

V

VI

VII

UNIDADE 1 – HISTÓRICO DA COMPUTAÇÃO .......................................................................... 1

TÓPICO 1 – BREVE HISTÓRICO ....................................................................................................... 31 INTRODUÇÃO .................................................................................................................................... 32 HARDWARE ......................................................................................................................................... 3

2.1 DISPOSITIVOS MECÂNICOS ...................................................................................................... 42.2 DISPOSITIVOS ELETROMECÂNICOS ...................................................................................... 82.3 COMPONENTES ELETRÔNICOS ............................................................................................... 10

RESUMO DO TÓPICO 1 ....................................................................................................................... 12AUTOATIVIDADE ................................................................................................................................ 13

TÓPICO 2 – GERAÇÃO DOS COMPUTADORES ......................................................................... 151 INTRODUÇÃO .................................................................................................................................... 152 PRIMEIRA GERAÇÃO: 1945-1956 ................................................................................................... 153 SEGUNDA GERAÇÃO: 1956-1963 ................................................................................................... 174 TERCEIRA GERAÇÃO: 1965-1970 ................................................................................................... 195 QUARTA GERAÇÃO: 1971- ATÉ OS DIAS ATUAIS ................................................................... 206 UM POUCO DA HISTÓRIA DA APPLE ........................................................................................ 217 UM POUCO DE BILL GATES E A MICROSOFT ......................................................................... 228 QUINTA GERAÇÃO ........................................................................................................................... 23

8.1 JOGOS ............................................................................................................................................... 238.2 REDES NEURAIS ............................................................................................................................ 248.3 LINGUAGEM NATURAL ............................................................................................................. 248.4 SISTEMAS ESPECIALISTAS ......................................................................................................... 248.5 ROBÓTICA ...................................................................................................................................... 25


TÓPICO 3 –TIPOS DE COMPUTADORES E SEUS COMPONENTES ...................................... 291 INTRODUÇÃO .................................................................................................................................... 292 SUPERCOMPUTADORES ................................................................................................................. 293 COMPUTADORES MAINFRAME .................................................................................................. 304 MINICOMPUTADORES ................................................................................................................... 315 MICROCOMPUTADORES ............................................................................................................... 326 COMPUTADORES MÓVEIS ............................................................................................................ 337 FUNÇÕES PRIMÁRIAS DE UM COMPUTADOR ...................................................................... 34

7.1 PROCESSAMENTO DE DADOS ................................................................................................. 357.2 ARMAZENAMENTO DE DADOS .............................................................................................. 357.3 MOVIMENTAÇÃO DOS DADOS ............................................................................................... 357.4 CONTROLE ..................................................................................................................................... 36

8 PRINCIPAIS COMPONENTES ESTRUTURAIS DE UM COMPUTADOR ........................... 368.1 CPU ................................................................................................................................................... 378.2 ARMAZENAMENTO DE DADOS / MEMÓRIA ....................................................................... 38

sumáriO

VIII

8.2.1 Memória principal ................................................................................................................. 388.2.2 Armazenamento secundário ................................................................................................ 39

8.3 OS DISPOSITIVOS DE ENTRADA/SAÍDA ................................................................................ 408.4 INTERCONEXÃO DE SUBSISTEMAS ........................................................................................ 40

9 MICROPROCESSADORES / MICROCONTROLADORES / SISTEMAS EMBARCADOS. 4010 ARQUITETURA RISC E CISC ........................................................................................................ 42

10.1 CAUSAS PARA UMA ARQUITETURA COMPLEXA ............................................................ 4210.2 RISC POR QUE? ............................................................................................................................ 4310.3 PIPELINING .................................................................................................................................. 45

LEITURA COMPLEMENTAR .............................................................................................................. 46RESUMO DO TÓPICO 3 ....................................................................................................................... 62AUTOATIVIDADE ................................................................................................................................ 63

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

TÓPICO 1 – SISTEMAS DE NUMERAÇÃO .................................................................................... 671 INTRODUÇÃO .................................................................................................................................... 672 SISTEMA DE NUMERAÇÃO ........................................................................................................... 673 SISTEMA DE NUMERAÇÃO DECIMAL ...................................................................................... 684 SISTEMA DE NUMERAÇÃO BINÁRIO ........................................................................................ 695 SISTEMA DE NUMERAÇÃO OCTAL ............................................................................................ 706 SISTEMA DE NUMERAÇÃO HEXADECIMAL ........................................................................... 717 CONVERSÕES ENTRE SISTEMAS DE NUMERAÇÃO ............................................................ 718 CONVERSÃO DE DECIMAL PARA BINÁRIO ............................................................................ 729 CONVERSÃO DE DECIMAL PARA OCTAL ................................................................................ 7310 CONVERSÃO DE DECIMAL PARA HEXADECIMAL ............................................................. 7311 CONVERSÃO DE BINÁRIO PARA DECIMAL .......................................................................... 7412 CONVERSÃO DE OCTAL PARA DECIMAL .............................................................................. 7513 CONVERSÃO DE HEXADECIMAL PARA DECIMAL ............................................................. 7714 REGRAS DE FIXAÇÃO .................................................................................................................... 78RESUMO DO TÓPICO 1 ....................................................................................................................... 80AUTOATIVIDADE ................................................................................................................................ 81

TÓPICO 2 – BASES COMPUTACIONAIS ........................................................................................ 831 INTRODUÇÃO .................................................................................................................................... 832 ARQUITETURA DE COMPUTADORES ....................................................................................... 843 SOFTWARE ........................................................................................................................................... 85

3.1 CATEGORIAS DE SOFTWARE .................................................................................................... 853.1.1 Softwares básicos ................................................................................................................... 853.1.2 Softwares utilitários ............................................................................................................... 873.1.3 Softwares aplicativos ............................................................................................................. 873.1.4 Ferramentas de desenvolvimento ....................................................................................... 88

4 REDES DE COMPUTADORES ......................................................................................................... 89RESUMO DO TÓPICO 2 ....................................................................................................................... 96AUTOATIVIDADE ................................................................................................................................ 97

TÓPICO 3 – DADOS .............................................................................................................................. 991 INTRODUÇÃO .................................................................................................................................... 992 ENTENDENDO O TIPO ABSTRATO DE DADOS ...................................................................... 100

2.1 MODELO PARA UM TAD ............................................................................................................ 1002.2 ENTENDENDO PILHAS ............................................................................................................... 101

IX

2.3 ENTENDENDO FILAS .................................................................................................................. 1062.4 ENTENDENDO LISTAS LINEARES GERAIS ........................................................................... 1092.5 ENTENDENDO ÁRVORES .......................................................................................................... 1122.6 ENTENDENDO GRAFOS ............................................................................................................. 114

LEITURA COMPLEMENTAR .............................................................................................................. 115RESUMO DO TÓPICO 3 ....................................................................................................................... 132AUTOATIVIDADE ................................................................................................................................ 133

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

TÓPICO 1 – FUNDAMENTOS DE LÓGICA DE PROGRAMAÇÃO .......................................... 1371 INTRODUÇÃO .................................................................................................................................... 1372 FUNDAMENTOS DE LÓGICA DE PROGRAMAÇÃO ............................................................. 1383 LÓGICA ................................................................................................................................................. 1394 LÓGICA DE PROGRAMAÇÃO ....................................................................................................... 140RESUMO DO TÓPICO 1 ....................................................................................................................... 143AUTOATIVIDADE ................................................................................................................................ 144

TÓPICO 2 – CONSTANTES E VARIÁVEIS ...................................................................................... 1451 INTRODUÇÃO .................................................................................................................................... 1452 CONSTANTES ..................................................................................................................................... 1453 VARIÁVEIS ........................................................................................................................................... 1464 TIPOS DE DADOS .............................................................................................................................. 1475 DECLARANDO CONSTANTES E VARIÁVEIS ........................................................................... 1476 COMANDOS BÁSICOS DE UM ALGORITMO .......................................................................... 1497 EXPRESSÕES ........................................................................................................................................ 151RESUMO DO TÓPICO 2 ....................................................................................................................... 153AUTOATIVIDADE ................................................................................................................................ 154

TÓPICO 3 – ESTRUTURAS DE CONTROLE ................................................................................... 1551 INTRODUÇÃO .................................................................................................................................... 1552 ESTRUTURAS DE CONTROLE SEQUENCIAL ........................................................................... 1553 ESTRUTURAS DE CONTROLE CONDICIONAL ....................................................................... 1564 ESTRUTURAS DE CONTROLE DE REPETIÇÃO ....................................................................... 159

4.1 ESTRUTURA DE REPETIÇÃO ENQUANTO-FAÇA ............................................................... 1594.2 ESTRUTURA DE REPETIÇÃO PARA-FAÇA ............................................................................ 1604.3 ESTRUTURA DE REPETIÇÃO REPITA_ATÉ ............................................................................ 161


TÓPICO 4 – TIPOS ESTRUTURADOS .............................................................................................. 1651 INTRODUÇÃO .................................................................................................................................... 1652 REGISTROS .......................................................................................................................................... 1653 VETORES .............................................................................................................................................. 1664 MATRIZES ............................................................................................................................................ 168RESUMO DO TÓPICO 4 ....................................................................................................................... 171AUTOATIVIDADE ................................................................................................................................ 172

X

TÓPICO 5 – SUBALGORITMOS E ESCOPO DE IDENTIFICADORES ................................... 1731 INTRODUÇÃO .................................................................................................................................... 1732 ESCOPO DE IDENTIFICADORES .................................................................................................. 174LEITURA COMPLEMENTAR .............................................................................................................. 179RESUMO DO TÓPICO 5 ....................................................................................................................... 184AUTOATIVIDADE ................................................................................................................................ 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 1UNIDADE 1

BREVE HISTÓRICO

1 INTRODUÇÃOEmbora 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 componentes 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álvulas, com transistores, com circuitos integrados e com

integração em larga escala.

Agora vamos entender cada etapa desta evolução.

2.1 DISPOSITIVOS MECÂNICOS

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

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

É importante distinguir o início dos ábacos, conhecidos como placas de contagem ou calculadora decimal manual. O ábaco é um pedaço de madeira, pedra ou metal com sulcos esculpidos ou linhas pintadas entre os quais pérolas, pedras ou discos de metal são movidos. Tanto o ábaco como a placa de contagem, são auxiliares mecânicos utilizados para contagem, eles não são calculadoras. A pessoa que opera o ábaco executa cálculos em sua cabeça e usa o ábaco como um auxílio físico para manter o controle da contagem.

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.


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.

http://ds-wordpress.haverford.edu/bitbybit/bit-by-bit-contents/chapter-one/1-8-leibniz-and-the-stepped-reckoner/

http://ds-wordpress.haverford.edu/bitbybit/bit-by-bit-contents/chapter-one/1-8-leibniz-and-the-stepped-reckoner/


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.

http://addiator.blogspot.com.br/2011/10/jacquards-loom-and-stored-programme.html

http://addiator.blogspot.com.br/2011/10/jacquards-loom-and-stored-programme.html


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.

http://history-computer.com/Babbage/AnalyticalEngine.html


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.


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.

http://www.kerryr.net/pioneers/gallery/ns_bush5.htm


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

a) Chinesesb) Incasc) Romanosd) Í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.

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?

14

15

TÓPICO 2

GERAÇÃO DOS COMPUTADORES

UNIDADE 1

1 INTRODUÇÃOEm 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-1956Os 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.


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

http://www.hnf.de/en/museum/die-erfindung-des-computers/eniac-life-size-model-of-the-first-vacuum-tube-computer.html

http://www.hnf.de/en/museum/die-erfindung-des-computers/eniac-life-size-model-of-the-first-vacuum-tube-computer.html

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-1963O 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.

http://blogs.loc.gov/loc/2008/04/my-first-bloggiversary/univac/


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.


19

4 TERCEIRA GERAÇÃO: 1965-1970Os transistores foram um grande avanço para os computadores. No entanto,

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

Com a invenção de circuitos integrados, o número de transistores que poderia ser colocado em um único chip dobrava de dois em dois anos, diminuindo o tamanho e o custo dos computadores e ainda aumentando a sua potência.

Estes computadores de terceira geração podiam executar instruções em bilionésimos de segundo. O tamanho destas máquinas caiu para o tamanho de armários de arquivo pequenos. No entanto, o grande avanço na era dos computadores ainda estava por vir.

FIGURA 11 – CIRCUITOS INTEGRADOS

FONTE: Disponível em: <http://buvenes.blogspot.com.br/2012/01/computer-history-and-generations.html>. Acesso em: 2 mar. 2016.


20

5 QUARTA GERAÇÃO: 1971- ATÉ OS DIAS ATUAISEsta 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.

https://delphinemeow.files.wordpress.com/2014/04/ibm-pc.jpg


21

6 UM POUCO DA HISTÓRIA DA APPLESteven 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.

http://lounge.obviousmag.org/advibe/2014/05/jobs.html


22

7 UM POUCO DE BILL GATES E A MICROSOFTEm 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.


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ÇÃOA 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.


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 linguagem e fazer pesquisas para responder as perguntas.

Estas redes neurais também estão se tornando importantes em aplicações muito menores, como o recurso de reconhecimento de voz em muitos computadores pessoais atuais e telefones celulares.

8.3 LINGUAGEM NATURAL

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

Da mesma forma, a linguagem natural está atualmente limitada a um tom de voz, e dispositivos de computação de inteligência mais artificial e não pode distinguir entre uma frase de voz suave, e uma sentença de raiva.

8.4 SISTEMAS ESPECIALISTAS

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


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

AUTOATIVIDADE

3 Computadores da quinta geração são baseados em:

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?

a) ( ) Tubos a vácuob) ( ) Circuitos integradosc) ( ) Microprocessadoresd) ( ) 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 Ib) ENIACc) Windowsd) Z3

28

29

TÓPICO 3

TIPOS DE COMPUTADORES E SEUS

COMPONENTES

UNIDADE 1

1 INTRODUÇÃOQuando 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 SUPERCOMPUTADORESSupercomputador é 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.


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 MAINFRAMEComo 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.

http://www.peimag.com/top-10-most-powerful-supercomputers-in-the-world/

http://www.peimag.com/top-10-most-powerful-supercomputers-in-the-world/

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 MINICOMPUTADORESUm 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.

https://tegrupo7.wordpress.com/


32

5 MICROCOMPUTADORESMicrocomputadores são os que as pessoas estão mais familiarizadas na

sua vida diária, não profissional, mas é claro que isso não significa que eles são exclusivos para a casa. Microcomputadores são pequenos computadores que rodam em microprocessadores em suas unidades de processamento central. Eles são muito mais baratos do que os supercomputadores, computadores de grande porte e até mesmo minicomputadores, porque eles foram feitos para usos diários que são mais práticos do que profissional. A gama de capacidades para microcomputadores é vasta. Um editor de filme poderia usar um microcomputador para executar muitos programas de edição intensivos de uma só vez, enquanto que um aluno pode usar um microcomputador para digitar um texto.

A maioria das pessoas usa o que chamamos de computadores pessoais, e até mesmo dentro desta definição existem diversas variações. Estas incluem:

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

• Consoles de video game: algumas pessoas não pensam consoles de videogame como computadores, mas eles são. Eles têm muitos dos mesmos componentes de hardware como computadores, mas geralmente são menos avançados, razão pela qual eles são capazes de custar muito menos do que um computador de jogos de alto nível.

• Diversos: outros exemplos de microcomputadores incluem TVs inteligentes.


33

FIGURA 17 – MICROCOMPUTADORES

FONTE: A autora.

6 COMPUTADORES MÓVEISEstes 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.


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 COMPUTADORTodos 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.


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


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.


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


8.2 ARMAZENAMENTO DE DADOS / MEMÓRIA

O processador é o cérebro do computador. Todos componentes fundamentais para o computador têm lugar no processador. Outros componentes contribuem para o cálculo, mas o processador é onde a ação fundamental tem lugar.

No computador possuímos dois tipos fundamentais de memória:

A memória principal usada para armazenar informações para acesso imediato pela CPU. Também chamamos a memória principal de armazenamento primário. Algumas funções da memória são:

• Estreitamente ligadas ao processador.• Os conteúdos são mudados rapidamente e facilmente.• Detém os programas e dados que o processador está trabalhando ativamente.• Interage com os milhões de processamento por segundo.

Armazenamento secundário: dispositivos fornecem armazenamento permanente de grandes quantidades de dados. O armazenamento secundário também é chamado de memória secundária, memória externa, armazenamento de backup ou armazenamento auxiliar.

Este pode consistir de armazenamento de disco rígido, pendrive, HD externo. Algumas de suas características são:

• Ligado à memória principal através de um controlador.• O conteúdo é facilmente alterado.• Utilizado para a armazenagem a longo prazo de programas e de dados.

8.2.1 Memória principal

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

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


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


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


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


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

10 ARQUITETURA RISC E CISCArquiteturas 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:


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


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


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


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.


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


O Apple II foi o primeiro computador de baixo custo que, de forma notável, podia ser usado por pessoas comuns – ninguém precisava ser um geek para utilizá-lo.

Mas àquela altura, ninguém havia visto o Apple II. Eu ainda estava finalizando-o, e naquele momento, ainda trabalhávamos em nossas casas: eu trabalhava em meu apartamento e Steve trabalhava pelo telefone de seu dormitório na faculdade. Ainda testávamos computadores na garagem da casa dos pais dele. E eu ainda estava montando calculadoras na HP e pensando que a Apple era apenas um hobby. Eu ainda planejava trabalhar na HP para sempre.

Mas não demorou muito para eu ter um Apple II funcionando logo após a entrega das placas do Apple I para Paul Terrell. E como eu disse antes: o Apple II não era apenas duas vezes melhor. Era algo como dez vezes melhor.

Concluí a placa, que era o núcleo do Apple II, em agosto de 1976. Lembro-

me disso muito bem porque foi nesse mesmo mês que Steve e eu viajamos para a mostra PC’ 76, em Atlantic City.

Pegamos o avião em San Jose e sentamos juntos, levando o Apple I e o Apple II conosco a bordo. O aspecto engraçado dessa viagem foi que um bando de pessoas que conhecíamos do Homebrew e que agora trabalhavam nas várias pequenas empresas de informática concorrentes da Apple estavam naquele mesmo voo. Pudemos ouvi-las falando sobre o avanço dos negócios: falavam sobre propostas e utilizavam terminologias que nunca havíamos escutado antes. Sentimo-nos muito distantes de todas aquelas discussões.

Mas dentro de nós sabíamos que tínhamos um segredo. Um grande segredo. Talvez não fizéssemos parte daqueles grupos de empresários, mas sabíamos que possuíamos um computador melhor. Na verdade, possuíamos os dois melhores computadores disponíveis no mercado da época. O Apple I e o Apple II. E ninguém no mundo sabia ainda do Apple II.

Quando a exposição começou em Atlantic City, tive sorte porque não

precisei empurrar o Apple I em nosso estande. Não tenho perfil de vendedor. Steve Jobs e Dan Kottke é que fizeram isso. Fiquei no andar de cima terminando as últimas sequências do BASIC.

A exposição estava cheia de empresas jovens e mal financiadas como a

Apple. Os proprietários eram parecidos conosco. Isto é, não eram executivos bem vestidos, empresários ou gerentes de empresa participando da mostra. Mas um grupo de pessoas bastante desleixado.

Eles atuavam no mesmo ramo de negócio que o nosso, e muitos eram nossos concorrentes diretos. Apesar de sermos todos amigos, ainda assim éramos concorrentes.


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


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


51

slots – um para a impressora e outro para um modem. Ele achava que assim seria possível fabricar uma máquina menor e mais barata – e que fosse boa o suficiente para as tarefas diárias.

Mas eu queria mais slots; 8 deles. Porque tinha na cabeça a ideia de que as pessoas iriam querer muitas coisas no futuro, e que de forma alguma deveríamos limitá-las.

Normalmente, sou uma pessoa fácil de se relacionar, mas daquela vez disse para Steve: “Se é o que quer, vá conseguir outro computador para você”. Eu não conseguiria economizar um único chip reduzindo o número de slots de 8 para 2, e eu sabia que pessoas iguais a mim poderiam eventualmente descobrir coisas para adicionar a qualquer computador.

Na época, eu estava em posição de agir assim. O que não aconteceria sempre. Alguns anos mais tarde, a Apple prosseguiu com o projeto do Apple III, que foi simplesmente um desastre – e a máquina tinha menos slots.

Mas em 1976, ganhei a discussão, e o Apple II foi fabricado e no final saiu da maneira que eu queria.

Lembro-me de um dia chegar à HP – onde ainda estava trabalhando – e mostrar o Apple II para os outros engenheiros. Demonstrei-o fazendo um redemoinho de cores. E os outros engenheiros se aproximavam para dizer que aquele era o melhor produto que já tinham visto. E a HP ainda não havia encontrado uma maneira de executar corretamente aquele tipo de projeto.

Um dia, meu chefe, Pete Dickinson, disse que algumas pessoas em minha

divisão de calculadoras haviam criado um novo projeto, que seguiu para a aprovação da diretoria, um projeto para desenvolver uma pequena máquina de mesa com um microprocessador, memória DRAM, uma pequena tela de vídeo e um teclado. E até já tinham designado cinco pessoas para desenvolver o BASIC para ela.

O horrível de tudo aquilo é que eles sabiam o que eu havia feito com o Apple I – e mesmo com o Apple II. Mas mesmo assim começaram o tal projeto sem mim! Por quê? Não sei. Acho que perceberam que o projeto deles era igual ao que eu já havia feito.

Mas mesmo assim fui falar com o gerente do projeto, Kent Stockwell. Embora tivesse criado computadores como o Apple I e o Apple II, eu queria tanto trabalhar em um computador na HP que faria qualquer coisa para isso. Eu poderia ser um mero engenheiro da interface da impressora. Algo pequeno.

Então disse a Kent: “Todo meu interesse na vida tem sido os computadores. Não as calculadoras”.

Após alguns dias, fui recusado novamente.

52


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”.


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


Bem, ele também recusou, mas nos colocou em contato com um sujeito chamado Mike Markulla. Don nos disse que Mike tinha apenas 30 anos de idade, mas que já havia se aposentado pela Intel. Ele nos contou também que Mike se interessava por equipamentos eletrônicos. E que por isso talvez soubesse o que fazer conosco.

A primeira vez que encontrei Mike, achei-o a pessoa mais legal que já tinha conhecido. Era um rapaz jovem com uma bela casa nas colinas com vista para as luzes de Cupertino. Ele tinha uma vista deslumbrante, uma esposa maravilhosa, todo o pacote.

E ainda melhor: ele realmente adorou nosso computador! E não conversou conosco como se estivesse escondendo coisas e pensando em como nos enganar. Ele foi verdadeiro, o que ficou óbvio desde o início. E que, de fato, fazíamos algo muito importante.

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

Mike demonstrava bom senso, falando normalmente em termos de qual poderia ser o futuro de uma nova indústria de computadores de uso doméstico. Porém, eu sempre pensara que o Apple II seria algo como o hobby de pessoas que quisessem simular uma situação do trabalho ou jogar videogame.

Mas Mike falava de algo diferente. Ele falava em introduzir o computador na vida de pessoas normais, em casas normais, fazendo em casa atividades como procurar a receita favorita ou conferir o saldo bancário. “Isso é o que vem vindo”, ele disse. Ele tinha a visão do Apple II como um verdadeiro computador residencial.

Claro que Steve e eu já vínhamos atuando um pouco em torno de tal ideia. Isto é, Paul Terrell da Byte Shop já tinha nos pedido algo inovador e pronto para usar. E nós planejávamos seguir naquela direção, além de utilizar gabinetes de plástico. Tínhamos até planejado contratar um amigo de Steve, Rod Holt, para criar uma fonte de alimentação com comutação muito mais eficiente que a fonte anteriormente disponível – e sabíamos que isso geraria menos calor, fator necessário para colocarmos a placa e nossa fonte de alimentação em um gabinete de plástico.

Mas quando Mike concordou em assinar ele nos disse: “Seremos uma empresa da Fortune 500* em dois anos. Este é o início de uma indústria. E acontece uma vez em cada década”.


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


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,


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 pequena sala para instalar uma bancada de laboratório para testes e consertos de bugs. Na verdade, era uma grande bancada de laboratório. Toda nossa equipe principal estava a postos. Steve, eu, Mike Markulla, Rod Holt e, agora, um sujeito chamado Mike Scott.

Contratamos Mike Scott para ser presidente um pouco antes de Mike

Markulla chegar (portanto, agora tínhamos dois Steves e dois Mikes). Mike, ou “Scotty”, como o chamávamos, era um sujeito com experiência em administração. Ele veio da National Semiconductor, onde havia sido diretor.

Acho que muitas pessoas se esqueceram dele, mas Mike foi presidente e líder da Apple por quatro anos – ele abriu nosso capital para o mercado quatro anos mais tarde.

Àquela altura, tínhamos a ideia de anunciar e mostrar o Apple II na West

Coast Computer, feira de informática que ocorreria dali a quatro meses. Essa feira, criada por Jim Warren (outro membro do Homebrew), aconteceria em São Francisco, em janeiro de 1977.

Portanto, eu teria quatro meses para finalizar o projeto do Apple II. Naquele momento, eu estava completando a codificação de 8 Kbytes que precisávamos liberar para a Synertek, empresa que faria os chips de memória ROM para nós. Tais chips seriam os responsáveis por fazer o Apple II rodar o BASIC.

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

Estávamos a apenas três dias do início da West Coast Computer quando recebemos nossos três primeiros gabinetes de plástico como amostra. Então montamos o computador completo com a placa dentro. Ele ficou com a cara do que viria a ser o Apple II e agora poderíamos mostrá-lo na feira.

Finalmente, nos dias anteriores à feira, Mike Markulla explicou como deveríamos nos vestir, como deveria ser nossa aparência e como deveríamos agir. Ele coordenou até mesmo a maneira como deveríamos falar com as pessoas e mostrar-lhes o equipamento.

58


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.


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


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!


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


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 principais elementos 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ÇÃOAtravé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ÇÃONa 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 1000Sí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 3IV 4VIII 8XIX 19LXXII 72CI 101MMVII 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 DECIMALO 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ÁRIOO 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 = 4FONTE: 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


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 OCTALO 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 Decimal12 = 1023 = 1935 = 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.


71

6 SISTEMA DE NUMERAÇÃO HEXADECIMALO 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 Decimal47 = 7168 = 10475 = 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ÇÃOA 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.


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ÁRIOA 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.


73

9 CONVERSÃO DE DECIMAL PARA OCTALDa 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 HEXADECIMALA 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).


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 DECIMALA conversão de números representados no sistema octal para o sistema de

numeração decimal pode ser efetuada utilizando-se o método da soma dos termos, conforme demonstrado na figura a seguir.


75

FIGURA 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 DECIMALA 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.


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.


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 DECIMALA conversão de números representados no sistema hexadecimal para o

sistema de numeração decimal pode ser efetuada através do método da soma dos termos, conforme apresentado na figura a seguir.

FIGURA 32 – EXEMPLO DE CONVERSÃO DE HEXADECIMAL PARA DECIMAL

FONTE: A autora

Esta conversão também pode ser efetuada através do método de operações sucessivas e alternadas de multiplicação e adição.

FIGURA 33 – EXEMPLO DE CONVERSÃO DE HEXADECIMAL PARA DECIMAL

FONTE: A autora


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ÇÃOApó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.


79

FIGURA 34 – CALCULADORA WINDOWS NO MODO PROGRAMADOR

FONTE: A autora

80

RESUMO DO TÓPICO 1Mais 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

Agora vamos praticar:

1 Converta os números binários para decimal:

AUTOATIVIDADE

a) (101)2b) (100111)2

2 Converta os números abaixo de decimais para a base binária:

a) 10110b) 4010

3 Converta os números abaixo de decimais para a base octal:

a) 14410b) 4310

82

83

TÓPICO 2

BASES COMPUTACIONAIS

UNIDADE 2

1 INTRODUÇÃOUm 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.


84

2 ARQUITETURA DE COMPUTADORESRelembrando 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 é um sistema composto por duas partes importantes: hardware e software (FOROUZAN; MOSHARRAF, 2011). O hardware é composto pelos equipamentos físicos, ou seja, pelas máquinas e demais equipamentos ligados ao computador. Já o software é composto pelo conjunto de programas que são executados neste hardware.

3.1 CATEGORIAS DE SOFTWARE

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

O conjunto de softwares existentes pode ser dividido em categorias. As principais categorias de software existentes são conhecidas como softwares básicos, softwares utilitários, softwares aplicativos e ferramentas de desenvolvimento.

3.1.1 Softwares básicos

Na categoria de softwares básicos estão principalmente os sistemas operacionais.

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

Um Sistema Operacional é complexo e em função disso é complexo também defini-lo.

Forouzan e Mosharraf (2011) sugerem algumas definições comuns:

• Interface entre o hardware e o usuário;

• Programa que facilita a execução dos programas;

• Gerenciador que supervisiona as atividades dos componentes do sistema computacional.


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.


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


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) é


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 COMPUTADORESNa 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,


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).


91

Os sinais podem ser entendidos como ondas que são propagadas através de algum meio físico, o qual pode ser um cabo, o ar ou outros meios disponíveis. Para que o processo de transmissão de informação ocorra, há necessidade da execução de uma sucessão de processos, os quais são relacionados a seguir:

• A geração de um conteúdo a ser transmitido;• A codificação deste conteúdo em um conjunto bem definido de símbolos;• Esta codificação do conteúdo deve atender aos critérios necessários para que

possa ser transmitido adequadamente através do meio físico utilizado;• A realização da transmissão do conteúdo;• A decodificação do conteúdo transmitido e a reprodução do mesmo;• A recriação do conteúdo que foi transmitido, mesmo que haja certo grau de

degradação da qualidade do conteúdo para o entendimento do destinatário.

Na transmissão de dados em redes, podemos classificar os sinais em dois tipos: sinais analógicos e sinais digitais. A Figura 35 representa a forma de variação de um determinado sinal analógico. A Figura 36 representa a forma de variação de um determinado sinal digital. Na transmissão de dados os tipos de sinais mais comumente utilizados são o analógico e o digital. A denominação do sinal analógico está associada à característica do sinal de ter uma variação contínua no tempo. Já a denominação do sinal digital está associada à característica do sinal de ter uma variação denominada discreta, ou seja, com variações em forma de pulsos.

FIGURA 35 – REPRESENTAÇÃO DE UM SINAL ANALÓGICO

FONTE: Disponível em: <http://cgrbrasil.com.br/artigos/diferenca-entre-sinal-digital-e-analogico/>. Acesso em: 30 mar. 2016.

Ambos os termos são bastante utilizados quando a transmissão de dados é o assunto em pauta. Estas definições permitem qualificar a natureza da informação quanto à característica dos sinais utilizados para a transmissão através dos meios físicos disponíveis.


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.


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.


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ônicas comuns, linhas de comunicação privadas, satélites, cabos submarinos e diversos outros meios de comunicação e telecomunicação, com o objetivo de estabelecer a troca de informações e serviços.

A internet permite unir entidades de pesquisa, órgãos culturais, usuários particulares, órgãos governamentais, bibliotecas e empresas. O controle da internet é descentralizado, utilizando os protocolos TCP/IP como estrutura básica para comunicação e serviços de rede.

Isto é devido ao fato da arquitetura TCP/IP fornecer não somente os protocolos que habilitam a comunicação de dados entre redes, mas também possuir uma série de características que contribuem para a eficiência da arquitetura.


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 2Chegamos 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

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.

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:

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ÇÃOPara 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


2 ENTENDENDO O TIPO ABSTRATO DE DADOSProcessamos 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


Em nosso dia a dia utilizamos muitos e diferentes tipos de pilhas. O que nos é mais comum são pilhas de moedas ou de livros. Qualquer situação que podemos adicionar ou remover um objeto do topo caracteriza uma pilha. Caso queira remover um objeto diferente daquele que está no topo, primeiro devemos remover todos os objetos acima dele (FOROUZAN; MOSHARRAF, 2011).

FIGURA 39 – REPRESENTAÇÃO DE PILHAS


Existem muitas operações com pilha, mas na computação existem quatro básicas: pilha cria, pilha_insere, pilha exclui e pilha_vazia.

Para criarmos uma pilha vazia temos a seguinte sintaxe:

pilha_cria (nomedapilha)

nomedapilha é o nome da pilha a ser criada. Essa operação apresenta como resultado uma pilha vazia (FOROUZAN; MOSHARRAF, 2011).

FIGURA 40 – REPRESENTAÇÃO DE CRIAÇÃO DE UMA PILHA


pilha_cria

Operação pilha_vazia

A operação inserção na fila insere um item no topo da fila. Veja a sintaxe:

pilha_isere(nomedapilha, itemdedados)

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


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


30

78

20

Elementodo topo

Pilha antes da exclusão

pilha_exclui

Operação

30

Dadoseliminados

78

20

Elementodo topo

Pilha antes da exclusão

Elementodo topo

Elementodo topo

30

78

20 20

78

30

Dados a sereminseridos

Operação

pilha_insere

Pilha depoisda inserção

Pilha depoisda 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


A operação pilha vazia verifica o status da pilha. Veja a sintaxe:

pilha_vazia(nomedapilha)

nomedapilha é o nome da pilha. Esta operação resulta em verdadeiro se a pilha estiver vazia, senão resulta em falso.

Para definirmos uma pilha como um TAD utilizamos conforme segue:

TAD de pilhas

Definição: uma lista de itens de dados que somente pode ser acessada em uma extremidade, chamada topo da pilha.

Operações: pilha_cria: cria uma pilha vazia. pilha_insere: insere um elemento no topo. pilha_exclui: exclui um elemento no topo. pilha_vazia: verifica o status da pilha.


FIGURA 43 – APLICANDO OPERAÇÃO DE PILHA


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

1210

210

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


a. TAD

topo

contador topo

S

[n]

[6][5][4][3][2][1]

S

contador topo

b. Implementaçãoem vetor

c. Implementação emlista 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


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


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


fila_criaOperaçã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


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


inicioda fila

fimda fila

inicioda fila

fimda 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

inicioda fila

fimda fila

inicioda fila

fimda fila

fila_insere

Dado a ser inserido

20 2078 78

34

34

OperaçãoFila antes Fila depois

108


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


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


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


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


Lista(antes da inserção)

elementos

Restante dos dados

Lista(depois da inserção)

Chave

Lista

Elementoinserido

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


Lista(antes da exclusão)

lista_exclui (lista, alvo, elemento)

Elemento aser 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


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.


112


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


Observando a figura anterior vemos que a terceira operação insere os novos dados na posição correta, porque a operação de inserção aciona o algoritmo de busca no nível da implementação para descobrir onde os novos dados devem ser inseridos. Na quarta operação é excluído o item de dados 3 da lista, porém antes ele verifica se a lista realmente está vazia. E na última operação insere 6 no local apropriado.

As listas lineares são utilizadas em situações nas quais os elementos são acessados aleatoriamente ou sequencialmente, como em uma faculdade, uma lista linear pode ser utilizada para armazenar informações sobre os alunos que se matriculam a cada semestre.

2.5 ENTENDENDO ÁRVORES

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

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


Tipo de nó Arco chegando Arco saindoraiz 0 0 ou mais

folha 1 0interno 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


E

A

I

A: raizB e F: nós internosC, D, E, G, H e I: folhas

HG

F

D

B

C

Nós

114


FIGURA 57 – REPRESENTAÇÃO DE SUBÁRVORES


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


a. Grafo dirigido b. Grafo não dirigido

A A

D

E

FFBB

CC D

E


Á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


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)

https://aprendendo-computacao-com-python.readthedocs.org/en/latest/capitulo_20.html#id2

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


3 ÁRVORES DE EXPRESSÕES

Uma árvore é uma forma natural para representar a estrutura de uma expressão. Ao contrário de outras notações, a árvore pode representar a computação de forma não ambígua. Por exemplo, a expressão infixa 1 + 2 * 3 é ambígua, a menos que saibamos que a multiplicação é feita antes da adição.

A árvore de expressão seguinte representa a mesma computação:

FIGURA 2

As células de uma árvore de expressão podem ser operandos como 1 e 2 ou operações como + e *. As células contendo operandos são folhas; aquelas contendo operações devem ter referências aos seus operandos. (Todos os nossos operandos são binários, significando que eles têm exatamente dois operandos).

Podemos construir árvores assim:

>>> tree = Tree(‘+’, Tree(1), Tree(‘*’, Tree(2), Tree(3)))

Examinando a figura, não há dúvida quanto à ordem das operações; a multiplicação é feita primeiro para calcular o segundo operando da adição.

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


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


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


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


>>> 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


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? yIs it a bird? nWhat is the animals name? dogWhat question would distinguish a dog from a bird? Can it flyIf the animal were dog the answer would be? n

Are you thinking of an animal? yCan it fly? nIs it a dog? nWhat is the animals name? catWhat question would distinguish a cat from a dog? Does it barkIf the animal were cat the answer would be? n

Are you thinking of an animal? yCan it fly? nDoes it bark? yIs it a dog? yI 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


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 antes dos seus operandos.pós-ordem (postorder): uma forma de percorrer uma árvore visitando os filhos de cada célula antes da própria célula.in-ordem (inorder): uma forma de percorrer uma árvore visitando a subárvore esquerda, seguida da raiz e finalmente da subárvore direita.

FONTE: Disponível em: <https://aprendendo-computacao-com-python.readthedocs.org/en/latest/capitulo_20.html>. Acesso em: 22 mar. 2016.

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?

a) ( ) Pilhab) ( ) Árvorec) ( ) Listad) ( ) Filae) ( ) 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) ( ) Ab) ( ) Bc) ( ) Cd) ( ) D

4 Descreva o que é um grafo dirigido e um grafo não dirigido.

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?

134

135

UNIDADE 3

LÓGICA DE PROGRAMAÇÃO


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ÇÃOO 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ÇÃOPara 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 algoritmos desenvolvidos neste livro serão utilizadas chaves { } para delimitar o início e fim de comentários.

• Endentação: é o alinhamento das instruções de forma a simplificar a identificação da subordinação dos blocos de instruções. A endentação também é chamada de indentação ou identação na área de programação. É altamente recomendável que os algoritmos, assim como os programas, sejam endentados, pois facilita o entendimento. Para a maioria das linguagens de programação a endentação não exerce influência. Nestes casos, quem é beneficiado pela endentação é a pessoa que precisa ler e entender o código escrito.

3 LÓGICAPessoas 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.


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ÇÃOQuando 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 3fim

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 dadosIndica o sentido do fluxo de

dados. Serve para conectar os blocos existentes.

Entrada de dadosIndica que serão recebidas

informações através do teclado.


142

FIGURA 60 – CONTINUAÇÃO FIGURAS UTILIZADAS NOS FLUXOGRAMAS

FONTE: Araújo (2007, p. 80)

ProcessamentoIndica 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 CondicionalIndica tomada de decisão. Divide

o fl uxo do programa em dois caminhos.

Conector Serve para identifi car o limite de um laço de repetição.

Repetição com variável de controle

Usado especifi camente 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 fi nal

Usado para o comando de repetição com teste lógico no

fi nal

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 fl uxogramas. 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 1Comando 2Comando 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ÇÃOConforme 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 CONSTANTESConstantes como o próprio nome diz, é tudo que é fixo, estável, inalterável,

imutável, contínuo, incessante, invariável, de valor fixo e que é aplicado em diversos pontos de vista. Assim, constante é uma grandeza numérica fixa utilizada normalmente em uma expressão aritmética ou matemática, a qual define um valor que será inalterado na expressão, independentemente das variáveis envolvidas na operação a ser realizada (MANZANO; OLIVEIRA, 2014).

Como exemplo de uso de uma constante podemos utilizar um algoritmo para calcular o imposto de uma nota fiscal, neste algoritmo poderá ser declarada uma constante que irá armazenar o valor percentual do imposto. Caso a legislação mude, basta alterar o valor da constante, assim todos os locais onde ela está sendo utilizada serão automaticamente atualizados com o novo valor.

146


3 VARIÁVEISVariá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 DADOSO 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”; [email protected], 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ÁVEISA 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


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.


149

6 COMANDOS BÁSICOS DE UM ALGORITMOOs 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


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:


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 soma de 5 + 3 é 8

7 EXPRESSÕESNo 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


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 inteirosMod 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çãoe Conjunção

ou Disjunçãonã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

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):

AUTOATIVIDADE

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ÇÃOAs 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 SEQUENCIALEsta 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:


156

Algoritmo Calcula;varPrimeiro, 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 CONDICIONALPara 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 verdadeirafim_seinstruçõ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ãose (Prosseguir = verdadeiro) então se (Nome <> ’ ’) entãose ((A > 10) e (A < 20)) entãose 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 verdadeirasenão instruções executadas após condição ser falsafim_seinstruçõ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 sesenão

início senão escreva(A, “ é menor que 10.”);

fim senã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ãoinício se

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

escreva(A, ’ está entre 10 e 15’); fim se

senãoinício senão escreva(A, ’ está entre 16 e 20’);fim senão;

fim sesenão

início senão escreva(A, ’ não está entre 10 e 20’);fim senão;

fim_se;

Para a resolução de seleções múltiplas utiliza-se o comando escolha caso. Para a construção da instrução utiliza-se os comandos caso, seja, faça, senão e fim_caso.

Vejamos a sintaxe:

Escolha (expressão)Caso <rótulo1>: <bloco de comandos>Caso <rótulo2>: <bloco de comandos>Caso <rótulo3>: <bloco de comandos>


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.


160

enquanto (<condição>) faça Instruções a serem executadas enquanto a condição for verdadeirafim_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


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.


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

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 pesoacima de 20,0 e abaixo de 25,0 = peso normalentre 25,0 e abaixo de 30,0 = sobrepesoentre 30,0 e abaixo de 40,0 = obeso40,0 e acima = obeso mórbidoO algoritmo deverá ser executado até que seja informado “FIM” no

nome da pessoa.

d) Faça um algoritmo que leia o nome de uma pessoa e várias ligações telefônicas (número do telefone e valor da ligação), enquanto o número do telefone informado for diferente de zero. Ao final escreva o nome do cliente e o valor da conta telefônica.

e) No controle de qualidade de uma empresa são classificadas as mercadorias como de primeira, de segunda e refugo. Elabore um algoritmo para ler 100 peças e no final escreva quantas são de primeira, quantas são de segunda e quantas são refugo.

Caro acadêmico, como forma de fixar o conteúdo estudado, realize a autoatividade proposta a seguir:

1 Desenvolva os algoritmos propostos a seguir.

165

TÓPICO 4

TIPOS ESTRUTURADOS

UNIDADE 3

1 INTRODUÇÃOA 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 REGISTROSRegistros 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.


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 VETORESVetor é 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.


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 MATRIZESMatriz é 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.


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ÇÃOOs 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 subalgoritmoDefinição de constantesDefinição de tipos de dadosDefinição de variáveisInício do subalgoritmoCorpo principal do subalgoritmoFim 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.


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 IDENTIFICADORESO 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.


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.


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.


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 fundamental entre estas formas de passagem de parâmetros é que na primeira os dados de origem não são afetados e, na segunda, são os dados de origem que estão sendo alterados.

É importante que se conheça as consequências do uso de ambos para utilizar cada forma nas situações que forem mais adequadas, evitando eventuais falhas na execução por problemas na lógica empregada.


179


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.


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:


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.


182

Obs.: Diferentemente do que fora visto anteriormente, o visualg não utiliza o ; ao final de cada instrução.

IMPORTANTE

Para finalizar, o resultado deste programa é como apresentado pela figura a seguir:


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

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

____________________________________________________________

Documents

Lógica e OrganizaçãO de cOmputadOres