# Pensar em código

> Os conceitos de programação, construindo um projeto pequeno por módulo.
>
> Apostila do curso, gerada de https://poppy.lat/aprender/ em 2026-10-06. A versão do site é sempre a mais atual.
> Linguagens: Ori e Aipo. Para quem: Quero aprender a programar.

## Sumário

1. **Primeiro programa**. Projeto: Cartão de apresentação no terminal
   - Seu primeiro programa (8 min)
   - Várias linhas de texto (em breve)
   - Comentários: notas para quem lê (em breve)
   - Montar o cartão (em breve)
2. **Valores e nomes**. Projeto: Calculadora de gorjeta
   - em preparação
3. **Decisões**. Projeto: Classificador de senhas
   - em preparação
4. **Repetição**. Projeto: Tabuada e contador de palavras
   - em preparação
5. **Funções**. Projeto: Conversor de unidades
   - em preparação
6. **Dados com forma**. Projeto: Agenda de contatos
   - em preparação
7. **Quando algo dá errado**. Projeto: Leitor de arquivo de notas
   - em preparação
8. **Organizar e testar**. Projeto: Lista de tarefas
   - em preparação

---

## 1. Primeiro programa

**Projeto do módulo:** Cartão de apresentação no terminal

### Lição 1: Seu primeiro programa

*Cerca de 8 min. Versão online: https://poppy.lat/aprender/pensar-em-codigo/primeiro-programa/ola*

**Nesta lição você vai:**

1. Criar um arquivo de código.
2. Rodar esse arquivo pelo terminal.
3. Entender o que cada linha faz.

**O que você vai construir:** um programa que mostra uma frase de apresentação no terminal. É a primeira peça do **cartão de apresentação**, o projeto deste módulo.

> **Escolha a sua linguagem**
>
> Os exemplos aparecem em duas abas: **Ori** e **Aipo**. Escolha uma e siga com ela até o fim. O site lembra a sua escolha nas próximas lições. Você pode trocar quando quiser.

#### Antes de começar

Você precisa de duas coisas:

- **A linguagem instalada.** Siga o guia de instalação da [Ori](https://poppy.lat/ori/docs/guides/getting-started/install) ou da [Aipo](https://poppy.lat/aipo/docs/guides/getting-started/installation) e volte aqui.
- **Um terminal aberto em uma pasta vazia.** O terminal é a janela onde você digita comandos. Crie uma pasta chamada `cartao` e abra o terminal dentro dela.

#### Passo 1: crie o arquivo

Um programa é um arquivo de texto com instruções. A extensão no fim do nome diz qual linguagem ele usa.

Crie um arquivo novo na pasta `cartao`:

- Em Ori, com o nome `cartao.orl`.
- Em Aipo, com o nome `cartao.aipo`.

#### Passo 2: escreva o programa

Copie o código para dentro do arquivo e salve.

**Ori**

```ori
module app.cartao

import ori.io as io

main()
    io.println("Olá! Eu sou a Ana.")
end
```

**Aipo**

```aipo
io.println("Olá! Eu sou a Ana.")
```

Troque **Ana** pelo seu nome. Mantenha as aspas `"` no começo e no fim da frase.

#### Passo 3: rode o programa

No terminal, digite o comando e aperte **Enter**:

**Ori**

```bash
ori run cartao.orl
```

**Aipo**

```bash
aipo run cartao.aipo
```

`run` quer dizer "rodar". O comando pede à linguagem para ler o arquivo e fazer o que ele manda.

> **Checkpoint**
>
> Se apareceu esta linha no terminal, deu certo:
>
> ```text
> Olá! Eu sou a Ana.
> ```
>
> Com o seu nome no lugar de Ana.

> **Se travar**
>
> - **"command not found" ou "não é reconhecido como comando":** a linguagem não está instalada, ou o terminal foi aberto antes da instalação. Feche o terminal, abra de novo e tente outra vez.
> - **"file not found" ou "arquivo não encontrado":** o terminal está em outra pasta. Confira se o nome do arquivo está igual, com a extensão, e se o terminal está dentro da pasta `cartao`.
> - **Um erro apontando para a linha da frase:** confira se a frase começa e termina com aspas `"`.

#### O que cada linha faz

Leia só a aba da linguagem que você escolheu.

**Ori**

```ori
module app.cartao        -- 1. o nome deste arquivo dentro do projeto

import ori.io as io      -- 2. traz as ferramentas de entrada e saída, com o nome curto "io"

main()                   -- 3. o começo do programa: é aqui que ele começa a rodar
    io.println("Olá! Eu sou a Ana.")   -- 4. mostra a frase e pula para a próxima linha
end                      -- 5. o fim do bloco que começou em main()
```

**Aipo**

```aipo
io.println("Olá! Eu sou a Ana.")   # mostra a frase e pula para a próxima linha
```

Em Ori, tudo depois de `--` é um **comentário**. Em Aipo, tudo depois de `#` é um comentário. O computador ignora comentários: eles são notas para quem lê. Você vai usar isso na lição 3.

A parte mais importante é igual nas duas linguagens: `io.println("...")`.

- `io` é um grupo de ferramentas para **entrada e saída** (em inglês, *input/output*): ler do teclado, mostrar no terminal.
- `println` é a ferramenta que **imprime uma linha**: mostra o texto e pula para a linha de baixo.
- O texto entre aspas é uma **string**, o nome que as linguagens dão para um pedaço de texto.

> **Onde elas diferem**
>
> Em **Aipo**, o arquivo pode começar direto pela instrução. A linguagem já conhece `io` e roda as linhas de cima para baixo.
>
> Em **Ori**, todo arquivo diz o seu nome com `module`, traz o que vai usar com `import` e coloca as instruções dentro de `main()` ... `end`. Dá mais texto no começo, mas deixa claro, logo no topo, de onde cada coisa vem. A trilha de Ori explica por quê.

#### Resumo

- Um programa é um arquivo de texto com instruções.
- O comando `run` pede para a linguagem executar o arquivo.
- `io.println("...")` mostra uma linha de texto no terminal.

#### Palavras novas

- **Terminal:** a janela onde você digita comandos para o computador.
- **Comando:** uma instrução digitada no terminal, como `ori run cartao.orl`.
- **String:** um pedaço de texto dentro do código, sempre entre aspas.
- **Comentário:** uma nota no código para quem lê. O computador ignora.

#### Próximo passo

Na próxima lição, o cartão ganha mais linhas: nome, o que você faz e onde te encontrar.

---

Fim da apostila. Dúvidas, correções e ideias: https://poppy.lat/aprender/