UNDBAnálise e Desenvolvimento de Sistemas3º período
O semestre inteiro, em cinco notascurrículo revisado, checklist, glossário e laboratório — uma nota por disciplina
Cada nota pega a disciplina oficial e a reescreve como plano de estudo: o que aprender, em que ordem, com qual ferramenta e por que aquilo importa para quem quer viver de construir software. Todas abrem com uma seção “do zero” — se você nunca viu o assunto, comece por ela e o resto passa a fazer sentido.
Treino para a prova: a lista de exercícios de Estrutura de Dados tem página própria — 12 questões com passo a passo, simuladores de pilha, fila e lista encadeada, e dois quizzes cronometrados.
Os vereditos vêm da triagem de cada nota: aprofundar = vale ir além do teto do curso; profundidade média = dominar o recorte útil e deixar o resto em nível de prova; satisfazer = cumprir bem a disciplina sem gastar horas extras.
Por que estudar as cinco juntas
Elas convergem no mesmo lugar
Cada disciplina parece um assunto isolado no papel do curso. Não são: as cinco desembocam na mesma coisa — a capacidade de construir e conduzir um sistema real para um negócio real.
Nenhuma das cinco é um fim em si. Modelagem descobre o fluxo do negócio; banco guarda o que esse fluxo produz; estrutura de dados faz o código sobreviver ao crescimento; arquitetura explica onde o tempo é gasto; estatística decide se o que você mudou realmente mudou alguma coisa. Estudar cada uma apontando para o mesmo sistema é o que converte cinco notas em uma competência.
cruzamento 1
Estrutura de Dados × Arquitetura
“Array é rápido” é meia frase. A outra metade está em Arquitetura: elementos lado a lado na memória cabem juntos no cache — a estrutura é rápida porque o hardware é assim. Os tópicos ED 2.1 e ARQ 3.2 são o mesmo fato visto de dois lados.
cruzamento 2
Estrutura de Dados × Banco de Dados
O índice que faz uma consulta SQL voar é uma árvore de busca — a mesma do módulo 4 de Estrutura de Dados. Quem entendeu ED 4.2 não precisa decorar BD 4.1: já sabe por que a busca cai pela metade a cada passo.
cruzamento 3
Modelagem × Banco × Estatística
O processo mapeado em BPMN vira o esquema do banco (as entidades são os objetos que o fluxo movimenta), e as métricas do processo — lead time, taxa de erro — são exatamente o que Estatística ensina a ler sem se enganar.
Como ler qualquer uma das notas
O que há dentro de cada disciplina
Todas as cinco seguem a mesma anatomia. Aprender a ler uma é aprender a ler as cinco.
abertura
Do zero, sem jargão
A seção para quem não tem familiaridade nenhuma: o assunto explicado com analogias do mundo real antes de qualquer termo técnico. Se você é leigo, é por aqui que se entra.
a bússola
Promessa e ponte
Uma frase dizendo o que você sabe fazer ao terminar, e outra dizendo por que aquilo importa para a carreira — o critério para decidir onde gastar horas.
o plano
Currículo revisado
Cinco módulos com carga horária e sentido, reordenados para ensinar melhor do que a ordem tradicional. A ordem dos módulos é a ordem de estudo.
o controle
Checklist de tópicos
Cada tópico é uma caixa para marcar. O progresso fica salvo no seu navegador e aparece no anel lateral, no cartão da disciplina e no topo desta página.
o entendimento
Diagramas e exemplos
Todo mecanismo que a prosa não mostra vira desenho: o caminho de uma consulta, a árvore de um índice, a curva de um algoritmo, o fluxo de um processo.
a prática
Laboratório e recursos
A ferramenta concreta de cada disciplina, o primeiro passo para instalar, e a regra do laboratório — o ato que transforma leitura em capacidade. Mais os livros e vídeos que valem o tempo.
Uma advertência que vale para as cinco: ler não é estudar. Cada nota tem uma “regra do laboratório” — escrever a consulta, implementar a estrutura, desenhar o diagrama, calcular na planilha. É esse ato, e não a leitura, que move o checklist. Marque a caixa depois de fazer, nunca depois de ler.
A promessa: formado por esta disciplina, você modela os dados de um negócio real e conversa com eles em SQL fluente — projeta o esquema que não trai o cliente daqui a um ano e extrai a resposta que a pergunta de negócio pede.
Carga horária no padrão UNDB; ajustar quando o plano de ensino chegar.
Módulo zero · para quem nunca viu isso antes
Do zero, sem jargão
Se “tabela”, “chave” e “SQL” ainda soam como palavras de outra pessoa, comece aqui. Esta seção não é do currículo: é o chão que ele pressupõe. Quinze minutos de leitura e o resto da nota passa a fazer sentido.
1. O que é um banco de dados, afinal
É o lugar onde um sistema guarda o que precisa lembrar. Quando você se cadastra num site e volta no dia seguinte e ele ainda sabe seu nome, é um banco de dados fazendo isso. Todo aplicativo que você usa — o banco, o iFood, o Instagram — é, por baixo, uma pilha de telas conversando com um banco de dados.
A comparação honesta é com uma planilha: linhas, colunas, valores. Se você já usou Excel, já viu 60% da ideia. O banco de dados é o que a planilha vira quando ela precisa aguentar coisas que planilha não aguenta:
Planilha quebra quando…
Várias pessoas mexem ao mesmo tempo
Duas pessoas editando a mesma linha, e uma sobrescreve a outra sem avisar. O banco foi feito para centenas de escritas simultâneas sem que ninguém perca trabalho.
Planilha quebra quando…
Alguém digita o que não devia
Na planilha nada impede um preço negativo, um email repetido ou um pedido sem cliente. O banco recusa — você escreve as regras uma vez e ele passa a defendê-las.
Planilha quebra quando…
São milhões de linhas e perguntas cruzadas
“Quanto cada cliente do Maranhão gastou em julho, por produto?” Na planilha isso é uma tarde de trabalho manual. No banco é uma pergunta escrita em cinco linhas, que responde em milissegundos.
2. A anatomia: tabela, linha, coluna, chave
Quase todo o vocabulário do semestre está nesta única imagem. Vale demorar nela.
Tabela, linha, coluna, célula, chave. É este o vocabulário — e ele é o mesmo em qualquer banco do mundo. A única palavra que não vem da planilha é chave primária: o identificador que garante que “Ana Lopes” não vire duas pessoas diferentes se alguém a cadastrar de novo.
3. Por que não uma tabela só
A pergunta natural de quem vem da planilha: se dá para colocar tudo numa aba só, por que dividir? Porque informação repetida sempre acaba divergindo. Se o telefone da Ana está copiado em cada um dos 40 pedidos dela, mudar o telefone significa acertar 40 lugares — e bastam 39 para o banco passar a mentir.
A solução é guardar cada coisa uma vez e ligar as tabelas por um número. O pedido não guarda “Ana Lopes, São Luís, ana@mail.com”; guarda apenas cliente_id = 1 — um endereço que aponta para a linha da Ana. Esse número emprestado é a chave estrangeira, e é literalmente tudo que existe por trás da palavra “relacional”.
Se você levar uma só ideia desta seção, leve esta: um banco de dados relacional é um conjunto de tabelas que se apontam por números. Modelar é decidir quais tabelas existem; consultar é seguir esses apontamentos para juntar de volta o que foi separado.
4. Como se conversa com um banco: SQL
Você não clica no banco — você escreve uma frase para ele, em SQL. E SQL foi desenhada nos anos 70 para parecer inglês, o que a torna surpreendentemente legível: cada linha da consulta é um pedaço da frase.
O que se escreve
O que isso diz, em português
SELECT nome, email
“me mostre o nome e o email…”
FROM cliente
“…da tabela de clientes…”
WHERE cidade = 'São Luís'
“…mas só de quem é de São Luís…”
ORDER BY nome
“…em ordem alfabética…”
LIMIT 10
“…e me traga só os dez primeiros.”
Junte as cinco linhas e você tem uma consulta de verdade, do tipo que roda em produção. É este o tamanho da coisa: o módulo 1 inteiro são variações e combinações dessa frase.
5. Quem é quem — os nomes que confundem no começo
a língua
SQL
O idioma em que se fazem pedidos ao banco. Não é um programa: é uma linguagem, e quase a mesma em todos os bancos relacionais.
o programa
PostgreSQL, MySQL, SQLite
Os SGBDs — os programas que efetivamente guardam os dados e entendem SQL. Escolher um é como escolher entre Word e Google Docs: muda a ferramenta, não o idioma.
a janela
Beekeeper, DBeaver, pgAdmin
Clientes gráficos: a tela onde você digita SQL e vê o resultado em forma de tabela. Não guardam nada — são só a vitrine do banco.
o desenho
Esquema e modelo ER
O mapa de quais tabelas existem e como se ligam. O modelo ER é esse mapa desenhado no papel, antes de existir banco nenhum — é o assunto do módulo 2.
Pronto para o resto da nota. Daqui em diante, quando aparecer “junção”, leia “juntar duas tabelas seguindo o número que uma guarda da outra”; quando aparecer “normalizar”, leia “separar em tabelas para não repetir informação”. Todo o resto são detalhes destas duas frases.
Por que esta disciplina importa
Ponte com a trajetória
SQL é inegociável na carreira dev (todo posting pede) e é a espinha de qualquer sistema que você construir para cliente — site com conteúdo, dashboard, automação. Modelagem de dados é irmã da sua arquitetura de informação: os dois ofícios são “dar forma estruturada ao que o negócio significa”.
Veredito: aprofundar além do teto do curso — junto com Estrutura de Dados, a dupla mais valiosa do semestre.
68 horas, cinco módulos
Currículo revisado
Nota de ordem: SQL de leitura vem antes de modelagem de propósito — consultar dados dá fome de entender como eles são desenhados. Cursos costumam fazer o inverso e perder o aluno na teoria.
modelar e construir o banco de um negócio seu, de ponta a ponta
Como usar: siga o checklist na ordem dos módulos — a ordem deles já é a ordem de estudo. O capstone pode começar cedo: a partir do módulo 2 você já modela o domínio; cada módulo seguinte adiciona uma camada ao mesmo banco. Se algum termo da tabela acima ainda for opaco, a seção “Do zero” cobre o vocabulário que estes cinco módulos pressupõem.
Módulo 1 · 18h
SQL de leitura
Fazer perguntas a dados e obter respostas. É o que você usa todo dia — e o que toda vaga cobra.
Checklist
8 tópicos
0/8
A consulta não roda na ordem em que é lida.FROM monta o conjunto de linhas, WHERE corta, GROUP BY resume, HAVING corta os grupos — e só então SELECT escolhe as colunas. Daí duas regras que parecem arbitrárias e não são: WHERE não enxerga apelido criado no SELECT, e filtro de agregado (SUM(...) > 1000) vai no HAVING, nunca no WHERE.
A junção é uma pergunta sobre correspondência. Ana casa duas vezes (duas linhas no resultado — junção multiplica, não “cola lado a lado”). Bruno não casa: o INNER o descarta, o LEFT o mantém e preenche com NULL. É por isso que “clientes que nunca compraram” se escreve LEFT JOIN … WHERE pedidos.num IS NULL.
1.8 na prática — a pergunta de negócio “quais clientes não compram há 90 dias?” traduzida:
-- um cliente por linha, com a data da última compraSELECT c.nome, MAX(p.data) AS ultima_compra
FROM clientes c
LEFT JOIN pedidos p ON p.cliente_id = c.id
GROUP BY c.id, c.nome
HAVINGMAX(p.data) < CURRENT_DATE - INTERVAL'90 days'ORMAX(p.data) IS NULL-- nunca comprouORDER BY ultima_compra NULLS FIRST;
Módulo 2 · 14h
Modelagem: do negócio ao esquema
Traduzir um negócio real em entidades e relações. É aqui que se decide se o banco vai trair o cliente daqui a um ano.
Checklist
7 tópicos
0/7
A cardinalidade não é rótulo: é uma constraint. O 1:N entre cliente e proposta é a FK em proposta. O 1:1 é a mesma FKmais um UNIQUE — sem ele, nada impede duas propostas virarem o mesmo engajamento. E o N:M não tem como existir entre duas tabelas: precisa da terceira, cuja chave primária é o par.
2.4 — Normalização, em uma planilha que dói
O ponto de partida de quase todo iniciante: uma tabela só, larga, que parece prática e mente três vezes.
pedido_id
cliente
cliente_cidade
uf
itens
1001
Ana Lopes
São Luís
MA
teclado, mouse, hub
1002
Ana Lopez
São Luís
MA
monitor
1003
Bruno Sá
Sao Luis
MA
cadeira, apoio
1FN — atomicidade
“teclado, mouse, hub” em uma célula
Uma célula, um valor. Enquanto três produtos moram numa string, não há como contar itens, somar valor nem filtrar por produto — só truque de texto. Correção: uma linha por item, em pedido_item.
2FN — dependência parcial
“Ana Lopes” repetido a cada pedido
O nome do cliente depende do cliente, não do pedido. Repetido, ele diverge: Ana Lopes e Ana Lopez viram duas pessoas para o banco. Correção: o cliente vira tabela; o pedido guarda só a FK.
3FN — dependência transitiva
cidade e UF penduradas no pedido
A cidade depende do cliente, que depende do pedido — dois saltos. São Luís e Sao Luis convivem, e corrigir a cidade de alguém exige varrer todos os pedidos. Correção: cidade mora junto do cliente, em um só lugar.
Uma frase para levar: normalizar é garantir que cada fato viva em um só lugar. Toda anomalia de banco iniciante — duplicata que diverge, exclusão que apaga o que não devia, atualização que esquece uma linha — é um fato morando em dois lugares.
2.5 — E quando desnormalizar? Relatório lê e não escreve: se o total do pedido já está calculado numa coluna, ninguém corre risco de contradizê-lo — não há segunda escrita. Sistema transacional escreve o tempo todo, e cada cópia é uma chance de divergir. Daí a regra: relatórios perdoam o que sistemas não perdoam.
Módulo 3 · 12h
SQL de escrita e desenho físico
Criar, alimentar e alterar esquemas com segurança — inclusive contra você mesmo às onze da noite.
Checklist
5 tópicos
0/5
3.1 — cada constraint é uma regra do negócio
CREATE TABLE proposta (
id bigserialPRIMARY KEY,
cliente_id bigintNOT NULLREFERENCES cliente(id),
valor numeric(12,2)NOT NULLCHECK (valor > 0),
status textNOT NULLDEFAULT'rascunho'CHECK (status IN ('rascunho',
'enviada','aceita','recusada')),
criada_em timestamptzNOT NULLDEFAULT now()
);
Cada linha carrega uma frase que o cliente diria em voz alta: “proposta é sempre de alguém”, “não existe proposta de valor zero”, “status é um destes quatro”. Constraint é regra de negócio que o banco recusa violar — não confie na aplicação para isso.
3.2 — o hábito que salva a noite
-- 1. escreva primeiro como SELECTSELECT * FROM proposta
WHERE status = 'enviada'AND criada_em < CURRENT_DATE - 30;
-- 2. confira a contagem. só então:BEGIN;
UPDATE proposta SET status = 'recusada'WHERE status = 'enviada'AND criada_em < CURRENT_DATE - 30;
-- olhe o número de linhas afetadasCOMMIT; -- ou ROLLBACK, se assustou
UPDATE sem WHERE atinge a tabela inteira, em silêncio e sem confirmação. Escrever o WHERE antes do SET, rodar como SELECT primeiro e abrir transação são três hábitos baratos que evitam o desastre caro.
3.4 — a view como móvel da casa: quando a mesma consulta é reescrita pela terceira vez, ela deixou de ser pergunta e virou parte da estrutura. CREATE VIEW lhe dá um nome, e a definição passa a viver num lugar só — a mesma economia da normalização, aplicada a consultas.
Módulo 4 · 12h
O banco por dentro
Índices, transações e por que consultas ficam lentas. O módulo que separa quem usa banco de quem entende banco.
Checklist
6 tópicos
0/6
Índice é o índice remissivo do livro. Sem ele, achar maria@… exige ler a tabela inteira; com ele, o banco desce a árvore e chega em três saltos — e o número de saltos quase não cresce quando a tabela cresce. A conta tem outro lado: o índice ocupa espaço e toda escrita passa a manter a árvore. Por isso se indexa o que se busca, não tudo. EXPLAIN é onde você lê qual dos dois caminhos o banco escolheu — Seq Scan ou Index Scan.
A transação existe por causa do instante entre os dois UPDATE. Nele o dinheiro não está em lugar nenhum — e é exatamente esse estado que a atomicidade proíbe de sobreviver. O isolamento é o mesmo problema visto de fora: enquanto A e B estão no meio da transferência, outra sessão não pode somar os saldos e achar que faltam R$ 100.
4.5 · noção honesta
O que o NoSQL troca
Documento e chave-valor compram flexibilidade de forma e escala horizontal vendendo junções, constraints e, muitas vezes, garantias transacionais. Para um catálogo de formas irregulares ou um cache, é bom negócio. Para propostas, engajamentos e pagamentos que precisam bater, você está vendendo justamente o que precisa.
4.6 · dever de casa do autônomo
Backup que você já restaurou
pg_dump agendado é metade do serviço. A outra metade é pg_restore num banco vazio, feito ao menos uma vez — backup nunca testado é hipótese, não garantia. Um cliente perdoa lentidão; não perdoa perda de dado.
Módulo 5 · 12h
Capstone: o banco da prática
Modelar e construir o banco de um negócio seu, de ponta a ponta — a peça que fica no portfólio e um dia vira o CRM real.
Checklist
5 tópicos
0/5
MÓD. 2Domínio e ERentidades, relações e cardinalidades do negócio no papel
MÓD. 2Esquema normalizadoER traduzido em tabelas, chaves e 3FN
MÓD. 3ConstruçãoCREATE TABLE com constraints e carga de dados realistas
MÓD. 1As 10 perguntasas consultas que o dono do negócio realmente faria
MÓD. 4Ajuste e publicaçãoíndices onde o EXPLAIN pedir, README e GitHub
O capstone não começa no módulo 5 — ele termina nele. Cada módulo anterior adiciona uma camada ao mesmo banco, e o que o módulo 5 faz é fechar, documentar e publicar.
18 termos, em ordem de aparição
Glossário
Os termos que esta nota (e o semestre) usam como se você já os conhecesse. Ler de cima a baixo é uma miniatura do curso.
18 termos
Termo
O que é, em uma linha
Banco de dados relacional
Um sistema que guarda dados em tabelas que se referenciam entre si — o modelo dominante há 50 anos.
SGBD
O software que administra o banco (PostgreSQL, MySQL…) — o banco é o acervo; o SGBD é o bibliotecário.
Tabela
O contêiner básico: linhas (registros — “um cliente”) e colunas (campos — “nome”, “email”).
SQL
A linguagem padrão para conversar com bancos relacionais — tanto para perguntar quanto para criar e alterar.
Consulta (query)
Uma pergunta escrita em SQL: “quais clientes compraram este ano?” vira um SELECT.
Junção (JOIN)
A operação que combina duas tabelas pelas suas relações — “clientes com seus pedidos” — o coração do SQL.
NULL
A ausência de valor numa célula — nem zero nem vazio: desconhecido — e fonte clássica de resultados surpreendentes.
Agregação
Resumir muitas linhas em um número: soma, média, contagem — a base de qualquer relatório.
Modelo ER
O diagrama entidade-relacionamento: o desenho de o que existe no negócio (entidades) e como se conecta, feito antes de criar tabelas.
Chave primária
A coluna que identifica cada linha unicamente (o “CPF” da tabela).
Chave estrangeira
Uma coluna que aponta para a chave primária de outra tabela — é o que materializa uma relação.
Normalização
O método de organizar tabelas para que cada fato viva em um só lugar — sem duplicação, sem contradição.
Esquema (schema)
O desenho completo do banco: quais tabelas, colunas, tipos e relações existem.
Migração (migration)
Uma alteração de esquema registrada como script versionado — como o banco evolui sem caos.
Índice
Estrutura auxiliar que acelera buscas numa coluna (como o índice remissivo de um livro) — em troca de espaço e escrita mais lenta.
Transação
Um grupo de operações que ou acontece inteiro ou não acontece — o que impede débito sem crédito numa transferência.
ACID
As quatro garantias das transações (atomicidade, consistência, isolamento, durabilidade) — o contrato de confiabilidade do banco.
NoSQL
A família de bancos não-relacionais (documentos, chave-valor) — troca as garantias relacionais por flexibilidade/escala em casos específicos.
Onde o estudo encosta em dado real
Laboratório
A ferramenta
PostgreSQL
O SGBD open-source mais respeitado do mercado; um programa que roda na sua máquina e guarda bancos de verdade. Acompanhado de um cliente gráfico — Beekeeper Studio ou DBeaver, ambos gratuitos: a janela onde você digita SQL e vê os resultados em tabela.
Para começar
Três instalações e um banco pronto
Instalar o Postgres (brew install postgresql no Mac, ou o instalador oficial), instalar o Beekeeper, conectar em localhost — e importar um banco de exemplo pronto (o clássico Northwind para Postgres: uma empresa fictícia com clientes, produtos e pedidos) para ter dados reais para interrogar desde o primeiro dia.
O ato recorrente — a regra do laboratório:todo tópico estudado termina com SQL digitado por você contra um banco real. No módulo 1, cada conceito vira 3–5 consultas suas contra o Northwind — não copiadas: formuladas a partir de uma pergunta de negócio que você inventa. Do módulo 2 em diante, o alvo muda para o banco da prática DxE que você mesmo vai modelar e construir; cada módulo adiciona uma camada ao mesmo banco, até ele ser o capstone completo.
O que ler, ver e praticar
Recursos
Recurso
Serve a
Livro principal:Learning SQL (Alan Beaulieu, O’Reilly)
Mód. 134
Livro de apoio:Database Design for Mere Mortals (Michael Hernandez)
Mód. 25 modelagem como ofício
Curso em vídeo: CS50 SQL (Harvard/Malan, gratuito)
Mód. 134 na ordem
Interativo: SQLBolt (sqlbolt.com)
Mód. 1 os primeiros 30 minutos de cada tópico
Apêndice
Plano oficial
Plano de ensino ainda não disponível — colar aqui quando chegar e mapear: tópico oficial → código revisado; o que cai em prova; o que o plano omite.
Triagem antecipada
Aprofundar
Risco previsível do curso: ficar longo demais em álgebra relacional formal e diagramação, e curto demais em SQL fluente — se acontecer, os módulos 1 e 3 daqui são o antídoto. Se o curso usar MySQL, siga o curso na prova e o PostgreSQL no laboratório; a diferença é pequena e a tradução é instrutiva. O curso quase certamente ensinará modelagem antes de SQL — sem problema: acompanhe a prova na ordem deles, estude na ordem daqui.
Alavanca de projeto
O trabalho da disciplina vira o capstone
O trabalho da disciplina vira o capstone 5.x apontado para a prática DxE — o banco que um dia vira o CRM/pipeline real do seu negócio. Cenário inventado, nunca.
A promessa: formado por esta disciplina, você deixa de ser alguém que usa arrays e objetos por hábito e passa a ser alguém que escolhe a estrutura certa para cada problema e prevê como o código se comporta quando os dados crescem — a diferença entre usar uma biblioteca e entender o que ela faz.
Carga horária no padrão UNDB; ajustar quando o plano de ensino chegar.
Prova chegando? A lista de exercícios do professor está destrinchada em página própria: as 12 questões com dica, passo a passo e solução comentada, três simuladores (pilha, fila e lista encadeada) e dois quizzes para treinar sem consultar.
Módulo zero · para quem nunca viu isso antes
Do zero, sem jargão
Esta é a disciplina com o nome mais intimidante do semestre e o conteúdo mais concreto. Se “Big-O”, “lista ligada” e “árvore binária” ainda parecem coisa de outro planeta, quinze minutos aqui resolvem — o assunto inteiro cabe em duas ideias.
1. Guardar não é só guardar
Imagine que você precisa organizar mil fichas de clientes. Você pode empilhá-las numa caixa — rápido de guardar, terrível de achar. Pode alinhá-las numa estante numerada — achar a de número 738 é instantâneo, mas inserir uma no meio obriga a empurrar todas as outras. Pode organizá-las por ordem alfabética — achar “Silva” é rápido porque você abre no meio e descarta metade.
Pronto: você acabou de inventar array, lista e árvore de busca. Uma estrutura de dados é uma decisão sobre qual operação você quer que seja barata — e toda escolha torna outra coisa cara. Não existe estrutura melhor; existe estrutura certa para o que você mais faz.
2. A segunda ideia: o que acontece quando cresce
Um código que roda em 0,2 segundo com 100 clientes pode levar seis horas com 100 mil. Não porque a máquina piorou — porque o método escolhido cresce mal. A disciplina chama isso de complexidade, e a notação para escrever isso se chama Big-O. É só isso: uma forma de dizer “se os dados dobrarem, o tempo dobra / quadruplica / quase não muda”.
As duas frases que a disciplina inteira desdobra: (1) cada estrutura torna barata uma operação e cara outra; (2) o que importa não é quanto o código demora hoje, mas como esse tempo cresce quando os dados crescem.
3. As seis formas que você vai encontrar a vida inteira
Existem centenas de estruturas. Estas seis cobrem quase tudo que um dev usa — e você já usa quase todas sem saber o nome.
Você já usa todas. O array do JavaScript é a primeira; o histórico do Ctrl+Z é uma pilha; a fila de mensagens de um app é uma fila; Map e Object são tabelas hash; o HTML da página aberta agora é uma árvore. A disciplina não apresenta coisas novas — ela dá nome, preço e regra de uso ao que você já manuseia no escuro.
4. E “algoritmo”?
Uma receita: uma sequência finita de passos que resolve um problema. Toda função que você escreve é um algoritmo. Ordenar uma lista, achar o maior número, montar uma rota — cada um tem várias receitas possíveis, e elas custam preços diferentes. Metade da disciplina é conhecer as estruturas; a outra metade é conhecer as receitas clássicas e o preço de cada uma.
Um aviso de tradução. O curso provavelmente ensinará tudo isto em C ou Java. Você escreve TypeScript. Não é problema — é vantagem: traduzir cada conceito para o seu stack força o entendimento real, porque não dá para traduzir o que não se entendeu. É o que o laboratório desta nota manda fazer.
Por que esta disciplina importa
Ponte com a trajetória
Esta é a disciplina mais estruturante do semestre para a carreira dev. Todo código JS/TS que você escreve já é estrutura de dados (arrays, objects, Maps, o DOM é uma árvore, o roteamento é um grafo); entrevistas técnicas são majoritariamente isto; e a intuição de complexidade é o que separa sistemas que escalam de sistemas que morrem com o cliente dentro.
Veredito: aprofundar além do teto do curso — junto com Banco de Dados, a dupla mais valiosa do semestre.
ordenar, buscar, e implementar a caixa de ferramentas inteira em TypeScript
Como usar: siga o checklist na ordem dos módulos — a ordem deles já é a ordem de estudo. Os recursos ao final dizem com o quê estudar cada módulo.
Módulo 1 · 10h
Complexidade e o custo das coisas
Ler o preço de um algoritmo antes de pagá-lo. Dez horas que mudam como você olha para qualquer código pelo resto da vida.
Checklist
5 tópicos
0/5
A forma da curva é a única coisa que importa. Big-O ignora constantes e detalhes de máquina porque, quando n cresce, a forma vence tudo: um O(n²) escrito por um gênio em C perde para um O(n log n) escrito por um iniciante em JavaScript, desde que os dados sejam grandes o bastante. Perceba onde as curvas se cruzam — antes desse ponto, o algoritmo “pior” pode ser o mais rápido; é por isso que a análise fala de crescimento, não de velocidade.
O gráfico convence os olhos; a tabela convence a intuição. Contagem aproximada de operações:
Complexidade
n = 10
n = 1.000
n = 1.000.000
Exemplo típico
O(1)
1
1
1
acessar arr[500], ler map.get(k)
O(log n)
3
10
20
busca binária, descer uma árvore de busca
O(n)
10
1.000
1.000.000
find, includes, somar tudo
O(n log n)
33
10.000
20.000.000
sort — o melhor preço possível para ordenar
O(n²)
100
1.000.000
1.000.000.000.000
dois laços aninhados sobre a mesma lista
Leia a última célula em voz alta. Um trilhão de operações é ordem de horas de processamento — para uma tarefa que o O(n log n) resolve em segundos. Quase todo “o sistema travou quando a base cresceu” é um laço dentro de outro laço que ninguém notou enquanto a base era pequena.
Módulo 2 · 16h
Estruturas lineares
O que arrays e listas realmente são por baixo do JavaScript — e por que a resposta muda as suas escolhas.
Checklist
6 tópicos
0/6
A diferença inteira está no endereço. No array, a posição é uma conta aritmética sobre o endereço inicial — por isso o acesso não depende do tamanho. Na lista ligada não há conta: cada nó só conhece o vizinho, então chegar ao quarto exige passar pelos três primeiros. Em compensação, inserir no meio do array desloca tudo o que vem depois, enquanto na lista custa duas atribuições. Em JavaScript, na prática, o array quase sempre ganha — o custo do deslocamento é pago por memória contígua e cache (o assunto do módulo 3 de Arquitetura), enquanto cada nó espalhado é um salto que o processador não consegue prever.
Módulo 3 · 14h
Hash, pilhas e filas
As estruturas que resolvem 80% dos problemas reais — e as três que mais aparecem em entrevista.
Checklist
6 tópicos
0/6
Duas regras de porta, e nada mais. Pilha e fila não são estruturas novas — são restrições impostas sobre uma lista: só se mexe nas pontas, e a escolha de qual ponta define tudo. A pilha lembra a ordem inversa dos acontecimentos (por isso serve para desfazer e para voltar de uma função); a fila preserva a ordem de chegada (por isso serve para trabalho pendente e para explorar um grafo camada por camada).
É por isso que Map e Object parecem mágica. A chave não é procurada: é convertida em endereço por uma conta. O preço da mágica são as colisões — duas chaves diferentes que caem no mesmo balde — e é lidar com elas que ocupa todo o design de uma tabela hash. O O(1) é uma média com boa função de hash e espaço sobrando, não uma garantia.
Módulo 4 · 16h
Árvores e grafos
As estruturas de tudo que é hierárquico ou conectado — o DOM, as rotas do app, as dependências do package.json.
Checklist
8 tópicos
0/8
A árvore de busca é o “abrir o dicionário no meio” virado estrutura. Cada comparação joga fora metade do que sobrou: é isso, e só isso, que o O(log n) significa. Mas a mágica é condicional: inserir dados já ordenados produz uma corrente, não uma árvore, e o custo volta a ser O(n). É o mesmo mecanismo do índice de banco de dados — a árvore B do módulo 4 de Banco de Dados é uma prima gorda desta, feita para caber em blocos de disco.
4.6–4.7 · grafo
Quando a hierarquia vira rede
Árvore é um grafo com regra: cada nó tem um pai só, e não há ciclo. Tire a regra e você tem um grafo — o mapa de ruas, a rede de amigos, as dependências entre pacotes (onde um ciclo significa exatamente aquele erro de importação circular).
4.7 · BFS e DFS
Duas maneiras de explorar
Em largura (BFS) visita camada por camada e usa uma fila — é o que encontra o caminho mais curto. Em profundidade (DFS) vai fundo até o fim e volta, usando uma pilha (ou recursão) — é o que detecta ciclos. Note que as estruturas do módulo 3 reaparecem aqui como motor: não é coincidência, é o desenho do curso.
Módulo 5 · 12h
Algoritmos clássicos + capstone
Ordenar, buscar, e implementar a caixa de ferramentas inteira em TypeScript — o repositório que vira peça de portfólio.
Checklist
5 tópicos
0/5
Estrutura
Acessar
Buscar
Inserir
Use quando…
Array
O(1)
O(n)
O(n)
a ordem importa e você acessa por posição — o padrão
Lista ligada
O(n)
O(n)
O(1)
insere e remove muito nas pontas, e nunca acessa por índice
Pilha / Fila
—
—
O(1)
a ordem de saída é a regra do problema (desfazer, tarefas, BFS)
Tabela hash
—
O(1)*
O(1)*
você busca por uma chave e não se importa com ordem
Árvore de busca
O(log n)
O(log n)
O(log n)
precisa de busca rápida e de percorrer em ordem
* média, com boa função de hash e sem excesso de colisões. Esta tabela é o resumo executivo da disciplina — se você souber reconstruí-la de cabeça e justificar cada célula, os 30 tópicos foram aprendidos.
MÓD. 2LinkedList.tslista simples e duplamente ligada, com testes
MÓD. 3Stack · Queue · HashTableas três que resolvem o dia a dia
MÓD. 4BST · Graphárvore de busca e grafo com BFS e DFS
MÓD. 5README e publicaçãocada estrutura com sua tabela de complexidade
18 termos, em ordem de aparição
Glossário
Os termos que esta nota (e o semestre) usam como se você já os conhecesse. Ler de cima a baixo é uma miniatura do curso.
18 termos
Termo
O que é, em uma linha
Estrutura de dados
Uma forma organizada de guardar dados na memória para que certas operações (buscar, inserir, remover) fiquem baratas.
Algoritmo
Uma receita de passos finitos que resolve um problema — toda função que você escreve é um.
Complexidade
O quanto um algoritmo custa (em tempo ou memória) à medida que os dados crescem — não quanto demora hoje, mas como escala.
Big-O
A notação dessa escala: O(n) = custo cresce junto com os dados; O(n²) = cresce ao quadrado; O(1) = não cresce.
Array
A estrutura mais básica: elementos lado a lado na memória, acessados por posição (índice).
Ponteiro / referência
Um valor que não é o dado, mas o endereço de onde o dado está — o que permite estruturas ligadas.
Nó
A unidade das estruturas ligadas: um pacotinho com o dado + referência(s) para outros nós.
Lista ligada
Corrente de nós, cada um apontando para o próximo — cresce fácil, mas não tem acesso direto por posição.
Pilha (stack)
Estrutura onde só se mexe no topo: o último a entrar é o primeiro a sair (como pilha de pratos).
Fila (queue)
O oposto: o primeiro a entrar é o primeiro a sair (como fila de banco).
Tabela hash
Estrutura que transforma uma chave (“nome”) num endereço direto via uma função matemática — busca quase instantânea; é o que existe por trás de Map e Object no JS.
Colisão
Quando duas chaves diferentes caem no mesmo endereço da tabela hash — todo o design de hash é lidar com isso.
Árvore
Estrutura hierárquica: um nó raiz com filhos, que têm filhos — o DOM de uma página é uma árvore.
BST (árvore binária de busca)
Árvore com regra de ordem (menores à esquerda, maiores à direita) que torna a busca logarítmica — cada passo descarta metade.
Percurso (traversal)
Qualquer método sistemático de visitar todos os nós de uma árvore ou grafo.
Grafo
Rede de nós (vértices) conectados por ligações (arestas) — mapas, redes sociais, dependências entre pacotes.
BFS / DFS
As duas formas canônicas de explorar um grafo: em largura (camada por camada) ou em profundidade (um caminho até o fim, depois volta).
Recursão
Função que chama a si mesma para resolver versões menores do mesmo problema — a linguagem natural de árvores.
Onde o estudo vira capacidade
Laboratório
A ferramenta
TypeScript + Vitest
TypeScript rodando no VS Code, com Vitest — uma biblioteca que executa testes automáticos: você escreve “espero que buscar(5) devolva verdadeiro”, roda, e ela confirma ou acusa o erro.
Para começar
Um repositório e uma pasta por módulo
Um repositório novo (data-structures-ts), criado com npm create vite@latest — ou só npm init + npm i -D vitest typescript. Uma pasta por módulo.
O ato recorrente — a regra do laboratório:nenhuma estrutura é considerada estudada até existir implementada e testada por você. Estudou lista ligada → escreve LinkedList.ts + um teste que insere, remove e busca. Estudou hash → HashTable.ts. O ciclo é sempre: ler/assistir → implementar do zero (sem copiar) → testar → só então marcar o tópico no checklist. É esse ciclo que transforma leitura em capacidade — e o repositório resultante é o capstone 5.5, peça de portfólio.
O que ler, ver e praticar
Recursos
Recurso
Serve a
Livro principal:Entendendo Algoritmos (Aditya Bhargava, trad. do Grokking Algorithms)
Mód. 1345 visual, direto, do tamanho certo
Livro de apoio:Learning JavaScript Data Structures and Algorithms (Loiane Groner — autora brasileira, exemplos em JS)
Mód. 2–5 a implementação no seu stack
Vídeo: CS50 (Harvard/Malan), semanas de Data Structures
Mód. 23 a memória vista de perto
Vídeo: série Estruturas de Dados do canal Programação Dinâmica (PT-BR)
Mód. 2–4
Apêndice
Plano oficial
Plano de ensino ainda não disponível — colar aqui quando chegar e mapear: tópico oficial → código revisado; o que cai em prova; o que o plano omite.
Triagem antecipada
Ultrapassar o teto do curso
É das poucas disciplinas do período cujo conteúdo canônico é estável e universal; qualquer aula fraca é contornável com os recursos acima. Linguagem provável do curso: C ou Java — traduza cada conceito para TS por conta própria; a tradução é o aprendizado.
Alavanca de projeto
Todo trabalho vira commit do capstone
Qualquer trabalho ou seminário da disciplina vira desculpa para o repositório do capstone 5.5 — entregue à escola o recorte que ela pedir, mas construa no seu repositório, no seu stack, como peça de portfólio.
Como usar: em cada questão, tente antes de abrir a solução. Os botões liberam ajuda em três níveis — dica, passo a passo e código comentado. Abrir a solução direto dá a sensação de aprender sem o aprendizado; o esforço de tentar é o que fixa.
Se o tempo é curto, esta é a ordem
Plano de ataque
A lista tem 12 questões, mas não pesam igual. Esta é a ordem de maior retorno por minuto — e o que fazer se sobrar pouco tempo.
é a colinha — depois de fazer as 11 anteriores, você a escreve de cabeça
0%
0/12 questões dominadas
Marque “consigo fazer sozinho” em cada questão só depois de escrever a resposta sem olhar. O número aqui em cima é o seu termômetro real para amanhã.
Domine isto e as 12 caem juntas
As cinco ideias que a lista inteira cobra
As 12 questões são cinco ideias disfarçadas. Quem entende as cinco resolve qualquer variação que o professor invente — inclusive as que não estão nesta lista.
Esta imagem responde as questões 1, 2 e 4 — e metade do quiz. A pergunta que decide tudo é uma só: “o segundo laço roda depois do primeiro, ou dentro dele?” Depois → soma. Dentro → multiplica. Não existe terceiro caso.
ideia 2
Uma passada, acumulando
Questões 3, 4 e 5 são o mesmo exercício com roupas diferentes: crie os acumuladores antes do laço, percorra uma vez atualizando todos, devolva no fim. Quem enxerga o padrão não precisa decorar nenhuma delas.
ideia 3
A estrutura vem do acesso
Não escolha pela “cara” do dado, escolha por como você vai buscá-lo: por posição → list; registro fixo que não muda → tuple; pertence ou não, sem repetir → set; busca por uma chave → dict.
ideia 4
Pilha e fila: a mesma lista, outra porta
Nenhuma das duas é estrutura nova — são restrições sobre uma lista. Só o topo, e o último entra primeiro a sair: pilha (LIFO). Entra por uma ponta e sai pela outra: fila (FIFO). A regra da porta é toda a diferença.
ideia 5
Nó = valor + endereço do próximo
Uma lista encadeada não tem índice, tem corrente. Cada nó guarda o dado e a referência ao seguinte. Toda operação — inserir, remover — é religar setas na ordem certa, e a ordem errada perde o resto da lista.
Parte I · Questões 1 e 2
Análise de complexidade
Questão 1
Dois laços em sequência
Considere o código. a) Determine a complexidade temporal usando Big-O. b) Explique por que os dois laços não resultam em O(n²).
def algoritmo(n):
for i in range(n):
print(i)
for j in range(n):
print(j)
o que está sendo testado se você sabe distinguir laços sequenciais de laços aninhados — e se sabe que constantes somem no Big-O.
Dica. Olhe a indentação. O segundo for está no mesmo nível do primeiro, ou dentro dele? Conte quantos print acontecem no total quando n = 5.
Passo a passo.
O primeiro laço executa printn vezes.
Quando ele termina, o segundo começa — e executa mais n vezes.
Total: n + n = 2n operações. Com n = 5: 5 + 5 = 10 prints.
Para ser O(n²), o segundo laço teria que rodar inteiro para cada volta do primeiro — ou seja, estar indentado dentro dele. Não está.
a) A complexidade é O(n) — linear.
b) Porque os laços são sequenciais, não aninhados. Um roda depois que o outro termina, então os custos se somam (n + n = 2n) em vez de se multiplicarem. Em O(n²) o laço interno executaria n voltas completas a cada uma das n voltas do externo, dando n × n. Como 2n cresce em linha reta com n — dobrar a entrada dobra o tempo — a constante 2 é descartada e a classe é O(n).
variação que pode cair e se houvesse três laços sequenciais? (3n → ainda O(n)) E se o segundo fosse for j in range(100)? (n + 100 → O(n), porque 100 não cresce com n)
Questão 2
Linear contra quadrático
a) Determine a complexidade de cada algoritmo. b) Qual tem melhor desempenho para listas grandes? c) Para uma lista de 10.000 elementos, explique por que o segundo se torna impraticável.
def algoritmo1(lista):
for x in lista:
print(x)
def algoritmo2(lista):
for i in range(len(lista)):
for j in range(len(lista)):
print(lista[i], lista[j])
o que está sendo testado se você consegue quantificar a diferença — e não só nomear as classes.
Dica. No item (c) o professor quer um número, não um adjetivo. Calcule 10.000 × 10.000 e transforme em tempo: um computador faz na ordem de 10 milhões de print por segundo (o print é lento justamente por escrever na tela).
Passo a passo.
algoritmo1: um laço percorrendo a lista uma vez → n operações → O(n).
algoritmo2: o laço de j está dentro do de i. Para cada um dos n valores de i, o de j dá n voltas → n × n → O(n²).
Com n = 10.000: o primeiro faz 10 mil operações; o segundo faz 100 milhões.
A diferença não é “um pouco mais lento”: é 10.000 vezes mais trabalho — e essa razão piora conforme a lista cresce.
a)algoritmo1 é O(n) (laço simples); algoritmo2 é O(n²) (laço aninhado).
b) O algoritmo1, com folga. Para listas grandes a diferença é de ordens de grandeza, não de porcentagem.
c) Com 10.000 elementos, o algoritmo2 executa 10.000 × 10.000 = 100.000.000 de operações, cada uma imprimindo na tela — algo entre dezenas de minutos e horas, além de gerar 100 milhões de linhas de saída. O algoritmo1 faria 10.000 operações, concluídas em fração de segundo. É por isso que O(n²) é considerado impraticável em escala: o custo cresce com o quadrado da entrada, então cada vez que a base dobra, o tempo quadruplica.
variação que pode cair se o laço interno fosse for j in range(i), o total seria n(n−1)/2 — ainda O(n²), porque a metade é uma constante.
Parte II · Questões 3 e 4
Vetores e matrizes
O padrão que resolve as duas:inicializa → percorre uma vez → devolve. Antes do laço você cria os acumuladores; dentro dele você atualiza todos de uma vez; depois dele você calcula o resultado final. Nunca percorra duas vezes o que dá para fazer numa passada.
Questão 3
estatisticas(lista) sem usar sum()
Escreva estatisticas(lista) que receba uma lista de números e retorne a média, a quantidade de pares e a quantidade de ímpares. Restrição: sem sum() e sem bibliotecas.
o que está sendo testado se você sabe somar “na mão” com acumulador e usar o resto da divisão (%) — e se lembra do caso da lista vazia.
Dica. Você precisa de três variáveis antes do laço: soma, pares e impares, todas começando em 0. Par é todo número cujo resto da divisão por 2 é zero: numero % 2 == 0. E a média é a soma dividida por len(lista) — o que quebra se a lista estiver vazia.
Passo a passo.
Trate primeiro o caso vazio: se a lista não tem elementos, não há média a calcular (divisão por zero).
Crie os três acumuladores zerados antes do laço — se criar dentro, eles reiniciam a cada volta.
Percorra a lista uma vez. A cada número: some ao total e classifique como par ou ímpar.
Depois do laço, divida a soma pelo tamanho para obter a média.
Devolva os três valores. Em Python, return a, b, c devolve uma tupla — e isto conecta com a Questão 5.
def estatisticas(lista):
# caso vazio: evita divisão por zeroifnot lista:
return (0, 0, 0)
soma = 0 # acumuladores nascem ANTES do laço
pares = 0
impares = 0
for numero in lista: # uma única passada → O(n)
soma += numero
if numero % 2 == 0:
pares += 1
else:
impares += 1
media = soma / len(lista)
return (media, pares, impares)
# teste
print(estatisticas([1, 2, 3, 4, 5, 6])) # (3.5, 3, 3)
print(estatisticas([10, 20, 30])) # (20.0, 3, 0)
print(estatisticas([])) # (0, 0, 0)
Complexidade: O(n) de tempo (uma passada) e O(1) de espaço (três variáveis, não importa o tamanho da lista). Se o professor perguntar, é essa a resposta.
variação que pode cair devolver também o maior e o menor — mesma passada, mais dois acumuladores iniciados com lista[0]. Ou contar positivos e negativos.
Questão 4
Maior elemento de uma matriz, sem max()
Escreva uma função que encontre o maior elemento de uma matriz sem usar max(). a) Quantas posições precisam ser visitadas? b) Qual a complexidade para uma matriz n × n? c) E para n × m?
o que está sendo testado laço aninhado com propósito legítimo (matriz é bidimensional) e a diferença entre n² e n·m.
Dica. Não comece com maior = 0 — se a matriz só tiver números negativos, a resposta sai errada. Comece com o primeiro elemento real: matriz[0][0]. E note que aqui o laço aninhado não é desperdício: você precisa mesmo olhar toda posição uma vez.
Passo a passo.
Uma matriz em Python é uma lista de listas: cada elemento da lista externa é uma linha.
Guarde matriz[0][0] como candidato a maior.
Laço externo percorre as linhas; laço interno percorre os valores daquela linha.
A cada valor, compare: se for maior que o candidato, ele vira o novo candidato.
No fim do percurso, o candidato é o maior de todos — porque nenhum valor ficou sem ser comparado.
def maior_da_matriz(matriz):
ifnot matriz ornot matriz[0]:
returnNone
maior = matriz[0][0] # candidato inicial: elemento REALfor linha in matriz: # percorre as linhasfor valor in linha: # percorre os valores da linhaif valor > maior:
maior = valor
return maior
m = [[3, 9, 2],
[7, 1, 8],
[4, 6, 5]]
print(maior_da_matriz(m)) # 9 (visitou 9 posições)
a) Todas: n × m posições (na matriz 3×3 do exemplo, 9). Não dá para visitar menos — qualquer posição não olhada poderia ser justamente a maior.
b) Matriz n × n: O(n²).
c) Matriz n × m: O(n · m). Repare que aqui o quadrático não é defeito: é o tamanho da entrada. Uma matriz n×n tem n² elementos, então ler todos custa n² — isso é linear no número de elementos.
variação que pode cair devolver também a posição (linha, coluna) do maior; somar todos os elementos; contar quantos são maiores que a média.
Parte III · Questões 5, 6 e 7
Tuplas, sets e dicionários
Quatro estruturas, quatro perguntas diferentes. O erro clássico de prova é escolher pela aparência do dado (“são vários nomes, então lista”) em vez de pelo uso. Se a pergunta que você vai fazer é “fulano está aí?”, o set responde em tempo constante; se é “qual o telefone de fulano?”, o dict responde direto; a lista obrigaria a varrer tudo nos dois casos.
Questão 5
A tupla do aluno
Dado aluno = ("João", 8.5, 7.0, 9.0), escreva um programa que 1) extraia o nome, 2) calcule a média, 3) informe se foi aprovado, 4) produza uma nova tupla com nome e média. Explique por que uma tupla pode ser mais adequada que uma lista.
o que está sendo testado indexação e fatiamento de tupla — e, principalmente, se você sabe justificar a imutabilidade.
Dica.aluno[0] é o nome; aluno[1:] é a fatia com as três notas — e continua sendo uma tupla. A pergunta conceitual quer três palavras: imutabilidade, registro de campos fixos e segurança.
Passo a passo.
Nome: posição 0.
Notas: da posição 1 até o fim → aluno[1:]. Não escreva aluno[1] + aluno[2] + aluno[3] à mão: se amanhã forem quatro notas, seu código quebra.
Some as notas num acumulador (mesmo padrão da Q3) e divida pela quantidade.
Aprovado: média ≥ 7,0 (adote e declare o critério).
Monte a nova tupla com (nome, media) — parênteses, não colchetes.
aluno = ("João", 8.5, 7.0, 9.0)
nome = aluno[0] # 1. extrair o nome
notas = aluno[1:] # fatia → (8.5, 7.0, 9.0)
soma = 0
for nota in notas:
soma += nota
media = soma / len(notas) # 2. média
aprovado = media >= 7.0 # 3. situação
resumo = (nome, media) # 4. nova tupla
print("Nome:", nome)
print("Média:", round(media, 2))
print("Situação:", "Aprovado"if aprovado else"Reprovado")
print("Resumo:", resumo)
# Saída:# Nome: João# Média: 8.17# Situação: Aprovado# Resumo: ('João', 8.166666666666666)
Por que tupla e não lista? Três razões, e o professor espera pelo menos duas:
Imutabilidade como proteção. Um registro de aluno tem campos fixos que não deveriam ser alterados por engano. aluno[1] = 10.0 levanta TypeError — a estrutura recusa a fraude em vez de aceitar em silêncio.
Semântica de registro. Lista costuma significar “vários itens do mesmo tipo”; tupla significa “um conjunto fixo de campos de significados diferentes” — nome, nota, nota, nota. A escolha comunica intenção a quem lê.
Pode ser chave de dict e elemento de set (é hashable), coisa que lista não pode — porque o que muda não pode ser usado como chave.
variação que pode cair desempacotamento: nome, n1, n2, n3 = aluno — sintaxe elegante que vale ponto extra se você citar.
Questão 6
Operações de conjunto entre duas turmas
Com turma_a = {1,2,3,4,5,6} e turma_b = {4,5,6,7,8,9}, determine: a) alunos nas duas turmas; b) só na A; c) só na B; d) em pelo menos uma.
o que está sendo testado traduzir português para operação de conjunto. É a questão mais rápida da lista — se você souber a tradução.
Dica — o dicionário português → símbolo: “nas duas” = interseção& · “só na A” = diferençaA - B · “em pelo menos uma” = união| · “em exatamente uma” = diferença simétrica^. Cuidado: “pelo menos uma” é união, não interseção.
turma_a = {1, 2, 3, 4, 5, 6}
turma_b = {4, 5, 6, 7, 8, 9}
# a) nas duas turmas — INTERSEÇÃO
print(turma_a & turma_b) # {4, 5, 6}
print(turma_a.intersection(turma_b)) # mesma coisa# b) somente na turma A — DIFERENÇA
print(turma_a - turma_b) # {1, 2, 3}# c) somente na turma B — DIFERENÇA (ordem invertida!)
print(turma_b - turma_a) # {8, 9, 7}# d) em pelo menos uma — UNIÃO
print(turma_a | turma_b) # {1,2,3,4,5,6,7,8,9}# bônus: em exatamente uma — DIFERENÇA SIMÉTRICA
print(turma_a ^ turma_b) # {1,2,3,7,8,9}
Duas armadilhas. (1) A diferença não é comutativa: A - B ≠ B - A. (2) O set não tem ordem — o Python pode imprimir {8, 9, 7} em vez de {7, 8, 9}, e isso não é erro. Se a ordem importasse, a estrutura estaria errada.
variação que pode cair “quantos alunos ao todo, sem contar ninguém duas vezes?” → len(turma_a | turma_b). Ou remover duplicatas de uma lista: list(set(lista)).
Questão 7
Agenda telefônica com dict
Crie um programa com dict para uma agenda telefônica que permita: cadastrar, remover, buscar pelo nome, alterar telefone e listar todos.
o que está sendo testado as operações básicas de dicionário e o cuidado com chave inexistente — que é onde a maioria perde ponto.
Dica. O nome é a chave e o telefone é o valor. Cadastrar e alterar são a mesma operação (agenda[nome] = telefone) — o que as diferencia é a verificação: cadastrar recusa se já existe, alterar recusa se não existe. Use if nome in agenda antes de remover, e .get() para buscar sem quebrar.
Passo a passo.
Cadastrar: se a chave já existe, avise; senão, agenda[nome] = telefone.
Remover:del agenda[nome] — mas só depois de confirmar que a chave existe, senão dá KeyError.
Buscar:agenda.get(nome, "não encontrado") devolve o padrão em vez de quebrar. Essa escolha vale ponto.
Alterar: confirma que existe e reatribui.
Listar:for nome, tel in agenda.items() — .items() entrega os pares.
agenda = {}
def cadastrar(nome, telefone):
if nome in agenda: # busca por chave: O(1)return f"{nome} já existe. Use alterar()."
agenda[nome] = telefone
return f"{nome} cadastrado."def remover(nome):
if nome notin agenda: # sem isto: KeyErrorreturn f"{nome} não encontrado."del agenda[nome]
return f"{nome} removido."def buscar(nome):
return agenda.get(nome, "não encontrado")
def alterar(nome, telefone):
if nome notin agenda:
return f"{nome} não encontrado."
agenda[nome] = telefone
return f"telefone de {nome} atualizado."def listar():
ifnot agenda:
return"agenda vazia"for nome, telefone in agenda.items():
print(f" {nome}: {telefone}")
print(cadastrar("Ana", "98111-1111")) # Ana cadastrado.
print(cadastrar("Carlos", "98222-2222"))
print(buscar("Carlos")) # 98222-2222
print(alterar("Carlos", "98999-9999"))
print(remover("Ana")) # Ana removido.
print(buscar("Ana")) # não encontrado
listar()
Por que dict e não lista de listas? Porque a pergunta da agenda é sempre “qual o telefone deste nome?”. No dict isso é O(1) — a chave vira endereço por uma função de hash. Numa lista você teria que varrer tudo: O(n). Com dez contatos ninguém nota; com dez mil, sim.
variação que pode cair menu interativo com while True e input(); guardar mais de um dado por contato (o valor vira um dict aninhado ou uma tupla).
Parte IV · Questões 8 e 9
Pilhas e filas
As duas são a mesma lista com uma regra de porta diferente. Brinque nos simuladores abaixo antes de ler as soluções — ver a estrutura mexer ensina mais rápido que ler sobre ela.
simulador 1
Pilha — LIFO: o último a entrar é o primeiro a sair
topo ↓
base
pilha vazia — empilhe alguma coisa.
saída montada: —
Questão 8
inverter(texto) usando pilha
Usando uma pilha, implemente inverter(texto). Entrada PYTHON → saída NOHTYP. A inversão deve usar explicitamente uma pilha.
o que está sendo testado se você entendeu que inverter é o efeito colateral natural do LIFO — e não se você conhece texto[::-1], que aqui seria zero.
Dica. Em Python a pilha é uma lista comum usando só dois métodos: append() para empilhar e pop() (sem argumento!) para desempilhar do topo. Empilhe letra por letra; depois desempilhe até a pilha esvaziar. Clique em “rodar inverter” no simulador acima e observe a ordem.
Passo a passo.
Crie a pilha vazia: pilha = [].
Percorra o texto e empilhe cada caractere. Depois de PYTHON, o topo é o N.
Crie uma string vazia para o resultado.
Enquanto a pilha não estiver vazia, faça pop() e concatene. O primeiro a sair é o último que entrou — o N.
Ao esvaziar, o resultado está invertido. Não é truque: é a definição de LIFO em ação.
def inverter(texto):
pilha = []
for caractere in texto: # empilha: P,Y,T,H,O,N
pilha.append(caractere) # append = push
invertido = ""while pilha: # enquanto não estiver vazia
invertido += pilha.pop() # pop() tira do TOPOreturn invertido
print(inverter("PYTHON")) # NOHTYP
print(inverter("ARARA")) # ARARA (palíndromo)
Cuidado com o pop(): sem argumento remove do fim (topo da pilha) — é O(1). Com pop(0) removeria do início, que é comportamento de fila e custa O(n). Trocar um pelo outro é o erro mais comum desta questão.
Complexidade: O(n) — cada caractere entra uma vez e sai uma vez.
variação que pode cair verificar se uma palavra é palíndromo usando pilha; validar parênteses balanceados ((a+b)*c) — o uso clássico de pilha, empilhando ao abrir e desempilhando ao fechar.
simulador 2
Fila — FIFO: o primeiro a entrar é o primeiro a sair
← sai dequeueentra ← enqueue
fila vazia — coloque alguém.
Questão 9
Classe Fila
Implemente uma classe Fila com enqueue(), dequeue(), front(), is_empty() e size(), usando uma lista Python. Teste com Ana, Carlos e João. Explique FIFO.
o que está sendo testado classe com estado interno + a diferença entre remover (dequeue) e espiar (front) — e se você protege contra fila vazia.
Dica.__init__ cria a lista vazia. Entra no fim (append), sai do início (pop(0)). front() devolve self.itens[0]sem remover — essa é a diferença que a questão quer ver. E toda operação que mexe no primeiro elemento precisa checar antes se a fila está vazia.
Passo a passo.
__init__: self.itens = [] — cada objeto Fila terá a sua própria lista.
enqueue(item): append coloca no fim da lista, que é o fim da fila.
dequeue(): se vazia devolve None; senão pop(0) tira o primeiro.
front(): mesma proteção, mas devolve self.itens[0] — consulta, não retira.
is_empty() e size() saem de len(self.itens).
Rode o teste: depois de enfileirar os três e dar um dequeue, sai Ana (a primeira que entrou) e front() passa a ser Carlos.
class Fila:
def __init__(self):
self.itens = []
def enqueue(self, item): # entra no FIM
self.itens.append(item)
def dequeue(self): # sai do INÍCIOif self.is_empty():
returnNonereturn self.itens.pop(0)
def front(self): # espia sem removerif self.is_empty():
returnNonereturn self.itens[0]
def is_empty(self):
return len(self.itens) == 0
def size(self):
return len(self.itens)
# teste pedido pela questão
f = Fila()
f.enqueue("Ana") # ['Ana']
f.enqueue("Carlos") # ['Ana', 'Carlos']
f.enqueue("João") # ['Ana', 'Carlos', 'João']
print(f.dequeue()) # Ana ← a primeira que entrou
print(f.front()) # Carlos ← agora é a primeira da fila
print(f.size()) # 2
print(f.is_empty()) # False
FIFO — First In, First Out. O primeiro elemento a entrar é o primeiro a sair, exatamente como a fila do banco: quem chega vai para o fim, quem é atendido é quem está na frente há mais tempo. A ordem de chegada é preservada. É o oposto da pilha (LIFO), onde o último a chegar é atendido primeiro. Usos reais: fila de impressão, atendimento por ordem de chegada, tarefas pendentes e a busca em largura (BFS) em grafos.
Detalhe que vale ponto extra:pop(0) é O(n), porque todos os elementos seguintes precisam ser deslocados uma posição para a esquerda. Para filas grandes usa-se collections.deque, cujo popleft() é O(1). Para a prova, a lista basta — mas citar isso mostra que você entende o custo.
variação que pode cair implementar a classe Pilha com push, pop, topo, is_empty, size — idêntica, trocando pop(0) por pop() e itens[0] por itens[-1].
Parte V · Questões 10, 11 e 12
Listas encadeadas
O assunto mais novo da lista — e o que mais derruba quem só decorou. A ideia é uma só: cada nó guarda o valor e o endereço do próximo. Não há índice; há corrente.
simulador 3
Lista encadeada — veja as setas religando
início (head)
lista vazia — insira um valor.
Questão 10
Classe No e encadeamento manual
Crie uma classe No que armazene um valor e a referência para o próximo nó. Monte manualmente 10 → 20 → 30 → None e percorra a lista imprimindo os valores.
o que está sendo testado se você entende que proximo guarda outro objeto (não uma cópia) e se sabe escrever o laço de percurso — o padrão que reaparece em toda operação de lista encadeada.
Dica. A classe tem só dois atributos: valor e proximo, e proximo começa como None. Encadear é atribuir: n1.proximo = n2. Para percorrer, use uma variável “andarilha” — atual — que começa no primeiro nó e vai recebendo atual.proximo até virar None.
Passo a passo.
Defina No com __init__(self, valor): guarda o valor e põe self.proximo = None.
Crie os três nós soltos: n1 = No(10), n2 = No(20), n3 = No(30). Neste instante nenhum conhece o outro.
Encadeie: n1.proximo = n2 e n2.proximo = n3. O de n3 já é None — e é justamente esse None que marca o fim.
Percorra: atual = n1; enquanto atual não for None, imprima atual.valor e avance com atual = atual.proximo.
Se esquecer o avanço, o laço roda para sempre. Se começar com atual = n1.proximo, você perde o primeiro valor.
class No:
def __init__(self, valor):
self.valor = valor
self.proximo = None# ainda não aponta para ninguém# criar os nós
n1 = No(10)
n2 = No(20)
n3 = No(30)
# encadear: 10 → 20 → 30 → None
n1.proximo = n2
n2.proximo = n3 # n3.proximo continua None = fim# percorrer
atual = n1 # começa na cabeçawhile atual isnotNone:
print(atual.valor, end=" → ")
atual = atual.proximo # AVANÇA (sem isto: laço infinito)
print("None")
# Saída: 10 → 20 → 30 → None
Por que None importa: ele é a única marca de “acabou”. Numa lista Python você sabe o fim por len(); numa encadeada, só descobre chegando lá. É por isso que acessar o k-ésimo elemento custa O(n) — não existe conta de endereço, existe caminhada.
variação que pode cair contar os nós; somar os valores; buscar um valor devolvendo True/False. Todas usam o mesmo laço de percurso — só muda o que acontece dentro dele.
Questão 11
O que acontece em inserir_inicio(5)
Dada a lista 10 → 20 → 30 → 40 → None, explique passo a passo o que acontece ao executar lista.inserir_inicio(5). Represente graficamente o antes e o depois.
o que está sendo testado se você sabe a ordem correta das duas atribuições — invertê-la é o erro clássico, e ele destrói a lista inteira.
Dica. São três linhas de código e a ordem é sagrada: criar o nó → o novo aponta para a antiga cabeça → a cabeça passa a ser o novo. Clique em “inserir_inicio(5) em 3 passos” no simulador acima e acompanhe a seta mudando.
Passo a passo — o que a máquina faz.
novo = No(5) — nasce um nó solto com valor 5 e proximo = None. A lista original continua intacta; ninguém aponta para ele ainda.
novo.proximo = self.inicio — o novo nó passa a apontar para o antigo primeiro (o 10). Agora existem dois caminhos para o 10: o inicio e o novo. Estado momentâneo e válido.
self.inicio = novo — a cabeça da lista passa a ser o 5. Pronto: 5 → 10 → 20 → 30 → 40 → None.
Se inverter os passos 2 e 3 — fazer self.inicio = novo antes de guardar a referência — você perde o endereço do 10, e com ele o resto da lista inteira. Sobra 5 → None. Os outros quatro nós ficam órfãos na memória e o coletor de lixo os recolhe. É este o erro que a questão está caçando.
Representação gráfica.
ANTES
inicio
↓
[10|•]→[20|•]→[30|•]→[40|✕]→ None
PASSO 1 — novo = No(5): nó solto, ninguém aponta para ele
inicio
↓
[10|•]→[20|•]→[30|•]→[40|✕]→ None
[5|✕]→ None
PASSO 2 — novo.proximo = inicio: o 5 passa a apontar para o 10
inicio
↓
[10|•]→[20|•]→[30|•]→[40|✕]→ None
↑
[5|•]
PASSO 3 — inicio = novo: a cabeça vira o 5
inicio
↓
[5|•]→[10|•]→[20|•]→[30|•]→[40|✕]→ None
DEPOIS: 5 → 10 → 20 → 30 → 40 → None
def inserir_inicio(self, valor):
novo = No(valor) # 1. cria o nó
novo.proximo = self.inicio # 2. novo aponta para a antiga cabeça
self.inicio = novo # 3. a cabeça passa a ser o novo
Complexidade: O(1). Repare que nada foi percorrido e nada foi deslocado — só duas setas mudaram, independentemente de a lista ter 4 ou 4 milhões de nós. É exatamente aqui que a lista encadeada ganha do array: inserir no início de um array custaria O(n), porque todos os elementos teriam que andar uma casa para a direita.
variação que pode cairinserir_fim (precisa percorrer até o último → O(n)) e remover_inicio (self.inicio = self.inicio.proximo → O(1)). Sabendo desenhar as setas, você deduz as duas na hora.
Questão 12
O quadro comparativo
Compare list, tuple, set, dict, pilha, fila e lista encadeada considerando: a) finalidade; b) duplicação; c) ordem; d) acesso por índice; e) complexidade das operações principais; f) aplicação prática.
o que está sendo testado a síntese de tudo. Se você fez as 11 anteriores, esta tabela você escreve de cabeça — e ela vale como colinha para a prova inteira.
Estrutura
Finalidade
Duplica?
Ordem
Índice
Complexidades
Aplicação prática
list
coleção sequencial de itens que muda
sim
mantém a de inserção
sim
acesso O(1) · busca O(n) · inserir no fim O(1) · inserir/remover no meio ou início O(n)
carrinho de compras, notas de um aluno, qualquer coleção que cresce
tuple
registro fixo, imutável
sim
mantém
sim
acesso O(1) · busca O(n) · não permite alteração
coordenada (x, y), registro de aluno, retorno de função com vários valores
agenda telefônica, cadastro por CPF, contagem de ocorrências
pilha
último a entrar, primeiro a sair (LIFO)
sim
mantém, mas só o topo é acessível
não (só o topo)
push O(1) · pop O(1) · topo O(1)
desfazer (Ctrl+Z), pilha de chamadas, parênteses balanceados, inverter texto
fila
primeiro a entrar, primeiro a sair (FIFO)
sim
mantém a de chegada
não (só a frente)
enqueue O(1) · dequeue O(n) com lista, O(1) com deque
fila de impressão, atendimento por chegada, tarefas pendentes, BFS
lista encadeada
sequência ligada por referências, sem bloco contíguo
sim
mantém
não (percorre)
inserir/remover no início O(1) · acessar o k-ésimo O(n) · buscar O(n)
base de pilhas e filas, listas que crescem muito e são percorridas em ordem
Se cair só uma linha desta tabela na prova, provavelmente é esta:set e dict buscam em O(1) porque a chave é convertida em endereço por uma função de hash; list e lista encadeada buscam em O(n) porque precisam olhar item por item. Essa é a diferença que muda o desempenho de um sistema real.
Agora sem consultar
Treino
Ler solução dá a sensação de aprender; responder sem olhar é aprender. Dois blocos: complexidade (o que mais cai) e rastreamento de estrutura (o que mais confunde). Erre à vontade aqui — cada erro vem com a explicação.
bloco 1 · 12 questões
Qual é a complexidade?
0 acertos · 0 erros
bloco 2 · 10 questões
Qual é o estado da estrutura?
0 acertos · 0 erros
Os erros que custam ponto
Colinha da véspera
Se você só tiver dez minutos antes da prova, leia esta seção. São os oito deslizes que mais aparecem em correção — todos de gente que sabia a matéria.
erro 1
Chamar de O(n²) o que é sequencial
Olhe a indentação antes de responder. Dentro → multiplica. Depois → soma. n + n é O(n).
erro 2
Iniciar maior = 0
Com valores negativos a resposta sai errada. Comece sempre com o primeiro elemento real da estrutura.
erro 3
Confundir pop() com pop(0)
pop() tira do fim — é pilha, O(1). pop(0) tira do início — é fila, O(n). Um caractere muda a estrutura inteira.
erro 4
Inverter a ordem no inserir_inicio
Primeiro novo.proximo = inicio, depoisinicio = novo. Ao contrário, você perde a lista toda.
erro 5
Esquecer o avanço no percurso
atual = atual.proximo dentro do while. Sem essa linha, laço infinito.
erro 6
Não tratar vazio
Média de lista vazia divide por zero; dequeue() de fila vazia quebra; del de chave inexistente dá KeyError. Uma linha de if resolve as três.
erro 7
Esperar ordem de um set
{8, 9, 7} é saída legítima. Set não tem ordem — se a ordem importa, a estrutura está errada.
erro 8
Usar sum(), max() ou [::-1] quando a questão proíbe
A restrição é a questão. O professor quer ver o laço, não o atalho.
As frases que valem ponto na dissertativa
Se perguntarem…
Responda com esta frase
por que não é O(n²)
“porque os laços são sequenciais, não aninhados: os custos se somam (n + n = 2n) em vez de se multiplicarem, e a constante é descartada”
por que tupla e não lista
“porque é um registro de campos fixos que não deve mudar; a imutabilidade protege contra alteração acidental e permite usá-la como chave de dicionário”
o que é FIFO
“first in, first out: o primeiro elemento a entrar é o primeiro a sair, preservando a ordem de chegada — como a fila do banco”
por que dict é melhor que lista aqui
“porque a busca é por chave: o dicionário converte a chave em endereço por hash e responde em O(1), enquanto a lista precisaria percorrer todos os elementos, O(n)”
vantagem da lista encadeada
“inserir e remover no início custam O(1), sem deslocar nenhum elemento — num array a mesma operação obrigaria a mover todos os seguintes”
desvantagem da lista encadeada
“não há acesso direto por índice: para chegar ao k-ésimo é preciso percorrer desde o início, O(n)”
Na hora da prova, se travar: desenhe. Caixinhas e setas para lista encadeada, uma coluna para pilha, uma linha com duas pontas para fila. Rastrear no papel com 3 ou 4 elementos resolve praticamente qualquer questão de rastreamento — e mostra raciocínio ao corretor mesmo se o código sair incompleto.
A promessa: formado por esta disciplina, você lê dados sem ser enganado por eles — e decide sob incerteza com método: sabe o que uma média esconde, o que uma amostra permite afirmar, e quando uma variação é sinal ou ruído.
Carga horária no padrão UNDB; ajustar quando o plano de ensino chegar.
Módulo zero · para quem nunca viu isso antes
Do zero, sem jargão
Estatística tem má fama por ser ensinada como fórmula. Não é fórmula: é um conjunto de defesas contra conclusões erradas. Esta seção mostra as três que valem por metade do curso — sem uma conta sequer.
1. A primeira defesa: um número resumido esconde coisas
“O salário médio da equipe é R$ 4.340.” Parece informação. Não é — depende inteiramente de como os salários se espalham. Veja o que acontece quando uma única pessoa é muito diferente das outras:
Média e mediana respondem perguntas diferentes. A média divide o bolo igualmente — útil para totais, frágil a extremos. A mediana marca o meio da fila — imune a extremos, e por isso é ela que se usa para renda, preço de imóvel e tempo de resposta. Quando alguém diz “a média é X” sem dizer como os dados se espalham, a frase ainda não é informação.
2. A segunda defesa: o gráfico pode mentir sem mentir
Nenhum dos dois gráficos abaixo tem um número errado. São os mesmos quatro valores. Um deles dá vontade de comemorar.
Os dados: 3,1% · 3,2% · 3,3% · 3,4%. Cortar o eixo é a manipulação mais comum do mundo corporativo — e raramente é má-fé: é entusiasmo. Aprender a olhar primeiro para o eixo, antes da forma das barras, é uma das habilidades mais rentáveis do semestre; ela também protege você de fazer isso sem querer no seu próprio relatório.
3. A terceira defesa: “mudou” exige prova
Sua página convertia 3,1% e passou a converter 3,4%. Mudou? Talvez nada tenha acontecido. Números que dependem de pessoas oscilam sozinhos: jogue uma moeda 20 vezes hoje e 20 amanhã e você não terá 10 caras nos dois dias. A oscilação natural tem nome — variação amostral — e a disciplina inteira existe para responder uma pergunta: essa diferença é grande o bastante para não ser só oscilação?
É esta a definição prática de “estatística decisória”: um conjunto de ferramentas para separar sinal (algo mudou de verdade) de ruído (o mundo oscilando como sempre oscilou) — e para admitir, honestamente, quando os dados que você tem não são suficientes para decidir.
4. O vocabulário mínimo
o que você quer saber
População
Todo o universo que interessa: todos os visitantes do site, todos os clientes possíveis. Quase nunca dá para medir inteiro.
o que você consegue medir
Amostra
O pedaço que você observou: os 800 visitantes desta semana. Toda a estatística é a arte de falar da população olhando só para a amostra.
o quanto isso oscila
Desvio padrão
A “largura” dos dados. Duas turmas com média 7 são mundos diferentes se uma varia de 6 a 8 e a outra de 2 a 10.
a honestidade obrigatória
Margem de erro
Nenhum resultado de amostra é um ponto: é uma faixa. “32% ± 3” é a forma correta; “32%” sozinho esconde o que você não sabe.
Por que esta disciplina importa
Ponte com a trajetória
Esta é a matemática do seu Metrics Framework — ler se o conteúdo está funcionando, se a taxa de conversão da Varredura mudou de verdade ou só oscilou, o que um teste A/B autoriza concluir. Para o dev, é a antessala de dados/analytics; para o autônomo, é defesa contra decidir por anedota.
Veredito: aprofundar — com foco em leitura e decisão, não em cálculo manual
correlação, regressão, e um dashboard estatístico da sua prática
Como usar: siga o checklist na ordem dos módulos. Os módulos 3 e 4 são o coração da disciplina; se o semestre apertar, corte no 2, nunca no 4.
Módulo 1 · 14h
Descrever dados honestamente
O que média, mediana e desvio contam — e escondem. Metade dos erros de leitura de dados morre aqui.
Checklist
7 tópicos
0/7
O teste de honestidade do módulo 1: ao ver qualquer número resumido, pergunte três coisas — quantos casos? (n), quanto varia? (desvio), tem extremo? (outlier). Um número sem essas três respostas ainda não autoriza decisão nenhuma. É esse reflexo, e não a fórmula da variância, que o módulo precisa deixar instalado.
Módulo 2 · 12h
Probabilidade para decisão
Intuição calibrada sobre chance, risco e condicional — a área onde o cérebro humano erra de forma mais previsível.
Checklist
6 tópicos
0/6
2.3–2.4 — a armadilha da inversão, com números
Um exame detecta 99% dos doentes e erra em 1% dos sadios. A doença atinge 1 pessoa em 1.000. Seu exame deu positivo. Qual a chance de você estar doente? A intuição grita “99%”. A conta diz outra coisa — imagine 100 mil pessoas:
Grupo
Pessoas
Exame positivo
Leitura
Doentes (0,1%)
100
99
o exame acerta quase todos
Sadios (99,9%)
99.900
999
1% de um grupo enorme ainda é muita gente
Total de positivos
—
1.098
dos quais só 99 estão realmente doentes
Resposta: cerca de 9%, não 99%. P(positivo | doente) é altíssima; P(doente | positivo) é baixa — e essas duas frases não são a mesma coisa. Trocá-las é o erro mais caro da estatística aplicada, e ele aparece em diagnóstico médico, detecção de fraude, filtro de spam e em toda métrica de alerta que você vier a construir: quando o evento buscado é raro, quase todo alarme é falso.
Módulo 3 · 14h
Amostras e distribuições
O que poucos dados permitem dizer sobre muitos — a peça que faz toda a inferência ser possível.
Checklist
6 tópicos
0/6
O sino não é uma escolha estética: é uma consequência. Sempre que muitos fatores pequenos e independentes se somam, o resultado tende a este formato — é o teorema central do limite, e é ele que permite calcular incerteza sem conhecer a população. A regra prática que sai daí: um valor a mais de dois desvios da média é incomum (5% dos casos); a três, é raro (0,3%). Todo teste de hipótese que vem no módulo 4 é essa régua aplicada.
3.2 — o viés que nenhuma conta corrige. Na Segunda Guerra, analistas mapearam onde os aviões voltavam furados e propuseram blindar essas áreas. Abraham Wald apontou o erro: os aviões atingidos naquelas áreas voltaram — devia-se blindar exatamente onde os que voltaram não tinham furos, porque quem levou tiro ali caiu. Toda pesquisa respondida só por quem quis responder tem o mesmo problema: os dados que faltam são justamente os que mudariam a conclusão.
Módulo 4 · 16h
Inferência: sinal vs ruído
Testes, intervalos e o que “significativo” significa — e não significa. O coração da disciplina.
Checklist
7 tópicos
0/7
O p-valor responde uma pergunta estranha — e só ela. “Se nada estivesse acontecendo, qual a chance de eu ver um resultado tão extremo quanto este?” Ele não é a probabilidade de você estar certo, nem a de a hipótese ser verdadeira, nem o tamanho do efeito. Um p de 0,04 com 30 visitantes e um p de 0,04 com 30 mil dizem coisas muito diferentes sobre relevância prática — e é essa distinção, entre significância estatística e importância real, que o módulo 4 precisa deixar gravada.
4.4 · os dois erros
Tipo I e tipo II
Tipo I: gritar que mudou quando não mudou — você troca o site inteiro por causa de ruído. Tipo II: não perceber uma mudança real — você descarta uma melhoria boa. Escolher o nível de significância é escolher qual dos dois erros você prefere cometer; não existe teste que evite os dois.
4.7 · p-hacking
Se você testar 20 coisas, uma “dá certo”
A 5% de significância, uma em cada vinte comparações aleatórias parece significativa por puro acaso. Testar vinte variações e reportar a vencedora é fabricar resultado sem mentir em nenhum número. A defesa é decidir antes o que vai medir — e contar quantas comparações foram feitas.
Módulo 5 · 12h
Relações + capstone
Correlação, regressão, e um dashboard estatístico da sua prática — com regra de decisão escrita antes de olhar o número.
Checklist
4 tópicos
0/4
Correlação é uma pergunta, não uma resposta. Duas séries que sobem juntas podem ter uma causando a outra, a segunda causando a primeira, uma terceira causando as duas (o confundidor), ou nada além de coincidência. A frase inteira do módulo 5 é: quando encontrar uma correlação, procure o calor. No seu caso concreto — “publiquei mais e vendi mais” — o confundidor costuma ser a estação, a campanha que rodou junto, ou o simples fato de você estar mais ativo em tudo naquele mês.
O capstone em uma frase: um painel das suas métricas reais onde, ao lado de cada número, esteja escrito o que precisaria acontecer para você concluir que mudou. Escrever a regra de decisão antes de ver o resultado é o que separa medir de se enganar com aparência de rigor.
20 termos, em ordem de aparição
Glossário
Os termos que esta nota (e o semestre) usam como se você já os conhecesse. Ler de cima a baixo é uma miniatura do curso.
20 termos
Termo
O que é, em uma linha
Variável
Qualquer característica que se mede ou registra: idade, cidade, valor da compra — o átomo dos dados.
Média / mediana / moda
Três formas de dizer “o típico”: soma÷total, o valor do meio, o mais frequente — e cada uma mente em situações diferentes.
Desvio padrão
O quanto os dados se espalham em torno da média — duas turmas com média 7 são mundos diferentes se uma varia de 6 a 8 e outra de 2 a 10.
Distribuição
O formato do conjunto: quais valores aparecem e com que frequência — visualizável como o perfil de um histograma.
Outlier
Um valor extremo e raro que distorce médias — o bilionário que entra no bar e “enriquece” a média de todos.
Probabilidade
A medida da chance de algo, de 0 (impossível) a 1 (certo) — a linguagem formal da incerteza.
Probabilidade condicional
A chance de A dado que B aconteceu — e a fonte do erro mais comum da área: P(A dado B) não é P(B dado A).
Valor esperado
A média ponderada dos resultados possíveis pelo peso das suas chances — o preço justo de uma aposta, o núcleo de decidir sob risco.
População vs amostra
Todo o universo que interessa vs o pedaço que você conseguiu medir — quase toda estatística é inferir o primeiro a partir do segundo.
Viés
Qualquer distorção sistemática na coleta que faz a amostra não representar a população — pesquisa de satisfação respondida só por quem reclamou.
Distribuição normal
O “sino”: o formato que surge naturalmente quando muitos fatores pequenos se somam — e a base matemática da inferência.
Erro padrão
O quanto o resultado de uma amostra tende a variar se você repetisse a coleta — a régua da incerteza amostral.
Inferência
O salto formal de “vi isso na amostra” para “posso afirmar isso do todo” — com honestidade sobre a margem de erro.
Hipótese nula (H₀)
A suposição de que nada mudou / não há efeito — o tédio que os dados precisam derrubar para você afirmar algo.
p-valor
A probabilidade de ver um resultado tão extremo quanto o observado se nada estivesse acontecendo — baixo = suspeite do tédio; não é “a chance de estar certo”.
Intervalo de confiança
A faixa dentro da qual o valor real provavelmente está — a forma honesta de reportar uma estimativa.
Significância estatística
“Dificilmente foi acaso” — que não é o mesmo que “importa na prática”: um efeito minúsculo pode ser significante e irrelevante.
Teste A/B
O experimento controlado do mundo digital: duas versões, público dividido ao acaso, e a inferência decide se a diferença é real.
Correlação
Duas variáveis que se movem juntas — o que não prova que uma causa a outra.
Regressão
O modelo que desenha a melhor reta (ou curva) através dos dados para descrever e prever uma relação.
Onde a conta vira decisão
Laboratório
A ferramenta
Google Sheets
A planilha que você já usa — o mesmo laboratório de Matemática para Negócios. Ela tem todas as funções estatísticas do curso (AVERAGE, MEDIAN, STDEV, CORREL, gráficos e histogramas): a estatística acontece nela, não na calculadora.
Para começar
Uma planilha por módulo, com dados seus
Alimentada com dados reais seus — as métricas do site/Instagram da prática, gastos domésticos, hábitos registrados. Dado inventado não ensina leitura; dado seu, sim.
O ato recorrente — a regra do laboratório:todo conceito estudado é reproduzido na planilha com dados reais antes de ser marcado no checklist. Estudou desvio padrão → calcula o das suas métricas e escreve uma frase interpretando. Estudou intervalo de confiança → constrói um sobre uma taxa sua. A pergunta-teste de cada sessão: “que decisão essa conta informaria?” — se não há resposta, a conta foi ritual, não estatística. O acúmulo dessas planilhas converge para o capstone 5.4.
O que ler, ver e praticar
Recursos
Recurso
Serve a
Livro principal:Estatística: o que é, para que serve, por que importa (Charles Wheelan)
Mód. 1–4 intuição antes de fórmula
Livro de apoio:OpenIntro Statistics (gratuito, openintro.org)
Plano de ensino ainda não disponível — colar aqui quando chegar e mapear: tópico oficial → código revisado; o que cai em prova; o que o plano omite.
Triagem antecipada
Aprofundar na leitura, satisfazer no cálculo manual
Tabelas de z e contas à mão ficam em nível de prova — a planilha calcula; o seu trabalho é interpretar. Risco previsível do curso: parar na descritiva e correr pela inferência, exatamente o inverso do valor; se acontecer, o módulo 4 daqui é o resgate.
Alavanca de projeto
Dataset seu, nunca inventado
Qualquer trabalho da disciplina aponta para o capstone 5.4 — as métricas reais da sua prática (Metrics Framework do DxE) em vez de dataset de exemplo.
A promessa: formado por esta disciplina, você enxerga o processo invisível dentro de qualquer negócio e o torna visível, discutível e melhorável em um diagrama — a habilidade de transformar “como as coisas funcionam aqui” em um mapa que todos leem igual.
Carga horária no padrão UNDB; ajustar quando o plano de ensino chegar.
Módulo zero · para quem nunca viu isso antes
Do zero, sem jargão
Esta disciplina tem o nome mais corporativo do semestre e o conteúdo mais imediatamente útil. Ela ensina a desenhar como o trabalho realmente acontece — e, feito isso, a enxergar onde ele emperra. Vale para uma empresa, para um freelancer e para a sua própria rotina.
1. O que é um processo
Um processo é uma sequência repetível de atividades que transforma uma entrada em algo de valor para alguém. Pedido de pizza: entra a fome do cliente, saem uma pizza entregue e um pagamento. Contratação: entra uma vaga aberta, sai uma pessoa trabalhando. Nada de misterioso — a novidade é olhar para isso como um objeto que pode ser desenhado, medido e melhorado.
Todo processo tem esta forma. O que muda é o tamanho e o número de caminhos possíveis. Note o ponto marcado: a passagem de mão — da cozinha para a entrega, do vendedor para o financeiro, de você para o cliente. Estatisticamente é ali que o trabalho para, se perde e volta; por isso um diagrama que mostra quem faz cada coisa vale muito mais que uma lista de passos.
2. Por que desenhar, se todo mundo já sabe como funciona
Porque ninguém sabe. Cada pessoa conhece o próprio pedaço e supõe o resto. Peça a três pessoas de uma empresa que descrevam o mesmo processo e você receberá três processos diferentes — todos sinceros. O diagrama não documenta um consenso: ele o produz, ao forçar as divergências para a superfície.
processo
Repetível, com fim previsto
“Atender um pedido.” Acontece muitas vezes, sempre com a mesma forma geral. É isto que se modela.
projeto
Único, com começo e fim
“Lançar o novo site.” Acontece uma vez. Não se modela como processo — se planeja como projeto.
procedimento
O passo a passo de uma atividade
“Como emitir a nota fiscal.” É o zoom dentro de uma caixinha do processo — instrução, não fluxo.
3. O par que organiza a disciplina inteira: AS-IS e TO-BE
AS-IS é o processo como é hoje, com todos os defeitos reais — inclusive os constrangedores. TO-BE é o processo como deveria ser, depois do redesenho. A tentação de todo iniciante é pular direto para o TO-BE, porque é mais agradável desenhar o ideal. É também a forma mais garantida de propor uma solução para um problema que não existe.
A regra de ouro do ofício: mapeie o real antes de desenhar o ideal, e valide o mapa com quem executa — nunca só com quem gerencia. O processo narrado pela gerência é o que deveria acontecer; o processo real inclui os atalhos, os retrabalhos e o WhatsApp paralelo que fazem a coisa funcionar apesar do desenho oficial.
Por que esta disciplina importa
Ponte com a trajetória
Esta disciplina é, disfarçada, uma ferramenta central da sua prática — a Varredura é levantamento de processo (como esse negócio capta, atende, entrega?), e o discovery de qualquer projeto é modelagem antes do build. É também o núcleo do ofício de analista de sistemas: quem modela o processo define o sistema. Parente direta da sua arquitetura de informação: IA estrutura conteúdo; modelagem de processos estrutura fluxo.
Veredito: profundidade média com recorte próprio — dominar BPMN prático e entrevista de levantamento; deixar a burocracia de frameworks como noção.
mapear AS-IS e propor TO-BE de um processo da sua prática
Como usar: siga o checklist na ordem dos módulos. Regra de laboratório: nenhuma semana sem diagrama.
Módulo 1 · 12h
Pensamento por processos
Ver o negócio como fluxos, não como departamentos — a virada de perspectiva que o resto da disciplina pressupõe.
Checklist
6 tópicos
0/6
1.5 — o conceito mais rentável do módulo: o dono do processo. Departamentos têm chefes; processos atravessam departamentos — e quase nunca têm dono. Quando ninguém responde pelo fluxo inteiro, cada área otimiza o próprio pedaço e o cliente espera na costura entre elas. Perguntar “quem é o dono deste processo?” numa reunião é, com frequência, a pergunta mais reveladora que um analista pode fazer.
Módulo 2 · 20h
BPMN na prática
A língua franca de desenhar processo — lida e escrita. O módulo mais longo do currículo, e com razão: fluência aqui é o que a disciplina entrega.
Checklist
9 tópicos
0/9
BPMN é pequeno onde importa. A notação completa tem dezenas de símbolos e quase ninguém os usa; a fluência real está em quatro formas e no rigor de nomeá-las bem. Erro nº 1 dos iniciantes: gateway sem pergunta escrita — um losango sem “aprovado?” obriga cada leitor a adivinhar o critério, que é exatamente o que o diagrama existia para eliminar.
As raias são a parte que muda conversas. Um fluxograma comum mostra o que acontece; um diagrama com piscinas e raias mostra quem faz e onde o trabalho troca de mãos — e é ao ver as próprias setas cruzando três raias que uma equipe entende por que o cliente espera cinco dias. Repare também nos dois tipos de seta: a cheia é sequência dentro da mesma organização, a tracejada é mensagem cruzando a fronteira. Confundir as duas é o erro de notação mais frequente do módulo.
Módulo 3 · 12h
Levantamento: descobrir o processo real
Entrevistar, observar e mapear o que acontece de fato — não o que dizem que acontece.
Checklist
5 tópicos
0/5
3.2 · o roteiro que funciona
Pergunte pelo caso, não pelo processo
“Como funciona o atendimento?” gera a versão oficial. “Me conta o último pedido que você atendeu — o que chegou primeiro, o que você fez, para quem mandou?” gera o processo real. E então: “e quando dá errado, o que acontece?” — porque o caminho da exceção costuma ser metade do trabalho e nunca aparece no manual.
3.3 · o gap dito-feito
Três processos, sempre
Existe o processo documentado (o manual), o narrado (o que as pessoas dizem que fazem) e o executado (o que de fato acontece, com atalhos e planilhas paralelas). Modelar o primeiro é perder tempo; modelar o terceiro é o serviço. Observar meia hora vale três entrevistas.
Módulo 4 · 12h
Análise e redesenho
Achar gargalo, desperdício e ponto de automação — e saber quando automatizar só acelera o caos.
Checklist
5 tópicos
0/5
A diferença entre as duas barras é o processo inteiro esperando.Lead time é o relógio do cliente; tempo de ciclo é o relógio de quem trabalha. Em processos administrativos reais a razão costuma ser brutal — 2% de trabalho, 98% de fila — e é por isso que a primeira pergunta de redesenho nunca é “como fazer mais rápido?”, e sim “por que isso está parado?”. As heurísticas de 4.3 seguem essa ordem: eliminar a espera, combinar aprovações, paralelizar o que não depende, e só então automatizar.
4.4 — o aviso que vale a disciplina inteira: automatizar um processo ruim produz um processo ruim mais rápido, com o defeito agora congelado em código e caro de mudar. Redesenhe primeiro, automatize depois. É também a resposta profissional para o cliente que chega pedindo “um sistema”: antes de construir, mapeie — e, com frequência, o mapa mostra que metade do sistema pedido não precisa existir.
Módulo 5 · 12h
Capstone: processo de um negócio real
Mapear o AS-IS e propor o TO-BE de um processo da sua prática — um documento apresentável a cliente.
Checklist
4 tópicos
0/4
MÓD. 3Levantarentrevista com quem executa + observação do caso real
MÓD. 2Desenhar o AS-IScom piscinas, raias e os caminhos de exceção
MÓD. 4Medirlead time, tempo de ciclo e onde o trabalho para
MÓD. 4Redesenhareliminar, combinar, paralelizar — automatizar por último
MÓD. 5ApresentarTO-BE com o ganho estimado, em linguagem de dono do negócio
Bônus estratégico: o TO-BE de um processo comercial é literalmente um entregável vendável. O capstone desta disciplina não é exercício escolar — é a primeira versão de um serviço que você pode oferecer a clientes.
16 termos, em ordem de aparição
Glossário
Os termos que esta nota (e o semestre) usam como se você já os conhecesse. Ler de cima a baixo é uma miniatura do curso.
16 termos
Termo
O que é, em uma linha
Processo
Uma sequência repetível de atividades que transforma uma entrada em algo de valor para alguém — “do pedido ao produto entregue”.
BPM
Business Process Management: a disciplina de gerenciar o negócio através dos seus processos — mapear, medir, melhorar, continuamente.
Modelagem
O ato de desenhar um processo num diagrama padronizado, tornando visível (e discutível) o que antes só existia na cabeça das pessoas.
BPMN
Business Process Model and Notation: a notação-padrão mundial para desenhar processos — um vocabulário visual fixo que todos leem igual.
AS-IS / TO-BE
O par central do ofício: o processo como é hoje (com os defeitos reais) vs como deveria ser (o redesenho proposto).
Evento
Nos diagramas, os círculos: algo que acontece — o processo começa, termina, ou é interrompido por algo (um prazo, uma mensagem).
Atividade
Os retângulos: algo que se faz — “emitir proposta”, “aprovar pedido”.
Gateway
Os losangos: os pontos de decisão ou divisão do fluxo — “aprovado? sim/não” — onde mora a lógica do processo.
Piscina (pool) / raia (lane)
A moldura que divide o diagrama por responsável: cada raia é um ator (vendedor, financeiro, cliente) — mostra quem faz o quê.
Fluxo de sequência / de mensagem
As setas: sequência liga passos dentro de uma organização; mensagem cruza a fronteira entre organizações (empresa ↔ cliente).
Ator
Qualquer pessoa, papel ou sistema que executa parte do processo.
Handoff
O momento em que o trabalho passa de uma mão para outra — estatisticamente, onde os processos mais quebram.
Levantamento
A investigação que descobre o processo real (entrevista, observação) — porque o processo narrado nunca é o executado.
Gargalo
O ponto do processo que limita a vazão do todo — onde o trabalho se acumula e espera.
Retrabalho
Trabalho refeito por erro ou falta de informação na primeira vez — o desperdício mais comum e mais invisível.
Lead time / tempo de ciclo
Quanto o cliente espera de ponta a ponta vs quanto tempo de trabalho efetivo o processo contém — a diferença entre os dois é espera.
Fluência vem de produzir, não de ler
Laboratório
A ferramenta
bpmn.io
Um editor gratuito de diagramas BPMN que roda direto no navegador, sem instalar nada — o Camunda Modeler é a mesma coisa em versão desktop, se preferir. Você arrasta eventos, atividades e gateways para a tela e conecta; a notação correta é imposta pela própria ferramenta.
Para começar
A pizza, hoje
Abrir demo.bpmn.io, desenhar o processo “pedir uma pizza” (do pedido à entrega, com um gateway “tem o sabor? sim/não”) e exportar o arquivo. Pronto: primeiro diagrama existe. Guarde todos numa pasta bpmn/ — a coleção é o registro do semestre.
O ato recorrente — a regra do laboratório:nenhuma semana de estudo termina sem um diagrama novo ou melhorado. Tópico de notação estudado → aplicado num processo real que você conhece (rotina da casa, fluxo de um comércio próximo, o comercial da prática DxE). Tópico de análise estudado → volte a um diagrama seu e marque gargalos e handoffs. A fluência em BPMN vem exatamente como fluência em idioma: produção regular, não leitura acumulada.
O que ler, ver e praticar
Recursos
Recurso
Serve a
Livro principal:Real-Life BPMN (Jakob Freund & Bernd Rücker)
Mód. 24 BPMN como se usa, não como se decora
Livro de apoio:BPM CBOK (ABPMP — consulta pontual, não ler inteiro)
Mód. 13 o vocabulário oficial que a prova vai usar
Vídeo: Camunda Academy — BPMN tutorials (gratuito)
Mód. 2 em ordem
Apêndice
Plano oficial
Plano de ensino ainda não disponível — colar aqui quando chegar e mapear: tópico oficial → código revisado; o que cai em prova; o que o plano omite.
Triagem antecipada
Profundidade média, com recorte
Fluência em BPMN + levantamento valem ouro para a prática; frameworks de governança (ITIL, COBIT — se o curso puxar para lá) ficam em nível de prova, sem culpa. Risco previsível: a disciplina virar decoreba de notação ou teoria de BPM sem modelar nada — o antídoto é o laboratório: nenhuma semana sem diagrama.
Alavanca de projeto
Um entregável que se vende depois
O trabalho da disciplina aponta para o capstone 5.x — o processo comercial da própria prática DxE mapeado de verdade. Bônus: o TO-BE desse processo é literalmente um entregável que você poderá vender a clientes.
A promessa: formado por esta disciplina, você sabe o que a máquina faz de verdade quando seu código roda — por que memória tem hierarquia, o que torna algo lento ou rápido, e o computador deixa de ser caixa-preta.
Carga horária no padrão UNDB; ajustar quando o plano de ensino chegar.
Módulo zero · para quem nunca viu isso antes
Do zero, sem jargão
Todo mundo usa computador; quase ninguém sabe o que há dentro. A boa notícia é que a estrutura essencial foi desenhada em 1945 e continua a mesma — três peças e um caminho entre elas. Entendido isso, o resto do semestre é detalhe.
1. Um computador tem três partes, e só
A ideia que fundou a computação moderna: guardar o programa na mesma memória que os dados. Antes disso, mudar o que a máquina fazia significava recabeá-la fisicamente. Depois disso, um programa passou a ser apenas mais um conteúdo na memória — e é por isso que um mesmo computador roda um navegador, um jogo e um compilador sem mudar um parafuso.
2. Por baixo de tudo: só liga e desliga
O computador não conhece letras, cores ou números — conhece tensão alta e tensão baixa, que chamamos de 1 e 0. Um bit é um desses; um byte são oito, e com oito bits dá para representar 256 coisas diferentes. Toda a montanha (o texto que você lê, a foto, o vídeo, o código) é combinação disso — o que muda é a convenção de leitura: os mesmos 8 bits são o número 65 ou a letra “A” dependendo do que o programa espera encontrar ali.
E como “ligado/desligado” vira raciocínio? Por portas lógicas: circuitos minúsculos que respondem “1” conforme uma regra — a porta E só liga se as duas entradas estiverem ligadas; a OU liga se qualquer uma estiver. Junte algumas e você tem um somador. Junte bilhões e você tem uma CPU. Não há nada além disso lá dentro.
3. O motivo pelo qual isso te interessa como dev
consequência 1
Onde o dado está importa mais que a velocidade do chip
Buscar um valor no cache do processador ou na memória principal é a diferença entre pegar algo na sua mesa e ir até outro andar. É o módulo 3, e é o de maior retorno da disciplina.
consequência 2
“Mais núcleos” não é “mais rápido”
Oito núcleos executam oito coisas ao mesmo tempo — se o seu problema puder ser dividido. Muitos não podem, e é por isso que o JavaScript resolve concorrência com um event loop em vez de threads.
consequência 3
0.1 + 0.2 não dá 0.3
Não é bug do JavaScript: é como frações viram binário. O motivo está no módulo 1 — e saber isso evita você usar float para dinheiro.
Aviso honesto sobre esta disciplina. Ela é a de menor retorno imediato entre as cinco do semestre — mas o que ela dá é permanente: a intuição de por que as coisas são rápidas ou lentas. Estude para entender, não para decorar nomenclatura de barramento e gerações de hardware; isso fica na prova e é esquecido sem culpa.
Por que esta disciplina importa
Ponte com a trajetória
Para um dev web, esta é a disciplina de fundação invisível: ela não vira entregável, mas explica os porquês que você vai encostar a vida toda — por que cache importa, o que é um processo, por que paralelismo é difícil, o que a nuvem virtualiza. A ponte é real, porém indireta; a intuição vale mais que o detalhe.
Veredito: satisfazer institucionalmente, com um núcleo conceitual escolhido a dedo — a disciplina do semestre onde menos horas extras devem ser gastas.
Como usar: siga o checklist na ordem dos módulos. O módulo 3 (memória) é o de maior retorno por hora; se só houver tempo para um, é ele.
Módulo 1 · 14h
Do bit à máquina
Como lógica vira circuito e circuito vira computador — a subida do 0/1 até a máquina inteira.
Checklist
6 tópicos
0/6
1.2 — o clássico que assusta iniciantes
// no console de qualquer navegador
0.1 + 0.2
→ 0.30000000000000004// e por isso, nunca:const total = preco * quantidade; // em R$// e sim, centavos como inteiro:const totalCentavos = precoCentavos * quantidade;
por que acontece
1/10 é dízima em binário
Em decimal, 1/3 = 0,333… não cabe em nenhum número finito de casas. Em binário, quem não cabe é 1/10: 0,0001100110011… repetindo para sempre. O computador guarda o mais próximo que cabe em 64 bits, e dois “mais próximos” somados dão um terceiro número muito próximo — mas não idêntico — de 0,3.
Não é defeito do JavaScript: é o padrão IEEE 754, o mesmo em Python, Java e C. A lição prática é curta e vale dinheiro: nunca represente valores monetários em ponto flutuante — use inteiros de centavos, ou o tipo numeric do banco.
Módulo 2 · 16h
CPU: o ciclo que executa tudo
O que um processador realmente faz com seu código: repetir três passos, bilhões de vezes por segundo.
Checklist
7 tópicos
0/7
É este o batimento cardíaco da máquina. Um clock de 3 GHz significa três bilhões desses ciclos por segundo. Duas consequências que a disciplina explora: o pipeline (começar a buscar a próxima instrução enquanto a atual ainda executa — linha de montagem, não fila) e o fim do crescimento de GHz por calor, que levou a indústria a colocar vários núcleos no lugar de um núcleo mais rápido. O laboratório desta nota — o Little Man Computer — é exatamente este desenho, animado na tela, com só dez instruções.
Módulo 3 · 16h · o de maior retorno
Memória: a hierarquia que domina a performance
Por que “onde o dado está” importa mais que “quão rápido o chip é”. Se você só estudar um módulo desta disciplina, estude este.
Checklist
6 tópicos
0/6
Aqui está o motivo de metade das otimizações do mundo. A pirâmide existe porque memória rápida é cara e memória grande é lenta; a saída foi empilhar as duas coisas e apostar que o próximo dado necessário estará perto do último — a localidade. Duas consequências diretas no seu código: percorrer um array na ordem é muito mais rápido que pular posições ao acaso (os vizinhos vêm juntos para o cache), e é por isso que arrays batem listas ligadas na prática, mesmo quando a tabela de complexidade diz o contrário.
Isto explica dois mistérios do JavaScript de uma vez. Por que copiar um objeto “não copia” (você copiou o endereço, não o conteúdo) e por que comparar dois objetos iguais dá false (endereços diferentes). E explica o garbage collector: como o monte não se limpa sozinho, o runtime periodicamente procura o que ninguém mais aponta e recolhe — trabalho que existe justamente porque a memória é finita e endereçada.
Módulo 4 · 12h
Entrada/saída e o computador moderno
Discos, barramentos, GPU e o caminho até a nuvem — o que existe entre o seu clique e o servidor.
Checklist
5 tópicos
0/5
4.1 · interrupção
A CPU não fica perguntando
Se o processador tivesse de checar “apertaram alguma tecla?” a cada ciclo, gastaria a vida perguntando. Em vez disso o hardware interrompe: o teclado avisa, a CPU pausa o que fazia, atende e volta. É o mesmo padrão dos callbacks e event listeners que você escreve — o navegador não pergunta se houve clique; ele é avisado.
4.2 · GPU
Muitos núcleos burros vencem poucos espertos
A CPU tem poucos núcleos muito capazes; a GPU tem milhares de núcleos simples que fazem a mesma conta em muitos dados ao mesmo tempo. Serve para pixels — e, por acidente feliz, para as multiplicações de matrizes que treinam modelos de IA. É por isso que a placa de vídeo virou o hardware mais disputado do mundo.
4.4 · a nuvem, sem mistério
Fingir máquinas dentro da máquina
Um servidor físico roda dezenas de “computadores” isolados. Máquina virtual = um sistema operacional inteiro fingido, pesado e muito isolado. Contêiner = só o seu programa e suas dependências, compartilhando o sistema do hospedeiro — leve e rápido de subir. Quando você faz deploy “na nuvem”, quase sempre é um contêiner que sobe.
Módulo 5 · 10h
A ponte para o software
O que disso aparece no seu código de todo dia — o módulo que converte a disciplina em intuição utilizável.
Checklist
4 tópicos
0/4
Se o gargalo é…
O sintoma
O que adianta
CPU-bound
processador a 100%, tudo travado enquanto calcula
algoritmo melhor (é aqui que Estrutura de Dados paga), ou dividir entre núcleos
Memory-bound
processador ocioso esperando dado chegar
estruturas contíguas, percorrer na ordem, caber no cache
I/O-bound
tudo parado esperando disco, rede ou banco
não otimizar o código: reduzir idas, agrupar consultas, cachear resposta
Esta tabela é a disciplina inteira condensada. Quase todo desenvolvedor iniciante otimiza código CPU-bound quando o problema era I/O — reescreve um laço para ganhar milissegundos enquanto uma consulta ao banco custa segundos. Saber em qual dos três mundos o seu gargalo mora, antes de mexer em qualquer linha, é o retorno prático de estudar arquitetura.
5.4 — o teste de que a caixa-preta abriu: escreva, com suas palavras, o caminho completo de um clique até o pixel — evento, interrupção, código JS, memória, requisição de rede, servidor, resposta, renderização. Se você consegue narrar isso sem lacunas, a disciplina cumpriu o que prometia; e o texto ainda vira conteúdo publicável da sua prática (diagnóstico técnico em linguagem de dono de negócio).
21 termos, em ordem de aparição
Glossário
Os termos que esta nota (e o semestre) usam como se você já os conhecesse. Ler de cima a baixo é uma miniatura do curso.
21 termos
Termo
O que é, em uma linha
Bit / byte
A menor unidade de informação (0 ou 1) e o pacote de 8 delas — tudo no computador é feito disso: números, texto, imagem, código.
Binário / hexadecimal
Os sistemas de contagem da máquina: base 2 (como os circuitos operam) e base 16 (a abreviação legível que os humanos usam para ela).
Ponto flutuante
O formato com que computadores representam números com vírgula — aproximado por natureza, daí 0.1 + 0.2 ≠ 0.3.
Porta lógica
O bloco elementar dos circuitos: recebe sinais 0/1 e responde 0/1 segundo uma regra (E, OU, NÃO) — bilhões delas compõem uma CPU.
Arquitetura de von Neumann
O desenho básico de quase todo computador: processador + memória única (para dados e programa) + entrada/saída, ligados por um barramento.
CPU
O processador: o componente que efetivamente executa instruções, uma após a outra, bilhões de vezes por segundo.
Registrador
As pouquíssimas “mãos” da CPU: minúsculos espaços de memória dentro dela onde os dados ficam durante a operação.
Instrução / assembly
O comando elementar que a CPU entende (“some”, “copie”, “pule”) e a linguagem quase-humana que o representa — todo código seu vira isso.
Ciclo de instrução
O batimento cardíaco da máquina: buscar a próxima instrução na memória → decodificar → executar → repetir.
Clock
O relógio que marca esse batimento — 3 GHz = 3 bilhões de ciclos por segundo.
Pipeline
A linha de montagem dentro da CPU: várias instruções em estágios diferentes ao mesmo tempo, em vez de uma por vez.
Núcleo (core)
Uma CPU completa dentro do chip — “8 núcleos” = 8 executores realmente simultâneos.
Cache
Memória pequena e caríssima colada na CPU que guarda o que foi usado há pouco — a diferença entre buscar na gaveta e buscar no depósito.
RAM
A memória de trabalho: rápida, ampla, e apagada ao desligar — onde programas e dados vivem enquanto rodam.
Memória virtual
A ilusão que o sistema operacional cria de que cada programa tem a memória toda só para si — trocando pedaços com o disco por trás.
Stack / heap
As duas regiões onde as variáveis de um programa vivem: a pilha (organizada, automática) e o monte (flexível, gerenciado — no JS, pelo garbage collector).
Barramento
As “estradas” internas por onde dados trafegam entre CPU, memória e periféricos.
Interrupção
O mecanismo pelo qual o hardware avisa a CPU que algo aconteceu (tecla apertada, dado chegou) sem que ela precise ficar perguntando.
GPU
O processador de milhares de núcleos simples — feito para fazer a mesma conta em muitos dados ao mesmo tempo (pixels, matrizes, ML).
Sistema operacional
O software que administra a máquina: reparte CPU e memória entre programas e esconde o hardware atrás de abstrações.
Virtualização / contêiner
Fingir máquinas dentro da máquina: a técnica que faz a nuvem existir — um servidor físico rodando dezenas de “computadores” isolados.
Uma CPU inteira, em miniatura
Laboratório
A ferramenta
Little Man Computer (LMC)
Um computador de brinquedo que roda no navegador — busque “LMC simulator”; a versão de Peter Higginson é a clássica. Tem só 100 endereços de memória e cerca de 10 instruções, e mostra na tela cada passo do ciclo buscar-decodificar-executar. É a CPU inteira, visível.
Para começar
Somar dois números, em câmera lenta
Abrir o simulador e rodar o programa de exemplo (somar dois números digitados). Assistir à execução passo a passo, vendo o acumulador e o contador de programa mudarem a cada ciclo.
O ato recorrente — a regra do laboratório: esta disciplina é conceitual, então o laboratório tem dois atos, ambos leves. (1) No módulo 2, escrever 3–4 programinhas no LMC (somar, comparar, um laço que conta até 10) — sentir na mão o que “a CPU executa instruções” significa. (2) Nos demais módulos, o ato é explicar por escrito: cada módulo termina com um parágrafo seu respondendo “o que eu entendo agora que não entendia antes?”. Eles acumulam para o mini-capstone 5.4. Aqui, a explicação própria é o experimento: se você consegue narrar o caminho do clique ao pixel, a caixa-preta abriu.
O que ler e ver
Recursos
Recurso
Serve a
Livro principal:Code: The Hidden Language of Computer Hardware and Software (Charles Petzold, 2ª ed.)
Mód. 1–2 a melhor abertura de caixa-preta já escrita
Livro de apoio:Organização Estruturada de Computadores (Tanenbaum)
Plano de ensino ainda não disponível — colar aqui quando chegar e mapear: tópico oficial → código revisado; o que cai em prova; o que o plano omite.
Triagem antecipada
Satisfazer institucionalmente
É a disciplina do semestre para não gastar horas extras — o retorno marginal para um dev web é menor que o de Estrutura de Dados, Banco ou Estatística. O corte inteligente: intuição de memória/cache e o ciclo da CPU valem para sempre; detalhe de circuito e microarquitetura, nível de prova e adeus sem culpa. Risco previsível: decoreba de nomenclatura de barramento e gerações de hardware — não convertem em nada; deixe na prova.
Alavanca de projeto
“Por que o site fica lento”
Se houver trabalho ou seminário, aponte para o 5.4 (“o que acontece quando meu código roda”) ou para “por que o site fica lento” — temas que rendem apresentação boa e viram conteúdo publicável da sua prática.