Pensamento Computacional

Prévia do material em texto

Apostila de Pensamento Computacional 
Marcio Quirino - 1 
 
SUMÁRIO 
Introdução aos Princípios Fundamentais da Computação ................................................................... 5 
Introdução .................................................................................................................................................. 5 
1 - Equação essencial dos computadores ......................................................................................... 5 
Equação fundamental ................................................................................................................................ 5 
Humano versus máquina ........................................................................................................................... 7 
A alegoria da caverna............................................................................................................................. 7 
2 - Processo de exploração do potencial dos computadores ........................................................... 8 
Entre códigos e algoritmos: aprendendo a lógica do computador .............................................................. 8 
Código ........................................................................................................................................................ 8 
Algoritmo .................................................................................................................................................... 9 
Definição ................................................................................................................................................ 9 
Programadores versus computadores.................................................................................................. 10 
Como os computadores evoluem ............................................................................................................. 10 
Lei de Moore ........................................................................................................................................ 10 
Reflexão ................................................................................................................................................... 11 
3 - Código de instrução de computadores ....................................................................................... 11 
Códigos em execução .............................................................................................................................. 11 
Preparação ........................................................................................................................................... 11 
Prática 1 ............................................................................................................................................... 11 
Prática 2 ............................................................................................................................................... 12 
Prática 3 ............................................................................................................................................... 13 
Prática 4 ............................................................................................................................................... 15 
Prática 5 ............................................................................................................................................... 16 
Considerações finais ................................................................................................................................ 16 
Explore + .................................................................................................................................................. 17 
Fundamentos de Softwares de Computadores ................................................................................... 18 
Introdução ................................................................................................................................................ 18 
1 - Conceitos básicos de softwares ................................................................................................. 18 
Conhecendo o software ........................................................................................................................... 18 
O que é software? ................................................................................................................................ 18 
Software de código aberto.................................................................................................................... 20 
O que é um programa? ........................................................................................................................ 21 
Como o programa vai parar na memória RAM? ................................................................................... 23 
2 - Softwares funcionais ................................................................................................................... 24 
Sistema Operacional ................................................................................................................................ 24 
Definição .............................................................................................................................................. 24 
Boot e Reboot ...................................................................................................................................... 26 
Versões de Sistemas Operacionais ..................................................................................................... 27 
3 - Tipos de linguagens de programação ........................................................................................ 28 
Apostila de Pensamento Computacional 
Marcio Quirino - 2 
 
Conceito ................................................................................................................................................... 28 
Tipos de linguagem de programação ....................................................................................................... 28 
Linguagem compilada .......................................................................................................................... 28 
Linguagem dinâmica ou interpretada ................................................................................................... 30 
Tendências ........................................................................................................................................... 30 
Considerações finais ............................................................................................................................ 31 
Referências .............................................................................................................................................. 31 
Explore + .................................................................................................................................................. 32 
Fundamentos de Hardware ................................................................................................................. 33 
Introdução ................................................................................................................................................ 33 
1 - O que é hardware? ..................................................................................................................... 33 
O conceito de hardware ........................................................................................................................... 33 
A origem da máquina ........................................................................................................................... 33 
O que difere hardware de software? ....................................................................................................33 
Lei de Moore ............................................................................................................................................ 35 
2 - Componentes básicos de hardware ........................................................................................... 37 
Componentes fundamentais do computador ............................................................................................ 37 
Processador e placa-mãe ........................................................................................................................ 37 
CPU ...................................................................................................................................................... 37 
Placa-mãe ............................................................................................................................................ 37 
Memória temporária ................................................................................................................................. 37 
Random Access Memory ..................................................................................................................... 37 
Memória persistente ................................................................................................................................. 38 
Avanço das tecnologias de armazenamento persistente ..................................................................... 39 
Sistemas de arquivos ............................................................................................................................... 40 
Microcontroladores ................................................................................................................................... 40 
3 - Unidades de armazenamento de dados..................................................................................... 41 
Unidades de armazenamento .................................................................................................................. 41 
Byte .......................................................................................................................................................... 42 
Bits e bytes ........................................................................................................................................... 42 
Por que os computadores funcionam dessa forma? ................................................................................ 43 
Considerações finais ................................................................................................................................ 44 
Referências .............................................................................................................................................. 45 
Explore + .................................................................................................................................................. 45 
Representação de Imagens em Computadores ................................................................................. 46 
Introdução ................................................................................................................................................ 46 
1 - Fundamentos de pixels ............................................................................................................... 46 
Fundamentos sobre pixels ....................................................................................................................... 46 
Grade de pixel .......................................................................................................................................... 48 
2 - Esquema Red Green Blue (RGB)............................................................................................... 49 
Apostila de Pensamento Computacional 
Marcio Quirino - 3 
 
Representação de cores em computadores ............................................................................................. 49 
Esquema de Cores RGB .......................................................................................................................... 50 
Funcionamento ..................................................................................................................................... 50 
Pensamento computacional ..................................................................................................................... 51 
Considerações finais ................................................................................................................................ 52 
Referências .............................................................................................................................................. 52 
Explore + .................................................................................................................................................. 52 
Noções de Programação: Exemplos Com Manipulação de Imagens Digitais ................................... 53 
Introdução ................................................................................................................................................ 53 
1 - Manipulação de dados ................................................................................................................ 53 
Manipulação singular de dados ................................................................................................................ 53 
Instruções para manipulação simples de dados ................................................................................... 53 
Prática 1 ............................................................................................................................................... 54 
Considerações ..................................................................................................................................... 55 
Manipulando cada bit ............................................................................................................................... 55 
Considerações ..................................................................................................................................... 56 
Evoluindo a prática ................................................................................................................................... 57 
Prática 3 ............................................................................................................................................... 57 
Prática 4 ............................................................................................................................................... 58 
2 - Repetição for ............................................................................................................................... 58 
Estruturas de repetição ............................................................................................................................ 58 
Estrutura de repetição for ..................................................................................................................... 58 
Vamos praticar ......................................................................................................................................... 60 
Prática 1 ............................................................................................................................................... 60 
Prática 2 ............................................................................................................................................... 61 
Prática 3 ............................................................................................................................................... 61 
Prática 4 ............................................................................................................................................... 63 
3 - Asexpressões em código de computador ................................................................................. 63 
Expressões............................................................................................................................................... 63 
Prática 1 ............................................................................................................................................... 66 
Considerações ..................................................................................................................................... 67 
Enigma 5-2-10 .......................................................................................................................................... 68 
Vamos desvendar o enigma 5-2-10 abordado no vídeo? ..................................................................... 68 
4 - A estrutura condicional if ............................................................................................................. 69 
O que são estruturas condicionais? ......................................................................................................... 69 
Estrutura condicional ............................................................................................................................ 70 
Vamos praticar ......................................................................................................................................... 70 
Prática 1 ............................................................................................................................................... 70 
Vamos experimentar? .......................................................................................................................... 71 
Prática 2 ............................................................................................................................................... 72 
Apostila de Pensamento Computacional 
Marcio Quirino - 4 
 
Continuando a praticar ............................................................................................................................. 72 
Que tal praticar um pouco? .................................................................................................................. 72 
Considerações ..................................................................................................................................... 73 
Pensamento computacional ..................................................................................................................... 74 
Considerações finais ................................................................................................................................ 76 
Referências .............................................................................................................................................. 76 
Explore + .................................................................................................................................................. 76 
Pensamento Computacional e Aplicações na Área de Conhecimento .............................................. 77 
Introdução ................................................................................................................................................ 77 
1 - Pensamento computacional........................................................................................................ 77 
O que é pensamento computacional? ...................................................................................................... 77 
Pilares do pensamento computacional ..................................................................................................... 79 
Apresentação ....................................................................................................................................... 79 
Primeiro pilar — decomposição................................................................................................................ 79 
Segundo pilar — abstração ...................................................................................................................... 80 
Terceiro pilar — reconhecimento de padrões........................................................................................... 80 
Quarto pilar — algoritmos ........................................................................................................................ 81 
Mercado de trabalho e pensamento computacional ................................................................................. 81 
2 - Pensamento computacional em Economia Criativa, Negócios e Ciências Jurídicas ............... 82 
Economia Criativa .................................................................................................................................... 82 
Reinventando o mundo dos negócios ...................................................................................................... 84 
Computação no Direito ............................................................................................................................. 86 
3 - Pensamento Computacional em Educação e Engenharia ........................................................ 88 
Educação no século XXI .......................................................................................................................... 88 
Aplicação do pensamento computacional ................................................................................................ 91 
Pensamento computacional e ensino da Engenharia .............................................................................. 93 
Considerações finais ................................................................................................................................ 94 
Referências .............................................................................................................................................. 95 
Explore + .................................................................................................................................................. 95 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 5 
 
Pensamento Computacional 
Introdução aos Princípios Fundamentais da 
Computação 
Introdução 
Você sabe como os computadores surgiram? Muitos pensarão em teorias da conspiração, grupos 
secretos, investimentos maciços de governos em tecnologia. Outros se lembrarão dos mais velhos 
comentando sobre os cartões perfurados e dos primeiros computadores, que eram do tamanho de uma sala. 
Um grupo de apaixonados por tecnologia comentará o uso dessa tecnologia durante as guerras do século 
XX, quando essas máquinas estavam relacionadas ao arquivo e trânsito de informações. 
No entanto, o processo é, definitivamente, mais longo e mais complexo. Os computadores não são 
chips, bits e afins. Computadores são o que as máquinas sempre representaram: homens em busca de 
soluções. Ao longo dos séculos, essa necessidade nos permitiu criar diques para contenção de água, 
prédios e até estradas para tornar as grandes viagens mais rápidas. 
Trata-se de entender que essas máquinas e seus componentes são nossos filhos; elas reproduzem 
e aceleram o volume de cálculos, armazenamentos e comunicações que nós idealizamos. Dessa forma, 
cada vez que precisamos de algo a mais, a máquina trabalha para atender nossas demandas. Entender isso 
é perceber que não estamos em uma maratona contra a tecnologia, com medo de nos tornarmos obsoletos. 
Novas tecnologias surgirão, e isso é algo que nós mesmos buscamos. Cada máquina, cada software, cada 
hardware tem o propósito de atender, acelerar e realizar um desejo do coletivo. Algo que não tem essa 
funcionalidade é abandonado, é esquecido. 
Seja bem-vindo ao mundo da tecnologia e lembre-se: você verá aqui o que é necessário para lidar 
com ela. 
1 - Equação essencial dos computadoresEquação fundamental 
Anotem a equação para não se esquecerem dela. O computador é igual a: 
 
Fonte: Estácio de Sá 
Vamos entender o que é isso. Este conteúdo trata dos recursos básicos do funcionamento dos 
computadores. Isso é muito importante, pois, em pleno século XXI, não é desejável que um profissional 
pense no computador como algum tipo de caixa mágica com a qual todos interagem diariamente. De fato, 
no mercado de trabalho atual, é cada vez mais importante que os profissionais saibam como o computador 
faz o que faz. 
É essencial perceber que o mercado de trabalho não é um ente determinador, mas, sem dúvida, a 
relação com a empregabilidade é fundamental. Você consegue perceber alguma função em que o uso 
tecnológico não é necessário? Pense bem: as salas de aula, os treinamentos... Enfim, tudo, de alguma 
forma, vivencia o uso da tecnologia. 
Apostila de Pensamento Computacional 
Marcio Quirino - 6 
 
Com isso, nós nos deparamos com um dilema: a adoção da tecnologia não é linear, nem todos têm 
acesso a ela nem possuem a mesma experiência como usuários. 
 
Durante muito tempo, pensou-se que lidar com os computadores consistia em dominar a tecnologia 
vigente e aprender suas técnicas e seus fundamentos, pois, assim, você estaria seguro. Mas como isso é 
possível tendo em vista que parte das pessoas já estão no topo do uso da tecnologia, enquanto outros ainda 
estão dando os primeiros passos? 
Atenção! 
O desespero de diversas instituições gerou o processo mais absurdo: já que todos não podem dispor de 
tecnologia, então vamos abrir mão dela. Isso só aumentou a segregação, a fragilidade de grupos sociais que não têm 
acesso à tecnologia. Quando fazemos isso, negamos a vários profissionais a possibilidade de diminuir essas 
diferenças. 
Porém, o que pode ser feito? Se não aprendermos a usar a tecnologia do momento, se renegarmos 
a tecnologia para garantir igualdade, qual a solução proposta? Uma ideia é entender o funcionamento básico 
dos computadores, perceber como funcionam essas máquinas e, independentemente da tecnologia atual, 
compreender qual o sentido de sua atualização — os computadores estão sempre sendo atualizados, uma 
vez que o homem precisa constantemente de novas respostas e possibilidades. 
Felizmente, qualquer pessoa pode compreender, basicamente, como os computadores 
funcionam. Nosso objetivo é explorar as qualidades essenciais dos computadores, como eles 
funcionam, o que eles podem e o que não podem fazer. Este conteúdo não requer nenhum 
conhecimento prévio em informática. 
A essência fundamental dos computadores é composta pelas seguintes características: 
 
Fonte: Estácio de Sá 
Você provavelmente deve pensar, “portanto, operações tão simples como essas não são capazes 
de gerar discernimentos ou entendimentos mais elaborados, como, por exemplo, identificar a impressão 
digital de uma pessoa, certo?”. Embora você pense dessa forma, computadores fazem isso: identificam 
digitalmente um indivíduo. 
Saiba mais 
Estudos revelaram que os humanos possuem impressões digitais singulares. Com base nisso, foi elaborada 
uma forma de retirar esses dados — primeiro, foi utilizada graxa para colher digitais; atualmente, usam-se luz e calor 
—, criando um banco de dados com essas informações. Portanto, o trabalho de discernimento é humano; o computador 
apenas cruza, de forma mais rápida e efetiva, os dados armazenados pelas pessoas. 
Apostila de Pensamento Computacional 
Marcio Quirino - 7 
 
Isso ocorre porque discernimento e compreensão são qualidades humanas! É importante 
compreender o seguinte: o computador é realmente um mundo mecânico, em que é possível executar 
operações muito simples a uma velocidade incrivelmente alta. Por exemplo, desde 2005, processadores são 
capazes de executar mais de 1 bilhão de instruções por segundo. Já os processadores lançados em meados 
de 2019 são capazes de executar mais de 48 bilhões de instruções por segundo. 
Ao longo do tempo, Hollywood tem retratado em seus filmes computadores que nunca são mostrados 
como mecânicos, mas sim como entidades com características essencialmente humanas, como 
discernimento, compreensão, criatividade e capacidade de se emocionar. 
A realidade não poderia estar mais distante daquilo que é mostrado nos filmes. O que temos é uma 
combinação engraçada, que une a poderosa capacidade de executar instruções a um conjunto de instruções 
que, inicialmente, parecem tolas. 
Então, é necessário compreender como é possível, mesmo assim, criar recursos/soluções 
interessantes e poderosos. Qualquer pessoa que interage com computadores, provendo instruções em 
alguma linguagem de programação, experimenta uma sensação vívida dessa combinação. 
Humano versus máquina 
E a inteligência artificial? E os robôs que podem ter sentimentos? Em todos esses casos, a equação 
fundamental se mantém. 
O computador possui a capacidade de fazer as ações sobre sequenciamento lógico definido, 
com um conjunto de variações e velocidades elevadas, conforme são ampliadas as capacidades de 
armazenamento e processamento. Por outro lado, se os comandos não forem estabelecidos, se os 
parâmetros não estiverem dispostos e estruturados, a máquina chega a um limite. 
Um dos principais movimentos intelectuais trabalhados pelos gregos foi perceber que, no mundo, 
existe uma parte física, calculável, com possibilidades amplas, e que, sem essa percepção, não é possível 
entendê-la — trata-se do mundo físico. Também temos outra parte, que, embora seja proveniente das 
representações físicas do mundo, não depende delas para a construção dos sujeitos. 
Estamos falando especificamente da metafísica, a construção de percepções mentais que olham 
pela lógica, pela argumentação, pelo estudo, pela dialogia, pela capacidade mental de o sujeito alcançar o 
entendimento universal. Essa parte não tem limites; suas representações são infinitas. 
Uma velha alegoria de Platão ajuda a explicar isso. Trata-se da alegoria da caverna, em que é 
mostrado que todos nós vivemos em um mundo limitado, físico, de pedra, com as representações nas 
paredes iluminadas por um fogo contínuo atrás de nós. Quando libertos, o que encontramos é um mundo 
infinito, perfeito, é o mundo do pensamento, da abstração. Nossa capacidade de abstração e de pensar é 
infinita, mas nossa capacidade de materializar o que foi pensado é limitada. Esse é um dos sentidos da 
alegoria. Buscamos ser mais eficientes, mais próximos das múltiplas possibilidades de nossa mente. 
O mundo perfeito, infinito, com possibilidades de construir e destruir, infelizmente, não mora em uma 
máquina, mas na capacidade humana. A máquina, o computador, é só mais um aprimoramento de nossos 
usos e nossas ferramentas, ainda que aprisionados, limitados, mas tentando e buscando ir mais longe. 
A alegoria da caverna 
Agora ficou claro? Vejamos mais um caso. Enfrentar uma máquina em um jogo de xadrez era uma 
das maiores diversões do século XX. Durante muito tempo, os grandes nomes do xadrez foram os 
vencedores, mas, lenta e continuamente, o desempenho das máquinas foi melhorando, e os jornais 
proclamavam:” Máquina vence o homem!”. 
Será mesmo? Claro que não! Essa disputa nunca foi entre a máquina e o homem, mas sim entre o 
programador e o xadrezista. 
Apostila de Pensamento Computacional 
Marcio Quirino - 8 
 
Enquanto as máquinas não receberam todas as informações para neutralizar, calcular as 
probabilidades e dar o melhor resultado, o programador perdeu. Porém, quando a capacidade de processar, 
arquivar e perceber os melhores algoritmos foi atingida, quando a máquina caminhou o bastante para dar 
respostas no tempo esperado, tivemos a impressão de que a máquina venceu o homem. Entretanto, tudo o 
que ela fez foi executar aquilo que o programador pediu, só que com uma capacidade que o homem, de 
forma direta, jamais conseguiria. 
2 - Processo de exploração do potencial dos computadores 
Entre códigos e algoritmos:aprendendo a lógica do computador 
Vamos voltar à dinâmica do entendimento do pensamento computacional. Você está fazendo uma 
prova de matemática, e o conteúdo é análise combinatória; portanto, aprendeu todas as fórmulas e métricas, 
basta aplicá-las. Agora, é ler o problema e colocar tudo lá. 
Se a máquina é extremamente rápida, mas muito tola, como é possível a implementação de tantos 
recursos úteis nos computadores? 
Você repetiu o dia inteiro: 
 
Fonte: Estácio de Sá 
E na hora surge uma dúvida: 
“É uma combinação simples ou com repetição? Não sei, eu só aprendi que essa é a fórmula. 
Não basta apenas colocar os números, e o resultado será alcançado?”. 
Claro que não! Uma fórmula é uma simplificação, e cada um de seus elementos só tem sentido se 
for observado dentro de um contexto. Demos o exemplo matemático, porém a matemática é apenas uma 
leitura da vida. 
Imagine um motorista que condicionou o seguinte: sinal (farol) amarelo é para parar. Porém, no 
trânsito, nem todos pensam da mesma forma. Logo, se esse motorista vê um sinal amarelo e para, pode ser 
que o condutor que vem atrás, por não pensar como ele, não consiga frear. O resultado é a colisão. O ponto 
é que, para que um computador execute o que você deseja, ele precisa de informações, padrões e leituras, 
pois só assim ele será capaz de ampliar suas possibilidades de soluções. 
Comentário 
Os computadores, e incluímos aí o seu celular ou o PC que você usa, têm a mesma dinâmica. Todos receberam 
informações — processos e procedimentos — para que pudessem executar o que se espera deles. É isso que vamos 
estudar agora. 
Código 
Para compreendermos o funcionamento de um computador, precisamos entender o que é um código. 
Então, dentro do computador, temos um corpo de códigos, e eles são apenas uma série de instruções, por 
exemplo: adicione dias e medidas e compare-os. Você se lembra da equação fundamental, não é mesmo? 
Um computador corresponde à incapacidade de pensar à velocidade X. Então, o trabalho da máquina 
consiste em apenas uma série de instruções; ela só executa o que é pedido na ordem em que recebeu as 
orientações de quem escreveu o código. O computador é capaz de passar por uma sequência de instruções 
de uma forma incrivelmente rápida. Quem pensa e estrutura, podendo ser cada vez mais complexo ou 
simples, é o sujeito que programa. 
Apostila de Pensamento Computacional 
Marcio Quirino - 9 
 
Há uma série de instruções, e o computador apenas caminha através delas, executando cada uma 
exatamente como instruído. São as famosas palavras executar e rodar, como você já deve ter ouvido. Então, 
sim, um código é executado de forma muitíssimo rápida, mas as instruções individuais são bastante simples, 
o que leva a uma pergunta natural: 
Se essas instruções são tão simples, como podemos ter um recurso útil? Ou seja, como tornar 
o computador capaz de realizar tarefas que dependam de algum nível de inteligência e 
discernimento? 
Vamos tentar algo prático. Usaremos o recurso de redução de olhos vermelhos de fotografias como 
um exemplo de utilidade do computador. Existem infindáveis exemplos diferentes, como enviar um e-mail, 
assistir a um vídeo on-line ou qualquer outra tarefa que executamos em nossos computadores diariamente. 
Que tal, agora, pensarmos nos filtros para maquiagem? Mas isso serve para quê? Para atender aos 
desejos do usuário. Diverte, faz rir, aumenta a autoestima. A programação não julga, não cria a demanda; 
ela atende à demanda. Embora receba as instruções e realize as tarefas, a utilidade é do usuário que 
precisava daquilo. 
Sempre que você pensar em um código, deve imaginar o seguinte: se ele foi criado e, principalmente, 
se alcança um grande número potencial de utilização, não foi o computador que evoluiu, mas a sociedade. 
Alguém captou uma demanda e observou que a máquina, que a criação de um código, poderia suprir essa 
carência, nem que fosse fazer rir. 
O que liga esses dois lados da essência de um computador: a demanda humana e a necessidade 
de criação de um código para alcançar a solução? A resposta é a seguinte: programadores. 
Voltemos ao exemplo dos olhos vermelhos. Um programador de computador talvez tenha tido a 
seguinte ideia: “Seria legal se os computadores fossem capazes de reduzir os olhos vermelhos de 
fotografias, pois esse defeito é meio macabro, e eu fico desconfortável ao vê-lo”. Essa é uma ótima ideia! 
Trata-se de um discernimento, uma escolha humana que atende a seus anseios: deveríamos ter redução 
de olhos vermelhos. Assim, o programador de computador pensa em uma maneira de tornar isso possível. 
Resumidamente, temos as seguintes etapas: 
1 - O programador procura a cor vermelha na foto e, talvez, checaríamos se ela tem uma forma 
arredondada. 
2 - Em seguida, o programador precisa pensar em uma forma de desempenhar cada um desses 
passos e escrever um algoritmo em instruções tão simples, tornando possível que o computador 
execute cada uma. 
3 - Ao final, o programador tem a função de redução de olhos vermelhos funcionando. 
O resultado do sequenciamento de instruções compreensíveis ao computador para realizar uma 
dada tarefa (ex: redução de olhos vermelhos) é chamado de algoritmo. 
Algoritmo 
Definição 
Para usar o e-mail, assistir a um vídeo, conversar pelo WhatsApp, realizar operações bancárias, ou 
qualquer outro recurso útil via computador, smartphones etc., foi preciso que, em algum momento, uma 
pessoa ou uma equipe pensasse: “Bem, deveríamos escrever um algoritmo para isso”. 
Alguém estruturou os procedimentos necessários e, depois, transformou os passos de alto nível em 
instruções suficientemente simples, para que o computador ou o smartphone pudesse executá-las. Essa 
pessoa ou a equipe trabalhou, então, escrevendo o código para a solução. Em seguida, um bom tempo foi 
gasto para testar e melhorar o código, até que ele, de fato, representasse com fidelidade o algoritmo 
projetado originalmente. 
Apostila de Pensamento Computacional 
Marcio Quirino - 10 
 
O programador pode se concentrar em ser criativo, para, então, criar um algoritmo capaz de resolver 
um problema real. 
Programadores versus computadores 
Programadores de computadores são os responsáveis por discernir um aproveitamento útil, 
transformar a ideia de aplicação (ex.: redução de olhos vermelhos em fotos) em um algoritmo e traduzir esse 
discernimento em uma sequência de instruções simples, compreensíveis para o computador. As máquinas, 
por outro lado, são inacreditavelmente rápidas. Assim, programadores e computadores formam uma 
combinação extremamente poderosa. Vamos entender agora a diferença entre código e algoritmo: 
 
Fonte: Estácio de Sá 
Suponha que você tenha pensado em um algoritmo com a finalidade de calcular a idade de pessoas 
com base em sua data de nascimento. Então, você começa a escrever um código que deve seguir uma das 
linguagens de programação padrão. Enquanto não estiver funcionando, não poderá ser classificado como 
um algoritmo, pois ainda não alcança sua finalidade. 
Como os computadores evoluem 
Lei de Moore 
A previsão feita há mais de 50 anos por Gordon Moore é fantástica. A tecnologia está em evolução 
e desenvolvimento contínuos. Afinal, cada vez mais, sistemas dependem da tecnologia, em virtude de sua 
interconexão, permitindo a ampliação da tecnologia e dos produtos e aumentando a velocidade de sua 
substituição. 
A cada geração, um conjunto geracional antigo de tecnologia está presente no mercado, sendo 
consumido por públicos que não teriam acesso antes. A cada evolução, porém, a capacidade de troca de 
dados e informações seriam maiores, e a necessidade de uso de material, menor, permitindo um 
barateamento relativo. No limite, a evolução tecnológica acaba barateando os computadores. 
A popularização dos computadores é uma das maiores provas daquilo que foi apontado por Moore. 
1 - Nos anos 1980, nos Estados Unidos (o que só ocorreu no Brasil a partirdos 1990), a primeira 
onda de computadores pessoais, os PC, ocupou os espaços nas lojas lentamente. Essas máquinas 
deixaram de ser enormes e pesadas. 
2 - Nos anos 2000, as telas e as conexões eram a novidade. 
3 - Nos anos 2010, as bandas largas se multiplicaram. 
Apostila de Pensamento Computacional 
Marcio Quirino - 11 
 
4 - Com o passar do tempo, o computador foi diminuindo, podendo ser encontrado em forma de 
tablets, laptops, smartphones. 
O acesso à tecnologia se deu em um tempo muito curto, o que é impressionante. Quando achamos 
que dominamos determinada tecnologia, tudo parece mudar de repente. É assustador! Mas sabe o que de 
alguma forma não mudou? A dinâmica. 
Reflexão 
Você aprendeu a lógica do funcionamento do computador. Vamos revisar. 
Relembrando 
Um computador é apenas mais uma das históricas tentativas humanas de facilitar e resolver demandas que 
surgem de forma recorrente. Na busca dessas demandas, cada inovação que aparece se torna-se uma estrutura — 
quer dizer, parte da sociedade, ao mesmo tempo, é estruturante e força novas buscas, transformando toda a sociedade. 
Nós, humanos, temos essa característica, e as máquinas vivem para atender a demandas que são pensadas e 
estruturadas por nós. 
Depois que uma demanda é pensada, precisamos focar o processamento das informações e a capacidade de 
armazená-las. Isso, aliás, é a origem de todo o processo da computação. Homens precisavam ampliar sua capacidade 
de armazenamento, de reprodução, de execução. 
3 - Código de instrução de computadores 
Códigos em execução 
Preparação 
Aqui queremos chegar ao ponto em que você possa escrever algum código de computador, executá-
lo e ver o que ele faz. No computador, tudo se resume realmente a códigos em execução (rodando). É assim 
que as coisas acontecem. Assim, para que a natureza dos computadores seja entendida, nada melhor do 
que rodar um pouco de código e ver como ele funciona. 
Atenção! 
Não se preocupe, pois não veremos casos complexos com um milhão de linhas de código, mas apenas um 
pouco de código. Somente o mínimo, para que você tenha o primeiro contato com o que é escrever código de 
computador. 
Antes de chegar ao código, será necessário um pouco de paciência. Os elementos de código que 
serão mostrados aqui não são chiques, chamativos ou complexos. Eles são muito simples. Talvez seja um 
pouco como um brinquedo de peças de encaixe, isoladas, dispersas, complexas; porém, com o tempo e a 
familiaridade, as possibilidades e o uso vão se modificando. 
Assim como usamos alguma língua (português, inglês etc.) para conversar com as pessoas, é 
necessário usar uma das linguagens disponíveis para escrever códigos que o computador compreenda. 
Existem várias linguagens de computador diferentes para informar ao computador o que fazer. 
Aqui, utilizaremos uma das mais usadas na atualidade, uma versão simplificada da linguagem 
Javascript, por exemplo, empregando instruções simplificadas para impressão na tela e nas estruturas de 
repetição. Usaremos somente os principais recursos, para que você possa escrever e manipular códigos 
bem simples e brincar com a ideia-chave: compreender de fato como funcionam os computadores. 
Prática 1 
Assista ao vídeo para o nosso primeiro exemplo prático. 
Para compreender como imprimir strings, veja a Prática 2 a seguir. 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 12 
 
Strings 
Strings e números são os dois tipos de dados muito comuns no código de computador. Por exemplo, uma string 
é usada para lidar com nomes de pessoas, endereços, endereços de páginas web, endereços de e-mail, ou até mesmo 
um parágrafo, quando alguém está redigindo uma redação. Todos esses exemplos de tipos de textos são armazenados 
na memória do computador como strings. 
Esse é apenas um segundo tipo de dados que seremos capazes de usar para informar ao computador como 
fazer as coisas. Existem muitos outros tipos de dados, mas, por enquanto, nós nos limitaremos aos vistos até agora. 
Outra novidade presente no código-fonte da Prática 2 é o uso de comentários na segunda linha. 
Prática 2 
Clique em Executar e observe o resultado apresentado em Saída. 
 
Fonte: Estácio de Sá 
O que temos de novidade aqui? O que fizemos foi usar a sintaxe padrão para informar ao computador 
que o que está sendo impresso é um texto (string). Para isso, cercamos as strings Teste, Bom dia e Tchau 
com aspas duplas. 
Ao clicar em Executar, você pode ver os textos e valores numéricos corretamente impressos em 
Saída. 
Dica 
Um comentário, em JavaScript, começa com duas barras. Em seguida, você pode escrever notas para você 
mesmo, para lembrá-lo, no futuro, do que você pretendia ou do que está tentando fazer neste ponto do seu código. O 
computador sabe ignorar comentários, então é apenas uma maneira de adicionar decorações/lembretes ao código com 
pequenas observações. 
O uso de comentários é considerado bastante importante, pois ajuda o programador a compreender um código 
que não foi escrito por ele, ou até mesmo um código que foi escrito por ele há tanto tempo que ele não lembra mais 
como raciocinou para escrever aquele trecho de código. 
Um exemplo intrigante que podemos citar aqui é colocar a palavra print no lugar de “Tchau”. Isso é 
intrigante, pois print também é o nome da instrução de impressão reconhecida pela linguagem de 
programação que estamos usando. 
O que ocorrerá ao substituirmos “Tchau” por print e clicarmos e Executar? Se você mesmo fizer este 
teste na Prática 2, obterá o resultado ilustrado no emulador a seguir. 
Apostila de Pensamento Computacional 
Marcio Quirino - 13 
 
 
Fonte: Estácio de Sá 
Como a string print está delimitada por aspas na terceira linha, o computador sabe que se trata 
apenas de mais um texto a ser impresso, e não de outra instrução print. Portanto, quando sequências de 
caracteres são colocadas entre aspas duplas, como neste exemplo, o computador entende que se trata 
apenas de dados passivos, e lida com eles conforme esperado. 
Atenção! 
Note que temos uma lição importante aqui sobre sintaxe. Nós já sabemos que ela é restrita e mecânica; no 
entanto, é importante entender que você está seguindo um padrão/convenção ao escrever um código de computador 
que envolve a sintaxe, o que é característico da linguagem de programação. Então, é muito comum, mesmo para 
programadores muito profissionais, a ocorrência de pequenos erros de sintaxe. 
Quando há um erro de sintaxe, ao clicarmos no botão de execução, alguns serão listados em Saída. 
Então, é parte da tarefa de quem escreveu o código corrigir esses erros até que o computador aceite que 
as instruções estão de acordo com o padrão de sintaxe da linguagem de programação em uso. Esse é 
apenas um processo rápido, superficial e comum. 
A razão pela qual estamos discutindo isso é que, quando alguém está apenas começando a aprender 
a escrever códigos (programar), será bastante comum se deparar com erros de sintaxe. Então, jamais se 
permita ter a impressão de que você não está entendendo como escrever código. Apenas entenda que todo 
mundo passa por erros de sintaxe, inclusive programadores com décadas de experiência. Então, quando se 
deparar com erros de sintaxe, apenas faça uma checagem rápida e cuidadosa para corrigir os erros e seguir 
adiante. 
Para promover a ideia de que o erro de sintaxe não é grande coisa, queremos mostrar como consertar 
isso. Veremos alguns exemplos práticos a seguir. São apenas alguns exemplos de código, todos com erros 
de sintaxe. Queremos que você treine o processo de identificá-los e corrigi-los. 
Prática 3 
Como vimos, todo mundo passa por erros de sintaxe. Vamos aprender a identificá-los e corrigi-los! 
O resultado de cada um dos seis exemplos a seguir deve imprimir, em Saída, as letras destacadas 
em verde. Você precisa corrigir a sintaxe de cada um dos seis exemplos. Depois que você corrigir a sintaxe 
das instruções, cada um dos seis exemplosimprimirá exatamente as três linhas indicadas em vermelho mais 
à frente. 
Apostila de Pensamento Computacional 
Marcio Quirino - 14 
 
 
Fonte: Estácio de Sá 
Saída esperada para cada um dos seis exemplos práticos a seguir: 
 
Fonte: Estácio de Sá 
... 
Por fim, precisamos abordar mais um conceito básico: variáveis. Uma variável no computador é 
como uma caixa, ou seja, um local onde podemos armazenar valores para uso futuro. Então, se tivermos 
um código em que atribuímos o valor 7 a uma variável V, o que isso significa é que há uma caixa no 
computador chamada V, conforme ilustrado na tabela a seguir, nós simplesmente podemos armazenar um 
valor, como um 7, nessa caixa. Também poderíamos armazenar qualquer valor que quiséssemos. 
O que significa na prática? 
“Caixa” de nome V, em que atribuímos o valor numérico 7: 
"Caixa" ← 7 
Sendo um pouco mais específico, essa “caixa” é, na verdade, um espaço na memória do computador, 
em que podemos armazenar valores, e V é o nome que damos a essa área reservada para armazenar o 
valor que desejarmos. Em linhas posteriores, no código, se um V aparecer, o computador sabe o que 
colocamos dentro da caixa (em nosso exemplo, o 7). A variável se torna uma espécie de abreviação 
conveniente para qualquer valor que eu queira usar. 
1 - Na primeira linha, atribuímos o valor 7 à variável que optamos por chamar de V. 
2 - Na segunda linha, damos um comando para imprimir o valor da variável, que será 7 neste 
exemplo. 
3 - Na terceira linha, imprimimos uma string informando “O valor da variável é:” e, depois, indicamos 
“V” para que o computador imprima de fato o valor recuperado da variável. 
Apostila de Pensamento Computacional 
Marcio Quirino - 15 
 
Clique em Executar e observe os resultados. 
 
Fonte: Estácio de Sá 
Notou que, sempre que V é referenciado no código, o computador o substitui pelo valor 7? Esse é o 
equivalente a ler o valor armazenado na caixa. 
Uma grande vantagem do uso de variáveis é que, se o programador quiser usar um valor diferente 
em seu código, basta trocar o valor na linha de atribuição de valor à variável, e todo o restante do código 
passará a usar o novo valor sempre que houver referência à variável, que, em nosso exemplo, é V. 
Prática 4 
Observe o que acontece quando substituímos 7 por 1980 e clicamos em Executar. Note que todos 
os locais em que V foi referenciado resultaram em 1980 na saída. 
 
Fonte: Estácio de Sá 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 16 
 
Prática 5 
Escreva, a seguir, um código que atribua a uma variável chamada N a string Guilherme, e depois 
clique em Executar para obter a seguinte Saída: 
Guilherme Guilherme Guilherme 
Eu conheço um amigo chamado Guilherme 
 
Fonte: Estácio de Sá 
Brinque à vontade com as práticas anteriores, até que fique à vontade para definir mais do que uma 
variável e imprimir mais do que um valor, até estar confortável com a ideia de que, para computadores, o 
uso do igual e de instruções significa atribuição. Isso é importante, pois, em matemática, o sinal de igual 
possui um significado diferente. 
Considerações finais 
Pensamento computacional parece um tema futurístico. Inclusive, muitos alunos devem ter se 
lembrado dos filmes de catástrofe, em que a tecnologia se levanta contra o homem. Neste material, você foi 
tranquilizado sobre essas questões. Primeiro, descobriu que máquinas são terrivelmente ignorantes e 
profundamente capazes. Somente a partir da interação e da estruturação de um conjunto de linguagens 
específicas, o grande potencial das máquinas — armazenamento e processamento — pode ser efetivamente 
estruturado. 
Sendo assim, pensamento computacional é um convite para que você entenda como funciona essa 
relação entre máquinas e homens e, com isso, perceba que não é preciso dominar tecnicamente uma 
ferramenta apenas em determinado momento, pois, embora elas sejam atualizadas constantemente, a 
dinâmica e os fins permanecem os mesmos. 
Nesse sentido, o que você precisa conhecer, então, são as linguagens que compõem esse novo 
universo: códigos e algoritmos. Se você entendeu que código são as instruções que o ser humano dá à 
máquina — mostrando que computadores executam nossas demandas — e que algoritmo é a linha desse 
comando estruturado para que a máquina interprete e execute, você entendeu a essência da dinâmica 
comando, forma de comando, execução, novas demandas, comandos e forma de comando, sempre 
impulsionada pelas demandas humanas. 
Para concluir, sugerimos que você faça inúmeros testes (em alguma das práticas acima) a fim de 
perceber como se relacionou com o assunto, criou e executou a dinâmica proposta. Como uma criança que 
aprende a engatinhar e a ficar em pé, daqui por diante, busque dar os primeiros passos, entendendo a 
mecânica, e, em breve, você estará correndo. 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 17 
 
Explore + 
A literatura e o cinema de ficção contribuíram muito para discutir a percepção da máquina (e do 
computador) como superior e possível inimiga da humanidade. Esta é uma das funções da arte: provocar 
nossa reflexão! Assim, além das obras citadas ao longo de nosso material, sugerimos algumas outras. 
Leia os seguintes livros: 
Admirável mundo novo, de Aldous Huxley (1932). 
Eu, robô, de Isaac Asimov (1950). 
Guerra dos mundos, de H.G. Wells (1898). 
O homem do castelo alto, de Philip K. Dick (1962). 
1984, de George Orwell (1949). 
Assista: 
A.I. – Inteligência artificial, de Steven Spielberg (2001). 
Animatrix, de Shinichiro Watanabe, Takeshi Koike, Yoshiaki Kawajiri, Peter Chung, Koji Morimoto, 
Mahiro Maeda e Andrew R. Jones (2003). 
Blade Runner – O caçador de androides, de Ridley Scott (1982). 
Ex-Machina: Instinto artificial, de Alex Garland (2015). 
Gattaca – A experiência genética, de Andrew Niccol (1997). 
Minority report – A nova lei, de Steven Spielberg (2002). 
O homem bicentenário, de Chris Columbus (1999). 
Wall-E, de Andrew Stanton (2008). 
Jornada nas estrelas: Picard, de Akiva Goldsman, Michael Chabon, Kirsten Beyer e Alex Kurtzman 
(2020–atualmente) 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 18 
 
Fundamentos de Softwares de Computadores 
Introdução 
Para que os computadores atuais possam ter alguma utilidade para nós, usuários, é necessário que 
eles recebam instruções das ações que devem executar, por exemplo, para que você assista a um vídeo, 
ouça um podcast ou leia este texto. 
Essas instruções são passadas aos computadores por meio dos softwares, que podemos chamar 
por agora de programas de computador. São esses programas, com inúmeras finalidades, que determinarão 
as ações que podem ser desenvolvidas pelo computador. 
De uma maneira simples, os programas são formados por instruções que são executadas por um 
componente chamado processador. O resultado do processamento das instruções ou de um conjunto de 
instruções determinará a finalidade do programa. 
Estamos falando de computadores, mas isso não ocorre apenas neles. Quaisquer dispositivos 
eletrônicos podem ter softwares para executar uma ação específica, como controlar o funcionamento de 
uma geladeira, ou de propósito mais amplo, como o computador que você carrega no seu bolso, o seu 
smartphone. 
1 - Conceitos básicos de softwares 
Conhecendo o software 
Aqui descreveremos os conceitos básicos sobre software de computadores e responderemos, de 
forma introdutória, às seguintes perguntas: 
1 - O que é software? 
2 - O que é código de computador? 
3 - Como os softwares rodam (são executados) em um computador? 
O que é software? 
Sempre que você baixa um programa ou vê um computador ligado, está presenciando algum 
software sendo executado. 
Até mesmo no passado, telégrafos, telefones, aparelhos de fax, todos já possuíam um software, um 
conjunto de ações programadas que usavam a estrutura física e lhes davam materialidade: voz, letras e 
imagens. Cada máquinaexercia exatamente a sua função, e repare: estamos indo além da função mecânica. 
Exemplo 
Imagine uma máquina de costura. 
Ela faz sempre a mesma operação, um movimento mecânico repetitivo. Porém, quem atua para que ela 
execute funções a partir do domínio de técnica é o sujeito; a máquina mecânica é estruturada, e a mente humana é 
quem faz a função. 
Quando um sujeito decidiu que era possível programar a máquina para fazer além da função repetida, para 
trançar uma estrutura, sucedendo e alcançando a partir disso objetivos claros e novos, criou-se o software. A máquina 
é capaz de ser programada para cumprir um conjunto de funções definidas e desenhadas pelo sujeito. 
O computador é filho da II Guerra Mundial, da necessidade de novos desenvolvimentos, de realizar 
processamento de informações e comunicação mais eficientes, cruzando dados e armazenamento. 
Apostila de Pensamento Computacional 
Marcio Quirino - 19 
 
Não basta construir a máquina; é necessário executar, definir o que se deseja, programar e 
reprogramar. 
Softwares para computadores passaram a ser uma demanda, uma construção e sofisticação 
contínuas. 
Sempre que um software é criado, imediatamente passamos a pensar em como melhorá-lo, 
transformá-lo em algo mais eficiente. Pessoas vivem disso e recriam isso. 
Nunca mais dominaremos perfeitamente todos os softwares que desejamos; afinal, sempre que 
aprendermos sobre um, novas mudanças estarão chegando. 
Já jogou videogame? Esses aparelhos mudaram e continuam mudando; atualmente, possuem 
gráficos e programações cada vez mais complexos. 
Para entender tudo isso, é necessário compreender o que é, afinal, um software para computadores. 
Afinal, o que é software? 
Software é o conjunto de funções executadas na programação de um computador. 
Embora não seja uma entidade física, ganha materialização em sua construção virtual, 
independentemente da rede. 
É a manifestação de uma imagem e dos desdobramentos a partir da construção de códigos e 
execuções. 
Vamos entender melhor esse processo: 
A CPU (Central Processing Unit), também chamada de processador, é uma espécie de cérebro. 
É ela quem realmente executa o que chamamos de “instruções de código de máquina”. 
Veja a imagem a seguir: 
 
Fonte: Estácio de Sá 
Essas instruções são extremamente simples e constituídas apenas dos números 0 (zero) e 1 (um), 
conhecido como código binário. 
Extremamente simples 
Por exemplo, em uma instrução de código de máquina, é possível adicionar dois números; já em outra pode-
se comparar dois números para ver qual deles é maior. 
Apostila de Pensamento Computacional 
Marcio Quirino - 20 
 
Podemos pensar no conjunto de instruções de código de máquina que uma CPU é capaz de executar 
como sendo um idioma de baixo nível, ou “código de máquina” (também conhecido como “código nativo”). 
O idioma do código da máquina está intimamente conectado ao projeto do hardware da CPU, ou seja, não 
é algo que possa ser mudado à vontade. 
Cada família de CPUs compatíveis (por exemplo, a popular família Intel x86 usada em computadores 
pessoais) possui seu próprio código de máquina específico, que não é compatível com o código de 
máquina de outras famílias de CPUs. 
Vamos a um exemplo: 
Exemplo 
Na linguagem JavaScript, a instrução (linha de código) para definir um pixel (ponto) da tela com nível de 
vermelho para o nível 255 seria: 
pixel.setRed(255). 
Essa instrução é muito mais complexa do que uma instrução de código de máquina individual que 
CPUs são capazes de executar. Então, nós a chamamos de uma instrução de alto nível. 
Instruções de alto nível são facilmente compreensíveis pelos humanos, mas os computadores 
não são capazes de executá-las. 
O que ocorre, então, é que, antes de ser executada, a instrução de alto nível será expandida em uma 
sequência – talvez cinco ou dez instruções de baixo nível (código de máquina) –, de modo que, quando 
essas cinco ou dez instruções forem executadas, uma após a outra, o resultado final terá o efeito de definir 
o valor vermelho do pixel para 255, conforme designado pela instrução de alto nível escrita pelo 
programador. Esse processo está resumido na imagem a seguir. 
 
Fonte: Estácio de Sá 
Você pode estar se perguntando: 
Como corrigir um erro de programação cometido pelo programador? 
Se você quiser adicionar um recurso para corrigir um bug no Firefox (por exemplo), a forma real de 
fazer isso é voltar ao código-fonte original e realizar os ajustes necessários, alterando as instruções. 
Em seguida, é necessário executar o compilador novamente para compilar (traduzir de linguagem 
C++ para linguagem de máquina) uma nova versão do Firefox que incluirá os ajustes realizados no código-
fonte. 
Software de código aberto 
É importante construirmos uma noção do que significa software de código aberto. 
Trata-se de uma forma de distribuição de software em que o programa compilado é fornecido, mas 
também há acesso ao código-fonte original do programa. 
Apostila de Pensamento Computacional 
Marcio Quirino - 21 
 
Geralmente, o código-fonte é acompanhado de uma licença que diz algo como: 
“Aqui está o código-fonte, se você quiser criar sua própria versão realizando as alterações que 
desejar, fique à vontade.” 
Atenção! 
Trata-se de uma forma de distribuição de software, normalmente gratuita, em que o programa compilado é 
fornecido, mas também há acesso ao código-fonte original do programa. 
Mas qual a diferença entre softwares de código aberto e softwares de código fechado? 
Código aberto 
Se forem necessários ajustes, correções e incrementações que você queira fazer com o programa – ou se o 
fornecedor original não existe mais –, você tem total liberdade para agir. 
Código fechado 
Se você precisa de algum recurso diferente ou adicional, ou se há um bug que precisa ser corrigido, você 
realmente depende do fornecedor, pois somente ele detém o código-fonte. 
Então, só o fornecedor é capaz de realizar ajustes e correções. 
Em geral, existem tipos diferentes de termos de licença para software de código aberto, mas, na 
maioria das vezes, eles exigem que, se você fizer alterações no código-fonte e adicionar algum recurso, 
você deve oferecer essas alterações à comunidade. Assim, da mesma maneira que você se beneficiou dos 
outros ao obter o programa gratuito e seu código-fonte, eles podem se beneficiar do seu trabalho. 
O que é um programa? 
Observe o lado direito da imagem abaixo e perceba que a CPU está executando uma sequência de 
instruções presentes na memória RAM. Então, um programa/aplicativo como, por exemplo, o navegador de 
Internet Firefox, ou o editor de textos Microsoft Word, nada mais é do que uma enorme sequência dessas 
instruções simples de código de máquina. 
 
Fonte: Estácio de Sá 
Assim, quando o Firefox está sendo executado no seu computador, isso significa que, em algum 
lugar na RAM, há um bloco dessas instruções, e a CPU as executa uma após a outra sequencialmente. 
Tudo o que você pode ver o Firefox fazendo – como piscar o cursor, conectar-se via rede a uma URL 
fornecida pelo usuário, desenhar imagens na tela, obter páginas da Web, entre outros – ocorre graças à 
Apostila de Pensamento Computacional 
Marcio Quirino - 22 
 
CPU, que roda as instruções de forma tão inacreditavelmente rápida que você interage com o Firefox de 
forma fluida e natural. 
Portanto, as instruções individuais são realmente triviais, certo? 
De que forma isso leva o cursor a piscar no ponto onde podemos digitar algo? 
Resposta 
Uma forma bastante simples de pensar sobre isso é usar uma analogia: o relacionamento entre areia e 
escultura. 
Cada instrução em código de máquina seria um grão de areia, que é sem sentido e parecido com todos os 
outros. Porém, se você juntar grande quantidade de maneira certa, pode construir uma estrutura complexa, conforme 
sua imaginação e seu objetivo. 
Em linhas gerais, é assim que programas como o Firefox, Chrome, MicrosoftWord, os jogos digitais, 
ou qualquer outro aplicativo são construídos. 
Se olharmos à esquerda da imagem abaixo, veremos a CPU trabalhando para executar as instruções 
de código de máquina disponíveis na RAM. 
 
Fonte: Estácio de Sá 
Comentário 
Para executar as instruções de código de máquina, as instruções usam um método chamado ciclo busca-
execução (Fetch Execute Cycle). 
No ciclo busca-execução, a CPU iniciará buscando a instrução 1, carregando-a para dentro de si 
(CPU), e a executará. 
Por exemplo, a CPU adicionará os dois números. Após executar a instrução 1, a CPU simplesmente 
desce na lista e executa novamente o ciclo busca-execução para a instrução 2. Em seguida, faz o mesmo 
para a instrução três, e assim por diante. As instruções são executadas uma após a outra, sequencialmente. 
Saiba mais 
Quando dizemos que uma CPU opera a 4 GHz (gigahertz), ou 4 bilhões de operações por segundo, estamos 
nos referindo exatamente a essas pequenas instruções. 
Existe uma enorme variedade de tipos de instruções, mas há dois tipos específicos que vale a pena 
comentarmos, mesmo em um curso introdutório. Veja a seguir: 
Apostila de Pensamento Computacional 
Marcio Quirino - 23 
 
Instrução para alterar a ordem de execução de instruções: 
Normalmente, a CPU apenas desce a lista e faz a execução das instruções na ordem em que elas 
estão armazenadas na memória. 
Conforme ilustrado na imagem a seguir, digamos que a instrução quatro diga: “Pule para trás e 
comece a executar novamente na instrução 1”. 
Nesse caso, a CPU executaria as instruções na ordem: 1, 2, 3, 4 e, em seguida, em vez de seguir 
para a instrução 5, daria um pulo para trás e iria para (goto) a instrução 1, executando-a novamente, seguida 
das instruções 2 e 3. 
É assim que as estruturas de repetição de instruções (loops) são implementadas pela CPU. 
 
Fonte: Estácio de Sá 
Você sabe o que é goto? 
A goto é uma instrução na linguagem de informática e significa: vá para a linha indicada e siga 
executando o código a partir desse local. 
Instrução que testa alguma condição: 
Se a condição for verdadeira, diz, por exemplo, que ela avance para a instrução 5. 
Há uma instrução que olhará para alguma condição; assim, se a condição for verdadeira, é como 
dizer à CPU: “Vá para (goto) a linha indicada”. Caso seja falsa, a CPU vai para (goto) outra linha. 
Então, organizando as instruções, você pode obter o efeito de uma estrutura condicional, conhecida 
como declaração if. 
A seguir, você fará uma descoberta a respeito do programa. 
Como o programa vai parar na memória RAM? 
Ao serem instalados, programas são colocados em um dispositivo de armazenamento persistente, 
como HD, SSD ou pendrive. 
Vamos entender com o exemplo do Firefox: 
Exemplo 
O programa é basicamente um arquivo chamado Firefox.exe, que possui muitos bytes. Na maioria dos casos, 
esses bytes são apenas as instruções que compõem o programa, além de alguns ícones e fotos. 
O que acontece quando você clica duas vezes no arquivo Firefox.exe, ou no atalho que aponta para 
esse arquivo? 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 24 
 
Basicamente, são os três passos indicados na imagem a seguir: 
 
Fonte: Estácio de Sá 
Veja a descrição de cada um desses passos: 
Passo 1 
Cópia dos bytes (ou seja, instruções) que compõem o arquivo do dispositivo de armazenamento 
persistente (HD, por exemplo) para uma área desocupada da memória RAM. Essa cópia é 
comumente chamada de carregar (load) o programa. 
Passo 2 
Após o carregamento (cópia do HD para a RAM), a CPU já é capaz de realizar o ciclo busca-
execução para rodar o programa Firefox. Então, o passo dois consiste em apenas dizer à CPU: 
“Aqui está a instrução 1 de um programa; você deve iniciar, a partir dessa instrução, o ciclo busca-
execução para rodar o programa”. 
Passo 3 
A CPU começa o processo de rodar/executar as instruções de forma incrivelmente rápida. Pronto, 
nosso Firefox está rodando, e o usuário já consegue navegar pela Internet. 
2 - Softwares funcionais 
Sistema Operacional 
Definição 
Comumente, quando se estuda conceitos básicos de software e como ocorre a execução de 
instruções pela CPU, surgem questionamentos como: 
1 - Quem lida com o duplo clique usado para ordenar que um programa seja executado? 
2 - Quem garante que um novo programa carregado na RAM irá para uma região da memória que 
esteja realmente ociosa, sem que haja sobreposição de outros programas em execução? 
3 - Quem ordena o carregamento de um programa do HD para a RAM? 
4 - Ao final da execução de um programa, quem realizada as operações, como, por exemplo, liberar 
a região da RAM onde o programa esteve durante sua execução? 
Apostila de Pensamento Computacional 
Marcio Quirino - 25 
 
A resposta às perguntas descritas anteriormente é a seguinte: o Sistema Operacional (SO). 
O SO é um conjunto de tipos de programas administrativos e de supervisão que organizam 
todo o sistema. O sistema operacional está para os computadores como o governo está para uma 
nação. 
O SO de um computador é como um primeiro programa de supervisão que começa a ser executado 
quando o computador é inicializado (“inicializa”). Ele desempenha um papel administrativo e contábil invisível 
nos bastidores. 
Quando um desktop, laptop ou smartphone é iniciado, o SO, normalmente, organiza as coisas e inicia 
um programa “explorador de arquivos” que exibe janelas e menus, entre outros, que mostram ao usuário 
quais sistemas de arquivos estão disponíveis. Isso permite que ele navegue e opere seu equipamento, 
solicitando que programas/aplicativos sejam iniciados ou finalizados, interagindo com esses 
programas/aplicativos. 
Em resumo, conforme ilustrado na imagem a seguir, o SO é responsável por intermediar as 
solicitações que os usuários fazem a programas/aplicações, gerenciando como tudo isso deve ser 
demandado do hardware. 
 
Fonte: Estácio de Sá 
O sistema operacional mantém as coisas organizadas em segundo plano para que vários programas 
possam ser executados ao mesmo tempo, o que é conhecido como “multitarefa”. Ele fornece a cada 
programa sua própria área de memória, de modo que cada programa acessa apenas seus próprios recursos, 
tentando limitar, por motivos de segurança, o que um programa incorreto ou mal-intencionado pode fazer. 
Manter os programas separados é conhecido como “área restrita”. Isso é importante para que cada 
programa funcione independentemente, sem interferir em outros programas ou no sistema como um todo. 
Da mesma forma, cada programa tem algum acesso à tela por meio de uma janela, mas essa área de saída 
é separada da saída de outros programas. 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 26 
 
Vamos ver dois exemplos? 
Arquivo Word.exe: 
Um arquivo .exe é essencialmente apenas um arquivo de instruções de código de máquina. Quando 
você clica duas vezes no programa, está ordenando que o SO “inicie” o programa, executando as etapas de 
limpeza de alocação de uma área de memória na RAM para o programa, carregando a primeira seção do 
código de máquina do programa nessa memória e, finalmente, direcionando a CPU para começar a executar 
esse código. 
Câmera Digital: 
Uma câmera digital também é um pequeno computador. Quando é iniciado, ele não executa um 
programa de gerenciamento de arquivos. Em vez disso, depois que a limpeza básica for configurada, a 
câmera poderá executar um único programa que desenha os menus, entre outros, na tela da câmera e 
responde a cliques nos botões da câmera, e assim por diante. 
Boot e Reboot 
O sistema operacional é, antes de qualquer programa do usuário, a primeira coisa a ser executada 
quando seu computador é ligado. 
Somente após o carregamento do SO, o usuário pode selecionar os programas que deseja rodar, 
clicando duas vezes nos ícones correspondentes na área de trabalho. 
Você pode estar se perguntando: 
Qual é o programa que cuida da inicializaçãodo SO logo que o computador é ligado? 
Há um programa especial, e muito pequeno, denominado firmware, que é gravado pela fábrica no 
hardware. 
O firmware é responsável por detectar quando um computador estava desligado e acaba de ser 
ligado, e realiza alguns procedimentos iniciais de teste de hardware, para então, basicamente, procurar um 
dispositivo de armazenamento persistente que contenha um SO instalado. 
Depois disso, é possível, então, iniciar seu carregamento (cópia das instruções que compõem o SO 
do disco para a RAM e indicação para a CPU de qual é a primeira instrução do SO a ser executada). 
Comentário 
O termo firmware é usado, geralmente, para se referir especificamente ao firmware de inicialização, que 
controla um computador desde o momento em que é ligado até o sistema operacional principal assumir o controle. 
A principal função do firmware de inicialização é inicializar o hardware e, em seguida, inicializar 
(carregar e executar) o sistema operacional principal. 
Veja, a seguir, o esquema de um computador pessoal. Nesse tipo de computador, o firmware de 
inicialização é chamado, geralmente, de BIOS (Basic Input/Output System), ou sistema básico de entrada e 
saída. 
Apostila de Pensamento Computacional 
Marcio Quirino - 27 
 
 
Fonte: Estácio de Sá 
Este processo é comumente denominado inicializar (boot ou boot up). 
E quando ocorre o Reboot? 
Resposta 
O reboot ocorre quando ordenamos ao SO que o computador seja reiniciado, ou seja, o próprio SO cuida das 
tarefas necessárias para a finalização e o desligamento do computador. Imediatamente, o computador é religado, e o 
processo de boot recomeça. 
Versões de Sistemas Operacionais 
Como já mencionado, a primeira coisa a ser executada quando seu computador é ligado é o SO. 
Antes mesmo de qualquer outro programa do usuário. Agora que conhecemos conceitualmente os sistemas 
operacionais, que tal darmos uma olhada em alguns exemplos de SO e onde são aplicados? 
Computador Pessoal (PC): 
Microsoft Windows: proprietário, pago. Usado em cerca de 80% dos desktops/laptops. 
Linux: aberto, gratuito. Usado em cerca de 80% dos servidores em ambientes de computação em 
nuvem. Em desktops e laptops, é usado principalmente por entusiastas e projetos de inclusão 
social. 
Mac OS X: proprietário, pago, específico para computadores Apple. Usado por cerca de 5% dos 
desktops/laptops. 
Smartphone: 
IOS: proprietário, específico para Apple Iphone. 
Android: aberto, usado pelos demais fabricantes (Samsung, Motorola, LG, Sony etc.). Projeto 
baseado no Linux. 
Depois do que estudamos até aqui, podemos fazer algumas perguntas: 
Somente os sistemas operacionais e os firmwares são exemplos de softwares funcionais? 
O que define um software como funcional? Qual a sua importância no âmbito do pensamento 
computacional? 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 28 
 
3 - Tipos de linguagens de programação 
Conceito 
Em sistemas computacionais contemporâneos, é extremamente raro escrever códigos de máquina 
manualmente. Isso ocorre porque eles são compostos por um número enorme de instruções muito simples; 
assim, fica difícil para os humanos fazerem esse processo. 
Em vez disso, um programador escreve o código (instruções) em uma linguagem de computador de 
“alto nível”, com recursos mais úteis e poderosos do que as operações simples encontradas no código da 
máquina. 
Exemplos de estruturas de alto nível são: 
1 - Estruturas de repetição (loops), em que o programador ordena que um conjunto de instruções 
seja executado repetidamente; 
2 - A função print(), que imprime algo na tela; 
3 - A estrutura condicional (if), em que o programador solicita que alguma condição seja testada e, 
caso passe no teste, algumas instruções sejam executadas. 
Nenhum desses recursos de alto nível está diretamente presente no código da máquina de “baixo 
nível”. Eles são adicionados por linguagens de programação, como JavaScript, Java, Python, C, C++, entre 
outras. 
Tipos de linguagem de programação 
A classificação de linguagens de programação é mais detalhada e abrangente do que a apresentada 
aqui, mas vamos nos limitar, por questões de simplicidade, a agrupá-las nestas categorias. 
O funcionamento de uma linguagem de programação é definida por seu tipo. Veja, a seguir, quais 
são. 
Linguagem compilada 
São aquelas em que o processo de tradução (compilação) é feito com antecedência e o código é 
necessariamente executável. 
Quando se utiliza uma linguagem compilada, é necessário executar um programa para traduzir os arquivos-
fonte, legíveis em linguagem de alto nível, em código executável. As linguagens compiladas têm a vantagem de 
produzir código de alta performance, o qual está ajustado para o funcionamento em um tipo específico de processador 
ou arquitetura de processador. Aplicativos compilados, chamados de código binário, só podem rodar no tipo de 
computador para o qual foram compilados, uma vez que esses aplicativos consistem, na realidade, em instruções em 
linguagem de máquina, entendidas e executadas pelo microprocessador. (INDRUSIAK, 1996, p. 4) 
Veja um exemplo de linguagem compilada: 
Na primeira linha do código a seguir, escrito na linguagem C++, o texto/string “Bom dia” está sendo 
atribuído à variável “a” e, na segunda linha, a variável “b” recebe o conteúdo da variável “a” (ex.: “Bom dia”), 
e a exclamação é adicionada ao final da frase. 
a = “Bom dia”; 
b = a + “!”; 
Então, o programador escreve o que é chamado de código-fonte na linguagem de programação que 
escolher. Como vimos, humanos preferem linguagens de alto nível pois são mais fáceis e intuitivas. 
Apostila de Pensamento Computacional 
Marcio Quirino - 29 
 
Como a CPU consegue executar (rodar) instruções escritas em linguagem de alto nível se 
sabemos que a CPU só executa código de máquina? 
Uma das estratégias utilizadas é usar o compilador. 
Como já vimos, trata-se de um software de propósito muito específico: olhar para o código-fonte 
escrito pelo programador e traduzi-lo, para criar um grande corpo de código de máquina compatível com a 
CPU em que o programador deseja rodar o programa. 
Exemplo 
Talvez haja uma parte do código-fonte onde exista uma instrução if (estrutura condicional), mas não uma 
instrução específica em um código de máquina para uma instrução if. 
No entanto, talvez haja uma sequência de cinco instruções de código de máquina que, na verdade, chegam ao 
mesmo resultado de uma instrução if. Portanto, o compilador faz esse tipo de expansão. 
Vamos usar o Firefox como exemplo novamente: 
Esse navegador é escrito em C++. Assim, para criar uma nova versão do Firefox, após realizar os 
ajustes desejados em seu código-fonte, alguém executa o compilador C++, que lê o grande corpo de código-
fonte em linguagem de alto nível que constitui o Firefox e produz, essencialmente, o arquivo Firefox.exe. 
Esse arquivo é a saída do compilador e contém as instruções de código de máquina obtidas mediante a 
tradução do código-fonte escrito pelos desenvolvedores do Firefox. 
A etapa de compilação pode ser feita uma vez e bem antes da execução do programa (por exemplo, 
produza o Firefox.exe na sede da entidade que o desenvolve, a Mozilla, e depois distribua o Firefox.exe para 
que usuários de PC com sistema operacional Windows possam usá-lo). 
Atenção! 
A compilação só precisa ser feita pelo desenvolvedor/programador uma vez. 
Conforme ilustrado pela imagem a seguir, o desenvolvedor/programador, que escreveu o código-
fonte, realiza a compilação e cria o arquivo executável (exemplo: Firefox.exe), e pode simplesmente enviá-
lo para que outras pessoas consigam rodá-lo em seus computadores, contanto que sejam compatíveis com 
o código de máquina gerado. Os usuários finais não precisam do código-fonte nem do compilador. 
 
Fonte: Estácio de Sá 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 30 
 
Preste atenção: 
O processo não funcionaao contrário. 
Ou seja: não é possível, a partir das instruções em código de máquina do Firefox.exe, realizar a 
tradução reversa e obter o código-fonte em linguagem de alto nível originalmente escrita pelo(s) 
programador(es). É até possível obter uma versão imperfeita do código-fonte original, mas ela ficará bem 
distante do ideal. 
Linguagem dinâmica ou interpretada 
A linguagem dinâmica se diferencia por se pautar no tempo de execução, cruzando os dados com 
os protocolos por meio de bibliotecas, criando “metaobjetos”, quer dizer, bibliotecas complexas de 
combinação e execução. Java, JavaScripts e Python são exemplos de linguagens de programação 
dinâmicas/interpretadas. 
 
Uma forma de compreender essa categoria é pensar que, em vez do compilador, é usado outro 
software de propósito especial denominado interpretador. 
Trata-se de um programa que lê código-fonte escrito em uma linguagem como Java, JavaScript, 
Python, entre outras, e o “executa/roda”. 
Exemplo 
Talvez o melhor exemplo para linguagem interpretada seja o JavaScript: 
Um interpretador para a linguagem JavaScript vem embutido em navegadores de Internet, como o Firefox, o 
Chrome, o Microsoft Internet Explorer ou o Microsoft Edge. 
Quando um navegador se depara com um website que contenha algum código JavaScript embutido, 
ele pode usar seu interpretador para executar esse código. Portanto, de forma bastante resumida, a maneira 
como um intérprete funciona é a seguinte: ele executa uma linha de código por vez. 
Supondo que o exemplo a seguir seja um código-fonte contendo duas instruções escritas em 
JavaScript, quando o interpretador JavaScript do navegador fosse executar isso, ele olharia a primeira linha 
e a executaria. 
//Código Javascript 
a = 1; 
b = a + 1; 
Portanto, neste exemplo, o interpretador diria: “Acho que preciso de um nome de variável ´a´, e 
preciso colocar o valor ‘1’ nela”. Então, após executar essa linha, ele seguiria em frente e 
interpretaria/executaria a próxima linha, e assim por diante. 
Tendências 
Falando de modo geral, a tendência para a programação de computadores caminha para o uso de 
linguagens dinâmicas/interpretadas. Isso ocorre porque há um consenso de que é bastante atraente poder 
programar de forma mais simples e eficiente, mesmo sabendo que o programa final rodará mais lentamente 
na CPU. 
Isso talvez seja um pouco contraintuitivo, mas podemos refletir sobre essa questão da seguinte 
forma: 
Qual o recurso mais escasso em programação de computadores? 
Geralmente, a resposta é: o programador! 
Apostila de Pensamento Computacional 
Marcio Quirino - 31 
 
Em todo o mundo, o mercado de trabalho da área da computação sofre, cada vez mais, com a falta 
de profissionais qualificados. Portanto, usar menos horas de trabalho dos programadores é um atrativo muito 
importante. 
O fato de que o programa rodará mais lentamente na CPU é considerado menos relevante, até 
porque, conforme a lei de Moore, as CPUs estão cada vez mais baratas e o poder de processamento delas 
cresce continuamente. 
Então, se pensarmos em qual será a tendência para os próximos anos, também há um consenso, no 
mercado, de que o programador continuará a ser considerado um recurso cada vez mais escasso se 
comparado ao poder de processamento das CPUs. 
Para finalizar, vale a pena comentar sobre uma coisa chamada JIT (Just in Time Compiler). O objetivo 
dos JITs é tentar obter o melhor dos dois mundos: linguagens compiladas e linguagens interpretadas. 
A ideia é ter os benefícios da maior simplicidade de desenvolvimento de programas usando 
linguagens dinâmica e, ao mesmo tempo, obter um programa que rode mais rapidamente na CPU. Dessa 
forma, o JIT é responsável por ler parte do código-fonte e tentar compilá-lo rapidamente, antes de executá-
lo. O mais interessante é que isso funciona muito bem! 
Comentário 
Navegadores modernos de Internet, como o Firefox, o Chrome, o Microsoft Internet Explorer e o Microsoft 
Edge, agora embutem JITs para código JavaScript. Assim, na verdade, quando você está executando o código 
JavaScript dentro do navegador, o JIT examina trechos do código dinâmico (Javascript) que estão sendo executados 
com muita frequência e compila o código nativo desses trechos em tempo real. 
O intérprete não é usado para casos simples, mas para seções importantes do código dinâmico 
(como o interior de uma estrutura de repetição), e o JIT cria um bloco de código de máquina na memória. 
O código da máquina é executado para essa seção do código dinâmico, oferecendo desempenho 
semelhante a linguagens compiladas, como C e C++, e é descartado quando o programa é encerrado. 
Note que, mesmo com o uso de JITs, linguagens interpretadas possuem desempenho inferior ao de 
linguagens compiladas com C e C++. 
Além do JavaScript, a linguagem Java também usa a tecnologia JIT extensivamente. O enorme 
ganho de desempenho dos navegadores de Internet nos últimos anos deve-se, em grande parte, à 
implementação da tecnologia JIT para JavaScript. 
Considerações finais 
Neste conteúdo, você mergulhou na representação do que é um software para computadores, 
reconhecendo alguns softwares funcionais que fazem parte do seu cotidiano. No fim, aproximou-se da 
linguagem de programação, podendo, com isso, perceber como a linguagem e sua dinâmica são atualizadas 
continuamente. 
Referências 
CARVALHO, A.; LORENA, A. Introdução à Computação: hardware, software e dados. 1. ed. Rio de 
Janeiro: LTC, 2017. 
DALE, N.; LEWIS J. Ciência da Computação. 4. ed. Rio de Janeiro: LTC, 2011. 
FEDELI, R. D.; POLLONI, E. G. F.; PERES, F. E. Introdução à Ciência da Computação. 2. ed. São 
Paulo: Cengage, 2010. 
FLANAGEN, D. Javascript: o guia definitivo. 6. ed. Porto Alegre: Bookman, 2013. 
GLENN, J. Ciência da Computação: uma visão abrangente. 11. ed. Porto Alegre: Bookman, 2013. 
Apostila de Pensamento Computacional 
Marcio Quirino - 32 
 
INDRUSIAK, L. S. Linguagem Java. Consultado em meio eletrônico em: 28 abr. 2020. 
TORETTA, L. Market Share Statistics for Internet Technologies. netmarketshare.com. Consultado 
em: 27 abr. 2020. 
Explore + 
Pesquise e leia o texto Mercado de TI pode apresentar déficit de 290 mil profissionais em 2024, 
publicado em 2019 no site itforum.com.br. 
Procure na Internet o artigo Proposta de integração da engenharia de software nas estratégias 
empresariais, de Adalberto Reis e Ivanir Costa, que apresenta uma reflexão sobre essa importante área do 
pensamento computacional. 
Pesquise também o livro Autonomia, liberdade e software livre, de Doriedson de Almeida e Nicia 
Riccio, que traz importantes reflexões a partir do tema “código aberto”. 
Consulte o artigo A eficácia do software de educação ambiental utilizado no ensino à distância, de 
Franklin Porto Jr., que apresenta a importante articulação de três temas extremamente atuais: pensamento 
computacional, meio ambiente e educação a distância. 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 33 
 
Fundamentos de Hardware 
Introdução 
O computador é formado por uma diversidade de componentes físicos que, juntos, permitem que nós 
usuários possamos utilizar para estudar, jogar, assistir vídeos, entre outras atividades que nos serão 
fornecidos pelos softwares, os chamados programas de computador. 
Esses componentes físicos são o hardware do computador. Podemos levar essa definição para 
outros tipos de dispositivos como o nosso smartphone, smartwatches, entre outros que também possuem 
componentes físicos que permitirão que os aplicativos possam exercer sua função. 
Para facilitar a compreensão de como uma máquina funciona, precisamos ser capazes de identificar 
os componentes existentes e o seu papel no funcionamento do computador e é isso que vamos fazer a partir 
de agora. 
1 - O que é hardware? 
O conceito de hardware 
Quem nunca ouviu a infame anedota: 
Hardware é o que você pode chutar, já software é o que você só pode xingar. (Autor desconhecido)Caso não tenha ouvido, você precisará ainda mais do que será visto aqui. Porém, se você conhece 
e achou que tinha entendido, saiba que essa definição não o ajuda muito. 
Para começar, estamos trabalhando com a construção do mercado de produtos que mais se modifica 
na contemporaneidade. A maior parte de nós compra um produto quando ele já está obsoleto para 
determinados setores, ainda que nos atenda muito bem. 
Já reparou como a aparência dele muda o tempo todo? Computadores e celulares evoluem de um 
ano para o outro. Se essa indústria muda tão rápido, como eu posso explicar o funcionamento de um 
hardware? Como é possível não lhe ofertar um produto obsoleto de antemão? 
Vamos pensar sobre a parte física dessas máquinas? Vamos lá! 
A origem da máquina 
Hardware é o termo usado para se referir à parte física de um equipamento. 
Devemos pensar que estamos falando dos componentes diretamente utilizados pela estrutura 
tecnológica. Você já viu o interior do seu celular? Tudo ali se encaixa, tem uma função, desde mecanismos 
para levar energia, poupar e armazenar dados até possibilidades de encaixes que agregam outras 
tecnologias. Cada um desses elementos é uma mistura de tecnologia de desenvolvimento técnico e 
equilíbrio econômico para produção em massa. 
O que difere hardware de software? 
O software é o código, ou seja, as instruções, o que é executado no computador. No entanto, por 
aqui, vamos nos concentrar no hardware. 
Vamos comparar o hardware computacional a outro objeto para ver se fica mais claro. 
Você já viu um piano? O esquema a seguir resume comparativamente o que é hardware e o que é 
software nos computadores e nos pianos. 
Apostila de Pensamento Computacional 
Marcio Quirino - 34 
 
 
Fonte: Estácio de Sá 
Então, um hardware é a estrutura física que permite executar as funções que desejamos. 
Vamos a outro exemplo que nos permite sofisticar um pouco mais a visão sobre o que é o hardware. 
Se olharmos um cérebro em um microscópio, veremos neurônios. Os neurônios são a unidade 
fundamental do hardware humano relacionado ao pensamento e processamento de informações. 
O cérebro do computador é a CPU (Central Processing Unit). Quando olhamos as partes de uma 
CPU, identificamos os transistores. 
Saiba mais 
O processador Intel Core i9 9900k, lançado em 2018, contém 12 bilhões de transistores. 
O transistor é provavelmente uma das invenções mais importantes do século. Este é um pequeno 
componente eletrônico que pode ser usado para criar todo tipo de coisas diferentes. 
Atualmente, encontramos transistores embutidos em componentes chamados de chips. 
chips 
Um chip é feito de um pequeno pedaço de silício, principal componente do vidro, de poucos milímetros (20mm). 
Diferentes componentes eletrônicos podem ser gravados no silício, o que permite construir componentes de maneira 
muito barata. 
Veja exemplos de diferentes formatos de transistores: 
 
Fonte: Estácio de Sá 
Os componentes mais comuns dos chips são os transistores. CPU, memórias e diversos outros 
dispositivos eletrônicos se resumem a chips compostos por transistores. 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 35 
 
Saiba mais 
Chips são dispositivos de estado sólido (solid state), isto é, sem qualquer tipo de partes móveis internamente. 
Não há engrenagens, rodas ou eixos que girem dobradiças. Isso torna os chips dispositivos muito confiáveis, pois 
partes móveis se desgastam com o tempo e requerem manutenção constante, como ocorre em motores de veículos. 
Além disso, eles são fabricados com altíssima quantidade, mas de forma muito barata. A combinação de baixo custo 
e alta confiabilidade é uma das principais forças motrizes da revolução dos computadores. 
Lei de Moore 
Uma das forças mais importantes do desenvolvimento do silício é a Lei de Moore, uma observação 
feita por Gordon Moore sobre como a fabricação de chips vinha sendo capaz de inserir cada vez mais 
transistores dentro de um chip. Essa lei diz que o número de transistores contidos em um chip dobra em um 
período entre 18 e 24 meses. 
Podemos entender a Lei de Moore sob dois aspectos: 
1 – Desempenho: A lei pode significar que a indústria tem conseguido dobrar o número de 
transistores embutidos em um chip a cada dois anos. Essa observação descreve um crescimento 
exponencial bastante poderoso. 
2 – Econômico: Os transistores estão ficando cada vez mais baratos. Dessa forma, com o passar 
do tempo, devido ao baixo custo, é possível criar sistemas computacionais em outros aparelhos, 
como telefone celular, geladeira, torradeira, termostatos e até em óculos. 
É importante entender que a Lei de Moore não é uma lei da natureza, como a lei da gravidade de 
Isaac Newton. Ao contrário, é apenas uma observação sobre como a fabricação de transistores tende a 
funcionar. O comportamento observado por Moore tem seguido firme desde 1965. Neste sentido, as 
possibilidades do desenvolvimento de melhoria e aceleração da parte física acabam por permitir o 
barateamento, transformando o hardware em uma variável importante para o desenvolvimento das 
sociedades tecnológicas. 
A qualidade duplicada da Lei de Moore permite que um computador de décadas atrás, que 
ocupava uma sala inteira e custava milhões de reais, seja, agora, do tamanho de um cubo de açúcar 
e custe menos de cem reais. 
Se pensarmos em apenas uma duplicação, que ocorre em um ano e meio, podemos ter a impressão 
de que não é algo tão importante. Porém, se pensarmos em um intervalo de 15 anos, teremos, segundo a 
Lei de Moore, dez duplicações, o que representa algo mil vezes maior. Observe: 
 
Fonte: Estácio de Sá 
Para termos a real noção da importância deste fenômeno para o crescimento do poder computacional 
na atualidade, pense que um telefone celular (smartphone) X, fabricado em 2019, possui poder de 
Apostila de Pensamento Computacional 
Marcio Quirino - 36 
 
processamento bilhões de vezes maior do que o computador de cálculo de trajetória usado na nave espacial 
Apollo XI (AGC – Apollo Guidance Computer), que levou o homem à Lua, em 1969. 
1969 
O contexto de conflitos mundiais do século XX fomentou fortemente a tecnologia. Durante a Guerra Fria, houve 
uma forte corrida espacial. Os soviéticos conseguiram enviar o homem ao espaço, com Iuri Gagarin, em 1961. Tal 
realização fez o presidente Kennedy prometer que os americanos chegariam à Lua, o que ocorreu em 1969. 
Uma forma internacionalmente conhecida para medir o poder computacional de processadores é o 
FLOPS (Floating-point Operations per Second ou Operações de Ponto Flutuante por Segundo), que indica 
quantas operações matemáticas com casas decimais o processador consegue realizar por segundo. 
Com base nisso, veja a comparação a seguir: 
 
1 – AGC (Fabricado em 1969 – 14,6 FLOPS): Capaz de realizar, aproximadamente, 14 operações 
matemáticas com casas decimais por segundo. 
2 – Smartphone (Fabricado em 2019 – Mais de 40 GFLOPS [Giga FLOPS]): Capaz de realizar 
cerca de 40 bilhões de operações por segundo. 
3 – Computador de mesa (Desktop) (Fabricado em 2019 – Pode chegar a 400 GFLOPS): Capaz 
de realizar, aproximadamente, 400 bilhões de operações por segundo. 
Supercomputadores fabricados em meados de 2019 possuem trilhões de FLOPS, como é o exemplo 
de um supercomputador disponível na Universidade de Campinas, que faz 4,5 trilhões de operações 
aritméticas por segundo. 
Exemplo 
Você provavelmente observou que a partir de 2000 surgiram os pendrives com, inicialmente, 8MB de 
capacidade de armazenamento. Pelo mesmo preço, em 2019, já era possível comprar pen drives de mais de 2000GB 
de capacidade. Ou seja, em menos de 20 anos, houve um aumento de 250 mil vezes na capacidade de armazenamento 
dos pendrives. 
Pela Lei de Moore, a fabricação dos chips que armazenam informação em pen drives evoluiu de tal 
forma que é possível embutir mais transistores por, praticamente, o mesmo preço. Então, eles podem 
oferecer maise mais capacidade de armazenamento. 
Os exemplos que vimos para o poder de processamento de celulares contemporâneos e a 
capacidade de armazenamento de pen drives evidenciam a qualidade exponencial da Lei de Moore. 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 37 
 
2 - Componentes básicos de hardware 
Componentes fundamentais do computador 
Para falar sobre computadores, vamos tratar dos componentes fundamentais que o constituem. A 
seguir temos a CPU, a memória RAM e a memória permanente (HD/pen drive), veja: 
1 - CPU – Cérebro: Também chamada de processador, é uma espécie de cérebro. É a CPU quem, 
de fato, processa instruções. 
2 - Memória RAM – Temporária: É uma espécie de memória temporária. Também chamada de 
memória volátil: tudo o que está na RAM (Random Access Memory) é instantaneamente apagado 
quando o computador é desligado. 
3 - Memória persistente – Permanente: Geralmente, é um disco, um HD (Hard-Disk) ou um pen 
drive. Os dados armazenados neste tipo de memória permanecem ali mesmo quando o computador 
é desligado e, por isso, é chamada de memória persistente. 
Vamos entender agora um pouco melhor como cada um desses componentes funcionam. 
Processador e placa-mãe 
CPU 
A parte mais importante do computador é a CPU. Ela faz a computação, ou seja, executa instruções. 
A CPU possui um rol padronizado de operações bastante simples para executar. Então, quando dizemos 
que um computador executa dois bilhões de operações por segundo, realmente estamos falando sobre a 
CPU. Isso significa que ela pode fazer centenas de bilhões de coisas muito simples por segundo. 
As instruções executadas pela CPU são escritas por pessoas que desejam usar o computador e seu 
incrível poder de processamento para alcançar algum objetivo útil. As instruções escritas em linguagens de 
programação são denominadas código de computador. 
Placa-mãe 
Já estudamos CPU, memória RAM e diversos tipos de armazenamento persistente (HD, SSD, M.2, 
pen drive), mas falta um componente fundamental do computador, que é responsável por interligar CPU, 
RAM, discos etc. 
Veja a seguir uma placa-mãe, onde todos os componentes eletrônicos são conectados. 
Observe como conectamos alguns dos componentes na placa-mãe: 
1 – A CPU é montada em um compartimento próprio da placa-mãe. 
2 – A CPU recebe uma aplicação de uma pasta térmica, que é importante para ajudá-la a transferir 
calor para o dissipador que será instalado por cima e, assim, manter-se adequadamente resfriada 
durante seu funcionamento. 
3 – Um dissipador de calor, também chamado de cooler, é firmemente preso por cima da CPU, 
ficando em contato com ao CPU e a pasta térmica. 
4 – Os pentes de memória RAM também precisam ser encaixados na placa. 
Memória temporária 
Random Access Memory 
A Random Access Memory (RAM), que significa Memória de Acesso Aleatório, pode ser chamada 
apenas de memória. A RAM é considerada a memória principal, pois é o armazenamento temporário usado 
pela CPU para manter os dados e o código utilizados enquanto processa instruções. 
Apostila de Pensamento Computacional 
Marcio Quirino - 38 
 
Em código de computador, quando escrevemos instruções como a = 2 + 5, com o objetivo de que a 
variável a receba a soma dos valores 2 e 5, ocorrem, na verdade, quatros eventos na memória RAM: 
1 – O valor 2 é armazenado em uma posição. 
2 – O valor 5 é armazenado em outra posição. 
3 – A instrução somar é armazenada em mais uma posição. 
4 – O espaço para a variável “a” é armazenado em mais um endereço. 
A CPU lê/carrega os valores 2 e 5 da memória RAM e, depois, a instrução soma. Então, a CPU 
realiza a operação e, depois, armazena o resultado na posição da memória reservada para a variável “a”. 
É importante observar que a CPU precisa da RAM para processar as instruções de acordo 
com o código de computador escrito pelo programador. É por isso que ela é chamada de memória 
principal. 
A principal característica da RAM é que ela não é uma memória persistente, mas, sim, uma memória 
volátil. Isso significa que, quando a energia elétrica é desligada, ela imediatamente fica em branco. Portanto, 
a energia elétrica funciona muito bem como armazenamento rápido e temporário, mas não se trata de um 
armazenamento de longo prazo. 
Exemplo 
Imagine que o computador desligue por acidente enquanto você está digitando o texto de um trabalho no Word 
antes de apertar o botão salvar. Você certamente ficará chateado, pois perderá as informações digitadas desde a última 
vez em que salvou seu trabalho. 
Isso ocorre porque esses caracteres ainda estavam somente na memória RAM, que não é persistente. Assim, 
a versão que você possui é a última versão que salvou. 
Memória persistente 
O nosso terceiro componente de hardware é a memória/armazenamento persistente, também 
chamada de memória secundária. Vejamos como ela funciona de forma diferente da memória RAM. 
 
Fonte: Estácio de Sá 
Em um editor de texto, quando você pressiona o botão salvar, instrui o computador a copiar a versão do 
documento que está na RAM (versão temporária) para o disco/pen drive/HD, que são memórias persistentes, ou seja, 
que permanecem com as informações armazenadas mesmo após o desligamento. 
Este exemplo simples permite que você compreenda a noção do que significa ser persistente, como 
um disco/HD/pen drive, ou volátil, como a RAM. 
Saiba mais 
Para equipamentos atuais, as memórias RAM, em geral, possuem capacidade de bilhões de bytes, enquanto 
discos/HDs/pen drives possuem capacidade de armazenamento de trilhões de bytes. Todos esses dispositivos, mesmo 
quando o fornecimento de energia elétrica é cortado, mantêm os dados, apesar de serem muito mais lentos do que a 
memória RAM. 
Apostila de Pensamento Computacional 
Marcio Quirino - 39 
 
Avanço das tecnologias de armazenamento persistente 
Conheça alguns dos dispositivos de armazenamento persistente: 
Hard Disk 
Por muito tempo, o armazenamento persistente em computadores foi feito com um disco rígido (HD 
– Hard Disk). No passado, o preço do armazenamento em memórias flash (tipo de memória que 
permite armazenar dados por longos períodos, sem precisar de alimentação elétrica), SSD, pen 
drives e cartões SD era muito mais caro que os discos rígidos e, por isso, os HDs eram usados 
para tudo. 
Note que um HD possui um disco giratório, que é rígido. Além disso, há uma pequena cabeça 
semelhante às agulhas dos toca-discos antigos que escreve e lê padrões magnéticos no disco para 
armazenar e ler dados. 
Quando você estiver operando um computador e ouvir vários sons agudos de “cliques”, o que você 
provavelmente está ouvindo é o disco rígido girando em seu pequeno compartimento, com sua 
cabeça se movimentando para um lado e para o outro. 
Solid State Disk 
Mais recentemente, houve avanços no que chamamos de discos de estado sólido (SSD – Solid 
State Disk). Assim, uma unidade SSD também armazena dados persistentemente, mas, em vez de 
usar discos, como nos HDs, são usados chips de memória de estado sólido. Estes componentes 
são chamados de sólidos, pois não há partes móveis, como discos e cabeças de escrita/leitura. Ao 
contrário, tudo é feito eletronicamente. 
Dispositivos de armazenamento baseados em SSD são dezenas e até centenas de vezes mais 
rápidos do que os discos rígidos, além de serem mais confiáveis, já que não possuem partes 
mecânicas móveis. Seguindo esta mesma tendência, um dos tipos mais recente de armazenamento 
secundário é chamado de SSD M.2. 
Pendrive 
Os pequenos pendrives USB utilizam tecnologia semelhante à do SSD. Seu tamanho reduzido nos 
permite levar nossos arquivos conosco para qualquer lugar. Desde o lançamento do seu primeiro modelo 
até hoje, a capacidade de armazenamento dos pendrives cresceu consideravelmente e promete aumentar 
ainda mais. 
Cartões SD 
Os cartões SD, usados em câmeras fotográficas digitais e celulares, conta com a mesma tecnologia 
usada no Solid State Diske nos pendrives. Apesar de seu pequeno formato, já existem cartões SD com 
capacidade de armazenamento acima de 500GB. 
Observando o avanço das tecnologias de armazenamento persistente, podemos reconhecer o 
padrão da Lei de Moore. Chips de memórias flash estão ficando mais baratos, e, assim, é cada vez mais 
comum o uso de dispositivos de armazenamento baseados em estado sólido. É possível que, em alguns 
anos, o disco rígido deixe de ser utilizado para o uso diário. 
Para chegar a este ponto, precisamos apenas que a Lei de Moore continue ocorrendo e que os 
preços de SSD sigam caindo até alcançarem um valor bastante convidativo, a ponto de as pessoas 
pensarem o seguinte: “Não precisamos mais de HD. Podemos apenas usar esses chips, pois eles são muito 
mais rápidos e confiáveis”. 
Apostila de Pensamento Computacional 
Marcio Quirino - 40 
 
Sistemas de arquivos 
Quando você tem um dispositivo de armazenamento secundário e persistente, há uma grande 
capacidade de armazenamento. Entretanto, por si só, estes dispositivos não estão realmente prontos para 
o usuário. 
Normalmente, o armazenamento de dados em disco rígido ou unidade flash é organizado com 
esquemas convencionados, que são conhecidos como sistemas de arquivos. 
Um sistema de arquivos é apenas uma maneira de organizar a grande área de bytes de dispositivos 
persistentes, dando a eles um tipo de estrutura familiar de arquivos e pastas. Cada arquivo e pasta possuem 
nomes, que podem ser movidos, copiados, editados, removidos etc. 
Microcontroladores 
Uma interessante consequência da Lei de Moore é que os computadores se tornaram tão pequenos 
e baratos, que você pode comprar versões cada vez menores dessas máquinas por preços relativamente 
baixos. Eles podem se encaixar em inúmeros lugares, o que antigamente era algo inimaginável. 
Um pequeno computador embutido em um único chip é conhecido como microcontrolador, que 
possui todos os componentes básicos, como CPU, RAM e armazenamento persistente, em uma escala 
realmente pequena. Logicamente, seu poder computacional, quando comparado a computadores de mesa, 
é bastante limitado. 
Então, microcontroladores são computadores realmente pequenos, que não têm muito poder, mas 
são muito baratos, e quem tornou isso possível foi a Lei de Moore. Veja alguns exemplos de equipamentos 
que utilizam microcontroladores: 
 
Fonte: Estácio de Sá 
 
Um carro mais moderno possui microcontroladores espalhados pelo chassi, realizando tarefas 
específicas para cada subsistema. 
Um bom exemplo de um microcontrolador é uma placa Arduino. Trata-se de um equipamento de 
projeto e de código aberto, oferecido apenas por artistas ou entusiastas, ou apenas para brincar. 
Observe o microcontrolador do Arduino, a seguir. É ali que ficam a CPU, a memória RAM e o 
armazenamento persistente. 
Apostila de Pensamento Computacional 
Marcio Quirino - 41 
 
 
Fonte: Estácio de Sá 
O microcontrolador está instalado sobre a placa azul, onde encontramos outros componentes 
auxiliares, ou seja, de suporte. Por exemplo, para alimentação elétrica e interface com um monitor de vídeo. 
Atualmente, é possível comprar um Arduino por valores acessíveis. Este é um item bem interessante 
para ser utilizado em sistemas computacionais a fim de ler sensores ou interruptores. Também é possível 
controlar pequenas luzes, por exemplo. Portanto, é apenas uma maneira divertida de brincar e fazer uma 
espécie de projeto de arte ou algo assim. 
O Arduino também é usado por escolas e universidades de todo o mundo, pois permite que alunos 
estudem e implementem sistemas computacionais de forma bastante efetiva a um custo realmente reduzido, 
inclusive sem a necessidade de gastos com licenças e royalties. 
3 - Unidades de armazenamento de dados 
Unidades de armazenamento 
Você já perguntou a alguém se o computador ou o celular que você estava querendo adquirir era 
bom? 
Tenho certeza de que alguma coisa assim já aconteceu, e você foi orientado a conferir qual era a 
memória RAM, a memória de armazenamento, a velocidade do processador etc. 
Com o tempo, ou você desistiu ou passou a aceitar o que as pessoas recomendavam. Afinal, o 
mundo da informática lhe apresentou algumas unidades de medidas novas. Certamente, você já teve um 
celular ou um computador com uma memória medida em mega. Depois, você notou que precisava de giga 
e, agora, muitos já dizem que você necessita de tera. 
Porém, o que significa isso? Quem faz a conta do espaço que uma foto ou um aplicativo ocupará no 
seu celular? 
Não há nada de simples nessas nomenclaturas, mas, aos poucos, elas passam a fazer parte de 
nosso cotidiano e acabam fazendo sentido. 
Antigamente, os computadores – famosas torres – tinham processadores tão barulhentos, que 
pareciam aviões decolando. Sempre que um problema era detectado, surgia a possibilidade de um 
aquecimento, e logo era posto um ventilador para esfriar as coisas. Assim, um processador era associado 
não à capacidade de processar, mas à velocidade do cooler, e por aí vai. 
As tecnologias físicas passaram pelo mesmo processo por séculos, ou seja, primeiro vem a invenção, 
depois, a desconfiança. Com a expansão, vem a assimilação. O resultado é a plena utilização dos 
vocabulários e das práticas da tecnologia, como se sempre tivessem sido íntimas de nós. Pense no número 
de pessoas que desejam saber quantos cavalos tem um motor, se a sua potência é 1.0 ou 2.0, com 8 
válvulas ou 16 válvulas. 
Apostila de Pensamento Computacional 
Marcio Quirino - 42 
 
O que você verá agora é uma breve introdução ao entendimento das unidades de medida e sua 
lógica de utilização. 
Byte 
Um byte é a espécie de medida mais comum de armazenamento de informações. Uma forma simples 
de pensar em um byte é imaginar uma letra que você digita no teclado. Cada caractere, como um “a” ou um 
“G”, pode ser internamente armazenado no computador como um byte. 
A capacidade de armazenamento de memórias, como RAM e discos/HD/pen drives, é medida em 
bytes. Podemos dizer que um megabyte é um termo que a maior parte de nós está acostumada a ouvir. 
Cada megabyte equivale a um milhão de bytes. 
Um gigabyte equivale a cerca de um bilhão de bytes. Com isso em mente, confira as unidades a 
seguir: 
 
Fonte: Estácio de Sá 
Os equipamentos atuais utilizam a seguinte escala: 
1 – Pendrive: GB 
2 – HD: TB 
3 – RAM: GB 
Bits e bytes 
Historicamente, computadores são construídos de forma que a unidade básica de informação a ser 
processada seja uma unidade denominada bit, que pode assumir apenas dois valores, 0 (zero) ou 1 (um). 
Provavelmente, você já ouviu a expressão que diz que computadores são apenas capazes de lidar com 
números 0 (zero) e 1 (um). Isso se refere a bits. 
Tudo o que computadores são capazes de fazer é necessariamente construído a partir dessa coleção 
de bits simples. Então, no hardware de computadores, qualquer componente interno é capaz de assumir 
dois estados diferentes e, quando assume um estado, ele pode ficar nele. Por exemplo, um transistor pode 
estar no estado ligado (1) ou no estado desligado (0). 
Apostila de Pensamento Computacional 
Marcio Quirino - 43 
 
Em um disco rígido, os dois estados diferentes são feitos com uma pequena área onde o fluxo 
magnético tem polaridade sul-norte (bit zero) ou polaridade norte-sul (bit um). 
Por que os computadores funcionam dessa forma? 
Os engenheiros que trabalham no desenvolvimento de computadores notaram que esta é uma forma 
muito mais barata de construir tais hardwares, pois a unidade fundamental de dados pode assumir mais do 
que dois estados, como em um computador em que a unidade fundamental de armazenamento seja o 
sistema decimal, que estamos acostumados a usar. 
Um bit, por si só, é pequeno demais para ser útil para qualquer coisa. Então, o que podemos fazer é 
agrupar oito bits para criar um byte. Então, ao olhar para um byte, você, na verdade, está olhando para 
um conjunto deoito dígitos binários, ou seja, cada dígito só pode assumir os valores zero ou um, veja: 
 
Fonte: Estácio de Sá 
Então, quanto de informação um byte pode conter exatamente? Em outras palavras, quantos padrões 
e combinações diferentes um byte pode assumir? 
Para começar essa discussão de forma simplificada, considere apenas um, dois ou três bits e veja 
quantas combinações de valores diferentes esses bits podem assumir: 
 
Fonte: Estácio de Sá 
Se prestar atenção, você notará que o número de possíveis combinações distintas duplica cada vez 
que adicionamos um bit ao número de bits usados para representar valores. 
Matematicamente, poderíamos expressar assim: 2x, onde x é o número de Bits. 
Portanto, se um Byte é um grupo de oito bits, teremos 28 = 256 combinações diferentes. 
Usando o raciocínio que foi ilustrado, sabemos que, com um byte (8 bits), podemos representar 28 
valores distintos, ou seja, 256 valores. 
Apostila de Pensamento Computacional 
Marcio Quirino - 44 
 
Mas qual é a utilidade do que acabamos de aprender? 
Vamos começar refletindo sobre como usar esses padrões para representar números decimais. Cada 
número receberá um dos 256 padrões diferentes. Assim, um byte pode representar cada número das 256 
combinações. 
 
Fonte: Estácio de Sá 
Não vamos entrar em mais detalhes sobre como eles são atribuídos, mas cada número precisa de 
um padrão e não pode compartilhar seu padrão com outro número. 
Ok, eu tenho 255. Por que não 256, já que 8 bits podem representar 256 padrões diferentes? 
A razão pela qual não é 256 é que começamos a contar do zero, e não do um. Então, um byte 
armazenará números entre zero e 255. Dessa forma, 255 é o máximo, mas são 256 valores distintos. 
Exemplo 
Uma boa forma de mostrar como um byte (0-255) é usado na prática é o sistema de representação de cores 
em computadores, em que cada um dos componentes R (Red – vermelho), G (Green – verde) e B (Blue – azul) são 
representados na memória do computador através de um byte cada. Ou seja, no padrão RGB, temos 256 níveis 
distintos de vermelho, 256 níveis distintos de verde e 256 níveis distintos de azul. Usando este padrão, o computador 
será capaz de representar 256x256x256 = 16.777.216 de cores (16.77 milhões de cores). 
Achou tudo muito confuso? Não se preocupe, pois, no vídeo a seguir, você poderá sanar as dúvidas 
que restaram sobre bit e byte. 
Considerações finais 
Neste conteúdo você conheceu o hardware, a forma como ele passou a ter sentido em seu cotidiano 
com a expansão dos computadores, que, na prática, representa uma continuidade da história humana na 
busca de melhorar sua vida e criar invenções e desenvolvimento tecnológico. 
As principais peças que compõem a computação estão em constante modificação. Percebê-las é 
entender sua tendência e suas capacidades de uso, conhecer o fenômeno de expansão e como elas estão 
diretamente relacionadas ao hardware, à melhoria do custo e às suas possibilidades de expansão. 
Por fim, você foi provocado a entender a constante ampliação das medidas e da capacidade de 
desenvolvimento que o hardware pode oferecer no cotidiano. 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 45 
 
Referências 
CARVALHO, A.; LORENA, A. Introdução à Computação: hardware, software e dados. 1. ed. Rio de 
Janeiro: LTC, 2017. 
DALE, N.; LEWIS J. Ciência da Computação. 4. ed. Rio de Janeiro: LTC, 2011. 
FEDELI, R. D.; POLLONI, E. G. F.; PERES, F. E. Introdução à Ciência da Computação. 2. ed. São 
Paulo: Cengage, 2010. 
FLANAGEN, D. Javascript: o guia definitivo. 6. ed. Porto Alegre: Bookman, 2013. 
GLENN, J. Ciência da Computação: uma visão abrangente. 11. ed. Porto Alegre: Bookman, 2013. 
Explore + 
Confira o que separamos especialmente para você! 
Leia a matéria Cluster da Unicamp faz 4,5 trilhões de operações por segundo, da revista Exame, 
para conhecer o projeto de um supercomputador. 
Pesquise na internet os seguintes artigos: 
Explorando novas tecnologias para o estímulo do pensamento computacional em alunos do ensino 
médio. 
Uma experiência do uso do hardware livre Arduino no ensino de programação de computadores. 
Redimensionamento da computação em processo de ensino na educação básica: o pensamento 
computacional, o universo e a cultura digital. 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 46 
 
Representação de Imagens em Computadores 
Introdução 
Seria possível abrir mão do computador no mundo atual? O que pode ser elemento de afinidade 
também pode resultar em aspecto de segregação. As duas últimas gerações, que foram as primeiras a ter 
computação na escola, aprendiam que essa era uma nova disciplina. Com o tempo, passou-se a contestar 
cada vez mais a utilidade das “aulas” de informática. Seria necessário que a computação estivesse, como 
no resto do mundo, inserida no contexto das práticas diversas. Assim, o computador passou a ser parte 
integrante das relações de ensino e aprendizagem. 
Dessa forma, algumas questões surgem: como formamos este mundo? Como podemos lidar com 
uma tecnologia que será constantemente superada, reinaugurada? Como fazemos para nos livrar da terrível 
sensação de estarmos obsoletos? Só há um jeito: inteirarmo-nos deste mundo, compreender como ele 
funciona, desmitificar o entendimento de que isso é tarefa dos iniciados. 
Aqui, você será convidado a se atrever, a tentar, a compreender em um nível mais avançado, para 
que possa ser um usuário mais competente e entender a dinâmica de abstração na construção dos 
programas. Para isso, escolhemos, como os seres humanos, há milênios, a primeira forma de tentar 
entender o mundo: construir e representar suas imagens. Se já o fizemos nas cavernas, com muito menos 
recursos, não serão algumas máquinas que vão nos intimidar. 
Abstração 
Capacidade de desconsiderar características naturais ou orgânicas do mundo real – temporais, espaciais e 
físicas – e concentrar a atenção nos atributos de maior importância, para que a solução alcançada seja tratável por 
computadores. 
Para começar, vamos assistir ao vídeo que aborda a evolução histórica da representação de 
imagens. Boa reflexão! 
1 - Fundamentos de pixels 
Fundamentos sobre pixels 
Agora, vamos aprender como imagens são representadas em computadores, ou seja, estudaremos 
as imagens digitais. Observe o exemplo a seguir, de um lindo pássaro, em que vemos as cores amarelo, 
roxo, azul, verde, preto e um fundo branco: 
 
Fonte: Estácio de Sá 
Você certamente observou como essa imagem é natural e arredondada. Temos a nítida impressão 
de que estamos olhando para um pássaro de verdade. 
Apostila de Pensamento Computacional 
Marcio Quirino - 47 
 
Na parte interna do computador, entretanto, essa imagem, e qualquer outra, resume-se a uma grande 
quantidade de números pequenos. 
Lembre-se: computadores são capazes de lidar somente com números. Então, como é que 
isso funciona? 
O primeiro passo para compreendermos as imagens digitais, ou seja, como o computador 
representa uma imagem por meio de um conjunto de números pequenos, é darmos um bom “zoom” na 
imagem para observarmos mais detalhes. Veja: 
 
Fonte: Estácio de Sá 
Você pode observar que há uma área azul no meio, uma parte maior em preto à esquerda e uma 
parte branca à direita. 
Você também pode constatar que a imagem é formada por pequenos quadrados, cada um de uma 
cor diferente. Eles são o que chamamos de pixels. 
Cada pixel é um quadrado. 
Quando olhamos para uma imagem digital como um todo, sequer percebemos que ela é formada por 
esses pequenos quadrados. 
Isso ocorre porque os pixels são tão pequenos que geram uma ilusão de ótica, assemelhando-se a 
uma imagem natural e arredondada. 
Realmente, só conseguimos notar que imagens são formadas por pixels quando usamos o recurso 
de zoom. 
Antes de prosseguirmos, faremos a seguinte e breve provocação: 
Você conhece algum outro exemplo, fora do mundo dos computadores, em que pontos (pixels)também 
sejam usados para representar imagens? 
A ideia básica por trás de imagens digitais é praticamente a mesma usada pelas nossas avós quando 
costuravam lindos bordados ponto de cruz. Nesses bordados, as imagens também são formadas por um conjunto de 
pequenos “x” (pontos de cruz), cada um de uma cor. Os pontos de cruz são os pixels dos lindos bordados das nossas 
avós. 
Por exemplo, se a imagem anterior do pássaro for representada por apenas 1.600 pixels, ficará 
conforme mostra a seguir: 
Apostila de Pensamento Computacional 
Marcio Quirino - 48 
 
 
Fonte: Estácio de Sá 
Não há um número-esquema para o número de pixels contidos em uma imagem. 
Quanto mais pixels houver em uma imagem, mais próxima ela será da realidade. 
As características fundamentais de qualquer imagem digital são: 
 
1 - Elas são formadas por pixels, que são quadrados; 
2 - Um pixel só pode assumir uma cor por vez. Você não pode, em um mesmo instante, representar 
mais de uma cor em um pixel. 
Se você quiser analisar a quantidade de pixels em uma imagem, basta checar quantos formam sua 
largura (colunas) e quantos formam sua altura (linhas). Então, o número total de pixels é apenas uma 
questão de multiplicação. 
Exemplo 
Se houver uma imagem com 800 pixels de largura por 600 de altura, o total de pixels será: 800 x 600 = 480.000. 
A imagem do pássaro é formada por 3.892 pixels de largura (colunas) e 3.328 pixels de altura (linhas): 
3.892 x 3.328. Aquele lindo pássaro foi representado pelo uso de 12.952.576 pixels, ou seja, quase 13 
milhões. Agora fica fácil entender por que a imagem nos parece tão natural. 
Você, provavelmente, já deve ter ouvido o termo megapixel. Ele é usado para se referir a 1.000.000 
(um milhão) de pixels. Então, o exemplo do pássaro possui praticamente 13 megapixels. 
Telefones celulares, atualmente, são capazes de capturar imagens com resoluções de 5, 10, 12, 16, 
20 e até 100 megapixels. 
Com o passar dos anos, as câmeras digitais se tornaram capazes de capturar cada vez mais 
megapixels. 
Grade de pixel 
Notamos que uma imagem digital é representada pelo computador como uma grade de pixels. Cada 
pixel é um quadrado que só é capaz de assumir uma cor por vez. Além disso, é necessário que haja um 
esquema de endereçamento para identificar cada pixel na composição da imagem. 
Nos computadores, foi padronizado o uso de um conjunto de números para representar a coluna em 
que o pixel se encontra, onde 0 (zero) corresponde à primeira coluna, 1 (um) corresponde à segunda, e 
assim por diante. Temos o conjunto de valores do eixo y, onde 0 (zero) representa a primeira linha (topo), 1 
Apostila de Pensamento Computacional 
Marcio Quirino - 49 
 
(um) representa a segunda, 2 (dois) representa a terceira etc. Historicamente, é assim que os pixels de uma 
imagem são enumerados pelo computador: 
 
Fonte: Estácio de Sá 
No gráfico, podemos ver três pixels indicados por setas. O pixel (5,0), em azul, o pixel (1,1), em 
branco, e o pixel (2,4), em amarelo. É bem comum dizer que esses valores são as coordenadas de um pixel, 
algo como o endereço da posição do pixel em referência ao canto superior esquerdo. 
Mesmo que uma imagem tenha 100.000.000 pixels, qualquer pixel em particular tem um número x,y 
que o identifica unicamente em relação a todos os demais da imagem. 
2 - Esquema Red Green Blue (RGB) 
Representação de cores em computadores 
Agora que sabemos como os computadores identificam pixels de uma imagem, vamos descobrir 
como representam a cor de cada um deles. Para entendermos como isso é feito, precisaremos recordar o 
lendário físico Isaac Newton e seu experimento com o prisma de cores, que atualmente chamamos de 
prisma de Newton, ilustrado na imagem a seguir: 
 
Fonte: Estácio de Sá 
Newton bolou e realizou esse famoso experimento com um prisma, que é apenas um pedaço 
triangular de vidro. Conforme mostrado, a luz solar branca vem da esquerda, e o prisma de vidro 
transparente divide esse fecho de luz em um espectro de cores, que está projetado na cadeira (o ideal é 
uma superfície branca), revelando que a luz branca não é algo puro e indivisível. 
Em vez disso, a luz branca pode ser separada em um espectro de cores constituintes. Essas são 
justamente as cores que você vê em um arco-íris. Portanto, as cores estão realmente em um espectro 
contínuo, conforme ilustrado a seguir: 
Apostila de Pensamento Computacional 
Marcio Quirino - 50 
 
 
Fonte: Estácio de Sá 
Uma forma de representar cores é pensar em cores puras como uma espécie de paleta. Um esquema 
mundialmente aceito é o uso das cores puras vermelho, verde e azul. 
 
Fonte: Estácio de Sá 
Você consegue identificar essas cores na imagem do prisma de Newton? 
Costuma-se utilizar essas três cores puras como constituintes para representar qualquer outra cor 
que desejarmos. 
Enquanto Newton usou um prisma para dividir a cor branca em um espectro contínuo de cores que 
a constituem (exemplo: arco-íris), desejamos usar cores constituintes e combiná-las para obter outras cores, 
e até mesmo a luz branca. 
Curiosidade 
Por trás desse “experimento de Newton ao contrário”, os pressupostos de Física não são exatamente os 
mesmos que Newton observou no experimento com o prisma de vidro. Contudo, é uma forma intuitiva de pensar como 
o computador usa cores constituintes e as combina para gerar qualquer outra cor. 
Se o espectro de cores é contínuo, ou seja, possui infinitas cores, por que só damos nomes às sete cores do 
arco-íris? 
Newton era adepto de convicções místicas, aquilo que acreditamos não ser científico, e, na época, havia sete 
planetas conhecidos. Então, Newton pensou que fazia sentido nomear sete cores conforme o número de planetas 
conhecidos. É como se ele tivesse forçado o nome Anil/Índigo para uma cor que poderia ser o azul apenas para 
potencializar o seu misticismo. 
Esquema de Cores RGB 
Funcionamento 
Agora, vamos estudar o esquema de codificação de cores específico chamado de Red Green Blue 
(RGB) ou Vermelho, Verde e Azul. Desejamos que esse esquema seja simples o suficiente para que nos 
tornemos capazes de instruir (codificar ou programar) computadores a representar qualquer cor como uma 
combinação dessas três. 
Se olharmos para a grade de pixels do gráfico visto anteriormente, precisaremos refletir sobre o que 
cada cor representa dentro da grade. No esquema RGB, vamos usar luzes vermelhas, verdes e azuis puras, 
e misturá-las em diferentes combinações para alcançarmos todas as cores possíveis. 
Apostila de Pensamento Computacional 
Marcio Quirino - 51 
 
1 – Vamos descrever o funcionamento do explorador RGB, que é bem simples, a seguir: 
2 – Há três controles deslizantes. Cada um serve para ajustar as intensidades de verde, azul e 
vermelho. 
3 – Se você escolher o valor 0 (zero) para o azul, significa que está ajustando o “pixel grande” do 
centro para que não tenha absolutamente nenhuma intensidade de azul. 
4 – À medida que você desliza o controle para a direita, vai aumentando a intensidade de luz azul 
para 1, 2, 3... até chegar ao nível 255, que representa o máximo de intensidade de luz azul que sua 
tela é capaz de emitir. O mesmo vale para o vermelho e para o verde. 
Já sabemos com mais detalhes como os computadores usam o esquema RGB para representar 
qualquer cor em um pixel. Agora, podemos refinar o diagrama que vimos no primeiro gráfico e apresentar o 
segundo, onde, além da posição de cada pixel, também representamos suas cores: 
 
Fonte: Estácio de Sá 
Essencialmente, cada um desses pixels tem seus próprios três números, que formam o código RGB 
de cores. Como já vimos, cada pixel possui uma única cor por vez. Toda a informação necessária para 
representar a cor de um pixel está nesses três números. 
Pensamento computacional 
Como humanos, estamos naturalmente acostumados a ver o mundo, pensar e refletir a respeito dele 
sob a ótica de tudo o que é natural e orgânico. Você lembrada imagem de um lindo pássaro vista no início? 
Primeiro, supomos que essa imagem fosse do mundo real e orgânico. 
Depois, fomos gradativamente reduzindo o desafio de representar uma imagem do mundo real em 
computador. A partir desse momento, passamos a empregar a grade de valores do segundo gráfico como 
um esquema cujos números representam digitalmente qualquer imagem que possamos imaginar. 
Quando temos um arquivo de computador que armazena uma imagem, na prática, o que está dentro 
desse arquivo são os dados de cada pixel, ou seja, números para a posição x,y do pixel na tela, e números 
(RGB) usados para indicar qual é a cor do pixel. 
E se pensarmos em um processamento nos dados? Por exemplo, se quiséssemos tirar uma foto e, 
talvez, torná-la um pouco mais clara? No computador, vamos traduzir isso em alguma operação com 
números. 
Agora que já estudamos a representação de imagens digitais, é fácil imaginar o que precisaríamos 
fazer. Por exemplo, poderíamos pegar cada pixel da referida imagem e aumentar os valores RGB em, 
digamos, 15%. Pronto! Geraríamos uma imagem mais clara! 
Tudo isso resume o que chamamos de pensamento computacional. 
Apostila de Pensamento Computacional 
Marcio Quirino - 52 
 
Considerações finais 
Com este estudo, você compreendeu como o computador é capaz de representar digitalmente por 
meio de números uma imagem do mundo real ou orgânico. 
Esse é um exemplo típico de uma habilidade chamada abstração – processo bastante comum em 
computação. Você começa com uma imagem inteira, sons inteiros, ou algo orgânico ou natural do mundo 
real que gostaria de representar, armazenar ou processar com computadores. 
Outras habilidades importantes nesse contexto são detectar padrões e escrever soluções, de forma 
que os computadores sejam capazes de executá-las. Esses são os pilares que formam o pensamento 
computacional. 
Em todas as pesquisas recentes de mercado e trabalho, o pensamento computacional tem sido 
apontado como uma das competências mais demandadas para os profissionais da era digital. Portanto, note 
a importância de desenvolvê-lo. 
Referências 
CARVALHO, A.; LORENA, A. Introdução à Computação: hardware, software e Dados. 1. ed. Rio de 
Janeiro: LTC, 2017. 
DALE, N.; LEWIS, J. Ciência da Computação. 4. ed. Rio de Janeiro: LTC, 2011. 
FEDELI, R. D.; POLLONI, E. G. F.; PERES, F. E. Introdução à Ciência da Computação. 2. ed. São 
Paulo: Cengage, 2010. 
FLANAGEN, D. Javascript: o guia definitivo. 6. ed. Porto Alegre: Bookman, 2013. 
FRAZÃO, D. Isaac Newton - cientista inglês. [S. l.]: eBiografia, 2020. 
GLENN, J. Ciência da Computação: uma visão abrangente. 11. ed. Porto Alegre: Bookman, 2013. 
Explore + 
Pesquise no YouTube o canal Nerdologia e assista ao vídeo: O computador ou o cérebro – quem é 
o mais potente? (2016), com o biólogo e pesquisador Atila Iamarino. 
Para saber mais sobre o assunto de explorador RGB, pesquise na internet a Tabela de Códigos 
RGB. 
Observe que mesmo tecnologias de ponta usam basicamente as mesmas ideias, noções e 
habilidades abordadas neste tema. 
Apostila de Pensamento Computacional 
Marcio Quirino - 53 
 
Noções de Programação: Exemplos Com Manipulação 
de Imagens Digitais 
Introdução 
Ao utilizarmos um computador, nós manipulamos diversos tipos de software: sistema operacional, 
aplicativos, editores de texto, entre outros. Para construir esse software, alguém, um programador ou 
desenvolvedor, escreveu uma sequência de instruções e códigos com a sequência de ações que devem ser 
desenvolvidas. 
Essa atividade é a chamada programação! 
O desenvolvedor utilizou alguma linguagem de programação e, respeitando a sua sintaxe e a sua 
semântica, codificou o algoritmo a ser utilizado com uma sequência de instruções e comandos dessa 
linguagem. 
Parece meio complexo, não? 
Bom, para que você possa compreender de forma mais fácil o significado da programação, vamos 
ver o conceito aplicado à manipulação de imagens digitais. 
1 - Manipulação de dados 
Manipulação singular de dados 
Você já ouviu falar em manipulação singular de dados? 
Neste módulo, vamos aprender a escrever códigos simples de computador para manipulação 
singular de dados. 
Por singular, entenderemos a ausência de condições de realizar uma manipulação de múltiplos 
dados de forma eficiente. 
Vamos com calma! Um pixel de cada vez... 
Para ilustrar melhor nossa discussão, usaremos como exemplo imagens para aplicação de nossos 
códigos/instruções. 
Como são instruções simples de manipulação de dados, você notará que, nos exemplos, 
manipularemos apenas um pixel de cada vez. 
Instruções para manipulação simples de dados 
Para começar, veja a imagem abaixo, cujo nome é circulo.bmp, composta por uma grade de 10x10 
pixels: 
 
Fonte: Estácio de Sá 
Apostila de Pensamento Computacional 
Marcio Quirino - 54 
 
A imagem possui um fundo branco, com um círculo desenhado. 
O BMP é um formato de arquivo usado para armazenar imagens digitais. 
Não se preocupe, pois o tamanho da figura não é um erro. A imagem realmente está muito pequena. 
Nosso primeiro impulso é realizar uma ampliação ou zoom para vê-la melhor. Esse é o ímpeto que 
queríamos provocar em você quando a colocamos com esse tamanho. 
Como escrever um código que solicita que o computador amplifique a imagem circulo.bmp? 
Para isso, usaremos três instruções que fazem parte do conjunto de funções da linguagem de 
programação JavaScript, veja: 
 
Fonte: Estácio de Sá 
Agora que você aprendeu os passos que permitem ao computador amplificar a imagem circulo.bmp, 
experimentaremos isso para alcançarmos um nível de amplificação que nos deixe confortáveis. 
Vamos praticar? 
Prática 1 
À esquerda, temos o Código-Fonte; à direita, a Saída resultante do processamento das instruções 
fornecidas. Logo abaixo, o botão Executar, que é a forma como ordenamos ao computador que executa as 
instruções fornecidas. 
 
Fonte: Estácio de Sá 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 55 
 
Percebeu a diferença? 
Note que aparece um círculo de 20x20 pixels, maior do que o apresentado na primeira figura. 
Agora altere a instrução setZoom para realizar um zoom de 10 vezes em vez de 20. Clique em 
Executar e observe o resultado. 
Considerações 
Embora bastante simples, as instruções apresentadas na tabela 1 e na prática que acabamos de 
realizar tornaram-nos capazes de instruir o computador a realizar ampliação de imagens digitais ao nosso 
comando. 
Dica 
Fique à vontade: pratique e experimente com qualquer valor que deseje para a instrução setZoom. Não tenha 
medo de errar! 
Manipulando cada bit 
Agora vamos partir para um segundo cenário um pouco mais interessante. 
Queremos estender o código usado na Prática 1 para sermos capazes de manipular individualmente 
cada pixel. 
Para isso, tudo que precisamos fazer é ajustar os passos da tabela 1 e adicionar duas novas 
instruções logo antes da instrução print, veja a seguir. Essas instruções também fazem parte das funções 
padronizadas pela linguagem JavaScript. 
 
Fonte: Estácio de Sá 
Onde aparece a primeira instrução nova da tabela 2? 
Resposta 
A primeira instrução nova que vemos nela é a do Passo 3, que instrui o computador a obter a referência ao 
pixel (4,4) da imagem armazenada na variável img e, então, a atribuir essa referência à variável pixel. 
A partir de agora, qualquer operação que fizermos com a variável img será efetuada sobre o pixel 
(4,4). 
Apostila de Pensamento Computacional 
Marcio Quirino - 56 
 
Em seguida, no Passo 4, a instrução pixel.setRed (255) ordena que o computador ajuste a saturação 
de vermelho do pixel para o nível 255, que é o maior valor possível. 
Agora, vamos realizar alguns experimentos simples com o código da tabela 2, manipulando o código-
fonte a seguir para observarmos o que acontece: 
 
Fonte: Estácio de Sá 
Note que o pixel (4,4), que fica mais ou menos no meio do círculo, ficou vermelho. 
ConsideraçõesFique à vontade para experimentar com a Prática 2. Você pode escolher qualquer valor entre 0 e 9 
para as coordenadas do pixel (lembre-se: é uma imagem de 10 pixels por 10 pixels) e qualquer valor entre 
0 e 255 para o nível de saturação vermelho do pixel (conforme o esquema de cores RGB). 
Esquema de cores RGB 
Esquema de codificação de cores, chamado RGB (Red, Blue, Green/Vermelho, Azul, Verde). Trata-se de um 
esquema simples que permite que possamos instruir (programar) o computador para representar qualquer uma das 
16.7 milhões de cores formadas com a combinação dessas três. 
Assim como a função setRed() ajusta o nível de vermelho para o pixel, temos duas outras funções 
análogas para manipular os níveis de azul e de verde de um pixel. A tabela 3 apresenta as três funções 
possíveis para essa manipulação, veja: 
 
Fonte: Estácio de Sá 
Apostila de Pensamento Computacional 
Marcio Quirino - 57 
 
Evoluindo a prática 
Prática 3 
Vamos realizar alguns experimentos simples com o código da tabela 3, manipulando o código-fonte 
a seguir para observar o que acontece: 
 
Fonte: Estácio de Sá 
Durante essa prática, observe com atenção a proposição em português feita no enunciado, em que 
o efeito desejado é descrito. 
Depois, tente refletir: 
Qual é o código de computador que você deve escrever, ou seja, as instruções e os valores 
digitados no código-fonte para alcançar o efeito proposto? 
Na prática, você aprenderá a traduzir: 
 
Fonte: Estácio de Sá 
O código fornecido ajusta o pixel (4,0) para vermelho. Ajuste o código para que o pixel (4,0) fique 
verde. Veja na solução: 
 
Fonte: Estácio de Sá 
Apostila de Pensamento Computacional 
Marcio Quirino - 58 
 
Prática 4 
Suponha que, em vez de manipular apenas um pixel por vez, conforme fizemos neste módulo, 
desejássemos manipular todos os pixels de uma imagem, digamos de 10x10 pixels (exemplo: circulo.bmp). 
Se usássemos o código que aprendemos a escrever, teríamos de escrever 100 vezes a instrução pixel = 
img.getPixel(), em que, a cada vez, passaríamos os valores x,y para cada um dos pixels da imagem. 
Isso traz vários problemas. 
1 – O primeiro deles é que o código ficaria difícil de ler/compreender. 
2 – O segundo é que, se for uma imagem maior, de 1980x1024 pixels, teríamos cerca de 2 milhões 
de pixels. 
Portanto, a instrução pixel = img.getPixel() teria de ser escrita cerca de 2 milhões de vezes no código 
fonte, a cada vez fazendo referência para um pixel diferente. 
Isso seria inviável, não é mesmo? 
No mundo real, quase sempre desejamos realizar operações com uma quantidade muito grande de dados. Os 
engenheiros e cientistas de computação pensaram nesta questão décadas atrás. 
Felizmente, há técnicas de programação/codificação que nos permitem manipular uma quantidade arbitrária 
de dados, sem ter de escrever muitos códigos de computador. 
2 - Repetição for 
Estruturas de repetição 
Estruturas de repetição são extremamente importantes, pois representam um grande aumento no 
poder de quem escreve códigos de computador em comparação com códigos, que são capazes de 
manipular dados singulares. Neste módulo, veremos os princípios dessas estruturas. 
Estrutura de repetição for 
Observe a imagem de um pássaro: 
 
Fonte: Estácio de Sá 
Imagem com 584 pixels de largura e 500 pixels de altura representando um pássaro. 
Se multiplicarmos o número de pixels de largura pelo número de pixels de altura, teremos o total de 
pixel da imagem. 
Neste caso: 
584x500 = 292.000 pixels ou quase 0.3 megapixels. 
Apostila de Pensamento Computacional 
Marcio Quirino - 59 
 
Essa nem é uma imagem muito grande, dado que os telefones celulares atuais são capazes de tirar 
fotografias de mais de 10 milhões de pixels (10 megapixels). 
Atenção! 
Mesmo assim, se o autor de um código de computador, sem usar estruturas de repetição, tentar escrever um 
código de computador para manipular cada um dos pixels da imagem da figura 2, precisará repetir 292 mil vezes as 
instruções que apontam para determinado pixel (exemplo: pixel = img.getPixel( x,y )), cada uma delas seguidas com 
as instruções de manipulação desejada (exemplo: pixel.setRed(255)). 
Claramente, isso não é uma maneira prática de realizar uma operação com grande quantidade de 
dados. As desvantagens vão desde um código de computador difícil de ler, por ser muito extenso, até a 
dificuldade de manutenção, atualização ou correção do código, caso haja necessidade futura. 
Então, o que queremos é uma construção na qual possamos escrever algumas poucas linhas de 
código que capturam certas mudanças desejadas. Depois, deixamos o computador executar essas linhas 
de código repetidamente, uma vez para cada dado que desejamos manipular, ou seja, em nosso exemplo, 
uma vez para cada pixel da imagem. 
Existem diferentes maneiras de realizar isso em códigos de computador, mas, por motivos de 
simplicidade, vamos estudar a estrutura de repetição for, também chamada de loop for. 
 
Fonte: Estácio de Sá 
Analise a sintaxe da estrutura de repetição for apresentada abaixo: 
 
Fonte: Estácio de Sá 
Sintaxe da estrutura de repetição for destacada em negrito. 
A linha de código for ( pixel: img ), traduzida de código de computador para português, significa: para 
cada pixel da imagem armazenada na variável img, repita uma a uma todas as instruções cercadas por abre 
chaves “{“ e fecha chaves “}” logo a seguir. 
No exemplo da figura 3, temos três instruções destacadas em cinza dentro da estrutura for. Nesse 
caso, estas serão as instruções repetidas para cada um dos 292 mil pixels da imagem “pássaro.jpg”. 
Toda a sintaxe apresentada é requerida para que o computador entenda que se trata de uma 
estrutura for e quais são as instruções a serem repetidas. 
Na prática, o que o computador fará para o código da figura 3 é fixar-se no primeiro pixel da imagem, 
(0,0), no canto superior esquerdo, e executar os três comandos que ajustam o nível das cores constituintes 
vermelho, verde e azul todas para 0. Este pixel, então, ficará preto. 
Apostila de Pensamento Computacional 
Marcio Quirino - 60 
 
1 – Observe a seta azul que liga o “}”, no final do loop for, no início da estrutura de repetição. 
Quando o computador percebe que está na linha de instrução que fecha a estrutura de repetição, 
acontece isso, conforme indicado pela seta azul: o computador volta novamente para o início do 
loop. 
2 – Em seguida, o computador se fixará no segundo pixel (1,0) da imagem e executará os três 
comandos em cinza, deixando o segundo pixel preto. O mesmo ocorrerá para o terceiro, o quarto, 
o quinto e para todos os 292 mil pixels da imagem do pássaro, até que toda a imagem esteja 
completamente preta. 
3 – Você perceberá que as três instruções em cinza que formam o corpo do loop for estão 
descoladas para a direita. Isso não é obrigatório para que o computador compreenda as instruções. 
4 – É, no entanto, uma convenção muito comum mostrar que as linhas de dentro da estrutura de 
repetição são especiais em relação às demais, porque são executadas várias vezes, até que a 
condição estabelecida no início da estrutura for seja satisfeita. 
Neste exemplo, a condição para finalizar é que as três instruções sejam executadas pelo computador 
para todos os pixels da imagem. 
A técnica de recuar a linha de código para deixar claro à pessoa que o estiver lendo que estas são 
instruções internas à estrutura de repetição é amplamente chamada de indentação. 
Vamos praticar 
Prática 1 
Vamos experimentar a estrutura for. Observe o código-fonte abaixo: 
 
Fonte: Estácio de Sá 
Lembre-se de que, ao clicar em Executar, o computador realizará os seguintes passos, conforme 
instruções: 
1 – Carregar a imagem “passaro.jpg” e armazená-la na variável img. 
2 – Para cada um dos 292 mil pixels da imagem “passaro.jpg”, executar as instruções indicadas: 
A – Ajustar intensidade de vermelho do pixel para 0 (zero); 
B – Ajustar a intensidade de verdedo pixel para 0 (zero); 
C – Ajustar a intensidade de azul do pixel para 0 (zero); 
D – Imprimir/apresentar a imagem na tela. 
Apostila de Pensamento Computacional 
Marcio Quirino - 61 
 
Note que o computador as executará para cada um dos 292 mil pixels da imagem. Então, temos um 
total de 876 mil operações a serem realizadas pelo computador. Ao clicar em Executar, tente observar 
quanto tempo o computador leva para ajustar/executar as 876 mil instruções necessárias para colorir de 
preto cada um dos 292 mil pixels da imagem “passaro.jpg” e, depois, apresentar a imagem na tela. 
A imagem preta deve aparecer na tela muito rapidamente: 
 
Fonte: Estácio de Sá 
Ao executar a Prática 1, você obteve um retângulo preto, o que não é muito útil. Entretanto, não deixe 
de refletir sobre o quão rapidamente o computador foi capaz de seguir suas instruções para manipular os 
quase 300 mil pixels da imagem. 
Prática 2 
Vamos seguir assistindo a um vídeo com uma segunda prática. 
Prática 3 
Agora, vamos obter o canal alfa vermelho da imagem do pássaro apresentado na figura 2 com base 
neste código-fonte: 
Execute o código-fonte e observe o canal alfa em vermelho da imagem apresentada: 
 
Fonte: Estácio de Sá 
O que você notou? 
Apostila de Pensamento Computacional 
Marcio Quirino - 62 
 
Assim como na Prática 1, observe o quão rapidamente o computador foi capaz de remover os 
componentes azul e verde da imagem em questão. Lembre-se: as instruções de dentro da estrutura for 
foram repetidas 876 mil vezes. 
Compare com a imagem original da figura 2, replicada logo a seguir (por comodidade), com a imagem 
resultante do item “a”. 
 
Fonte: Estácio de Sá 
Observe, também, que o lindo colar azul do pássaro praticamente desapareceu na imagem canal 
alfa vermelho resultante. Isso significa que o colar é constituído principalmente dos componentes verde e 
azul. 
Você compreendeu como o canal alfa em vermelho foi obtido? 
Para compreender melhor o código que foi executado, observe na caixa de código-fonte que a 
instrução pixel.setRed() está comentada, ou seja, marcada com “//” no início da linha: 
 
Fonte: Estácio de Sá 
Comentários de códigos são interessantes por duas razões: A primeira, é permitir que o autor do 
código-fonte documente seu código com frases que esclarecem o que ele estava pensando quando 
escreveu aquele trecho; A segunda, é fazer com que o computador ignore uma ou mais instruções. 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 63 
 
Prática 4 
Afinal para que serve a estrutura de repetição for? 
Atenção! 
A estrutura de repetição for é um recurso muito poderoso, que nos permite escrever algumas poucas linhas de 
código capazes de ordenar ao computador que processe/manipule uma enorme quantidade de dados. 
Neste módulo, usamos exemplos de imagens para demonstrar o enorme potencial das estruturas de 
repetição. Este foi apenas um exemplo. 
Esteja certo de que essa estrutura é amplamente usada em computação e faz parte do dia a dia de 
todos que, de alguma forma, escrevem códigos para computador. Por fim, devemos mencionar um detalhe 
da linguagem usada aqui: JavaScript. Essa linguagem não possui uma estrutura de repetição for tão 
compacta e simples como a que estudamos. 
Usamos uma versão com sintaxe propositalmente simplificada, pois nosso objetivo era compreender 
os princípios que motivam o uso de estruturas de repetição. Entendemos que o uso de uma estrutura 
simplificada ajudaria você a compreender melhor o que se passa. 
Não queríamos gastar muito tempo fazendo-o compreender detalhes de sintaxe. Este comentário é 
importante, pois, se você tentar aproveitar os códigos de computador que escrevemos aqui, provavelmente 
terá problemas devido ao nosso uso simplificado da estrutura de repetição for. 
Há outras linguagens de programação que possuem estrutura de repetição bem simular àquela que 
usamos aqui, mas não JavaScript. 
3 - As expressões em código de computador 
Expressões 
Neste módulo, estudaremos o uso de expressões em código de computador. Expressões são 
construções bastante importantes, pois, em vez de usar apenas valores simples em instruções, podemos 
combinar diferentes valores para calcular o parâmetro mais personalizado. 
Isso nos permite escrever códigos de computador que alcançam resultados mais realistas. Quando 
apresentarmos exemplos práticos de manipulação de imagens, você entenderá melhor o assunto. 
Usaremos a linguagem de programação JavaScript, com algumas simplificações para facilitar a 
compreensão. Se analisarmos o código/instrução a seguir, veremos um tipo bem simples de passagem de 
valor (51): 
 
Fonte: Estácio de Sá 
Dizemos que 51 é o valor passado como parâmetro para a função print. 
As linguagens de programação compreendem códigos que envolvem expressões, veja: 
Exemplo 
print(40+11); 
Então, o termo 40+11, passado como parâmetro para a função print, é o que chamamos de expressão. 
Apostila de Pensamento Computacional 
Marcio Quirino - 64 
 
Basicamente, em vez de um número fixo conhecido antecipadamente, podemos usar um pouco de 
expressão aritmética. Assim, temos uma forma mais rica de fornecer parâmetros para funções. 
Isso funciona da seguinte maneira: quando o computador executar a linha de código que contém a 
expressão, o primeiro passo será avaliá-la. Assim, ele lerá e resolverá a expressão para chegar ao valor 
resultante. Neste exemplo, 40+11 é apenas uma soma. O computador calcula que 40+11 é igual a 51. Uma 
vez que a expressão foi avaliada e o resultado foi 51, então, o computador continua a execução do código, 
usando o resultado da expressão como parâmetro para a função. Com efeito, em nosso exemplo o 
computador simplesmente imprimirá o valor 51 na tela. 
De fato, podemos usar expressões em qualquer local do código de computador onde valores 
numéricos são admitidos. Portanto, é possível sempre embutir expressões aritméticas para que seja 
computado o valor que desejamos usar de fato. Isso nos possibilita resolver problemas mais realistas. 
Antes de continuar, vamos conhecer três funções de manipulações de pixels que fazem parte da 
linguagem de programação JavaScript: 
 
Fonte: Estácio de Sá 
Suponha um pixel em amarelo (exemplo: Código RGB 255,255,0). Neste caso, a função 
pixel.getRed() retornará o valor 255, pois este é o valor atual do componente vermelho (R) do pixel. 
De forma análoga, a função pixel.getBlue() retornaria 0 (zero), pois este é o valor atual do 
componente azul (B) do pixel em questão. Isso ocorre porque o amarelo puro não possui azul em 
sua composição. 
Agora, vamos supor que desejamos duplicar o valor atual do componente vermelho de um pixel. Se 
esse valor for 50, ajustaremos para 100. Se for 105, ajustaremos para 210. Em resumo, desejamos realizar 
um ajuste relativo no valor. Então, seja qual for o valor atual, nós o duplicaremos. 
Já conhecemos a função pixel.getRed() e a possiblidade do uso de expressões. Logo, a tarefa ficou 
mais fácil. Uma primeira solução seria usar este código: 
ultimo = pixel.getRed(); 
pixel.setRed(ultimo*2); 
Agora veja as informações sobre a 1ª e a 2ª linhas: 
1ª linha: Chama pixel.getRed() e armazena o valor retornado na variável ultimo. 
2ª linha: Usa a função pixel.setRed() para informar que o novo valor deste pixel será o dobro do 
último valor.. 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 65 
 
Logo, quando começar a executar a segunda linha: 
O primeiro passo do computador será avaliar qual é o resultado da expressão ultimo*2. Se 
imaginarmos que o último valor para o pixel é 60, a expressão multiplicará esse valor por 2, o que 
resultará em 120. 
Em seguida, o computador executará a função pixel.setRed() com o valor 120 como parâmetro, o 
que dobrará a intensidade de vermelho do pixel em questão. 
Com efeito, o resultado das duas linhas de código é, de fato, duplicar a intensidade de vermelho do 
pixel atual. 
Agora queentendemos os princípios do uso de expressões em códigos de computadores, vamos 
analisar o mesmo exemplo de duplicação do valor atual da intensidade de vermelho de um pixel, porém com 
uma solução muito mais comum no mundo real. 
Veja a linha de código a seguir: 
pixel.setRed( pixel.getRed()*2 ); 
Na prática, desejamos mostrar que a solução em questão pode ser condensada em apenas uma 
linha de código. 
Note que a variável ultimo não tinha um objetivo muito importante no código. Ela apenas armazenava 
temporariamente o último valor do componente vermelho do pixel para que este fosse usado na instrução 
seguinte. 
Vamos supor que o pixel em questão esteja com os valores RGB (50,20,30). Então, o componente 
vermelho possui o valor 50. O computador fará o seguinte: 
1 – Executar a instrução pixel.getRed() para obter o valor atual do pixel, que é 50. 
2 – Avaliar a expressão pixel.getRed()*2 e resolvê-la, multiplicando o valor atual do pixel por 2 e 
obtendo o resultado 100. 
3 – Executar a instrução pixel.setRed() usando como parâmetro o resultado da operação aritmética 
do Passo 2, ou seja, o valor dobrado para o componente vermelho do pixel, que é 100. 
Com isso, o novo valor RGB para o pixel em questão será: RGB (100,20,30). Se fizermos o mesmo 
para todos os pixels de uma imagem, o usuário perceberá essa alteração como uma imagem com os tons 
de vermelho mais destacados. 
Se, no mesmo exemplo, desejássemos reduzir pela metade a intensidade de vermelho do pixel, a 
linha de código ficaria assim: 
pixel.setRed( pixel.getRed()/2 ); 
Note que, em vez de usarmos o asterisco, que denota multiplicação, utilizamos o “/”, que denota 
divisão. 
Outra forma de escrever a mesma solução seria multiplicar o pixel atual por 0.5, o que é o mesmo 
que dividir por 2. Então, nesse caso, teríamos: 
pixel.setRed( pixel.getRed()*0.5 ); 
Para entender melhor o assunto, vamos fazer alguns exercícios. 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 66 
 
Prática 1 
Vamos ajustar a tonalidade de cores de uma imagem por meio de instruções simples. Comecemos 
por esta: 
 
Fonte: Estácio de Sá 
Figura 4: Imagem de flores em amarelo com 587x330 pixels, totalizando quase 194 mil pixels. 
Suponha que desejemos ajustar essa imagem para obtermos tonalidades mais para o laranja. 
Para alcançar o objetivo desta prática, basta reduzir um pouco a intensidade do componente 
verde (G) de cada um dos pixels da imagem. 
pixel.setGreen( pixel.getGreen()*0.7 ); 
O que essa instrução faz é ajustar a intensidade de verde do pixel em questão para 70% do valor 
atual. Esse é o resultado aritmético que você obtém quando multiplica um valor por 0.7. 
Note que o código-fonte fornecido não contém a instrução citada. Apenas disponibilizamos o 
“esqueleto” do código contendo a solução: 
 
Fonte: Estácio de Sá 
img = new SimpleImage("img/flores.jpg"); 
for( pixel: img ){ 
// Insira suas linhas de código abaixo 
pixel.setGreen(pixel.getGreen() * 0.7); 
} 
print( img ); 
Se você clicar em Executar, o computador apenas apresentará a imagem original com as flores em 
amarelo. Isso ocorre porque não há instruções de ajuste de cores no código-fonte. 
Apostila de Pensamento Computacional 
Marcio Quirino - 67 
 
Você mesmo deve inserir a instrução que realiza a redução da tonalidade de verde do pixel. Insira a 
instrução dentro da estrutura de repetição for logo abaixo do comentário que indica aposição correta. Depois, 
clique em Executar para que o computador execute seu código. 
Considerações 
Reflita sobre a quantidade de operações realizada em um piscar de olhos pelo computador, dado o 
código-fonte que geramos. 
Para cada um dos 194 mil pixels da imagem da figura 4, o computador fez as seguintes operações: 
1 – Obteve a intensidade de verde do pixel; 
2 – Multiplicou a intensidade de verde do pixel por 0.7; 
3 – Ajustou a intensidade de verde do pixel para o resultado dos dois passos anteriores. 
Então, em português, poderíamos descrever o objetivo deste exercício simplesmente como: tornar a 
imagem um pouco mais laranja. 
Reflita sobre como esse objetivo foi traduzido do português para o código de computador que usamos 
ao realizarmos a operação. A capacidade de fazer essa tradução e escrever uma solução que computadores 
são capazes de executar rapidamente é uma habilidade chave para o chamado pensamento 
computacional. 
Voltando à imagem da figura 4, suponha, agora, que desejamos convertê-la em uma imagem de 
escala de cinza. 
Para alcançar o objetivo de converter a imagem de flores amarelas em uma imagem em escala de 
cinza, vamos calcular, para cada pixel, o valor médio dos componentes RGB. Depois, ajustaremos cada um 
dos três componentes para esse valor médio. Veja o trecho de código que calcula a média dos três 
componentes (R, G e B) para um dado pixel, depois, atribui esse valor médio aos três componentes de cor 
do pixel: 
 
soma=(pixel.getRed()+pixel.getGreen()+pixel.getBlue()); 
media= soma/3; 
pixel.setRed( media ); 
pixel.setGreen( media ); 
pixel.setBlue( media ); 
Copie e cole estas linhas de código no código-fonte de experimento de programação disponível no 
início desta prática: 
 
Fonte: Estácio de Sá 
Apostila de Pensamento Computacional 
Marcio Quirino - 68 
 
Como desejamos tornar todos os bits da imagem em escala de cinza, você deverá colar este trecho 
dentro da estrutura de repetição for. Depois, clique em Executar. Observe o computador executar suas 
instruções e transformar a imagem para a escala de cinza: 
Fique à vontade para experimentar com o código-fonte, obter diferentes resultados e refletir sobre o 
resultado obtido com as instruções que você testou. Por exemplo, você pode multiplicar a média por 1.1, 1.5 
ou 2 e observar como a imagem vai ficando mais clara. Não tenha medo de errar! 
Enigma 5-2-10 
Vamos desvendar o enigma 5-2-10 abordado no vídeo? 
Considere a imagem, contendo frutas em seis tons de cores: 
 
Fonte: Estácio de Sá 
Figura 5: Frutas em 6 cores diferentes, com 863 pixels de largura por 535 pixels de altura, totalizando 
quase 462 mil pixels. 
Esta imagem foi modificada, dividindo, para cada pixel, os valores dos componentes RGB (vermelho, 
verde e azul) por 5, 2 ou 10. Veja o resultado: 
 
Fonte: Estácio de Sá 
Figura 6: Imagem da figura 5, mas com os componentes RGB manipulados. 
Note que a imagem está mais escura, além de ter suas cores distorcidas. 
Vamos praticar! 
Recupere a imagem (Figura 6) para o lindo padrão de cores da figura 5 original. Fique à vontade para 
experimentar com as multiplicações pelos três valores citados e tente descobrir como retornar para as cores 
originais, ou seja, desvendar o enigma! 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 69 
 
Recomendação 
Para diminuir o número de combinações que você tentará, tenha em mente que, quando a imagem foi 
modificada, os valores 5, 10 e 2 foram usados apenas uma vez cada. 
Vamos lá! 
 
Fonte: Estácio de Sá 
img = new SimpleImage("img/frutas-5-2-10.jpg"); 
for( pixel: img ){ 
 // Insira suas linhas de código abaixo 
 pixel.setRed(pixel.getRed() * 10); 
 pixel.setGreen(pixel.getGreen() * 5); 
 pixel.setBlue(pixel.getBlue() * 2) 
} 
print( img ); 
Então, o que você precisa fazer é inserir as três instruções no código-fonte, dentro da estrutura de 
repetição for, conforme as possibilidades da tabela 6. Sempre clique em Rodar/Executar para conferir se 
obteve a imagem original de volta. 
No pior dos casos, você só precisará realizar seis tentativas. 
 
4 - A estrutura condicional if 
O que são estruturas condicionais? 
Estruturas condicionais são as linhas de código de computador empregadas para expressar a ideia 
de lógica ou seletividade. Usando esses tipos de instruções, somos capazes de preparar o computador para 
realizar um teste, cujo resultado será verdadeiro ou falso, aplicando-o para controlar se determinado pedaço 
de código será ou nãoexecutado. 
Todas as linguagens de programação possuem estruturas condicionais. Neste módulo, analisaremos 
um tipo específico: a declaração if (do inglês, if-statement). Não deixe de manter em mente que if, em inglês, 
significa “se”. 
Vamos nos basear em exemplos e práticas na linguagem JavaScript, estando sempre voltados para 
a resolução de interessantes problemas de manipulação de imagens. 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 70 
 
Estrutura condicional 
Veja a sintaxe de uma declaração if conforme a linguagem de programação JavaScript: 
if(pixel.getRed() > 160) { 
pixel.setRed(0); 
pixel.setGreen(0); 
Pixel.setBlue(0); 
} 
Repare na linha 1. Em português, essa instrução significa: 
Se a intensidade do componente vermelho do pixel for maior do que 160, então execute as 
instruções que estão entre as chaves esquerda e direita. 
Em outras palavras, as instruções das linhas 2, 3 e 4 só serão executadas pelo computador se o 
resultado do teste for verdadeiro. Pense nessa instrução como uma forma de selecionar os pixels que serão 
afetados pelas instruções das linhas 3, 4 e 5. Veja: 
1 – Por exemplo, ainda na instrução 1, se o valor do componente vermelho do pixel em questão for 
140, então, as instruções 2, 3 e 4 não serão executadas pelo computador, pois o teste if( 140> 160) 
retornará, é claro, falso. 
2 – Se o valor do componente vermelho do pixel em questão for 160, então as instruções 2, 3 e 4 
também não serão executadas, pois o resultado do teste if (140 > 160) será falso. 
3 – A execução das instruções 2, 3 e 4 só ocorrerá, por exemplo, se o valor do componente 
vermelho do pixel em questão, obtido pela função pixel.getRed(), for 161 ou qualquer valor maior 
do que este. 
4 – Note, na linha 1, onde há a instrução if, que o teste a ser realizado pelo computador está entre 
parênteses. Esta é uma sintaxe requerida pela linguagem JavaScript. 
Somente seguindo essa sintaxe o computador será capaz de entender que se trata de um teste que 
ele deve realizar, para então decidir se irá ou não executar as instruções entre as chaves esquerda“{“ e 
direita “}”, que delimitam a declaração if. 
Comentário 
Na prática, frequentemente vemos uma declaração if ser usada dentro de uma estrutura de repetição, como a 
estrutura for. Esse tipo de combinação permite que problemas bastante interessantes sejam resolvidos. 
Para o restante deste módulo, experimentaremos com a estrutura condicional if. Abordaremos várias 
práticas simples que envolvem manipulação de imagens digitais, começando por casos bem rudimentares 
e chegando a aplicações do mundo bem interessantes, ainda que simples. 
Optamos por usar exemplos com imagens digitais, pois esta é uma forma muito simples, intuitiva e 
rápida para você observar os efeitos da execução de algumas linhas de código de computador. Isso ocorre 
porque estamos acostumados a observar imagens do mundo real desde que nascemos. Então, este é um 
processo altamente intuitivo para todos. 
Para analisar e avaliar o efeito de determinadas linhas de código, basta observar a imagem e 
comparar o antes e o depois da execução do código. 
Vamos praticar 
Prática 1 
Considere a seguinte imagem: 
Apostila de Pensamento Computacional 
Marcio Quirino - 71 
 
 
Figura 7: Imagem representativa do esquema de Cores RGB. Fonte: Estácio de Sá 
Imagine que desejamos escrever um código de computador que altere somente a região em 
vermelho, transformando-a em cinza. 
Note que o vermelho equivale ao código RGB(255,0,0). Uma primeira tentativa para transformar a 
região vermelha em cinza seria pensar nesse código RGB. 
Então, podemos escrever um código que ordena ao computador que, para cada pixel da imagem, 
verifique se o componente vermelho é 255. Em caso positivo, ajuste a cor do pixel para cinza, ou seja, 
RGB(120,120,120). 
Vamos experimentar? 
No código-fonte à esquerda estão listadas as linhas de código que representam, em código de 
computador, o passo a passo da tentativa do parágrafo anterior. Clique em Rodar/Executar e observe o 
resultado. 
 
Fonte: Estácio de Sá 
Repare que não só a região vermelha foi transformada em cinza, mas também as regiões amarelo, 
branco e magenta. Colorimos mais do que a região proposta pelo exercício. Observe a tabela 7. Você notará 
que as cores amarelo, branco e magenta também possuem, assim como o vermelho, o valor 255 para o 
componente R. 
Então, nossa instrução if ao computador precisa ser mais específica. 
Relembrando 
O computador faz exatamente o que ordenamos. Na prática, precisamos checar três tarefas: para que apenas 
a região vermelha seja ajustada para cinza, devemos verificar se o Red é igual a 255, se o Green é igual a 0 (zero), e 
se o Blue é igual a 0 (zero). 
Então, você precisará substituir no código-fonte toda a linha da instrução if pela instrução a seguir: 
Apostila de Pensamento Computacional 
Marcio Quirino - 72 
 
if(pixel.getRed() == 255 && pixel.getGreen() == 0 && pixel.getBlue() == 0){ 
 
... 
 
} 
Você pode usar o recurso de copiar e colar para isso: 
 
Fonte: Estácio de Sá 
Em seguida, clique em Rodar/Executar e observe que o objetivo desta prática será alcançado. 
Observe que, com essa ação, você programou para que a região somente vermelha fosse ajustada 
para cinza, mas, ao mesmo tempo, permitiu que as regiões de interseção entre as três cores se 
apresentassem sem alteração. 
Prática 2 
Preparamos um vídeo abordando outra prática. 
Continuando a praticar 
Que tal praticar um pouco? 
Observe a seguinte imagem: 
 
Figura 8: Uma calçada com o meio-fio pintado de amarelo. Fonte: Estácio de Sá 
 
 
Imagine que desejamos ajustar a imagem para que o meio-fio fique cinza em vez de amarelo. 
Pela tabela 7 sabemos que o amarelo é uma cor composta pela combinação de vermelho e verde. 
Apostila de Pensamento Computacional 
Marcio Quirino - 73 
 
Vamos utilizar o código-fonte a seguir para experimentar com diferentes abordagens de construção 
para a instrução if até alcançarmos uma solução mais refinada que nos pareça suficientemente boa. 
 
Fonte: Estácio de Sá 
img = new SimpleImage("img/calcada.jpg"); 
for(pixel: img){ 
media = (pixel.getRed() + pixel.getGreen() + pixel.getBlue())/3 
if(pixel.getRed() > media && pixel.getGreen() > media){ 
 pixel.setRed( media ); 
 pixel.setGreen( media ); 
 pixel.setBlue( media ); 
} 
} 
print(img); 
Considerações 
Queremos tirar proveito do padrão da natureza que acabamos de observar. 
Tons de amarelo são caracterizados por níveis equivalentes de vermelho e verde e um nível de azul 
muito mais baixo. Como, porém, podemos escrever uma estrutura if para instruir o computador a selecionar 
os pixels que atendam a esse padrão? 
Felizmente, isso é muito simples! Observe as duas figuras a seguir: 
 
Fonte: Estácio de Sá 
Na primeira figura, se calcularmos a média dos três componentes R(97), G(97) e B(0), obteremos o 
valor 64.6. A linha tracejada representa onde estaria esse valor nos controles deslizantes. Repare que os 
componentes vermelho e verde estão acima da média. O mesmo comportamento se repete na segunda 
figura. 
Apostila de Pensamento Computacional 
Marcio Quirino - 74 
 
Então, vamos usar essa observação para construir uma solução mais inteligente para a instrução if 
e observar se, desse modo, selecionamos os pixels em amarelo do meio-fio de forma mais satisfatória. Volte 
ao código-fonte desta prática e realize os ajustes destacados em sublinhado a seguir: 
for(pixel: img){ 
 media=(pixel.getRed()+pixel.getGreen()+pixel.getBlue()) / 3; 
if(pixel.getRed() >media && pixel.getGreen() > media){ 
pixel.setRed(0); 
pixel.setGreen(0); 
pixel.setBlue(0); 
} 
} 
print(img); 
Agora, confirmamos que a nossa estrutura if é capaz de selecionar, de forma bem satisfatória, os 
pixels que desejamos ajustar para a tonalidade cinza. Já pensamos em uma forma de escrever a instrução 
if, de modo que os pixels domeio-fio sejam corretamente selecionados para modificação de cor. O último 
passo para alcançarmos nosso objetivo é ajustar as instruções internas à estrutura if, em que, de fato, as 
cores dos pixels selecionados são ajustadas. 
Durante os passos anteriores, deixamos as instruções alterando o valor dos componentes RGB para 
0 (zero), para que pudéssemos observar o que ficou em preto e refletir se a nossa estrutura if estava correta. 
Agora, pense um pouco: queremos que o meio-fio, que era amarelo, apareça em escala de 
cinza. 
Pela tabela 7 já sabemos que a escala de cinza equivale a dizer que os três componentes R, G e B 
possuem o mesmo valor. Ora, nós já ordenamos que o computador calcule automaticamente a média dos 
três componentes do pixel. 
Então, a variável chamada media contém uma estimativa de quanta luminosidade existe no pixel 
sendo tratado. Uma boa tentativa seria trocar o 0 (zero) das instruções de ajuste de cor internas ao if pela 
variável media. Realize esses ajustes no código-fonte, conforme destacado em sublinhado: 
for(pixel: img){ 
 media=(pixel.getRed() + pixel.getGreen() + pixel.getBlue())/3; 
if(pixel.getRed() > media && pixel.getGreen() > media){ 
pixel.setRed(media); 
pixel.setGreen(media); 
pixel.setBlue(media); 
 } 
} 
print(img); 
Pensamento computacional 
O pensamento computacional já é considerado em vários países do mundo como a competência 
fundamental usada por todas as pessoas nas próximas décadas. Assim como a leitura, a escrita e a 
aritmética, essa competência será imprescindível para o mercado de trabalho. 
Professores e alunos do ensino fundamental, ensino médio e ensino superior, além de cientistas, 
engenheiros, historiadores, artistas, médicos, advogados, todos precisarão usá-la para desempenhar seu 
papel de forma competitiva. Este estudo está baseado justamente no pensamento computacional. 
Primeiramente, compreendemos que o computador representa qualquer conceito do mundo real por 
meio de números. No caso de imagens, os números indicam a posição do pixel e sua cor. 
Para isso, precisamos desconsiderar qualquer outro detalhe da imagem que não seja fundamental 
para sua representação: 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 75 
 
1 – Quantos pixels usaremos para representá-la. 
2 – Qual é a cor de cada pixel. 
Esse tipo de habilidade é denominada abstração e constitui um dos pilares primordiais do 
pensamento computacional. 
Em seguida, escrevemos linhas de códigos (instruções) de computador para que ele fosse capaz de 
automaticamente manipular esses números e, assim, realizarmos ajustes nas imagens, conforme o objetivo 
proposto. 
Comentário 
Dessa forma, praticamos outra habilidade chave do chamado pensamento computacional, que é a automação, 
ou seja, escrever soluções na forma de instruções que o computador é capaz de seguir automaticamente para chegar 
ao resultado desejado. 
Durante o desenvolvimento das práticas, sempre paramos para observar e analisar os resultados 
obtidos nas imagens apresentadas. Então, refletimos sobre como poderíamos melhorar os resultados 
alcançados e realizamos ajustes em nosso código para alcançar resultados mais adequados. Isso constitui 
outro pilar fundamental do pensamento computacional, denominado análise/avaliação. 
Observe que, durante as práticas realizadas, o código-fonte que escrevemos sempre decompôs o 
problema proposto em partes mais simples, que seguiram o seguinte passo a passo padrão: 
1 – Carregar a imagem na memória para que fosse trabalhada – escrevemos uma linha de código 
que carrega a imagem. 
2 – Automaticamente processar, um a um, todos os pixels (centenas de milhares) de uma imagem 
– usamos a estrutura for para instruir o computador a repetir as instruções para cada pixel da 
imagem. 
3 – Selecionar em quais pixels desejamos realizar ajuste de cores – escrevemos a estrutura if para 
que o computador realizasse testes e, conforme o resultado (verdadeiro ou falso), executasse ou 
não as instruções de manipulação de cores do pixel. 
4 – Alterar a cor de um pixel – escrevemos linhas de código para alterar os componentes RGB 
(vermelho, verde e azul) para alterar a cor de um pixel, conforme nosso objetivo. 
5 – Imprimir o resultado na tela – escrevemos a função print para que o resultado das instruções 
(a imagem manipulada) fosse apresentado na tela. 
A habilidade de decompor um problema em problemas bem menores e mais simples, que podem ser 
resolvidos isoladamente com uma ou poucas linhas de código de computador, é mais um dos pilares do 
pensamento computacional, denominado decomposição. 
Além disso, durante a prática do ajuste de cor do meio-fio de amarelo para escala de cinza, foi preciso 
observar um padrão natural/orgânico de qualquer pixel de tonalidades amareladas. Eles possuem os 
componentes verde e vermelho maiores do que o componente azul. 
Usamos esta observação em nosso favor e escrevemos um código de computador que foi 
capaz de automaticamente selecionar pixels em diversos tons de amarelo, para que pudéssemos 
ajustar suas cores. Essa habilidade é denominada detecção de padrões. 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 76 
 
Considerações finais 
Praticamos aqui conceitos primordiais de pensamento computacional ao exercitarmos noções de 
programação de computadores com exemplos de manipulação de imagem. 
Além disso, realizamos experimentos práticos de programação embutidos no conteúdo digital. Não 
hesite em voltar ao conteúdo e usar esses experimentos para transmitir adiante o conhecimento adquirido. 
Referências 
CARVALHO, A.; LORENA, A. Introdução à computação: hardware, software e Dados. Rio de Janeiro: 
LTC, 2017. 
DALE, N.; LEWIS, J. Ciência da Computação. 4. ed. Rio de Janeiro: LTC, 2011. 
FEDELI, R. D.; POLLONI, E. G. F.; PERES, F. E. Introdução à Ciência da Computação. 2. ed. São 
Paulo: Cengage, 2010. 
FLANAGEN, D. JavaScript: o guia definitivo. 6. ed. Porto Alegre: Bookman, 2013. 
GLENN, J. Ciência da Computação: uma visão abrangente. 11. ed. Porto Alegre: Bookman, 2013. 
Explore + 
Confira a indicação que separamos especialmente para você! 
Pesquise o artigo Proposta de atividades para o desenvolvimento do pensamento computacional no 
ensino fundamental, de Daiane Andrade e outros autores. Campinas: Unicamp, 2013. p. 169-178. 
 
Apostila de Pensamento Computacional 
Marcio Quirino - 77 
 
Pensamento Computacional e Aplicações na Área de 
Conhecimento 
Introdução 
Há muitos anos, a sociedade utiliza computadores como ferramentas capazes de resolver as mais 
diversas dificuldades em todas as áreas do conhecimento como Saúde, Educação, Engenharia, Economia 
Criativa, Ciências Jurídicas e Tecnologia da Informação. 
Antes de qualquer problema ser solucionado, é necessário compreendê-lo, bem como as maneiras 
pelas quais ele pode ser resolvido. O pensamento computacional é o nome dado a um conjunto de 
habilidades que nos permite fazer isso. 
Neste conteúdo, perceberemos que, com as constantes mudanças que o mundo vem atravessando, 
torna-se cada vez mais importante a compreensão do pensamento computacional por profissionais de todas 
as áreas, e não apenas os ligados à Computação. 
1 - Pensamento computacional 
O que é pensamento computacional? 
A velocidade em que a sociedade está mudando nunca foi tão acelerada. A evolução, nas primeiras 
décadas do século XXI, equivale a centenas de anos da história humana. Nesse tempo, vimos tecnologias 
inovadoras serem lançadas e, alguns anos depois, serem substituídas por outras ainda mais disruptivas. 
Disruptivas 
Se entendemos disrupção como a interrupção de uma sequência normal de qualquer processo, podemos 
entender como tecnologias disruptivas aquelas que provocam uma mesma interrupção — ou transformação — no 
modo como determinado procedimento acontece. Além da atração natural que uma inovação como essa pode trazer, 
tais tecnologias também auxiliam na mudançade toda uma concepção acerca do processo em questão. 
Vejamos dois exemplos dessas tecnologias e seus impactos. 
1 – Antes de a escrita ser popularizada, grande parte do conhecimento produzido por indivíduos 
era perdida, pois a transmissão oral não tinha capacidade de ser perpetuada. A escrita acabou com 
essa limitação! Assim, o novo desafio passou a ser armazenar e difundir o conhecimento 
desenvolvido para todo o mundo. 
2 – A tecnologia veio suprir essa lacuna seja com a criação da imprensa no século XVI, seja com 
os computadores ultramodernos. Atualmente, o conhecimento gerado em qualquer parte do mundo 
pode ser consultado em segundos por outra pessoa do outro lado do globo. Isso permite melhor 
cooperação e, consequentemente, uma evolução mais rápida e efetiva de tudo ao nosso redor. 
O avanço da ciência e da tecnologia continua a progredir de forma cada vez mais rápida, tendo como 
uma das consequências desse processo uma sociedade largamente dependente e diferenciada da 
computação. Se compararmos o comportamento de diversos profissionais do século passado com os atuais, 
por exemplo, encontraremos grandes diferenças nas formas de pensar e fazer seu trabalho. 
Vejamos o caso de um cientista: 
Apostila de Pensamento Computacional 
Marcio Quirino - 78 
 
 
Fonte: Estácio de Sá 
Outro exemplo bastante claro são os engenheiros, que trocaram o lápis e o papel por softwares 
capazes de desenhar, projetar em 3D e realizar cálculos específicos de Engenharia de forma precisa e 
extremamente rápida. 
Essas e muitas outras profissões já utilizam o pensamento computacional para desenvolver soluções 
que permitem que a tecnologia se torne uma grande aliada de seus processos. E essa é uma tendência 
cada vez mais forte. 
Assim, observamos uma importante mudança no mercado de trabalho: algumas habilidades e 
competências, que antes eram específicas da área de Computação, passam a ser consideradas 
fundamentais para qualquer profissional do século XXI. Esse conjunto de habilidades denominamos 
pensamento computacional. 
Você compreendeu o que é pensamento computacional até aqui? Veremos a seguir mais 
detalhes sobre o assunto. 
Antes de entrarmos em detalhes, contudo, sobre o real significado do pensamento computacional, 
entenderemos primeiramente o que ele não é. Isso será importante para esclarecermos alguns mitos. Veja 
dois exemplos a seguir: 
Pensar como computadores: 
É comum associarmos, erroneamente, o termo pensamento computacional à ação de pensar como um 
computador. Mas computadores não pensam! Apenas seguem instruções expressas, objetivas e simples – por 
exemplo, somar dois números. 
Pensamento computacional é o mesmo que programar: 
É comum considerarmos que pensamento computacional seja o mesmo que programar, o que também não é 
verdade. Afinal, nem mesmo precisamos de um computador para praticar o pensamento computacional. 
De acordo com Blikstein (2008), pensamento computacional não se trata de saber navegar na 
internet, enviar e-mail, publicar material na web ou operar um processador de texto. Pensamento 
computacional significa saber usar o computador como um instrumento de aumento dos poderes cognitivo 
e operacional humanos. Em outras palavras, trata-se de usar computadores e suas redes para aumentar 
nossa produtividade, inventividade e criatividade. 
Agora, vamos começar a refletir sobre o que é, de fato, o pensamento computacional. 
Para que um computador funcione, por meio de linhas de código simples e diretas, é necessário que 
um indivíduo ou uma equipe reflita sobre como estruturar e organizar as instruções que serão passadas para 
a máquina. Essa pessoa ou grupo deve, então, escrever as instruções de forma que o computador resolva 
o problema proposto ao segui-las. 
Apostila de Pensamento Computacional 
Marcio Quirino - 79 
 
Essa maneira de compreender a dificuldade, raciocinar e buscar a melhor solução possível é a etapa 
que antecede à programação, também conhecida como pensamento computacional. 
A maior parte das pessoas aprende a utilizar o computador apenas como usuário de soluções já 
existentes. Por exemplo, por meio de um sistema de busca na web, os indivíduos usam palavras-chave para 
encontrar o assunto desejado e, assim, por meio das opções “copiar” e “colar”, tornam-se apenas repetidores 
de um conhecimento já existente. 
A partir de modelos, o pensamento computacional nos permite analisar um problema complexo, 
entender seus detalhes e propor possíveis soluções. É possível, então, escrever essas respostas de maneira 
que um computador, um humano ou ambos possam entendê-las. Note que, ao agir dessa forma, as pessoas 
estão construindo seu próprio conhecimento, no sentido de solucionar determinada questão proposta. 
Pilares do pensamento computacional 
Apresentação 
De forma geral, há quatro pilares ou habilidades necessárias para que possamos exercer o 
pensamento computacional, conforme ilustrado a seguir: 
 
Fonte: Estácio de Sá 
O objetivo é desenvolver um raciocínio mais estruturado e direto, o que pode auxiliar muito na solução 
de problemas complexos. Vamos entender cada um deles agora. 
Primeiro pilar — decomposição 
A decomposição busca dividir um problema ou sistema complexo em partes menores, mais fáceis 
de compreender, gerenciar e resolver. Quando deixamos de olhar para um sistema como um todo e 
estudamos cada uma de suas peças menores, fica mais simples de compreender e buscar a solução 
desejada. 
Para entender melhor a decomposição, imagine a seguinte situação. 
Uma companhia aérea precisa levar pessoas e bagagens de uma cidade até a outra, usando aviões. 
Se você precisasse explicar esse problema, como faria? 
Explicaria sobre aviões, pilotos, bagagens e emissão de passagens, tudo ao mesmo tempo? 
Apostila de Pensamento Computacional 
Marcio Quirino - 80 
 
Para tornar essa complicada questão tratável, precisamos abordá-la por partes, ou seja, decompor 
o problema. 
1 – Primeiro, você falaria sobre todas as possíveis formas de se comprar a passagem aérea: por 
meio do site da própria companhia ou de parceiros, por telefone ou, ainda, presencialmente. 
2 – Depois, você explicaria sobre as opções para a realização do check-in para confirmar sua 
presença naquele voo. Na sequência, daria orientação sobre o despacho de bagagens, caso 
necessário e esclareceria os procedimentos de embarque na aeronave. 
3 – Por fim, você gastaria algum tempo expondo os procedimentos realizados pelo piloto e pelo 
controle de tráfego aéreo para que a aeronave consiga decolar, voar até a cidade destino e pousar. 
Essa parte, por si só, é tão complicada, que você poderia decompô-la novamente em pedaços 
menores para facilitar suas explicações. 
Neste exemplo, estamos desagrupando uma questão complexa em outras menores que, por sua 
vez, também podem ser fragmentadas. A ideia principal da decomposição é dividir o problema até que se 
torne algo tratável e possa ser executado com satisfatório nível de eficiência. 
Recomendação 
No mundo da computação, o processo de decomposição ocorre de forma frequente, já que os computadores 
são inacreditavelmente rápidos, mas desprovidos de qualquer inteligência. Então, para que tenham utilidade, 
precisamos indicar quais instruções simples devem realizar, uma após a outra, até que o problema seja resolvido por 
completo. 
Segundo pilar — abstração 
Buscamos desconsiderar informações ou detalhes que não sejam imprescindíveis para resolver 
nosso problema. Ainda no exemplo da companhia aérea, vamos pensar no procedimento de embarque. 
Diariamente, os atendentes responsáveis pelo embarque fazem a verificação de milhares de 
passageiros que precisam viajar em seus aviões. Essas pessoas possuem diferentes características, além 
de portarem malas, bolsas, mochilas, casacos ou diversos outros tipos de objetos pequenos. 
Para cada avião, a verificação realizada pelos atendentes deve ser rápida e objetiva. A equipe tem 
poucosminutos para embarcar centenas de pessoas ao mesmo tempo, registrar informações importantes 
para o fornecimento adequado do serviço. Para isso, é preciso aplicar o princípio da abstração, que propõe 
ignorar detalhes irrelevantes para concentrar-se no que realmente importa. 
Em nosso exemplo, o atendente deve focar-se apenas nos dados de nome e foto presentes na 
carteira de identidade e confrontá-los com as informações do cartão de embarque, abstraindo todas as 
outras averiguações ou características físicas. O funcionário também deve se atentar ao número, ao peso e 
à dimensão dos itens de bagagem de mão, de modo que estejam em conformidade com as diretrizes de 
segurança. 
Não se preocupar com informações desnecessárias, além de economizar tempo, permite que 
possamos desenvolver a solução mais genérica possível, que atenderá a uma série de problemas que segue 
o mesmo padrão. Este será nosso próximo foco de estudo. 
Terceiro pilar — reconhecimento de padrões 
Padrões são semelhanças ou características que alguns dos problemas compartilham entre si. O 
reconhecimento dessas referências tem por objetivo aproveitar soluções já usadas no passado para lidar 
com uma nova dificuldade que seja suficientemente similar. 
Apostila de Pensamento Computacional 
Marcio Quirino - 81 
 
Em grandes aeroportos, é comum precisarmos caminhar longas distâncias para conseguirmos 
embarcar no voo. Sabemos que pessoas mais idosas ou com dificuldade de locomoção tendem a andar 
mais devagar. 
Porém, para que as companhias aéreas consigam cumprir a apertada agenda de viagens diárias, é 
importante que não haja atrasos. 
Logo, todos os passageiros precisam se deslocar em tempo hábil. 
Para solucionar essa questão, os aeroportos disponibilizam esteiras rolantes muito similares às 
escadas rolantes de shopping centers, porém mais apropriadas ao propósito de auxiliar o deslocamento de 
passageiros. Então, mesmo que um deles consiga andar por conta própria, poderá caminhar sobre a esteira 
com o intuito de diminuir o tempo de chegada ao portão de embarque. Note que, embora esse problema 
seja diferente de ajudar pessoas a subir ou descer pisos de shopping centers, as soluções são muito 
parecidas: um sistema de esteiras rolantes de metal movimentadas por motores elétricos. 
Podemos imaginar que um profissional, em algum momento, tentando solucionar essa questão, 
pensou: 
“Talvez possamos usar escadas rolantes modificadas para resolver o problema de demora no 
deslocamento de passageiros dentro de um terminal de aeroporto, pois, em ambos os casos, 
precisamos locomover pessoas a pé por alguns metros”. 
Os padrões podem ser observados tanto entre problemas diferentes quanto entre partes de uma 
mesma dificuldade. 
Quarto pilar — algoritmos 
Pilar fundamental do pensamento computacional é a automação por meio de algoritmos. 
Em nosso exemplo de uma empresa aérea, podemos relacionar a criação de algoritmos aos 
documentos com instruções dadas a cada funcionário, onde ele acessa detalhes passo a passo dos 
procedimentos que deve seguir para a realização de seu trabalho. 
Isso permite que o colaborador, mesmo que novato e sem conhecer as complexas engrenagens da 
companhia, possa facilmente seguir um conjunto de instruções simples, garantindo que o problema, pelo 
qual seja responsável, receba o tratamento adequado. 
Nesses exemplos, utilizamos analogias diferentes para várias situações típicas de uma empresa 
área, de modo a facilitar a compreensão dos quatro pilares do pensamento computacional. Entretanto, é 
importante que você mantenha em mente que a decomposição, a abstração, o reconhecimento de 
padrões e os algoritmos trabalham juntos para resolver um problema, não existindo uma ordem de 
importância ou de prioridade entre eles. São como as quatro pernas de uma mesa: sem uma delas, não é 
possível chegar ao resultado esperado. 
Dica 
Experimente aplicar em uma dificuldade que tenha ou em uma situação de seu cotidiano os quatro pilares do 
pensamento computacional e veja como eles podem facilitar ou acelerar sua resolução. 
Mercado de trabalho e pensamento computacional 
Cada vez mais competitivo, o mercado de trabalho busca profissionais que tenham, além de 
conhecimento teórico sobre o cargo que ocuparão, capacidade para inovar, planejar, decidir, aprender e ter 
boa relação interpessoal. Essas habilidades, também conhecidas como soft skills, são percebidas em 
atitudes simples, como a forma que um candidato se comporta em uma entrevista, um desafio ou uma 
dinâmica de grupo. 
Apostila de Pensamento Computacional 
Marcio Quirino - 82 
 
Soft skills 
“As chamadas habilidades interpessoais, cujo termo em inglês é soft skills, têm chamado a atenção das 
empresas, principalmente das áreas de vendas, marketing e software. Estudo realizado pela maior rede social 
profissional do mundo mostra que mais de 90% dos recrutadores admitem que as soft skills importam tanto ou mais 
que as competências técnicas. Trata-se de uma forma que ajuda a medir como o profissional se comporta em 
determinadas situações, além da relação com outras pessoas.” (CALIL, 2019, n. p.). 
Veremos a seguir a exposição de algumas das capacidades que o profissional deve ter. 
Capacidade de inovar 
A inovação ocorre por meio da capacidade de se pensar algo que já existe de uma maneira diferente, fugindo 
do óbvio, saindo do senso comum. O pensamento computacional está diretamente relacionado a essa habilidade, pois, 
a partir de um raciocínio diferente, você pode encontrar novas formas para resolver problemas, desde os mais simples 
aos mais complexos. 
Capacidade de planejar 
O planejamento é outra característica muito procurada pelos caça-talentos das organizações. As hierarquias 
institucionais estão cada vez mais auto-organizáveis. Em outras palavras, os profissionais conhecem os problemas 
que devem ser resolvidos e fazem seu próprio planejamento, sempre pensando em como sua atividade se encaixará 
no trabalho da equipe como um todo. Os quatro pilares aqui aprendidos potencializam o exercício dessa capacidade. 
Capacidade de aprender 
Até o século passado, o aprender consistia no fato de o estudante graduado já estar apto a exercer sua 
profissão pelo resto da vida, pois havia obtido todos os fundamentos necessários para isso. Atualmente, o 
conhecimento requer renovação constante, portanto uma das capacidades procuradas pelo mercado de trabalho é a 
aprendizagem dos novos padrões e tecnologias à medida que surgem. 
Capacidade de raciocinar logicamente 
O raciocínio lógico, muitas vezes atribuído indevidamente apenas aos matemáticos, é ferramenta com grande 
valor no mercado de trabalho. Sua aplicação na decomposição de problemas e no reconhecimento de padrões é 
indiscutível. Assim como nossas demais habilidades, quanto mais o raciocínio lógico é exercitado, mais se torna natural. 
O pensamento computacional influencia positivamente todas essas habilidades. Mais à frente, 
veremos exemplos de como esse conceito vem mudando o mundo a nossa volta. 
Atenção! 
Usar o pensamento computacional não é saber utilizar as ferramentas criadas pela tecnologia. É saber usar a 
tecnologia para criar novas ferramentas. 
Você pode aplicar o pensamento computacional para automatizar tarefas simples de seu dia a dia 
ou da empresa em que atua. 
2 - Pensamento computacional em Economia Criativa, Negócios e 
Ciências Jurídicas 
Economia Criativa 
Agora que você já sabe o que é pensamento computacional, vamos entender como ele se aplica às 
mais variadas áreas do conhecimento e como ele vem transformando o mundo a nosso redor, por meio da 
seguinte linha cronológica: 
Séc. XVIII 
A sociedade pautava sua economia em bens tangíveis de consumo desde a Primeira Revolução 
Industrial. 
Apostila de Pensamento Computacional 
Marcio Quirino - 83 
 
Séc. XXI 
A situação começou a mudar com o advento do pensamento computacional. 
2001 
O jornalista australiano PeterCoy publicou um artigo na revista americana Businessweek sobre 
uma nova modalidade econômica, que estaria se formando a partir de empresas com foco em 
conhecimento e inventividade. Assim, surgiu a expressão Economia Criativa. O governo local 
passou a incorporar, em sua estratégia política e macroeconômica, segmentos que tinham como 
base o capital intelectual e a criatividade, para impulsionar o desenvolvimento local, regional e 
nacional. 
Ao mesmo tempo, o Reino Unido incluiu pela primeira vez em sua balança comercial alguns itens, 
como: artes performáticas, artesanato, arquitetura, design, design de moda, editoração, editoração 
eletrônica, música, publicidade, rádio, TV, software, games, vídeo, cinema e fotografia. 
2007 
A Organização das Nações Unidas (ONU) se articulou, por meio da Organização das Nações 
Unidas para a Educação, a Ciência e a Cultura (Unesco) com a Conferência das Nações Unidas 
para o Comércio e o Desenvolvimento (UNCTAD), difundindo conceitos de Economia da Cultura e 
Economia Criativa em escala global. Foram desenvolvidas pesquisas sobre o setor cultural, sendo 
criada a coordenação da Rede de Cidades Criativas. Isso abriu possibilidades de desenvolvimento 
local com base em vocações criativas, conectando várias cidades do mundo que, a partir da 
obtenção do selo Cidade Criativa, passaram a compartilhar suas experiências e entrar em contato 
direto com um amplo repertório de práticas bem-sucedidas de desenvolvimento local. 
A UNCTAD afirma que o conceito de Economia Criativa está em constante evolução (UNITED 
NATIONS, 2004). Essa instituição estimula o debate para a criação de novas metodologias que gerem 
informações internacionalmente relevantes. Atualmente, podemos subdividir a Economia Criativa nos 
seguintes tipos de atividades: 
1 – Artes performáticas: Música ao vivo, teatro, dança, circo etc. 
2 – Artes visuais: Pintura, escultura, fotografia e antiguidades. 
3 – Audiovisual: Cinema, rádio, TV etc. 
4 – Edição e impressão: Livros, imprensa e outras publicações. 
5 – Expressões culturais tradicionais: Artesanato, festivais etc. 
6 – Design: Design gráfico de moda, de joias e de brinquedos. 
7 – Novas mídias: Software, games e demais conteúdos digitais. 
8 – Patrimônio cultural: Museus, bibliotecas, sítios arqueológicos etc. 
9 – Serviços criativos: Arquitetura, publicidade, recreação e pesquisa e desenvolvimento. 
A Economia Criativa, porém, não acontece sozinha. Para que seja possível, é necessário um 
ambiente propício com infraestrutura, política de incentivo e suporte tecnológico. O pensamento 
computacional é peça fundamental nessa nova área da Economia, pois é por meio dele que novas mídias 
podem ser desenvolvidas, como softwares, games e outros conteúdos digitais. 
Como tem ocorrido a prática da Economia Criativa? 
Vejamos, a seguir, sua aplicação em diversas áreas: 
Apostila de Pensamento Computacional 
Marcio Quirino - 84 
 
Biblioteca e museus 
Esses locais têm se reinventado com base na tecnologia, seja por meio de sistemas de busca mais rápidos e 
precisos para localizar suas obras, seja por hologramas, realidade virtual e outros efeitos que tornam ainda mais 
fascinantes as experiências de seus visitantes. 
Publicidade 
Essa área deixou de ser algo genérico e passou a ser direcionada exatamente para o público que pode 
converter-se em potencial consumidor. Essa inovação torna a experiência de uso melhor para os clientes, que veem 
anúncios de seu real interesse, e proporciona mais rentabilidade para as empresas, com maior retorno sobre a 
quantidade de propaganda exibida. 
Arquitetura e Design de interiores 
Essas áreas avançaram por meio de ferramentas gráficas que permitem que o cliente veja projetos em 3D ou 
até adentre sua nova casa, antes mesmo de a obra ser iniciada. O equivalente ocorre com a indústria da moda, de 
veículos, de joias, de brinquedos e de todas as outras áreas relacionadas ao Design. 
Shows e festivais 
Esses locais passaram a ser muito mais seguros e organizados a partir da tecnologia do pensamento 
computacional: desde a venda de ingressos inteligentes, que não podem ser falsificados ou revendidos ilegalmente, 
até o uso de robôs, para um ajuste perfeito dos equipamentos de som e luz. Isso sem falar dos festivais, transmitidos 
pela internet para todo o mundo, em tempo real. 
Fotografia e filmagem 
Essas áreas ultrapassaram todos os limites alcançados anteriormente por suas lentes de altíssima qualidade. 
Essa evolução ocorreu pelos inúmeros algoritmos de inteligência artificial, que corrigem cores, luzes, imperfeições e 
que, recentemente, vêm substituindo até a necessidade do uso da maquiagem, tornando as imagens capturadas 
melhores que a própria realidade. 
Cinema 
Os famosos efeitos especiais do cinema, antes exclusivos de produções milionárias como as de Hollywood, 
estão cada vez mais acessíveis devido ao barateamento da tecnologia. Isso permite que produtoras menores, de todas 
as partes do mundo, pratiquem sua criatividade e criem obras fantásticas, retratando a cultura de diferentes países e 
regiões. 
A Economia Criativa está em constante evolução com o apoio do pensamento computacional. A 
criatividade humana é inestimável e ainda insubstituível. Com o uso de algoritmos, a tecnologia é 
potencializada alcançando resultados inimagináveis. Você pode estar se perguntando: 
O pensamento computacional só afeta essa nova economia, que é movida pela criatividade? 
Isso é o que veremos a seguir. 
Reinventando o mundo dos negócios 
Os negócios tradicionais, que sempre movimentaram a economia do mundo, continuam existindo, 
mas a forma como ocorrem já é completamente diferente de 10 ou 15 anos atrás. A preocupação com a 
resiliência, a segurança e a eficiência dos negócios estão relacionadas diretamente à tecnologia. Sem ela, 
não é possível proporcionar uma boa experiência aos clientes, fazendo com que empresas sejam deixadas 
de lado e percam posicionamento no mercado. Independentemente do negócio praticado, as organizações 
precisam utilizar a tecnologia a seu favor. 
Reflexão 
Sabemos que mais do que vender um produto, as empresas devem conhecer seu cliente, suas necessidades 
e seus desejos, mas se sua empresa fosse tradicional, como se desenvolveria essa tarefa? Pense por uns instantes! 
Se pensarmos de forma tradicional, essa tarefa seria manual e cansativa, com análise feita por amostragem. No 
Apostila de Pensamento Computacional 
Marcio Quirino - 85 
 
entanto, por meio do pensamento computacional e de alguns algoritmos especializados, é possível individualizar cada 
consumidor. 
Você deve conhecer alguns casos clássicos de empresas que, por terem sua posição muito bem 
estabelecida no mercado, esqueceram da importância da inovação e não conseguiram mais acompanhar 
as mudanças no consumo. Vejamos dois exemplos a seguir: 
A Blockbuster — maior rede de locadoras de filmes e videogames no mundo, com sede no Estados Unidos 
— decretou falência em 2010, mesmo ano em que a Netflix iniciou sua expansão internacional, chegando ao Brasil em 
2011. Esta, por sua vez, fundada em 1997, iniciou-se como um serviço de entrega de DVDs pelos correios, mas soube 
se adaptar à nova realidade que se moldou no início do século, com a popularização da internet de banda larga. 
A Netflix se preocupou em compreender o perfil de seu público, antes mesmo de cogitar streaming, quando 
era apenas uma locadora. Percebeu que muitos clientes ficavam insatisfeitos por perderem o prazo de devolução e 
precisarem pagar multas, com frequência. Observando a necessidade do mercado, foi a primeira a criar um plano de 
locação mensal, com títulos ilimitados por cliente. Bastava escolher e aguardar a entrega, sem preocupações. 
Streaming 
Cada vez mais, essa tecnologia tem invadido o cotidiano das pessoas. Trata-se da transmissão de dados pela 
internet, fundamentalmente de áudio e vídeo, sem que o usuário tenha necessidade de fazer downloadou baixar esses 
dados. Isso permite que, gratuitamente ou com valores muito baixos, músicas e filmes sejam consumidos inclusive por 
smartphones de modelos mais simples. 
Além disso, o banco está, atualmente, na palma de nossas mãos, por meio de aplicativos em 
smartphones ou internet banking. Para os raros casos em que ainda precisamos de dinheiro em espécie, há 
caixas eletrônicos espalhados por shoppings, farmácias e pequenos mercados em toda a cidade. As 
transações financeiras por cartões de crédito, cada vez mais seguras, também estão mais populares e 
acessíveis. O ano de 2017 foi o primeiro em que essas operações superaram as realizadas em dinheiro, 
alcançando a marca de 23,3 trilhões em todo o mundo. 
Saiba mais 
Até o século passado, as greves dos bancários causavam comoção nacional. Saques, depósitos, 
transferências — nenhuma operação bancária era realizada durante dias. O país parava e torcia para que um acordo 
fosse realizado o mais rápido possível, para que tudo voltasse à normalidade. 
Além da forma tradicional, os cartões de crédito vêm apresentando variações por meio de aplicativos 
que geram QR Codes ou dispositivos de aproximação, que realizam pagamento com verificação biométrica 
ou reconhecimento facial. 
QR Codes 
“Evolução do código de barras [...] consiste em um gráfico 2D [...] que pode ser lido pelas câmeras da maioria 
dos celulares, encaminhando o usuário a um texto, a um endereço ou a uma imagem.” (ANDRION, 2019 ) 
E não são apenas os cartões de crédito que estão ganhando espaço. As criptomoedas, como o 
bitcoin, valorizam-se ano após ano, representando um sistema financeiro independente de governos ou 
agentes reguladores. É o que nos diz Azevedo: 
Essa criptomoeda é produzida de forma descentralizada por milhares de computadores, mantidos por pessoas 
que ‘emprestam’ a capacidade de suas máquinas para criar bitcoins e registrar todas as transações feitas. No processo 
de nascimento de uma bitcoin, chamado de ‘mineração’, os computadores conectados à rede competem entre si na 
resolução de problemas matemáticos. Quem ganha, recebe um bloco da moeda. (AZEVEDO, 2017, n. p.) 
O futuro de nossas relações econômicas ainda é incerto, mas podemos afirmar que a tecnologia 
estará presente nelas. A mudança é contínua nos paradigmas da administração do mundo dos negócios. 
Não basta aprendermos a conviver com as inovações tecnológicas atuais, precisamos estar preparados 
para todas as que ocorrerão no futuro, ano após ano. 
Apostila de Pensamento Computacional 
Marcio Quirino - 86 
 
Dessa maneira, todas as empresas que desejarem se manter competitivas precisam estar atentas 
às mudanças tecnológicas. Para isso, buscam profissionais preparados que saibam fazer bom uso do 
pensamento computacional em seu dia a dia, tornando, assim, o ambiente corporativo um lugar mais 
funcional e inovador. 
Computação no Direito 
A tecnologia evolui de forma crescente e avança sobre as mais diversas áreas de conhecimento, 
mas ela seria capaz de automatizar atividades classificadas como propriamente humanas? Será que 
poderíamos confiar a máquinas a tomada de decisões tão importantes para nossa sociedade? Estas 
perguntas vêm sendo respondidas em diversos lugares do mundo por meio de sistemas de apoio à decisão 
que, por si só, não têm autonomia para realizar escolhas, mas são de grande valia para facilitar o trabalho 
de profissionais das mais variadas áreas. 
Exemplos 
Na telemedicina, um médico auxiliado por tecnologia pode ter exames de imagem mais detalhados, 
diagnósticos facilitados, inúmeros robôs para dar mais precisão a seus movimentos. Mesmo com todas essas 
ferramentas, quem será responsável por realizar a cirurgia será o médico. E se ele souber aplicar o pensamento 
computacional para dominar toda essa tecnologia, a chance de sucesso será muito maior. 
No Brasil, em um passado muito recente, nos departamentos jurídicos das empresas, existiam pessoas 
responsáveis por verificar rotineiramente o Diário Oficial, para procurar por nomes, números de processos e outras 
informações relevantes para sua atividade. Todo esse trabalho manual, além de custoso e cansativo, poderia gerar 
erros, imprecisões ou atrasos. Hoje em dia, sistemas computacionais fazem essa verificação em minutos e com alta 
precisão, trazendo, consequentemente, vantagens financeiras para as organizações. 
Dessa forma, algumas pesquisas apontam que profissões podem ser substituídas por máquinas em 
um futuro breve. 
Curiosidade 
Certas funções relacionadas ao Direito, como assistente jurídico e paralegal, foram classificadas como de alto 
risco, mas outras funções, que envolvem inteligência social e criatividade, como as de advogado, apresentaram baixo 
risco de substituição. 
Paralegal 
“Alguém que, não sendo advogado, auxilia e assessora advogados, realizando funções paralelas e de grande 
importância para o sucesso do escritório de advocacia. Como é evidente, (esse profissional) não pode exercer 
atividades típicas de um advogado, como dar consultas ou assinar petições junto aos tribunais.” (FREITAS, 2010). 
O avanço, porém, do pensamento computacional não se limita apenas a automatizar trabalhos 
manuais. Os algoritmos vêm evoluindo para, por meio de inteligência artificial, interpretar textos, identificar 
tendências e até mesmo sugerir decisões com base nessas informações. Softwares já fazem buscas 
inteligentes na literatura jurídica, identificam os pontos mais relevantes em um processo, geram hipóteses a 
partir do aprendizado da máquina e elaboram respostas utilizando redação própria. 
Exemplo 
Um escritório de advocacia americano anunciou, em 2016, que havia contratado um robô-advogado. Tratava-
se do software ROSS Intelligence que, por meio do sistema de computação cognitiva da empresa International 
Business Machines Corporation (IBM), é capaz de utilizar inteligência artificial para realizar pesquisas jurídicas 
avançadas. Empregando linguagem comum, os advogados da empresa podem fazer perguntas ao sistema como se 
estivessem conversando com um colega de trabalho. 
Quanto mais o software é utilizado, mais elaboradas se tornam suas pesquisas, pois o algoritmo 
aprende por meio de um sistema de feedback. Esse sistema tem por objetivo diminuir os custos com pessoal 
Apostila de Pensamento Computacional 
Marcio Quirino - 87 
 
e o tempo necessário para realizar pesquisas, uma vez que pode executar milhares de instruções por 
segundo. 
Exemplo 
No estado americano de Wisconsin, outro algoritmo, denominado Correctional Offender Management Profiling 
for Alternative Sanctions (COMPAS), também ganhou muito destaque. Ele é utilizado para calcular a probabilidade de 
reincidência de um réu, baseado apenas em fatos e comportamentos, evitando, assim, erros humanos. Esse sistema 
funciona por meio de um formulário que, após preenchido e processado, gera um valor entre 1 e 10. Quanto maior é o 
valor, maior é considerada a periculosidade do indivíduo. 
O algoritmo utiliza diversos critérios para o cálculo da probabilidade de reincidência dos acusados. 
Entre eles estão: 
 
Fonte: Estácio de Sá 
Tais informações são fornecidas pelos próprios acusados ao responderem o questionário, que gera 
uma árvore de decisão. O sistema traça o perfil do suspeito e o disponibiliza para que o juiz responsável 
tome as medidas cabíveis. 
Inicialmente, a intenção do sistema era avaliar a necessidade de prisão do acusado em fases 
anteriores ao julgamento, porém, mesmo que indiretamente, o juiz e o júri acabam sendo influenciados pelo 
perfil traçado pelo algoritmo no momento de decidirem a sentença. Veja a seguir as implicações desse 
sistema: 
 
Fonte: Estácio de Sá 
Outro modelo que ganhou muita atenção foi o de Daniel Martin Katz, desenvolvido em 2014. Por 
meio de um algoritmo de aprendizado de máquina (machine learning) com métodos estatísticos, ele 
conseguiu prever 70% das decisões da Suprema Corte americana. Para isso,foram analisadas 28 mil 
decisões anteriores e mais de 240 mil votos. Utilizando apenas essas informações, as previsões foram 
realizadas. 
Apostila de Pensamento Computacional 
Marcio Quirino - 88 
 
Qual objetivo de Katz? 
O objetivo de Katz é reduzir os custos da Justiça e, consequentemente, torná-la mais acessível e 
eficiente. Seus resultados são considerados um avanço na denominada ciência da Previsão Legal 
Quantitativa — Quantitative Legal Prediction (QLP) — propiciando ampliação das potenciais aplicações de 
métodos quantitativos na análise do Direito. 
Em seu artigo, Katz afirma que chegou o momento em que softwares passarão a desenvolver tarefas 
próprias de advogados, inclusive algumas consideradas não triviais. Dessa maneira, uma vez criadas as 
soluções computacionais, a pressão pela redução de despesas forçaria escritórios e clientes a utilizarem a 
tecnologia para funções antes realizadas por equipes de operadores jurídicos. O resultado seria tão 
impactante que seria necessário repensar a própria prática do Direito. 
Após estudarmos esses três casos, podemos concluir que o pensamento computacional está cada 
vez mais presente no mundo jurídico. Apesar de não sabermos quanto tempo demorará para ele ocupar um 
espaço significativo nos tribunais brasileiros, precisamos estar preparados para essa nova realidade que 
está se desenhando, tornando-nos verdadeiros profissionais do século XXI, compreendendo e dominando 
o pensamento computacional. 
3 - Pensamento Computacional em Educação e Engenharia 
Educação no século XXI 
Após compreender a mudança que vem ocorrendo no mundo, você pode se perguntar: como 
podemos garantir que todos tenham a mesma oportunidade de sucesso nessa nova economia? A resposta 
a este questionamento não é simples, mas podemos iniciar com mudanças significativas na Educação. 
Os resultados das mudanças no campo da Educação não são de curto prazo. Uma mudança 
metodológica ou curricular pode levar uma geração inteira até ser percebida. Isso se deve à própria 
natureza do campo da Educação, que trabalha a formação do indivíduo, e não apenas o acúmulo de 
conhecimento. 
Ao longo do tempo, foi sendo desenvolvido, nas sociedades ocidentais, um pensamento mais 
utilitarista acerca da educação, que envolve questões como: 
1 - Para que aprender isso? 
2 - Para que serve? 
3 - Como se aplica? 
Essa maneira de encarar a educação desvirtua a concepção do próprio campo educacional, que 
pensa na formação como um todo, e não de forma fragmentada. Forma-se o indivíduo e o cidadão, lançando-
se mão de saberes diversos, oriundos das Ciências Humanas, Sociais, da Natureza, Exatas, Biológicas e 
afins. 
Contudo, isso não significa, de forma alguma, que a teoria esteja afastada da prática. Ao contrário, a 
educação contemporânea está cada vez mais vinculada à prática, e as tecnologias educacionais são 
ferramentas fundamentais na construção desse processo, o que transforma a aprendizagem em algo 
tangível, estimulando o interesse do aluno. 
As aulas de Matemática, muitas vezes, podem ser o terror dos estudantes, pois alguns deles não 
compreendem a importância de aprender a calcular uma equação de 2º grau, por exemplo. Muito do que 
aprendemos pode ser utilizado em situações cotidianas, enquanto outros conhecimentos servem para 
desenvolver nosso raciocínio e nos tornar capazes de resolver problemas complexos de diversas naturezas. 
Apostila de Pensamento Computacional 
Marcio Quirino - 89 
 
O desenvolvimento do pensamento crítico e de competências emocionais prepara os alunos para o 
sucesso a longo prazo. O aprendizado do pensamento computacional ajuda os jovens a desenvolver 
habilidades importantes não apenas para as disciplinas da área de Exatas, mas também de Ciências Sociais, 
Artes e Linguagem. Assim, eles serão mais capazes de articular um problema e de pensar logicamente. 
Esses aprendizados os ajudam não só a resolver problemas, mas também a perceber certas 
abordagens adotadas para a solução, ajudando a explorar causa e efeito, além de analisar como suas ações 
ou as de outras pessoas afetam a situação em questão. Essas habilidades podem ter impactos poderosos 
sobre os jovens e sobre como gerenciam seus relacionamentos com as pessoas a seu redor. 
Curiosidade 
O governo dos Estados Unidos possui uma iniciativa para preparar as crianças desde cedo para o “emprego 
do futuro”. Isso não significa simplesmente saber utilizar computadores, mas agir e tomar decisões com base nos 
quatro pilares do pensamento computacional. 
Por meio do programa Ciência da Computação para Todos, o governo dos Estados Unidos leva essa iniciativa 
a centenas de escolas por todo o país, oferecendo a crianças, principalmente a meninas e minorias, a oportunidade de 
criar suas próprias soluções para os problemas do mundo e, também, de ter melhores condições para concorrer a 
vagas no mercado de trabalho dos anos vindouros. 
Para que isso seja possível, os professores, formados em uma geração anterior, precisam receber treinamento 
especial para conhecer os diferentes tipos de abordagem para cada faixa etária, garantindo que o processo de ensino 
e aprendizagem tenha qualidade. 
É o que nos diz Blikstein a seguir: 
A inserção do pensamento computacional na escola não visa tão somente à empregabilidade, à 
competitividade e à ascensão econômica, mas principalmente à construção de competências e habilidades 
fundamentais aos seres humanos para o efetivo exercício da cidadania em uma sociedade digital. (BLIKSTEIN, 2008, 
n. p.) 
Ainda sobre os Estados Unidos, em 2010, algumas organizações propuseram um conjunto de 
ferramentas, denominadas Computational Thinking Toolkit (Kit de ferramentas para pensamento 
computacional), a fim de desenvolver as habilidades do pensamento computacional em escolas de educação 
básica. 
As ferramentas foram estruturadas em nove conceitos, baseados nos quatro pilares estudados 
anteriormente. São eles: 
 
Fonte: Estácio de Sá 
Esses nove conceitos devem ser aplicados em atividades práticas, de modo a proporcionar o 
desenvolvimento cognitivo dos alunos, substituindo, assim, a metodologia tradicional de aulas expositivas. 
Apostila de Pensamento Computacional 
Marcio Quirino - 90 
 
Dessa maneira, o aluno deixa de ser apenas um receptor passivo e passa a ser ator principal na construção 
de seu conhecimento, aumentando seu grau de entendimento e o interesse pelas aulas. 
Além dos Estados Unidos, diversos países desenvolvidos apresentam iniciativas promissoras na 
inclusão do pensamento computacional nos ensinos fundamental e médio, pois, assim como a alfabetização 
e o raciocínio lógico, quanto mais cedo se aprender o pensamento computacional, maior será a facilidade 
no processo de aprendizagem. 
Como é no Brasil? 
Atualmente, no Brasil, o ensino do pensamento computacional ainda está em fase embrionária, mas 
já há algumas iniciativas muito interessantes. A Base Nacional Comum Curricular (BNCC), homologada em 
2018, referencia diretamente o pensamento computacional em diversos trechos. A parte a seguir trata da 
progressão das aprendizagens essenciais do ensino fundamental para o ensino médio: 
A área de Matemática, no Ensino Fundamental, centra-se na compreensão de conceitos e procedimentos em 
seus diferentes campos e no desenvolvimento do pensamento computacional, visando à resolução e formulação de 
problemas em contextos diversos. (BRASIL, 2017, p. 471) 
Nesse aspecto, o pensamento computacional atua como ferramenta importante para combater a 
rejeição à Matemática, da qual tratamos anteriormente. Mas, para além disso, atua no sentido de pensar 
problemas de forma global, construindo diversas soluções possíveis. Novas habilidades e competências 
passam a ser desenvolvidas como análise e lógica, operacionalizadas a partir do conhecimento matemático 
desde a infância. 
Assim, a BNCC indica que o pensamento computacional: 
[...] envolve as capacidades decompreender, analisar, definir, modelar, resolver, comparar e automatizar 
problemas e suas soluções, de forma metódica e sistemática, por meio do desenvolvimento de algoritmos. (BRASIL, 
2017, p. 474) 
A proposta da Base Nacional Comum Curricular é criar uma familiaridade com as tecnologias e suas 
ferramentas, como planilhas eletrônicas e calculadoras, desde o ensino fundamental. 
Quando falamos nessa tecnologia, de imediato, muitos se remetem à área de Exatas, certo? 
Devemos lembrar, porém, que todas as áreas do conhecimento necessitam dessas habilidades e 
competências. 
Exemplo 
Construir gráficos a partir do domínio das planilhas eletrônicas é importante para compreender a demografia 
no estudo da Geografia, o tráfico de escravizados no estudo de História, entre tantos outros exemplos e demais 
possibilidades. 
O Ministério da Educação (MEC) incentiva o desenvolvimento de competências e habilidades 
relacionadas ao uso das tecnologias de forma transversal, presentes em todas as áreas do conhecimento. 
Além disso, aborda o assunto de forma direcionada, focando a compreensão das tecnologias e sua aplicação 
em diversas práticas sociais. 
O papel dessas tecnologias não é apenas tornar o processo de aprendizagem mais estimulante, mas 
sim trabalhar com o aluno na construção do conhecimento por meio de tais ferramentas. Na implantação do 
pensamento computacional nas escolas, esbarramos em alguns problemas. Vejamos dois deles: 
1 – A limitação das aulas de informática e a operação de editores de textos e navegadores de 
internet. 
2 – A falta de professores capacitados para aplicar esse conteúdo. 
Apostila de Pensamento Computacional 
Marcio Quirino - 91 
 
A tendência é que tal cenário mude em breve: professores de todas as áreas poderão reestruturar o 
conteúdo que lecionam para transformá-lo em um problema que possa ser solucionado a partir da aplicação 
do pensamento computacional em atividades tanto escolares quanto extracurriculares. 
Aplicação do pensamento computacional 
Vamos conhecer agora algumas ferramentas utilizadas para tornar possível a aplicação do 
pensamento computacional na área educacional. 
Bell, Witten e Fellows (2011) propõem uma técnica para ensinar Ciência da Computação por meio 
de atividades de entretenimento, sem a necessidade do uso do computador. Além de ser de fácil 
aplicação, essa técnica favorece países e lugares menos desenvolvidos, onde não há fácil acesso a 
tecnologias, fazendo, assim, um papel social. 
Utilizando jogos, atividades interativas e desenvolvimento colaborativo, essa técnica ensina 
pequenos conceitos de computação, conforme mostra a tabela a seguir: 
 
Fonte: Estácio de Sá 
Vamos ver um exemplo? No jogo de palavras, a criança deve procurar pelo conjunto de letras 
repetido e substituir por um retângulo em branco com uma seta. A imagem, a seguir, ilustra a atividade: 
 
Fonte: Estácio de Sá 
Em uma amostra pequena, a quantidade de letras economizadas parece pouca, mas quando 
aplicamos a mesma técnica em um poema completo, a economia pode ser muito grande. Veja: 
Apostila de Pensamento Computacional 
Marcio Quirino - 92 
 
 
Fonte: Estácio de Sá 
Apesar de parecer uma brincadeira ou um joguinho muito simples, essa mesma técnica é utilizada 
para compactar arquivos nos computadores. Além disso, outras ferramentas são usadas. Confira algumas 
delas: 
Plataforma Scratch: 
Oferece uma linguagem de programação visual baseada em blocos, voltada para crianças de 8 a 16 
anos, mas utilizada por pessoas de todas as idades. É disponibilizada em mais de 40 idiomas e ajuda os 
jovens a aprenderem a pensar criativamente, raciocinar sistematicamente e trabalhar em colaboração. 
Plataforma Hora do Código: 
Propõe uma experiência de uma hora de Ciência da Computação. Seu objetivo é mostrar que 
qualquer um pode aprender o básico de programação e ampliar a participação no campo 
computacional. Também com adesão mundial, já alcançou 100 milhões de alunos que 
programaram em um dos 45 idiomas disponíveis. 
O estudante pode selecionar entre os diversos temas de programação um que seja de seu 
interesse, desde a construção de um jogo simples até a criação de músicas com seleção de 
instrumentos e notas musicais. Uma vantagem dessa ferramenta é que, quando não houver 
laboratório de informática disponível para os alunos, eles poderão utilizar smartphones que, 
individualmente ou em pares, podem proporcionar o aprendizado necessário. 
Code.org: 
É uma organização sem fins lucrativos, com maior destaque e apoio direto de governos e das 
principais empresas de tecnologia (Amazon, Microsoft, Facebook, Google etc.). Seu objetivo é 
alcançar todas as crianças em todas as escolas do mundo, para que possam ter a oportunidade de 
aprender o pensamento computacional. 
Desde 2013, em parceria com todas as iniciativas vistas anteriormente, o projeto já alcançou 10% 
de todos os alunos do mundo, o que é um número incrível para tão pouco tempo, se considerarmos 
todas as desigualdades sociais do planeta. Isso foi possível devido a parcerias com mistérios da 
Educação de diversos países e apoio da Unesco. 
A Code.org é uma plataforma totalmente gratuita que oferece cursos para estudantes, treinamento 
e capacitação para professores e educadores e organiza campanhas para quebrar estereótipos 
criados em relação à Ciência da Computação. Para tornar o aprendizado mais atrativo aos 
estudantes, essas iniciativas utilizam a gamificação, expressão criada em 2002 para representar 
Apostila de Pensamento Computacional 
Marcio Quirino - 93 
 
técnicas que utilizam dinâmicas de jogos, cujo objetivo é facilitar o entendimento de determinado 
assunto por meio da interatividade e da motivação. 
Pensamento computacional e ensino da Engenharia 
Grande parte do ensino de Engenharia requer uma base sólida de Matemática, além de compreensão 
e vivência práticas. Porém, muitas mudanças recentes no ensino médio resultaram em queda nas 
habilidades e nos conhecimentos dos alunos em áreas como Aritmética e Leitura. Combinado com os alunos 
provenientes de uma distribuição geográfica maior, isso resulta em um conjunto heterogêneo de habilidades 
iniciais entre os estudantes. 
Engenharia 
Matemática 
Vivências 
Um segundo desafio está relacionado à crescente complexidade dos sistemas que os engenheiros 
recém-qualificados deverão analisar, projetar e testar em sua carreira. Não é mais adequado apenas 
compreender os princípios subjacentes. Um engenheiro graduado deve agora ter um conhecimento de 
trabalho muito mais profundo dos processos envolvidos no projeto desses sistemas complexos. 
Abordar a crescente lacuna entre as habilidades desiguais dos novos alunos e as expectativas mais 
altas dos alunos de graduação, dentro da duração limitada dos cursos típicos de Engenharia, é um desafio 
cada vez mais difícil. Para promover essa transformação, tais cursos precisam integrar o pensamento 
computacional em todos os aspectos do currículo. 
Comentário 
As experiências de várias instituições acadêmicas líderes dos Estados Unidos e da Europa demonstram que, 
quando isso é feito de forma sistemática, os alunos aprendem rapidamente conceitos matemáticos desde o início, 
usando ferramentas de software simbólicas e numéricas. Além disso, os estudantes adquirem uma compreensão mais 
profunda de programação e de Engenharia de Sistemas com o aprendizado prático baseado em projetos, por meio de 
laboratórios virtuais. 
Os alunos também aprendem a: 
Pensar de forma independente. 
Investigar e explorar ambientes. 
Aplicar as ferramentas usadas pelos engenheiros em sua profissão. 
As plataformas de programação e simulação numérica, por exemplo, o MATLAB, podem atuar como 
facilitadoras para promover a transição dos cursos tradicionais de Engenharia para os cursos modernos, em 
que os requisitos de análise definidos pelos organismos de acreditação, como o Conselho Regional de 
Engenharia e Agronomia(CREA), são atendidos. 
 
Uma superfície criada no Matlab. Fonte: Estácio de Sá 
Apostila de Pensamento Computacional 
Marcio Quirino - 94 
 
Essas plataformas permitem a integração do pensamento e das ferramentas computacionais para 
promover uma compreensão mais profunda dos princípios de Engenharia. Elas também permitem o uso de 
aplicativos simples para dar vida a conceitos, antes de incentivar e capacitar os alunos a desenvolverem 
suas próprias soluções. 
Hoje em dia, a maioria dos estudantes se sente confortável usando computadores ao iniciar 
seus estudos, mas poucos se sentem à vontade em aplicá-los para resolver problemas de 
Engenharia. Para fechar essa lacuna, o pensamento computacional e o desenvolvimento de 
habilidades associadas têm sido cada vez mais integrados ao longo do currículo. 
Embora a base matemática para o ensino dessa área seja relativamente estável, a complexidade e 
a natureza multidisciplinar dos problemas de Engenharia exigem atualmente que os cursos atendam a vários 
objetivos de aprendizado ao mesmo tempo. A capacidade de usar softwares não é apenas um requisito para 
os engenheiros de hoje, mas também uma solução que permite aos alunos colocarem em prática a teoria 
que aprenderam em sistemas reais. 
A experiência com uma variedade de ferramentas pode ajudar os estudantes a ampliar seus 
horizontes, mas esse benefício deve ser ponderado em relação à capacidade de explorar conceitos de 
Engenharia em maior profundidade, usando — e ganhando experiência com isso – o mesmo ambiente de 
ferramentas em cada ano de seus estudos. Professores em todo o mundo descobriram que o uso do mesmo 
conjunto de softwares, desde o primeiro ano até o final do curso, aprimora a experiência de aprendizado — 
particularmente quando essas mesmas ferramentas são usadas por engenheiros que trabalham com 
problemas do mundo real na indústria. 
Em vez de começar no primeiro ano de estudo com construções abstratas de programação, os alunos 
são introduzidos à computação por simulação e experimentam conceitos de Engenharia usando plataformas 
de hardware, como o LEGO Mindstorms. Essa introdução promove a retenção e ajuda a mitigar a lacuna 
de conhecimento de Matemática e Engenharia que são abordados nos semestres posteriores. As 
habilidades de programação são aprimoradas nos primeiros semestres dos cursos de Matemática e Física, 
que servem como pré-requisitos para entrar na sequência da Engenharia. 
LEGO Mindstorms 
Conjunto de hardware e software para o desenvolvimento de robôs programáveis com base em blocos de 
construção do sistema Lego — brinquedo cuja ideia principal é fazer combinações por meio do encaixe de pequenas 
peças, geralmente de plástico. 
Comentário 
À medida que o nível de conforto dos alunos com programação aumenta e a complexidade dos problemas 
estudados também, o componente de computação é estendido para incluir um simulador. 
Geralmente, os currículos de Engenharia culminam em uma série de cursos aplicados em laboratório, 
nos quais os estudantes são incentivados a demonstrar as habilidades de resolução de problemas, 
adquiridas com desenvolvimento de projetos desenvolvidos anteriormente. 
Ao ajudar a gerar entusiasmo, estabelecer um objetivo cedo e introduzir habilidades que são 
reforçadas posteriormente, a integração do pensamento computacional serve para envolver os alunos, 
mantendo-os motivados à medida que o nível de complexidade dos projetos aumenta. Isso permite aprimorar 
o aprendizado e aumentar a retenção. 
Considerações finais 
Como você deve ter percebido, há inúmeras possibilidades de utilização do pensamento 
computacional, seja nas áreas que lhe foram apresentadas, seja em tantas outras que você já identificou ou 
que identificará ao longo de sua profissão. 
Apostila de Pensamento Computacional 
Marcio Quirino - 95 
 
É muito importante que você busque conhecer cada uma das ferramentas indicadas, explorando 
possibilidades, identificando aquelas que melhor se aproximam de sua área de conhecimento e interesse. 
Afinal, como você também já sabe, as habilidades são aprimoradas na atuação prática. 
Em se tratando de pensamento computacional, essa prática está em plena transformação, o que 
exige de cada um de nós a busca incessante pelo conhecimento e pelo aprimoramento. 
Referências 
BECKER, D.; LAMEIRÃO, P. Better call ROSS. AB2L, 1 out. 2017. 
AZEVEDO, R. Entenda o que é bitcoin. Revista Exame On-line. Caderno MERCADOS, 16 jun. 2017. 
ANDRION, R. Você sabe o que é QR Code? A gente explica. Olhar Digital, 14 set. 2019. 
BELL, T.; WITTEN, I.; FELLOWS, M. Computer Science Unplugged. Christchurch: Canterbury 
University, 2011. 
BLIKSTEIN, P. O pensamento computacional e a reinvenção do computador na educação. Paulo 
Blikstein, 22 dez. 2008. 
BRASIL. Ministério da Educação. Base Nacional Comum Curricular: educação é a base. Brasília: 
MEC, 2017. 
BRASIL. Ministério do Turismo. Ministério da Cidadania. Secretaria Especial da Cultura. Assessoria 
de Comunicação. Quatro cidades brasileiras foram selecionadas para concorrer ao título de Cidade Criativa 
da Unesco. Brasília: MTur, MC, Secult, 2019. 
CALIL, M. As habilidades mais buscadas em entrevistas de emprego. Revista Exame, 14 maio 2019. 
FREITAS, V. P. de. Bacharel sem OAB poderia trabalhar como paralegal. Consultor Jurídico, 28 mar. 
2010. 
MAYBIN, S. Sistema de algoritmo que determina pena de condenados cria polêmica nos EUA. BBC 
News, 31 out. 2016. 
NEWBIGIN, J. A economia criativa: um guia introdutório. London: British Council, 2010. 
UNITED NATIONS. Creative industries and development. In: UNITED NATIONS CONFERENCE ON 
TRADE AND DEVELOPMENT, XI., 2004, São Paulo, Documents. São Paulo: Centro de Convenções do 
Anhembi, 2004. 
Explore + 
Como vimos, o pensamento computacional vem mudando o mundo a nosso redor por meio de seus 
quatro pilares. 
Para compreender melhor esses princípios, a British Broadcasting Corporation (BBC) preparou 
algumas lições bem simples e objetivas em: Computational thinking - KS3 Computing - BBC Bitesize. 
Pesquise na internet esse material, cujo original está em inglês, mas você pode usar o tradutor de seu 
navegador, se assim preferir, para fazer a leitura. 
Em relação à aplicação prática do pensamento computacional nas escolas, recomendamos que você 
acesse o site Code.org para conhecer a iniciativa.