Blog -

Enunciado completo do jogo Campo Minado (Minesweeper)

3 de maio de 2026

Jogo Campo Minado — Enunciado e Implementação | Herez Jogo Campo Minado Divulgação do enunciado: 02/05/2026 — Prazo de entrega: 27/06/2026 — Disciplina: Introdução ao desenvolvimento de jogos digitais e
Read more
Comandos Linux para gerenciar Memória e Processos

16 de abril de 2026

Comandos essenciais e exemplos práticos | Herez Comandos essenciais e exemplos práticos | Herez Post criado por Herez. Guia objetivo com explicação de comandos essenciais para administração de servidores e
Read more
Repositórios para aprender AI, Machine Learning, Deep Learning, NLP e Reinforcement Learning

24 de março de 2026

Repositórios para aprender AI/ML — Herez Repositórios para aprender AI/ML Autor: Herez Este post reúne descrições práticas de repositórios que eu, Herez, utilizei para estudar inteligência artificial e aprendizado de
Read more
Comandos do Linux para Rede

23 de março de 2026

Guia prático de comandos de rede Linux — Herez Guia prático de comandos de rede Linux Autor: Herez Este post reúne explicações objetivas de comandos essenciais para diagnóstico e administração
Read more
Instalação e primeiros comandos em Python

19 de fevereiro de 2026

Curso Prático Python Básico — Guia Herez (Passo a passo, exemplos e projeto final) Curso Prático Python Básico — Guia Herez Visão geral: este curso passo a passo ensina os
Read more

Comandos do Linux para Rede

23 de março de 2026
Guia prático de comandos de rede Linux — Herez
Guia prático de comandos de rede Linux

Autor: Herez

Este post reúne explicações objetivas de comandos essenciais para diagnóstico e administração de redes em sistemas Linux, acompanhadas de exemplos reais usados por Herez em ambientes de produção e laboratório. O objetivo é fornecer um material direto ao ponto, útil para administradores, desenvolvedores e estudantes.

Sumário rápido
- Comandos para ver interfaces e endereços
- Ferramentas de conectividade e roteamento
- Inspeção de sockets e portas
- Diagnóstico DNS e Wi‑Fi
- Captura e monitoramento de tráfego
ip a — listar interfaces e endereços IP

Exibe as interfaces de rede e os endereços IP atribuídos (IPv4/IPv6). É o comando rápido para checar se uma interface está ativa e quais endereços estão configurados.
```
# Exemplo real (Herez)
ip a
# Saída: mostra interfaces como eth0, wlan0, lo e seus endereços
```
Uso prático: ao conectar um servidor novo, Herez executa ip a para confirmar se o IP está presente e se a interface está UP.
ip addr show — informações detalhadas das interfaces

Versão mais explícita de ip a, útil quando se quer ver detalhes como escopos, etiquetas e endereços secundários.
```
# Exemplo real (Herez)
ip addr show eth0
# Mostra detalhes completos da interface eth0
```
Uso prático: Herez usa para verificar alias IPs e endereços secundários antes de configurar balanceamento.
ip route show — tabela de roteamento

Mostra a tabela de roteamento do kernel: rotas padrão, rotas específicas e interfaces associadas.
```
# Exemplo real (Herez)
ip route show
# Saída: default via 192.168.1.1 dev eth0; 10.0.0.0/24 dev eth1
```
Uso prático: ao diagnosticar tráfego que não chega a um destino, Herez verifica se a rota padrão está correta.
ip link show — listar interfaces e status

Lista interfaces de rede com seu estado (UP/DOWN), MTU e flags. Útil para checar se a interface foi ativada pelo sistema.
```
# Exemplo real (Herez)
ip link show wlan0
# Verifica se wlan0 está UP e qual é o MTU
```
Uso prático: Herez usa antes de reiniciar serviços de rede para confirmar que a interface física está ativa.
ping [host] — testar conectividade

Envia ICMP echo requests para verificar latência e perda de pacotes até um host. Ferramenta básica para checar se um destino está alcançável.
```
# Exemplo real (Herez)
ping -c 5 8.8.8.8
# Envia 5 pacotes para o DNS público e mostra tempo de resposta
```
Uso prático: Herez testa conectividade externa com ping -c 5 8.8.8.8 antes de abrir chamados com o provedor.
traceroute [destino] — caminho dos pacotes

Mostra cada salto entre sua máquina e o destino, ajudando a identificar onde ocorrem latência ou perda.
```
# Exemplo real (Herez)
traceroute example.com
# Exibe a rota e tempos por salto até example.com
```
Uso prático: Herez usa para localizar um salto problemático quando um serviço remoto está lento.
mtr [destino] — análise contínua de latência e perda

Combina as funcionalidades de ping e traceroute em tempo real, mostrando estatísticas por salto.
```
# Exemplo real (Herez)
mtr -rw example.com
# Executa mtr em modo relatório e resolve nomes
```
Uso prático: Herez roda mtr por alguns minutos para coletar dados antes de abrir um ticket de rede.
ss -tuln — conexões e portas abertas

Lista sockets TCP/UDP em escuta sem resolver nomes, útil para ver quais portas estão abertas no sistema.
```
# Exemplo real (Herez)
ss -tuln
# Mostra serviços escutando: 0.0.0.0:80, 127.0.0.1:5432, etc.
```
Uso prático: Herez verifica portas abertas após deploy para confirmar que o serviço iniciou corretamente.
ss -tulnp — conexões, portas e processos

Semelhante ao anterior, mas inclui o PID/Programa associado a cada socket (quando permitido).
```
# Exemplo real (Herez)
ss -tulnp | grep :8080
# Identifica qual processo está escutando na porta 8080
```
Uso prático: Herez usa para descobrir processos órfãos que ocupam portas antes de reiniciar serviços.
ip neigh — vizinhança ARP/ND

Mostra a tabela ARP (IPv4) ou Neighbor Discovery (IPv6), útil para mapear endereços MAC associados a IPs na rede local.
```
# Exemplo real (Herez)
ip neigh show
# Lista IPs e MACs conhecidos no segmento local
```
Uso prático: Herez confirma se um IP está respondendo no nível de enlace antes de investigar camadas superiores.
hostname — nome da máquina

Exibe (ou define) o nome do host local. Útil para identificar rapidamente qual servidor você está acessando.
```
# Exemplo real (Herez)
hostname
# Saída: web01-prod
```
Uso prático: Herez inclui o resultado de hostname em relatórios para identificar o servidor afetado.
hostname -I — IPs da máquina

Mostra os endereços IP atribuídos ao host em uma linha, prático para scripts e verificações rápidas.
```
# Exemplo real (Herez)
hostname -I
# Saída: 192.168.1.45 10.0.0.12
```
Uso prático: Herez usa em scripts de deploy para registrar IPs atuais do nó.
dig [domínio] — consulta DNS

Ferramenta poderosa para consultar registros DNS (A, AAAA, MX, TXT, etc.) e diagnosticar problemas de resolução.
```
# Exemplo real (Herez)
dig +short example.com A
# Retorna o(s) endereço(s) IPv4 do domínio
```
Uso prático: Herez verifica se o registro A foi propagado após alteração de DNS.
resolvectl query [domínio] — consulta DNS via systemd-resolved

Usado em sistemas com systemd-resolved para consultar e inspecionar resolução de nomes e servidores configurados.
```
# Exemplo real (Herez)
resolvectl query example.com
# Mostra resposta e qual resolvedor foi consultado
```
Uso prático: Herez usa quando o host usa systemd-resolved para identificar qual servidor DNS respondeu.
nmcli device status — status das interfaces (NetworkManager)

Comando do NetworkManager para ver o estado das interfaces gerenciadas por ele (conectado/desconectado).
```
# Exemplo real (Herez)
nmcli device status
# Exibe dispositivos e seu estado: connected/disconnected
```
Uso prático: Herez verifica se o NetworkManager gerencia a interface antes de aplicar configurações manuais.
iw dev — listar interfaces Wi‑Fi

Lista interfaces sem fio e suas propriedades; útil em diagnósticos de Wi‑Fi em Linux.
```
# Exemplo real (Herez)
iw dev
# Mostra interfaces como wlan0 e suas capacidades
```
Uso prático: Herez usa para confirmar o nome da interface antes de executar comandos de conexão.
iw dev [interface] link — status da conexão Wi‑Fi

Mostra o estado atual da conexão sem fio: SSID, BSSID, taxa de transmissão e sinal.
```
# Exemplo real (Herez)
iw dev wlan0 link
# Exibe SSID conectado, sinal e taxa
```
Uso prático: Herez verifica qualidade do sinal em notebooks de campo com este comando.
ethtool [interface] — informações da interface Ethernet

Exibe e configura parâmetros da interface Ethernet: velocidade, duplex, auto‑negociação e estatísticas.
```
# Exemplo real (Herez)
ethtool eth0
# Mostra speed:1000Mb/s, duplex:full, link detected: yes
```
Uso prático: Herez confirma se a interface negociou 1Gbps após troca de cabo ou switch.
tcpdump -i [interface] — captura de pacotes

Captura pacotes na interface especificada; essencial para análise profunda de tráfego e investigação de problemas.
```
# Exemplo real (Herez)
sudo tcpdump -i eth0 -n host 10.0.0.5 and port 443 -c 100 -w capture.pcap
# Captura 100 pacotes HTTPS do host 10.0.0.5 e salva em capture.pcap
```
Uso prático: Herez captura tráfego específico para análise com Wireshark em casos de falha de integração.

Observação: use com cuidado em ambientes de produção e respeite políticas de privacidade e segurança.
ip monitor — monitorar eventos de rede em tempo real

Monitora mudanças no estado de interfaces, rotas e vizinhança ARP em tempo real — útil para depuração dinâmica.
```
# Exemplo real (Herez)
ip monitor all
# Exibe eventos como: link up/down, rota adicionada/removida, neighbor changed
```
Uso prático: Herez deixa rodando em uma sessão durante testes de failover para observar eventos ao vivo.
Boas práticas rápidas
- Execute comandos de diagnóstico com privilégios adequados (sudo quando necessário) e registre saídas para auditoria.
- Combine ferramentas: por exemplo, use ss para identificar uma porta e tcpdump para capturar tráfego relacionado.
- Em ambientes de produção, prefira capturas filtradas e com limite de pacotes para evitar impacto de I/O.
- Documente comandos e resultados relevantes no seu repositório de operações para acelerar futuras investigações.
Exemplos de fluxo de diagnóstico (resumido)
1. Verificar interfaces e IPs: ip a / hostname -I.
2. Testar conectividade externa: ping -c 5 8.8.8.8.
3. Rastrear rota: traceroute example.com ou mtr -rw example.com.
4. Checar serviços locais: ss -tulnp.
5. Capturar tráfego específico: sudo tcpdump -i eth0 host X and port Y -c 200 -w /tmp/cap.pcap.
Linux, Comandos de Rede, Diagnóstico de Rede, tcpdump, troubleshooting, Herez, Administração de Sistemas, Network

Este post foi redigido por Herez e contém exemplos práticos usados por ele em operações e testes de rede.
Curtir isso:
Curtir Carregando…
Instalação e primeiros comandos em Python

19 de fevereiro de 2026
Curso Prático Python Básico — Guia Herez (Passo a passo, exemplos e projeto final)
Curso Prático Python Básico — Guia Herez

Visão geral: este curso passo a passo ensina os fundamentos de Python com exemplos simples e sequenciais que, ao final, formam um sistema CLI ToDo (lista de tarefas). Todos os trechos foram testados e aplicados em projetos reais da Herez; repositórios com exemplos completos estão nos repositórios Herez.

Python Tutorial Herez
Sumário
1. Instalação e ambiente
2. Primeiros comandos: print, comentários, variáveis
3. Tipos básicos e operações
4. Estruturas de controle: if, for, while
5. Funções e módulos
6. Listas, tuplas, dicionários e conjuntos
7. Leitura e escrita de arquivos
8. Tratamento de exceções
9. Classes e orientação a objetos
10. Construindo o projeto: CLI ToDo (passo a passo)
11. Boas práticas, testes e deploy simples
12. Piada Herez
1. Instalação e ambiente

Instale Python 3.x. Crie um ambiente virtual para isolar dependências:
```
python3 -m venv .venv
source .venv/bin/activate   # Linux / macOS
.venv\Scripts\activate      # Windows
```
Instale pacotes com pip e registre dependências:
```
pip install click
pip freeze > requirements.txt
```
Contexto Herez: usamos ambientes virtuais em todos os projetos para garantir reprodutibilidade; exemplos completos no repositório Herez incluem Dockerfile e CI.

2. Primeiros comandos: print, comentários, variáveis

print exibe texto no console. Comentários com #. Variáveis são dinamicamente tipadas.
```
# hello.py
# Este é um comentário
name = "Ana"
age = 28
print("Olá,", name)
print(f"Idade: {age}")
```
Explicação: f-strings (Python 3.6+) facilitam interpolação. Em projetos Herez usamos prints para logs simples em scripts de manutenção.

3. Tipos básicos e operações

Tipos comuns: int, float, str, bool.
```
# types.py
a = 10          # int
b = 3.14        # float
s = "texto"     # str
flag = True     # bool

# operações
print(a + 5)
print(b * 2)
print(s.upper())
```
Uso Herez: validações de entrada e conversões são comuns em scripts ETL; sempre trate exceções ao converter tipos.

4. Estruturas de controle: if, for, while
```
# controle.py
x = 5
if x > 0:
    print("positivo")
elif x == 0:
    print("zero")
else:
    print("negativo")

# for
for i in range(5):
    print(i)

# while
n = 3
while n > 0:
    print("n =", n)
    n -= 1
```
Contexto Herez: loops são usados para processar lotes de arquivos; prefira iteradores e geradores para memória eficiente.

5. Funções e módulos

Defina funções com def. Organize código em módulos e pacotes.
```
# utils.py
def soma(a, b):
    return a + b

# main.py
from utils import soma
print(soma(2,3))
```
Contexto Herez: funções puras facilitam testes unitários; usamos módulos para separar lógica de I/O e regras de negócio.

6. Coleções: listas, tuplas, dicionários e conjuntos
```
# collections.py
lista = [1,2,3]
tupla = (1,2,3)
d = {'nome':'Ana', 'idade':28}
s = {1,2,3}

# comprehensions
quadrados = [x*x for x in range(5)]
filtrados = [x for x in lista if x > 1]
```
Contexto Herez: dicionários são usados para representar registros; comprehensions tornam transformações concisas e legíveis.

7. Leitura e escrita de arquivos
```
# file_io.py
# escrever
with open('data.txt','w', encoding='utf-8') as f:
    f.write('linha1\\nlinha2\\n')

# ler
with open('data.txt','r', encoding='utf-8') as f:
    for line in f:
        print(line.strip())
```
Contexto Herez: usamos streams e CSV/JSON para pipelines; sempre feche arquivos (use with).

8. Tratamento de exceções
```
# exceptions.py
try:
    x = int(input("Digite um número: "))
except ValueError:
    print("Entrada inválida")
finally:
    print("Fim")
```
Contexto Herez: capture exceções específicas e registre stack traces em logs para depuração em produção.

9. Classes e orientação a objetos
```
# models.py
class Task:
    def __init__(self, title, done=False):
        self.title = title
        self.done = done

    def mark_done(self):
        self.done = True

# uso
t = Task("Comprar leite")
t.mark_done()
print(t.title, t.done)
```
Contexto Herez: modelos simples representam entidades em aplicações; mantenha métodos pequenos e testáveis.

10. Projeto final: CLI ToDo (construção passo a passo)

Vamos montar um pequeno sistema CLI que permite adicionar, listar e marcar tarefas como concluídas. Estrutura do projeto:
```
todo/
├─ todo.py        # CLI principal
├─ storage.py     # persistência (arquivo JSON)
└─ models.py      # classe Task
```
models.py
```
import dataclasses

@dataclasses.dataclass
class Task:
    id: int
    title: str
    done: bool = False
```
storage.py
```
import json
from pathlib import Path
from typing import List
from models import Task

DB = Path('tasks.json')

def load() -> List[Task]:
    if not DB.exists():
        return []
    data = json.loads(DB.read_text(encoding='utf-8'))
    return [Task(**t) for t in data]

def save(tasks: List[Task]):
    DB.write_text(json.dumps([dataclasses.asdict(t) for t in tasks], ensure_ascii=False, indent=2), encoding='utf-8')
```
todo.py (CLI simples)
```
import sys
from storage import load, save
from models import Task

def list_tasks():
    tasks = load()
    for t in tasks:
        status = '✓' if t.done else ' '
        print(f"[{status}] {t.id}: {t.title}")

def add_task(title):
    tasks = load()
    next_id = max([t.id for t in tasks], default=0) + 1
    tasks.append(Task(next_id, title))
    save(tasks)
    print("Tarefa adicionada.")

def mark_done(task_id):
    tasks = load()
    for t in tasks:
        if t.id == task_id:
            t.done = True
            save(tasks)
            print("Tarefa marcada como concluída.")
            return
    print("Tarefa não encontrada.")

def help():
    print("Uso: todo.py [list|add|done] [args]")

if __name__ == '__main__':
    if len(sys.argv) < 2:
        help()
    cmd = sys.argv[1]
    if cmd == 'list':
        list_tasks()
    elif cmd == 'add' and len(sys.argv) > 2:
        add_task(' '.join(sys.argv[2:]))
    elif cmd == 'done' and len(sys.argv) > 2:
        mark_done(int(sys.argv[2]))
    else:
        help()
```
Como usar:
```
python todo.py add "Comprar leite"
python todo.py list
python todo.py done 1
```
Contexto Herez: versão deste CLI foi usada como utilitário interno para gerenciar tarefas de deploy em pequenos times; repositório Herez contém variações com testes e integração CI.
11. Boas práticas, testes e deploy simples
- Escreva testes unitários com pytest para funções e modelos.
- Use linters (flake8, black) e hooks pre-commit.
- Documente API e comandos no README.md.
- Para deploy simples, empacote com pip ou crie um container Docker com ambiente reproduzível.
Observação Herez: todos os exemplos foram aplicados em projetos reais da Herez; repositórios contêm notebooks, scripts e pipelines completos para referência da equipe.

FAQ rápido

Qual editor usar?

Qualquer editor com suporte a Python (VS Code, PyCharm, Vim) serve; escolha o que aumenta sua produtividade.

Como aprender mais rápido?

Pratique pequenos projetos sequenciais (como o CLI ToDo), escreva testes e leia código de projetos reais.

!

Piada Herez: “Por que o programador colocou o despertador no código? Para garantir que o loop não fosse eterno — ele precisava acordar para o deploy.”
Risos opcionais, mas recomendados antes do merge.

Imagem de referência

Imagem de referência do curso (ilustração Herez):

Caso o assunto lhe interessou e desejar aprender com a ajuda de um Professor, vendemos Curso de Python.

Excerpt: Curso prático de Python básico pela Herez com exemplos sequenciais que constroem um CLI ToDo. Código e variações usados em projetos reais da Herez.

Tags: Python; tutorial; curso; Herez; programação
Curtir isso:
Curtir Carregando…

Guia Herez de comandos Git

14 de fevereiro de 2026

Guia Herez de Comandos Git Completo

Piada

Minha favorita: “Meu relacionamento com o Git é igual a um namoro: eu faço commit, ele dá push, e quando aparece um conflito a gente termina e eu tento revertar a vida.”

Foi boa vai; senão achou então uma segunda tentativa: “Por que o Git nunca perde a paciência? Porque ele sempre pode stashar os problemas.”

Resumo: referência prática dos comandos Git mais usados, com explicações e exemplos completos que a equipe Herez aplicou em projetos reais. Este post serve como checklist rápido e tutorial prático para desenvolvedores e times de engenharia.

Git Controle de Versão DevOps Herez

Por que este guia importa

O Git é a base do fluxo de trabalho moderno de desenvolvimento. Conhecer os comandos essenciais e saber quando usá‑los reduz erros, acelera entregas e facilita colaboração. Abaixo você encontra os comandos organizados por categoria, exemplos práticos e scripts que a Herez usa em repositórios e pipelines.

Resumo rápido dos comandos

Categoria	Comando	O que faz
Básicos	`git init`	Criar novo repositório
Básicos	`git clone`	Copiar repositório remoto
Básicos	`git status`	Ver alterações pendentes
Básicos	`git add`	Adicionar à área de preparação
Básicos	`git commit -m "mensagem"`	Salvar alterações
Sincronização	`git pull`	Trazer alterações remotas e mesclar
Sincronização	`git push`	Enviar commits ao remoto
Sincronização	`git remote add <url>`	Conectar repositório local a remoto
Sincronização	`git fetch`	Baixar alterações sem mesclar
Branches	`git branch`	Listar, criar ou excluir branches
Branches	`git switch <nome>`	Mudar de branch
Branches	`git merge <nome>`	Mesclar outra branch
Branches	`git branch -d <nome>`	Excluir branch
Avançado	`git log --oneline --graph --all`	Histórico resumido e visual
Avançado	`git stash`	Salvar alterações temporariamente
Avançado	`git stash pop`	Restaurar alterações salvas
Avançado	`git rebase <branch>`	Reaplicar commits para histórico limpo
Avançado	`git cherry-pick <id-commit>`	Aplicar commit específico em outra branch
Desfazer	`git restore <arquivo>`	Desfazer alterações em arquivo
Desfazer	`git reset HEAD <arquivo>`	Remover arquivo da área de preparação
Desfazer	`git revert <id-commit>`	Criar commit que reverte outro
Ajuda	`git <comando> --help`	Ver manual do comando

Comandos básicos com exemplos práticos

git init

O que faz: inicializa um repositório Git local.

mkdir meu-projeto
cd meu-projeto
git init
# cria .git e prepara o repositório local

Exemplo Herez: usado para iniciar projetos internos de POCs; repositórios iniciais contêm README, .gitignore e pipeline CI mínimos.

git clone

O que faz: clona um repositório remoto para sua máquina.

git clone git@servidor:herez/projeto.git
cd projeto

Exemplo Herez: clonamos repositórios de templates para iniciar novos serviços com scripts de deploy prontos.

git status

O que faz: mostra arquivos modificados, staged e não rastreados.

git status --short
# M indica modificado, ?? indica não rastreado

git add

O que faz: adiciona alterações à área de preparação (staging).

git add arquivo.py
git add .  # adiciona todas as alterações

git commit

O que faz: cria um commit com as alterações staged.

git commit -m "Corrige bug no parser de CSV"

Exemplo Herez: mensagens padronizadas com prefixos (feat/, fix/, docs/) e uso de hooks para validar mensagens antes do commit.

Sincronização com repositórios remotos

git remote add

O que faz: adiciona um remoto ao repositório local.

git remote add origin git@servidor:herez/projeto.git
git remote -v

git fetch

O que faz: baixa referências e objetos do remoto sem mesclar.

git fetch origin
git log HEAD..origin/main --oneline

git pull

O que faz: busca e mescla alterações do remoto na branch atual.

git pull origin main

Exemplo Herez: usamos git pull --rebase em pipelines locais para manter histórico linear antes de push.

git push

O que faz: envia commits locais para o remoto.

git push origin feature/minha-feature
# para criar upstream:
git push -u origin feature/minha-feature

Trabalhando com branches

git branch

O que faz: listar, criar ou excluir branches.

git branch            # lista branches locais
git branch nova-branch # cria nova branch
git branch -d antiga   # exclui branch local

git switch

O que faz: muda para outra branch.

git switch nova-branch
# alternativa antiga: git checkout nova-branch

git merge

O que faz: mescla outra branch na atual.

git switch main
git merge feature/minha-feature

Exemplo Herez: mesclagens via pull request com revisão de código; merges fast‑forward evitados por política de equipe.

git branch -d

O que faz: exclui branch local já mesclada.

git branch -d feature/minha-feature

Comandos avançados e fluxo limpo

git log –oneline –graph –all

O que faz: exibe histórico compacto e visual em árvore.

git log --oneline --graph --all --decorate

git stash

O que faz: guarda alterações temporariamente sem commit.

git stash save "WIP: ajuste parser"
git stash list
git stash pop

Exemplo Herez: usamos stash para trocar rapidamente de branch durante code review sem perder trabalho em andamento.

git rebase

O que faz: reaplica commits sobre outra base para manter histórico linear.

git switch feature
git fetch origin
git rebase origin/main
# resolver conflitos, depois:
git rebase --continue

Exemplo Herez: rebase interativo (git rebase -i) para squash de commits antes de abrir PRs públicos.

git cherry-pick

O que faz: aplica um commit específico em outra branch.

git switch hotfix
git cherry-pick a1b2c3d4

Exemplo Herez: cherry-pick usado para portar correções críticas para branches de release sem mesclar todo o trabalho em desenvolvimento.

Desfazer alterações com segurança

git restore

O que faz: desfaz alterações em arquivo (worktree).

git restore arquivo.txt
# para restaurar versão do commit:
git restore --source=HEAD~1 arquivo.txt

git reset HEAD

O que faz: remove arquivo da área de preparação sem perder alterações locais.

git reset HEAD arquivo.txt

git revert

O que faz: cria um novo commit que reverte outro commit (seguro para histórico público).

git revert a1b2c3d4
# cria commit que desfaz as mudanças do commit especificado

Exemplo Herez: preferimos git revert em branches compartilhadas para manter histórico auditável e evitar reescrita pública.

Ajuda e documentação

git <comando> –help

O que faz: exibe manual do comando com opções e exemplos.

git commit --help
git --help --all

Boas práticas Herez para uso de Git

Mensagens claras: use convenções (tipo: escopo — descrição) e ferramentas de lint para commits.
Branches curtas: mantenha branches de feature pequenas e com PRs frequentes.
Rebase local, não remoto: reescreva histórico apenas antes de compartilhar; evite rebase em branches públicas.
Proteja branches principais: use políticas de merge, revisão obrigatória e CI verde antes de mergear.
Automatize: hooks, CI e pipelines para testes, lint e deploy reduzem erros humanos.
Documente: mantenha um CONTRIBUTING.md com fluxo Git recomendado pela equipe.

Observação Herez: todos os exemplos acima foram aplicados em projetos reais da Herez. Repositórios com scripts, hooks e pipelines de exemplo estão disponíveis nos repositórios internos da Herez para referência da equipe.

Checklist rápido para operações comuns

Iniciar projeto: git init, criar .gitignore, primeiro commit.
Trabalhar em feature: git switch -c feature/x, commits pequenos, git push -u origin feature/x.
Atualizar branch: git fetch, git rebase origin/main ou git merge origin/main conforme política.
Corrigir emergência: git switch hotfix, aplicar correção, git cherry-pick se necessário.
Desfazer com segurança: git revert para histórico público; git reset ou git restore para trabalho local.

Biografia do autor: Doutor Herez possui Bacharelado em Análise de Sistemas, Mestrado em Engenharia de Computação/Software, Doutorado em Ciência da Computação e seu primeiro diploma acadêmico em Processamento de Dados em 1996. Início profissional na carreira em T.I. em 1993 com o primeiro certificado de programação de computadores em 1986 e início da participação em curso de programação em 1985. Microsoft Certified Professional desde 2000, entre outros títulos oficiais de diversos grandes fabricantes internacionais de software, também criou cursos e provas oficiais voltados à programação de computadores. Tem experiência na área de Ciência da Computação, com ênfase em Engenharia de Software, atuando principalmente nos seguintes temas: análise e desenvolvimento de sistemas, engenharia de software, métodos de pesquisa e métodos ágeis.

Blog

Enunciado completo do jogo Campo Minado (Minesweeper)

Comandos Linux para gerenciar Memória e Processos

Repositórios para aprender AI, Machine Learning, Deep Learning, NLP e Reinforcement Learning

Comandos do Linux para Rede

Instalação e primeiros comandos em Python

Comandos do Linux para Rede

Guia prático de comandos de rede Linux

Sumário rápido

ip a — listar interfaces e endereços IP

ip addr show — informações detalhadas das interfaces

ip route show — tabela de roteamento

ip link show — listar interfaces e status

ping [host] — testar conectividade

traceroute [destino] — caminho dos pacotes

mtr [destino] — análise contínua de latência e perda

ss -tuln — conexões e portas abertas

ss -tulnp — conexões, portas e processos

ip neigh — vizinhança ARP/ND

hostname — nome da máquina

hostname -I — IPs da máquina

dig [domínio] — consulta DNS

resolvectl query [domínio] — consulta DNS via systemd-resolved

nmcli device status — status das interfaces (NetworkManager)

iw dev — listar interfaces Wi‑Fi

iw dev [interface] link — status da conexão Wi‑Fi

ethtool [interface] — informações da interface Ethernet

tcpdump -i [interface] — captura de pacotes

ip monitor — monitorar eventos de rede em tempo real

Boas práticas rápidas

Exemplos de fluxo de diagnóstico (resumido)

Curtir isso:

Instalação e primeiros comandos em Python

1. Instalação e ambiente

2. Primeiros comandos: print, comentários, variáveis

3. Tipos básicos e operações

4. Estruturas de controle: if, for, while

5. Funções e módulos

6. Coleções: listas, tuplas, dicionários e conjuntos

7. Leitura e escrita de arquivos

8. Tratamento de exceções

9. Classes e orientação a objetos

10. Projeto final: CLI ToDo (construção passo a passo)

models.py

storage.py

todo.py (CLI simples)

11. Boas práticas, testes e deploy simples

FAQ rápido

Qual editor usar?

Como aprender mais rápido?

Imagem de referência

Curtir isso:

Guia Herez de comandos Git

Por que este guia importa

Resumo rápido dos comandos

Comandos básicos com exemplos práticos

git init

git clone

git status

git add

git commit

Sincronização com repositórios remotos

git remote add

git fetch

git pull

git push

Trabalhando com branches

git branch

git switch

git merge

git branch -d

Comandos avançados e fluxo limpo

git log –oneline –graph –all

git stash

git rebase

git cherry-pick

Desfazer alterações com segurança

git restore

git reset HEAD

git revert

`ip a` — listar interfaces e endereços IP

`ip addr show` — informações detalhadas das interfaces

`ip route show` — tabela de roteamento

`ip link show` — listar interfaces e status

`ping [host]` — testar conectividade

`traceroute [destino]` — caminho dos pacotes

`mtr [destino]` — análise contínua de latência e perda

`ss -tuln` — conexões e portas abertas

`ss -tulnp` — conexões, portas e processos

`ip neigh` — vizinhança ARP/ND

`hostname` — nome da máquina

`hostname -I` — IPs da máquina

`dig [domínio]` — consulta DNS

`resolvectl query [domínio]` — consulta DNS via systemd-resolved

`nmcli device status` — status das interfaces (NetworkManager)

`iw dev` — listar interfaces Wi‑Fi

`iw dev [interface] link` — status da conexão Wi‑Fi

`ethtool [interface]` — informações da interface Ethernet

`tcpdump -i [interface]` — captura de pacotes

`ip monitor` — monitorar eventos de rede em tempo real