O que é pensamento computacional? — Pensamento computacional

Pensando como um programador

Pensamento computacional não é sobre pensar como um computador. É sobre desenvolver uma abordagem sistemática para resolução de problemas que funciona seja escrevendo código, projetando um sistema ou debugando um incidente em produção.

É a habilidade que separa alguém que sabe escrever sintaxe de alguém que sabe resolver problemas.

"Pensamento computacional são os processos de pensamento envolvidos em formular problemas e suas soluções de forma que as soluções sejam representadas em um formato que possa ser efetivamente executado por um agente processador de informação."

Jeannette Wing, 2011, citando Jan Cuny e Larry Snyder

Os quatro pilares

O pensamento computacional se apoia em quatro habilidades interconectadas:

flowchart TB
  subgraph CT["Pensamento computacional"]
    D["1. Decomposição<br/>quebrar problemas grandes em pequenos"]
    P["2. Reconhecimento de padrões<br/>enxergar semelhanças e estruturas recorrentes"]
    A["3. Abstração<br/>esconder detalhes, focar no que importa"]
    AL["4. Pensamento algorítmico<br/>projetar soluções passo a passo"]
  end

Vamos pré-visualizar cada um com um exemplo do mundo real antes de mergulhar fundo nas aulas seguintes.

Pilar 1: decomposição

Quebrar um problema complexo em partes menores e gerenciáveis.

Imagine que pedem para você construir um sistema de registro de usuários no Rails. Ao invés de tentar resolver tudo de uma vez, você decompõe:

flowchart TB
  R["Construir o cadastro de usuário"] --> A["Criar o model User<br/>name, email, password_digest"]
  R --> B["Construir o formulário de cadastro<br/>HTML + validações"]
  R --> C["Escrever o service de cadastro<br/>criar usuário, enviar email de boas-vindas"]
  R --> D["Adicionar política de senha<br/>tamanho mínimo, complexidade"]
  R --> E["Tratar erros<br/>email duplicado, entrada inválida"]
  R --> F["Escrever testes pra cada parte"]

Cada sub-problema é pequeno o suficiente para resolver independentemente. Isso é decomposição: e é a fundação da engenharia de software.

Pilar 2: reconhecimento de padrões

Identificar similaridades, tendências e estruturas recorrentes.

Depois de decompor um problema, você frequentemente nota padrões:

Formulário de cadastro      →  tem campos, validações, submit, erros
Formulário de login          →  tem campos, validações, submit, erros
Formulário de editar perfil  →  tem campos, validações, submit, erros

Padrão: Todos os formulários compartilham a mesma estrutura!

Reconhecer esse padrão leva a soluções reutilizáveis: form builders, partials compartilhados ou service objects com uma interface comum.

Em Ruby, padrões levam a código DRY:

# Padrão: todo serviço retorna um Result
module Auth
  class RegisterUserService
    Result = Data.define(:success, :user, :errors)

    def self.call(email:, username:, password:, password_confirmation:, time_zone: nil)
      # ... lógica ...
      Result.new(success: true, user: user, errors: [])
    end
  end

  class AuthenticateUserService
    Result = Data.define(:success, :user, :error)

    def self.call(email:, password:)
      # ... lógica ...
      Result.new(success: true, user: user, error: nil)
    end
  end
end

Pilar 3: abstração

Focar no que é importante e esconder detalhes desnecessários.

Quando você dirige um carro, você não pensa sobre injeção de combustível ou relações de engrenagem: você pensa em dirigir, acelerar e frear. O carro abstrai a complexidade.

Em programação, abstração significa criar interfaces que escondem detalhes de implementação:

# Abstração de alto nível: o quê (não como)
result = Auth::RegisterUserService.call(email:, username:, password:, password_confirmation:)

# O chamador não precisa saber:
# - Como a senha é hasheada
# - Qual tabela do banco armazena usuários
# - Quais validações executam
# - Como o fuso horário informado pelo navegador é conferido

O Rails em si é uma abstração massiva:

# Você escreve isso:
Catalog::Course.where(level: :intern).order(:position)

# O Rails abstrai:
# - Geração de SQL
# - Gerenciamento de conexão com o banco
# - Mapeamento do result set para objetos Ruby
# - Conversão de tipos

Pilar 4: pensamento algorítmico

Projetar soluções passo a passo que possam ser seguidas com precisão.

Um algoritmo é uma sequência finita de passos bem definidos que resolve um problema. Pensamento algorítmico significa projetar esses passos antes de escrever código:

Algoritmo: Autenticar um usuário

1. Receber email e senha
2. Encontrar usuário pelo email no banco de dados
3. Se usuário não encontrado → retornar erro "Credenciais inválidas"
4. Comparar senha com hash armazenado
5. Se senha não confere → retornar erro "Credenciais inválidas"
6. Se senha confere → criar sessão, retornar sucesso

Observe: a mesma mensagem de erro para "usuário não encontrado" e "senha errada": esta é uma decisão de segurança (prevenindo enumeração de usuários) sobre a qual o pensamento algorítmico ajuda você a raciocinar.

Como os pilares trabalham juntos

Os quatro pilares não são passos sequenciais: são lentes que você aplica simultaneamente:

flowchart LR
  P["Problema: construir um sistema de acompanhamento de progresso"]
  P --> D["1. Decomposição<br/>rastrear aulas concluídas · % de conclusão · dar XP · mostrar no painel"]
  P --> R["2. Reconhecimento de padrões<br/>conclusões = recibos de leitura · XP = um razão contábil · progresso = concluídas / total × 100"]
  P --> A["3. Abstração<br/>model LessonCompletion · UserGamificationQuery · presenter do painel"]
  P --> G["4. Pensamento algorítmico<br/>achar matrícula → criar conclusão → dar XP<br/>contar conclusões / contar aulas × 100"]

Pensamento computacional vs codificação

Codificação é a implementação. Pensamento computacional é a estratégia.

Pensamento Computacional	Codificação
Qual problema estamos resolvendo?	Qual linguagem/framework?
Como dividimos isso?	Quais classes/métodos?
Quais padrões existem?	Quais abstrações/gems?
Quais são os passos?	Qual é a sintaxe?
Esta é a abordagem certa?	Este código funciona?

Você pode ser ótimo em codificação mas terrível em resolução de problemas. Pensamento computacional garante que você resolva o problema certo da maneira certa antes de escrever uma única linha de código.

Por que este curso importa

Todo desenvolvedor sênior que você admira tem fortes habilidades de pensamento computacional: frequentemente sem saber o nome formal. Eles:

Quebram requisitos ambíguos em tarefas claras (decomposição)
Reconhecem quando um problema é similar a um que já resolveram antes (reconhecimento de padrões)
Projetam interfaces limpas que escondem complexidade (abstração)
Planejam sua abordagem antes de codificar (pensamento algorítmico)

Nas próximas seis aulas, vamos praticar cada pilar profundamente, construindo em direção a um desafio final onde você aplica todos os quatro para resolver um problema real.

Resumo

Pilar	Descrição	Exemplo Rails
Decomposição	Quebrar grandes problemas em partes pequenas	Feature → Models + Service + Controller + View
Reconhecimento de Padrões	Identificar similaridades e estruturas recorrentes	Todos os serviços retornam objetos Result
Abstração	Esconder detalhes, expor interfaces limpas	`Course.where(level: :intern)` esconde SQL
Pensamento Algorítmico	Projetar soluções passo a passo	Fluxo de autenticação: encontrar → verificar → sessão