O que é um flowchart?

Pensando em imagens

Um flowchart (fluxograma) é um diagrama visual que representa um processo como uma sequência de passos conectados por setas. Cada passo é desenhado como uma forma geométrica, e as setas mostram o fluxo: a ordem em que os passos executam.

Flowcharts são usados desde os anos 1920 na engenharia industrial, mas se tornaram essenciais para a computação nos anos 1940 quando Herman Goldstine e John von Neumann os desenharam em 1947 para planejar programas para o computador IAS que construíam em Princeton.

Um flowchart está para um programa assim como uma planta está para um edifício: um plano visual que mostra a estrutura antes de construir.

Por que flowcharts importam

Você pode pensar: "Posso escrever código. Por que desenhar uma imagem primeiro?"

Porque flowcharts ajudam você a:

1. Pensar antes de codificar: Diagramar força você a entender a lógica antes de escrever uma única linha.
2. Identificar casos faltantes: Um flowchart torna lacunas na sua lógica visíveis. Aquele caso extremo que você perderia no código? É óbvio quando um ramo não leva a lugar nenhum.
3. Comunicar com não-desenvolvedores: Gerentes de produto, designers e clientes conseguem ler um flowchart. Eles não conseguem ler Ruby.
4. Debugar lógica complexa: Quando um processo de múltiplos passos tem um bug, rastrear pelo flowchart é mais rápido que ler condicionais aninhadas.
5. Documentar decisões: Seis meses depois, um flowchart explica por que o código funciona do jeito que funciona.

Os elementos básicos

Todo flowchart é construído com poucas formas. Aqui estão as quatro essenciais:

1. Terminal (retângulo arredondado)

flowchart TB
  S([INÍCIO])

Marca o início ou fim de um processo. Todo flowchart tem um INÍCIO e pelo menos um FIM.

2. Processo (retângulo)

flowchart TB
  P[Calcular total]

Representa uma ação ou operação: algo que faz trabalho. No código, mapeia para uma instrução ou chamada de método.

3. Decisão (losango)

flowchart TB
  D{idade >= 18?}
  D -->|Sim| Y[ ]
  D -->|Não| N[ ]

Representa uma pergunta com dois ou mais resultados. Mapeia diretamente para if/else no código. Cada caminho de saída deve ser rotulado.

4. Seta de fluxo

flowchart LR
  A[ ] --> B[ ]

Conecta formas e mostra a direção da execução. Setas sempre apontam de um passo para o próximo.

Seu primeiro flowchart: login

Vamos desenhar um processo simples de login:

flowchart TB
  S([INÍCIO]) --> I[Digitar email e senha] --> V{Credenciais válidas?}
  V -->|Sim| R[Redirecionar pro painel] --> E1([FIM])
  V -->|Não| X["Mostrar erro "Login inválido""] --> E2([FIM])

Agora compare com o código Rails:

class Auth::SessionsController < ApplicationController
  def create
    result = Auth::AuthenticateUserService.call(
      email: params[:email],
      password: params[:password]
    )

    if result.success                             # Losango de decisão
      reset_session
      session[:user_id] = result.user.id
      redirect_to post_sign_in_path(result.user)  # Ramo Sim
    else
      flash.now[:alert] = result.error            # Ramo Não (.now: só neste render)
      render :new, status: :unprocessable_content
    end
  end
end

Veja como o flowchart e o código têm a mesma estrutura? Esse é o poder dos flowcharts: eles tornam a estrutura do código visível.

Flowcharts vs. outros diagramas

Flowcharts são um entre muitos tipos de diagrama. Aqui está quando usar cada um:

Flowcharts se destacam em responder: "O que acontece passo a passo?"

Uma requisição Rails como flowchart

Toda requisição Rails segue um fluxo:

flowchart TB
  R([Requisição chega]) --> RT[Router casa a rota] --> C[Action do controller] --> B{before_action passa?}
  B -->|Sim| M[Consulta ao model] --> V[Renderiza a view] --> H([HTML enviado])
  B -->|Não| X[Redireciona ou interrompe]

Esse modelo mental (Router → Controller → Model → View) é a fundação de toda aplicação Rails.

Lendo um flowchart: as regras

1. Comece no INÍCIO: sempre comece no terminal marcado INÍCIO.
2. Siga as setas: nunca pule entre formas sem uma seta.
3. Nas decisões, escolha um caminho: leia a pergunta, siga a saída rotulada (Sim/Não, Verdadeiro/Falso).
4. Caixas de processo executam: quando você chega em uma caixa de processo, aquela ação acontece.
5. Pare no FIM: quando você chega em um terminal marcado FIM, o processo está completo.

Regra de ouro: Se você não consegue traçar um caminho claro do INÍCIO ao FIM, o flowchart (e provavelmente o código) tem um bug.

Resumo