Como funciona a avaliação

Nesta disciplina, você entrega cada tarefa fazendo um commit. Ao longo das aulas, os cartões "Ponto de commit" mostram exatamente o que salvar e quando.

Como é um "Ponto de commit"

Quando você conclui uma tarefa, encontra um cartão como este (numeração e pontos são ilustrativos):

Ponto de commit · T1 (5 pts) #

exemplo — pisca o LED_BUILTIN

git add . && git commit -m "T1: exemplo — pisca o LED_BUILTIN" && git push

Clique em Copiar no bloco de código do cartão e cole o comando no terminal, dentro da pasta do seu repositório. Feito isso, a tarefa está entregue.

Passo a passo

1. Faça a tarefa descrita logo antes do cartão.
2. Copie o comando do cartão e rode no terminal. Ele é algo como:

   git add . && git commit -m "T1: ..." && git push

3. Pronto — esse commit registra a tarefa T1. Siga para o próximo ponto.

A mensagem do commit é o que vale

A mensagem começa com o código da tarefa (T1:, T2:, …). É por ela que a correção automática identifica o que você entregou — não altere esse prefixo e use exatamente o que o cartão copia.

Regras que importam

• Um commit por tarefa, na ordem. Prefira commitar cada ponto separadamente.
• Pode refazer: se melhorar uma tarefa, faça um novo commit com o mesmo código (T2: ...). Vale sempre o mais recente.
• Não esqueça o git push — sem enviar, seu trabalho não chega para correção.
• Uma tarefa sem commit correspondente vale zero.

Como a nota é calculada

• A cada push, uma correção automática avalia cada tarefa no estado do commit dela. Por isso tudo bem reescrever o mesmo arquivo entre as partes: cada Tn é avaliado no seu próprio ponto da história.
• Cada tarefa verifica se o projeto compila e se cumpre os requisitos daquele ponto. A nota da tarefa é proporcional ao que passou.
• A nota final é a soma dos pontos, normalizada de 0 a 10.

Dicas rápidas

• Compile/teste antes de commitar.
• Use exatamente a mensagem do cartão (o botão de copiar já traz o código certo).
• Fez os commits na ordem T1, T2, …? Ótimo — é assim que a numeração casa com a correção.

---

Errei o commit, e agora?

Fique tranquilo: a correção sempre usa o commit Tn: mais recente de cada tarefa. Ou seja, na maioria dos casos você não precisa desfazer nada — é só fazer um commit novo. "Refazer" é mais seguro que "desfazer".

Regra de ouro

Errou algo? Faça um novo commit com o mesmo token (T3: ...). O mais recente vale.

1) Errei a mensagem (token errado ou esqueci o Tn:), mas o conteúdo já está certo

O trabalho está salvo, só faltou a etiqueta. Um commit vazio recria o marcador no estado atual:

git commit --allow-empty -m "T3: descricao certa"
git push

2) Esqueci um arquivo ou o conteúdo estava errado

Corrija e faça um novo commit com o mesmo token:

git add .
git commit -m "T3: descricao certa"
git push

3) Foi o último commit e eu ainda NÃO dei push

Aí dá para corrigir o próprio commit com --amend:

git commit --amend -m "T3: mensagem corrigida"   # so a mensagem
# ou, para incluir um arquivo esquecido:
git add arquivo_esquecido
git commit --amend --no-edit

E o reset?

Quase nunca é necessário para a avaliação. Evite git reset --hard — ele apaga trabalho. O único uso tranquilo é desfazer o último commit local, antes do push, para refazê-lo:

git reset --soft HEAD~1   # desfaz o commit, mantem as mudancas prontas para recommitar

Nunca use push --force no repositório do grupo

--amend e reset reescrevem a história e exigiriam git push --force para enviar — isso pode apagar o trabalho dos colegas. Em repositório compartilhado, a regra é: sempre um commit novo, nunca force-push.

Um alívio: como cada tarefa é avaliada no estado congelado do seu commit Tn:, editar o mesmo arquivo depois (em outra tarefa) não estraga as tarefas anteriores.

---

Me perdi — como voltar a um commit que funcionava?

Bagunçou pastas e arquivos e não sabe mais o que mudou? Calma: tudo que você commitou está guardado. A ideia é trazer os arquivos de volta de um commit bom e fazer um commit novo por cima, sem apagar nada da história.

Regra de ouro (de novo)

Voltar no tempo = restaurar os arquivos + commit novo. Não use reset --hard nem push --force para isso.

0) Confira se você está na pasta certa

Muitas vezes o "me perdi" é só estar fora do repositório, ou dentro de um clone dentro de outro clone:

pwd                              # onde estou?
git rev-parse --show-toplevel    # qual é a raiz do repositório?
git status                       # em que branch estou e o que mudou

Se o git status disser HEAD detached, você "viajou" para um commit antigo com git checkout <hash>. Volte para a branch principal:

git switch main    # ou master, conforme o seu repositório

1) Ache o último commit que funcionava

git log --oneline                  # lista resumida de commits
git log --oneline --grep="^T3:"    # só os commits da tarefa T3

Anote o código (hash) do commit bom, por exemplo a1b2c3d.

2) Traga os arquivos de volta e faça um commit novo (recomendado)

git restore --source=a1b2c3d --staged --worktree -- .
git commit -m "T4: volta ao estado de T3 e refaz"
git push

Seus arquivos rastreados ficam exatamente como naquele commit (os que não existiam lá são removidos). Funciona mesmo depois do push e é seguro no repositório do grupo. Use no commit o token da tarefa em que você está.

Quer recuperar só um arquivo ou uma pasta?

git restore --source=a1b2c3d -- src/main.cpp

3) Só quero descartar o que ainda NÃO commitei

git restore .     # desfaz alterações em arquivos já rastreados
git clean -n      # MOSTRA os arquivos novos que seriam apagados
git clean -fd     # apaga de fato (só depois de conferir o -n!)

4) E o reset --hard?

Só em um caso: o commit ruim ainda não foi enviado (sem push). Mesmo assim, crie um backup antes:

git branch backup-antes-do-reset   # rede de seguranca
git reset --hard a1b2c3d

Já deu push? Então nada de reset --hard

Se o commit já está no servidor, o reset exigiria git push --force, que pode apagar o trabalho dos colegas. Use a opção 2 (restaurar + commit novo).

5) Fiz besteira e perdi trabalho — o git reflog salva

O reflog guarda todos os lugares por onde você passou, inclusive depois de um reset --hard:

git reflog                     # lista os estados recentes (HEAD@{0}, HEAD@{1}, ...)
git branch resgate HEAD@{3}    # recupera o estado de 3 passos atrás numa branch nova

Depois é só usar a opção 2 com o hash da branch resgate.

Por que isso não prejudica sua nota

Cada tarefa é corrigida no estado congelado do seu commit Tn:. Restaurar arquivos e commitar de novo não altera as tarefas já entregues — só cria uma entrega nova.

---

Para instrutores — cartão para colar no início de cada lab

Cole este :::info de 4 linhas no topo de cada aula (ele resume o essencial e aponta para esta página):

:::info[Avaliação por commits]
Cada cartão **Ponto de commit** é uma tarefa: faça-a, copie o comando do cartão e rode.
A mensagem começa com o código (`T1:`, `T2:`…) — é como a correção identifica sua entrega.
Um commit por tarefa; pode refazer (vale o mais recente); e **não esqueça o `git push`**.
Detalhes em [Como funciona a avaliação](/labs/como-funciona-avaliacao).
:::

Renderizado, fica assim:

Avaliação por commits

Cada cartão Ponto de commit é uma tarefa: faça-a, copie o comando do cartão e rode. A mensagem começa com o código (T1:, T2:…) — é como a correção identifica sua entrega. Um commit por tarefa; pode refazer (vale o mais recente); e não esqueça o git push. Detalhes em Como funciona a avaliação.