@aninhasalesp

Recursão

2025-09-17T00:00:00-03:00

Terceiro capítulo da série de estudos sobre o livro Entendendo Algoritmos de Aditya Y. Bhargava.

Se você está acompanhando a série, já resumi os capítulos anteriores 👀, então volta lá se tu tiver alguma dúvida:
- Capítulo 1 - Introdução a algoritmos
- Capítulo 2 - Ordenação por seleção
- Capítulo 3 - Recursão -📍 você está aqui

Oi, pessoal! Mais um resuminho do nosso livro querido 😊

Esse capítulo foi um dos que mais me tirou a sensação de que programação é mágica. Bora entender recursão e pilhas sem medo?

Neste capítulo, o autor explica de forma simples o conceito e o uso da recursão, dividindo a explicação em caso base e caso recursivo. Ele sugere que você, ao menos uma vez, analise uma função recursiva com papel e caneta, acompanhando passo a passo, assim você entenderá como a função funciona.

Recursão

É a técnica onde uma função chama a si mesma para resolver um problema, dividindo-o em problemas menores. Devido ao fato de uma função recursiva chamar a si mesma, é mais fácil de escrevê-la de forma errada e acabar em um loop infinito. Para que a recursão funcione corretamente, ela deve conter um caso base para parar as chamadas e um caso recursivo que aproxime o problema da solução final.

Como a recursão funciona:

Antes de mostrar um exemplo de recursão, vamos entender como ela funciona.

Caso base: define quando a função deve parar de se chamar. Sem ele, a recursão continuaria indefinidamente, causando erro.
Caso recursivo: é a parte em que a função se chama novamente, aproximando-se da solução final a cada passo.

Um exemplo clássico é o cálculo do fatorial de um número::

def fatorial(n):
    if n == 0 or n == 1:  # Caso Base
        return 1
    else:  # Caso Recursivo
        return n * fatorial(n - 1)

print(fatorial(5))  # Saída: 120

Nesse exemplo:

Caso Base: n é 0 ou 1, o fatorial é 1
Caso Recursivo: Se n é maior que 1, o fatorial é n * fatorial(n-1)

Olha como fica quase poético, cada número chama o próximo até o 1 dizer “chega, agora volta”. Aí a multiplicação acontece no caminho de volta.

Pilha

Suponha que você esteja fazendo um churrasco para os seus amigos. Você tem uma lista de afazeres em forma de uma pilha de notas adesivas. Quando você insere um item, ele é colocado no topo da pilha. Quando você lê um item, lê apenas o item do topo da pilha e ele é retirado da lista. Logo, sua lista de afazeres contém apenas duas ações: push (inserir) e pop (remover e ler).

Esta estrutura de dados é chamada de pilha. A pilha é uma estrutura de dados simples e nós usamos o tempo todo sem perceber.

Pilha de chamadas

Sempre que uma função é chamada, o computador precisa “lembrar” de onde ela parou para poder continuar depois. Essa memória temporária é organizada numa pilha de chamadas (call stack).

Funciona assim:

A cada nova chamada de função, o computador empilha informações sobre essa execução (como parâmetros e variáveis locais).
Quando a função termina, o computador desempilha esses dados e volta para o ponto anterior.

A metáfora do livro é ótima, pense em uma pilha de pratos na cozinha. Você só consegue pegar (ou retirar) o prato que está por cima. Assim também funciona com funções, o último que entrou é o primeiro que sai (LIFO: Last In, First Out).

Podemos visualizar isso com um exemplo simples em Python:

def cumprimenta(nome):
    print("Oi,", nome)
    despedida()

def despedida():
    print("Tchau!")

cumprimenta("Ana")

Ordem de execução na pilha:

cumprimenta(“Ana”) é chamada → vai para a pilha.
Dentro dela, despedida() é chamada → fica no topo.
despedida() roda e sai da pilha.
cumprimenta(“Ana”) roda até o fim e sai da pilha.

Ou seja, tudo organizado, prato por prato.

Esse exemplo já mostra que não é só recursão que usa pilha, mas qualquer função. A diferença é que a recursão força a pilha a crescer muito mais rápido.

Pilha de chamadas com recursão

Com recursão, essa pilha pode crescer bastante, porque a função vai se chamando várias vezes até chegar no caso base.

Exemplo simplificado com fatorial(3):

O programa chama fatorial(3)
    - empilha fatorial(3)

Para resolver, precisa de fatorial(2)
    - empilha fatorial(2)

Para resolver, precisa de fatorial(1)
    - empilha fatorial(1)

fatorial(1) chega no caso base e retorna 1
    - desempilha fatorial(1)

Agora fatorial(2) consegue calcular 2 × 1 = 2
    - desempilha fatorial(2)

Por fim, fatorial(3) calcula 3 × 2 = 6
    - desempilha fatorial(3)

No fim, cada chamada só consegue terminar depois que a chamada menor retorna. É por isso que definir bem o caso base é tão importante, sem ele, a função nunca para de empilhar chamadas e acaba estourando a memória (stack overflow).

Esse “estouro da pilha” é justamente de onde veio o nome do site Stack Overflow.

Quando vi esse processo pela primeira vez, parecia uma espécie de “mágica”, como se o computador simplesmente soubesse de onde voltar.

Foi nesse momento que percebi que entender programação é muito sobre desmistificar. Não é dom, não é gênio, é só empilhar e desempilhar com calma. Hoje, sempre que vejo um código recursivo, tento imaginar essa pilha acontecendo em segundo plano, isso traz clareza e ainda transforma o “eu não nasci pra isso/nunca vou entender isso” para um “hihi que legal” 😎

Então, da próxima vez que você se perder num código recursivo, respira: desenha a pilha, segue os passos, e lembra que não é mágica, é só prática!!!

Curiosidades 💡

Uma recursão muito comum fora da programação: bonecas russas (matryoshkas). Cada boneca guarda outra dentro, até que a última (caso base) não guarda mais nenhuma.
Algumas linguagens aplicam otimização de recursão de cauda (tail call optimization), que reaproveita os quadros da pilha para não estourar a memória em funções recursivas muito profundas. Python, porém, não faz isso.
A pilha de chamadas é invisível na maior parte do tempo, mas você já viu ela funcionando, quando o Python mostra um traceback (aquele erro cheio de setas, indicando em que função a execução estava).
Muitas funções recursivas podem ser reescritas de forma iterativa (usando laços for ou while). Isso evita o risco de estouro da pilha em casos de chamadas muito profundas.
Para entender recursão, você precisa primeiro entender recursão. 😅

Exercícios recomendados 👩🏻‍💻💞

Para reforçar o aprendizado, aqui vão alguns desafios práticos:

LeetCode

Merge two sorted lists - Dá pra resolver recursivamente, tratando como o caso base quando uma lista chega ao fim.
Climbing Stairs - Um problema clássico de recursão + otimização (parecido com Fibonacci).

Exercism

Flatten Array - Recebe uma lista que pode conter sublistas e precisa retornar tudo “achatado” em uma única lista
Recursão com Python - Reforça o conceito de recursão e tem o exercício “Luhn” que admite uma abordagem recursiva

Desafio extra

Crie uma função recursiva que percorre pastas e arquivos no seu computador (ou só numa lista aninhada simulada). Isso é literalmente como muitos sistemas de arquivos funcionam.

Espero que tenha aproveitado o conteúdo! ✨💕

Se tiver alguma sugestão de exercício ou melhoria na explicação, me conta aqui 🫂🌻

Ordenação por Seleção, Arrays e Listas

2025-08-27T00:00:00-03:00

Segundo capítulo da série de estudos sobre o livro Entendendo Algoritmos de Aditya Y. Bhargava.

Capítulo 1 - Introdução e Busca Binária
Capítulo 2 - Arrays, Listas e Ordenação por Seleção -📍 você está aqui
Capítulo 3 - Recursão

Espero que vocês tenham gostado da forma como estruturei o primeiro capítulo, seguirei naquela mesma linha de raciocínio e explicação. Se você tiver alguma sugestão de exercício ou melhoria na explicação, me conta aqui que eu ficarei feliz em receber esse feedback 🫂💕

No capítulo 2, o autor aprofunda dois conceitos fundamentais: estruturas de dados (como arrays e listas) e a eficiência dos algoritmos (notação Big O). Para ilustrar isso, ele apresenta o algoritmo de ordenação por seleção.

Arrays e Listas

Antes de falar em ordenação, é importante entender como os dados podem ser armazenados na memória. 👀

O autor traz uma analogia que faz o entendimento ficar muuuito mais fácil. Em resumo, a ideia é algo assim:

Imagine que você vai a um show e precisa guardar suas coisas na chapelaria (eu nem sabia que isso existia 🤔). Apenas algumas gavetas estão disponíveis e você pode guardar um item por gaveta. Você pega e guarda suas coisas nessas gavetas, fecha, e está pronto para ir ao show.

A memória do computador funciona mais ou menos assim. O computador parece um grande conjunto de gavetas, e cada gaveta tem um endereço. Cada vez que tu armazena um item na memória, o computador fornece um endereço para guardar esse item.

E aí, se tu quiser armazenar múltiplos itens, existem duas maneiras principais de fazer isso: arrays e listas.

Arrays

São blocos contíguos de memória (um ao lado do outro).
Cada elemento pode ser acessado diretamente pelo índice, permitindo uma leitura rápida.
- Isso significa que a operação de busca por posição é O(1), ou seja, constante.

arr = [10, 20, 30]
print(arr[1])  # acesso direto ao 20

O lado ruim do array é que, se tu quiser adicionar mais um item e a gaveta seguinte estiver ocupada, será necessário solicitar ao computador uma área de memória maior para armazenar todos os itens e mover os existentes para lá.
Então adicionar novos itens a um array é algo que pode ser muito lento.
Deletar um elemento é tão custoso quanto adicionar, todos os elementos seguintes precisam ser movidos.

Listas encadeadas

Seus itens podem estar em qualquer lugar da memória.
Cada item armazena o endereço do próximo item da lista.
Semelhante a uma caça ao tesouro, cada pista encontrada indica onde está a próxima etapa.
Adicionar um item é simples, você coloca o item em qualquer lugar da memória e atualiza o endereço do item anterior.
Para deletar, é tão simples quanto, basta alterar o endereço do item anterior para apontar para o próximo item.
O lado ruim da lista encadeada é que, para acessar um elemento específico (por exemplo, o último), você não pode ir direto, precisa percorrer a lista item por item até chegar lá.

  class Node:
      def __init__(self, valor):
          self.valor = valor
          self.proximo = None

  a = Node(10)
  b = Node(20)
  a.proximo = b

  # Percorrendo
  n = a
  while n:
      print(n.valor)
      n = n.proximo

Explicando o código acima: 1. Crio a classe Node, que armazena um valor (valor) e um ponteiro para o próximo nó (proximo). 2. Crio dois nós: a com valor 10 e b com valor 20. 3. Ligo a ao b com a.proximo = b. 4. Percorro a lista com while n: imprimindo n.valor até chegar no final (None).

A saída pra esse código:

10
20

Não sei vocês, mas entender a diferença entre arrays e listas foi um verdadeiro estalo para mim. Como aprendi Python primeiro, eu meio que usava essas estruturas no automático… 🥲 Pode parecer algo óbvio ou até desnecessário, afinal, lidamos com arrays e listas o tempo todo, mas foi incrível compreender por que as coisas funcionam do jeito que funcionam. Minha cabeça finalmente começou a encaixar as peças e perceber a lógica por trás das operações. Fiquei meio que:

Aqui estão os tempos de execução para as operações mais comuns em arrays e listas encadeadas

Acho importante trazer essa tabela, para que o entendimento sobre notação Big O se consolide e pra todos entenderem o impacto das nossas escolhas em diferentes situações.

A interpretação pra essa tabela de uma forma mais explícita seria:

Leitura:
- Array → O(1): Em um array, cada posição tem um endereço fixo na memória. Então, se você quiser o 5º elemento, o computador vai direto nele de uma forma super rápida e em tempo constante.
- Lista → O(n): uma lista encadeada, cada elemento sabe apenas quem é o próximo. Então, para achar o 5º elemento, você precisa começar do 1º, depois o 2º, depois o 3º… até chegar no 5º. Quanto maior a lista, mais tempo demora.
Inserção:
- Array → O(n): Se o array estiver cheio e você quiser enfiar um novo item no meio, tem que “empurrar” todos os outros elementos uma posição para frente. Isso pode levar bastante tempo.
- Lista → O(1): Se você já sabe a posição, inserir numa lista é rapidinho, basta mudar quem aponta pra quem e pronto.
Deleção:
- Array → O(n): Se você remove um item no meio do array, precisa “puxar” todos os elementos da frente uma posição pra trás para fechar o buraco.
- Lista → O(1): Assim como na inserção, basta mudar os ponteiros para pular o item que você quer remover. Não mexe em mais ninguém.

Ordenação por seleção

O autor apresenta o algoritmo Selection Sort, que é simples de implementar, mas não muito eficiente. A diferença entre arrays e listas em Python torna importante entender como o algoritmo percorre e manipula os elementos.

Ideia do algoritmo

Encontrar o menor elemento da lista
Colocá-lo na primeira posição
Repetir para as posições seguintes até ordenar toda a lista

Implementação em Python:

def busca_menor(arr):
    """
    Encontra o índice do menor elemento em um array.

    Parâmetros:
    arr (list): Lista de elementos comparáveis.

    Retorna:
    int: Índice do menor elemento encontrado.
    """
    menor = arr[0]
    menor_indice = 0
    for i in range(1, len(arr)):
        if arr[i] < menor:
            menor = arr[i]
            menor_indice = i
    return menor_indice

def ordenacao_por_selecao(arr):
    """
    Ordena uma lista usando o algoritmo de ordenação por seleção.

    A função cria uma nova lista, removendo o menor elemento
    da lista original a cada iteração e adicionando-o à lista ordenada.

    Parâmetros:
    arr (list): Lista de números a serem ordenados.

    Retorna:
    list: Nova lista ordenada em ordem crescente.
    """
    novo_arr = []
    for i in range(len(arr)):
        menor = busca_menor(arr)
        novo_arr.append(arr.pop(menor))
    return novo_arr

print(ordenacao_por_selecao([5, 3, 6, 2, 10])) # Saída: [2, 3, 5, 6, 10]

Complexidade e Big O

O selection sort precisa percorrer todos os elementos várias vezes.
Para n elementos, ele faz aproximadamente n × n operações.
Isso significa que seu desempenho é O(n²).

Este é um exemplo clássico que mostra como algoritmos diferentes podem resolver o mesmo problema com eficiências diferentes, destacando a importância de escolher o algoritmo certo dependendo do tamanho e da estrutura dos dados.

Curiosidades

As listas em Python são, na verdade, arrays.
O método append (adicionar no final) é considerado de complexidade O(1) na média. Isso porque adicionar um item no final geralmente é bem barato: só colocar no próximo espaço livre.
O “custo alto” aparece em operações como insert ou remove no meio da lista. Aí é preciso deslocar todos os elementos seguintes, o que pode ser O(n).
Uma forma de visualizar: pense numa pilha de pratos. Colocar ou tirar um prato do topo (como append e pop) é fácil. Mas se você quiser enfiar ou tirar um prato do meio da pilha (insert ou remove), vai ter que mover todos os pratos que estavam em cima primeiro.

Exercícios recomendados 👩🏻‍💻💞

Para reforçar o aprendizado, aqui vão alguns desafios práticos:

LeetCode

Two Sum - clássico de arrays
Best Time to Buy and Sell Stock - Percorrer array com análise de tempo
Merge Sorted Array - Manipulação de listas ordenadas

Exercism

Isogram - Percorre strings/arrays verificando duplicatas

E assim, fechamos o segundo capítulo! Espero que tenha sido útil e leve de ler 💁🏻‍♀️✨

Busca Binária e Introdução à Análise de Algoritmos

2025-08-12T00:00:00-03:00

Início de uma série de estudos sobre o livro Entendendo Algoritmos de Aditya Y. Bhargava.

Capítulo 1 - Introdução e Busca Binária -📍 você está aqui
Capítulo 2 - Arrays, Listas e Ordenação por Seleção
Capítulo 3 - Recursão

Esse livro foi indicado por uma amiga, Ana Paula Mendes, e eu não imaginava o quanto iria gostar. A leitura é leve, clara e muito acessível. Se você, como eu, tem dificuldade em manter a constância em leituras técnicas, esse livro é um achado, fácil de entender, ótimo para aprender ou revisar conceitos.

Ele apresenta ideias da ciência da computação que estão no nosso dia a dia, muitas vezes sem que a gente perceba.

Uma das coisas que mais me chamam atenção nesse livro é o jeito como o autor ensina, sempre com exemplos. Em vez de encher de símbolos e fórmulas, ele quer que a gente visualize os conceitos. Ele acredita, e eu concordo, que aprendemos melhor quando conseguimos relacionar o conteúdo com algo que já conhecemos. E, pra isso, os exemplos ajudam muito.

E o melhor é que ele desenha 🤩! Sabe aquela frase “quer que eu desenhe pra você entender”? Eu respondo “sim, por favorrrrr!” e ele realmente desenha. É maravilhoso ✨.

Dá pra sentir que tudo foi pensado com cuidado, desde o conteúdo, os exemplos ilustrados até a recapitulação no fim de cada capítulo.

Depois dessa introdução, bora ver o que o capítulo 1 ensina.

A busca binária em resumo

Pensa numa lista telefônica com 1 milhão de nomes. Olhar folha por folha seria um pesadelo, né? Agora, e se eu te dissesse que dá para encontrar qualquer nome em no máximo 20 tentativas? 👀

O truque é simples: a cada etapa, tu elimina metade das opções. Comece considerando o elemento que está bem no meio da sequência. Em uma lista telefônica, isso seria abrir o livro bem no meio. Em uma lista com 10 itens, isso seria pegar o 5o item. Agora compare esse item do meio com o que você está buscando: se eles forem iguais, parabéns, você encontrou o que procurava! Agora, se o item que você encontrou for MAIOR que o item que você procura (no caso de nomes em uma lista telefônica, pense em qual nome vem primeiro na ordem alfabética), quer dizer que o item buscado está na primeira metade da lista. Caso contrário, o item está na segunda metade da lista. E assim você consegue cortar a lista pela metade apenas comparando o item procurado com o item do meio. Depois disso, basta pegar a parte que você selecionou e aplicar a mesma estratégia, checando o item do meio e descartando metade da lista. Observação: Essa técnica só funciona se a lista de itens estiver ordenada!

E o mais legal é que, mesmo que a lista dobre de tamanho, tu só precisa de mais uma etapa para chegar ao resultado. 🤓

Exemplo: Para facilitar a conta, vamos pegar uma lista menor de 128 nomes e calcular o número máximo de etapas que levaríamos para encontrar um nome específico. Logo em seguida, dobramos o tamanho da lista e vemos que isso adiciona apenas mais uma etapa:

def max_etapas(n):
    etapas = 0
    while n > 1:
        n //= 2
        etapas += 1
    return etapas

print(max_etapas(128)) # 7
print(max_etapas(128*2)) # 8

Observação importante: numa lista telefônica física, a gente já sabe pular quase direto para a letra certa, o que lembra mais o funcionamento de um hashmap (ou dict no Python), que encontra um item em tempo constante. Mas no computador, quando temos apenas uma lista ordenada (como [1, 3, 5, 7, 9, 11, 13]), não existe esse “pulo mágico”, é aí que a busca binária pode ajudar, cortando a lista ao meio de forma sistemática até encontrar (ou concluir que o elemento não está lá).

Legal né? Isso é ciência da computação!! 💁‍♀️✨

Exemplos básicos de busca binária:

Pense em um número entre 1 e 100. Dá para adivinhar em, no máximo, 7 tentativas:

Minha primeira pergunta: “É 50?”

Se você disser “maior”, eu sei que está entre 51 e 100
Se disser “menor”, está entre 1 e 49

Segunda pergunta: Digamos que seja maior que 50. “É 75?” (meio entre 51 e 100)

Maior? Está entre 76 e 100
Menor? Está entre 51 e 74

E assim por diante, sempre eliminando metade das possibilidades.

Vamos ver como fica com uma quantidade maior de números:

Itens na lista	Busca linear (tentativas)	Busca binária (tentativas)
1.000	até 1.000	até 10
1.000.000	até 1.000.000	até 20

Sim, 20 tentativas para encontrar algo entre 1 milhão de opções! 🚀

Esse “milagre” da busca binária acontece por causa de um conceito chamado logaritmo, e já já eu te mostro o porquê.

Agora que você já entendeu a busca binária, vamos entrar em mais três pontos que andam de mãos dadas: logaritmos, tempo de execução e notação Big O.

Preparei um resumo rápido de cada um, do jeito que fez sentido pra mim. Se em algum momento ficar confuso, não tem problema, dá uma olhada no livro que é sucesso 🫂💖

Logaritmos:

O número máximo de tentativas na busca binária é dado por log₂(n), logaritmo na base 2 de n.

Se o nome assusta, pensa assim:

log₂(n) é o número de vezes que você precisa dividir n por 2 até chegar em 1

Exemplo:

log₂(128) = 7, 7 cortes ao meio até sobrar 1 item
log₂(256) = 8, só mais uma etapa, mesmo dobrando o tamanho da lista

A base “2” vem justamente porque a cada passo cortamos a lista pela metade.

Tempo de execução:

Sempre que falamos sobre um algoritmo, é importante pensar no tempo de execução, quanto esforço (ou quantos passos) ele precisa para chegar ao resultado.

Na busca linear (a pesquisa simples), verificamos item por item:

Lista com 100 números → até 100 tentativas
Lista com 4 bilhões de números → até 4 bilhões de tentativas

O tempo de execução cresce na mesma proporção que o tamanho da lista. Chamamos isso de tempo linear.

A busca binária é um outro mundo:

Lista com 100 números → no máximo 7 tentativas
Lista com 4 bilhões → no máximo 32 tentativas

Isso acontece porque a busca binária corta as possibilidades pela metade a cada passo. Esse tipo de crescimento é chamado de tempo logarítmico.

Notação Big O

A notação Big O é um jeito de medir a eficiência de um algoritmo, mostrando como o tempo de execução cresce conforme aumentamos o tamanho da entrada.

O(log n), tempo logarítmico (ex: pesquisa binária)
O(n), tempo linear (ex: pesquisa simples)
O(n * log n), um algoritmo rápido de ordenação, como quicksort (Capítulo 4)
O(n²), um algoritmo de ordenação mais lenta, como ordenação por seleção (Capítulo 2).
O(n!), um algoritmo extremamente lento, como o do caixeiro viajante (Capítulo 1).

O livro ilustra isso de forma bem visual e intuitiva: cresce linearmente, cresce em log, cresce muito, cresce lento… e por aí vai.

Agora que vimos como a busca binária funciona, vale notar que ela não está restrita a livros, ela aparece em várias situações do nosso dia a dia

Sistemas de busca (Google, WhatsApp, Spotify): por trás, usam variações de busca binária em listas ordenadas ou índices.
Filtragem de dados: encontrar rapidamente um registro específico em planilhas ou bases de dados grandes.
Depuração de código: reduzir o espaço do problema pela metade a cada teste para achar onde o bug está.

Observação: para que a busca binária funcione, os dados precisam estar ordenados.

Vamos praticar rapidinho?

Aqui está uma lista ordenada de números: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32]

Tente encontrar o número 22 de duas formas:

Busca linear: Vá um a um desde o 2.
Busca binária: Comece no meio, elimine metade a cada passo.

Compare quantos passos cada método precisou

Curiosidades

O git tem uma funcionalidade chamada git bisect que usa busca binária para ajudar desenvolvedores a encontrarem bug
Se o item que estamos buscando for o primeiro item da lista, esse é o melhor caso na busca linear e o pior caso na busca binária
A implementação do sortedcontainers usa busca binária (a partir do módulo bisect), veja aqui

Exercícios recomendados 👩🏻‍💻💞

Para reforçar o aprendizado, aqui vão alguns desafios práticos:

LeetCode

Binary Search — implementação direta.
Search Insert Position — variação para encontrar onde inserir um número.
First Bad Version — busca binária aplicada em API.

Exercism

Binary Search (Python Track) — implementação e testes.

Dica: resolva primeiro o problema sem olhar a solução e depois compare com implementações otimizadas.

E assim começa meu roadmap de estudo: cada capítulo do livro vem acompanhado de exercícios para fixar o conteúdo.

Como criei meu blog 💁‍♀️✨

2025-07-28T00:00:00-03:00

Ter um espaço só meu, fora de redes sociais, longe dos algoritmos, era um desejo antigo. Um cantinho para escrever sobre o que gosto, do meu jeito, sem pressa. E foi assim que nasceu o meu blog. 💛

Neste post, compartilho como tirei a ideia do papel, desde a escolha da stack até o deploy.

A stack que escolhi

Optei por usar o Pelican, um gerador de site estático escrito em Python. Ele me atraiu por vários motivos:

É feito com Python 🐍
Gera HTML puro (leve, rápido e fácil de hospedar)
- Ou seja: não tem nada sendo processado dinamicamente no servidor; Isso deixa o site mais rápido, seguro e barato/fácil de hospedar (como no GitHub Pages, que só serve arquivos estáticos).
A estrutura é simples de customizar
Permite escrever os posts em Markdown 📝
A documentação… é meio confusa, mas fui até o fim mesmo assim 😅

Além do Pelican, usei o uv como gerenciador de pacotes e ambientes virtuais, ele é rápido e prático, e tem substituído o uso manual do venv e do pip.

🛠️ Passo a passo

1. Criar o ambiente e instalar o Pelican

Usei o uv para criar meu ambiente virtual com:

uv venv

Depois disso, ativei o ambiente manualmente com:

source .venv/bin/activate

O uv venv já cria o ambiente e ativa os pacotes com isolamento, mas, por hábito (e um pouco de força do costume), usei source .venv/bin/activate logo depois. O uv também poderia dispensar esse passo.

Esse passo não é automático, o uv venv cria o ambiente, mas não o ativa. Eu fiz isso por hábito, já que é o modo tradicional que muitos de nós usamos com venv.

No entanto, o uv também oferece uma forma mais moderna (e prática!) de lidar com ambientes virtuais: você pode pular o uv venv e o source, e simplesmente deixar que ele gerencie tudo pra você:

uv add pelican[markdown] # declara o `pelican` como uma dependência do projeto

uv run pelican-quickstart # executa o comando `pelican-quickstart` dentro do ambiente virtual gerenciado automaticamente pelo `uv`

Assim, o uv cria o ambiente e executa os comandos dentro dele automaticamente, sem precisar ativar nada “na mão

Só uma observação: se você preferir usar a forma uv add ... e uv run ..., o arquivo Makefile precisaria ser alterado, substituindo a linha PELICAN=pelican por PELICAN=uv run pelican - ou todas as referências a make <rule> precisariam virar PELICAN="uv run pelican" make <rule>.

2. Organização do projeto

Segui as perguntas do setup e logo já tinha uma estrutura básica criada. A partir disso, organizei o repositório com o seguinte foco:

content/ → onde ficam os posts em Markdown
output/ → site gerado (HTML)
theme/ → arquivos do tema e personalizações

O repositório está disponível aqui: github.com/aninhasalesp/meublog

A pasta pelican-themes/ foi criada por mim manualmente pra colocar o tema clonado e fazer as modificações.

3. Escolhendo e personalizando o tema 🎨

Usei o tema notmyidea-cms, que vem com o Pelican, e fui personalizando aos poucos.

No pelicanconf.py:

THEME = "pelican-themes/notmyidea-cms"

Fiz as seguintes mudanças:

Rodapé com meu nome e link pro GitHub ❤️
Comentários com Utterances
Botões de compartilhamento (LinkedIn, WhatsApp e Telegram)
Ajustes no CSS para espaçamentos, layout e cores

4. Comentários com Utterances 💬

Usei o Utterances para habilitar comentários nos posts. É leve, usa issues do GitHub, é simples e eficiente:

<div id="comments">
  <script src="https://utteranc.es/client.js"
    repo="aninhasalesp/meublog"
    issue-term="pathname"
    theme="github-light"
    crossorigin="anonymous"
    async>
  </script>
</div>

5. Escrevendo os posts ✍️

Os posts ficam em content/ e são escritos assim:

Title: Primeiro post
Date: 2025-07-20
Category: pessoal
Summary: Um breve texto pra dar boas-vindas ao blog.

---

Esse é o primeiro post do blog! 🎉

6. Customizações no tema

Editei os arquivos dentro de pelican-themes/notmyidea-cms/ e deixei o blog com mais identidade.

No CSS:

Ajustei padding e margin
Alinhei melhor os elementos
Adicionei ícones e links visuais

No HTML (como o base.html):

Adicionei o rodapé
Posicionei os botões de compartilhamento

💡 Fazer as edições direto no tema funcionou bem pra mim, mesmo que não seja o ideal a longo prazo.

7. Gerando os arquivos estáticos

Para compilar o blog e gerar os arquivos HTML:

make html

Durante o desenvolvimento, usei o servidor local pra visualizar as mudanças:

pelican --listen

8. Deploy no GitHub Pages 🚀

Usei GitHub Pages pra hospedar o blog. O processo foi:

Gerei os arquivos com pelican content ou make html
Subi a pasta output/ para o branch gh-pages
Configurei o domínio personalizado no GitHub e apontei o DNS para os servidores do GitHub

O Makefile ajuda bastante, publiquei com:

make github

Esse comando está no meu Makefile e automatiza a geração e envio do conteúdo. Se quiser ver, ele basicamente faz:

cd output
git checkout -b gh-pages
git add .
git commit -m "Deploy"
git push -f origin gh-pages

No GitHub, fui na aba Settings > Pages e configurei pra servir o site a partir do branch gh-pages, pasta raiz (/).
Adicionei um arquivo CNAME com meu domínio personalizado (anapaula.org)
Apontei os DNSs da minha hospedagem pro GitHub Pages
Ativei o HTTPS no painel

Se você quiser automatizar esse deploy com GitHub Actions, também dá. Mas como é um blog pessoal que não atualizo todos os dias, preferi o método manual.

9. Domínio personalizado 🌐

Registrei o domínio anapaula.org e configurei para ser usado no meu blog hospedado via GitHub Pages.

O que eu fiz: No painel da empresa onde registrei o domínio, adicionei os seguintes registros DNS:

Tipo A (IPv4): apontando para os IPs do GitHub Pages:

185.199.108.153
185.199.109.153
185.199.110.153
185.199.111.153

CNAME (se quiser usar subdomínio): apontando para suaconta.github.io

Dentro da pasta output/ (que é a que vai para o GitHub Pages no branch gh-pages), criei um arquivo CNAME com o conteúdo:

anapaula.org

Isso é necessário para que o GitHub saiba qual domínio deve ser vinculado ao seu site. Esse arquivo é incluído automaticamente no deploy quando rodo make github.

No repositório no GitHub, fui em Settings > Pages e:

Marquei a opção “Use a custom domain” e coloquei anapaula.org
Ativei o HTTPS (pra garantir navegação segura)

Segui a documentação oficial do GitHub Pages para configurar tudo isso: 👉 documentação github-pages

Conclusão

O processo teve tropeços (a documentação do Pelican podia ser melhor 😅), mas valeu demais. Ter um espaço meu, com o meu nome e com a minha cara, era um desejo antigo que finalmente saiu do papel.

Se você também pensa em criar um blog, seja técnico ou pessoal, recomendo muito! E se eu puder ajudar de alguma forma, é só me chamar. 💛

O código-fonte do blog está no GitHub: aninhasalesp/meublog 🌱

Carreira x Filhos

2025-07-23T00:00:00-03:00

Vi um post no LinkedIn recentemente (infelizmente perdi o link) sobre uma candidata a uma vaga que, no currículo, escreveu com destaque: (SEM FILHOS).

Pra quem não sabe, eu sou mãe de uma menina de 9 anos. Isso causa espanto em algumas pessoas porque sou considerada jovem demais pra ser mãe.

Essa é minha filha, Maria Eduarda 💕:

Por muito tempo me culpei por ter sido mãe cedo, por não ter seguido a linha do tempo que parece ser a “correta” para a maioria das pessoas:

estudar ➜ se formar ➜ trabalhar ➜ casar ➜ juntar dinheiro ➜ ter filhos

Também me sentia mal por não ter a mesma experiência técnica que muitos dos meus amigos.
A verdade é que, enquanto eles estavam na faculdade ou fazendo mestrado, eu estava aprendendo a ser mãe, aprendendo como manter uma criança viva, sendo eu mesma praticamente uma criança.

Mas o que isso diz sobre mim e meu perfil profissional?

Quando nos tornamos mães, a vida não para pra gente aprender a ser mãe, a vida continua, acontece em paralelo à maternidade.
Enquanto eu aprendia a ser mãe, também era estudante, mulher migrando de área, mudando de estado em busca de oportunidades melhores pra mim e pra minha filha.
Busquei apoio nas PyLadies locais, buscava algo que me mostrasse que eu era capaz de trabalhar fora de casa, e não só em casa.

Hoje, sou uma mãe que trabalha, estuda, treina, ajuda a filha com as provas, colabora com a comunidade Python, cozinha, palestra em eventos, viaja a trabalho e mantém a casa organizada (na medida do possível) no meio de tudo isso.

Tá, mas… o que isso tem a ver com meu perfil profissional?

Sou uma profissional com excelente gestão de tempo, foco em produtividade, que sabe priorizar o essencial, que organiza tarefas, que está sempre aprendendo algo novo.
Sou alguém que se formou com uma criança correndo pela casa, que sabe se comunicar com clareza e que, mesmo com algumas inseguranças, consegue se reinventar quando necessário.
Quando eu preciso estudar algo profundamente, crio uma palestra e submeto em eventos, é assim que aprendo e compartilho.

Não sou a Mulher-Maravilha. Não sou boa em tudo.
Sou um ser humano em constante mudança, que se adapta, que mergulha de cabeça no que se propõe a fazer e isso me agrega muito profissionalmente.

Hoje, não me culpo mais por ter sido mãe cedo.
Hoje, agradeço.
Sem minha filha, eu talvez não tivesse a garra, a facilidade de lidar com obrigações em meio ao caos, num curto espaço de tempo e, principalmente, não teria aprendido tão cedo a pedir ajuda antes de perder tempo esperando que as coisas acontecessem magicamente.

Contratem mães.
Mesmo que a prioridade número um delas não seja sua empresa, elas ainda fazem dela uma prioridade. E o que elas entregam tem muito valor. 💖

Personalizando o GitHub 🤌🏻💕

2025-07-16T00:00:00-03:00

Ei, tu já visitou algum perfil no GitHub que parecia te contar a história da pessoa e/ou com o que ela trabalha, mesmo sem abrir nenhum repositório? Ou que tu tenha achado fofinho e super organizado?

Eu acho incrível como as pessos conseguem dar vida àquele cantinho, fica com personalidade, cuidado e, muitas vezes, até com afeto. ✨

Neste post, eu te mostro como personalizar o seu perfil no GitHub. Bora lá?

1. Criando o seu README de perfil

Acesse o GitHub e clique em “New repository”
No campo de nome, digite exatamente o seu nome de usuário
Marque a opção “Add a README file”
Clique em “Create repository”

Pronto! Agora você tem um espaço só seu, no topo do seu perfil.

2. O que colocar no seu README? 💁‍♀️✨

Não existe uma fórmula certa, mas aqui vão ideias que funcionam bem:

Sobre você:
- Uma frase que te represente
- Curiosidades, onde você está, o que faz
- Um toque pessoal (hobbie, projetos pessoais, playlists favoritas)
Tecnologias:
- Ferramentas e libs que você usa no dia a dia
- Linguagens que domina ou tem estudado
URLs:
- Seu blog, LinkedIn, site pessoal, email
Destaques:
- Fixe seus repositórios mais importantes no perfil
- Pode até explicar brevemente o que eles fazem ou por que são especiais pra você

3. Dicas de cuidado 🌿

Escreva com simplicidade e verdade
Organize com títulos, espaçamentos e listas
Use emojis se quiser, mas com moderação

4. Não precisa ser perfeito

O mais importante é que ele diga algo sobre você. Ta tudo bem ser simples no início e ir crescendo aos poucos. A ideia não é impressionar, é se expressar 💜

Ah, se quiser ver como ficou o meu, está aqui!

Se tiver dúvidas pra começar, me chama, vou adorar ajudar 🌷.

Meu ambiente dev

2025-06-10T00:00:00-03:00

Decidi compartilhar como monto meu ambiente de desenvolvimento, desde a instalação do sistema até as ferramentas e extensões que uso no dia a dia.

Sistema Operacional

Começo com a instalação do Linux. Tenho um guia pessoal que sigo sempre que preciso configurar uma máquina nova talvez eu compartilhe em outro post futuramente.

Ferramentas e utilitários que instalo

Esses são alguns dos programas e bibliotecas que instalo e uso com frequência:

Cursor: Ainda não usei de fato. Apesar de parecer promissor, não acho ideal para o trabalho por envolver dados sigilosos.
UV: Perfeito! Super rápido, uso muito no dia a dia com Python.
1Password: Tem sido ótimo para gerenciar senhas com segurança.
Bottom: MUITO LINDO e fácil de entender. Um monitor de sistema que dá gosto de usar.
Lazygit e Lazydocker: Os dois lazy são ótimos, leves e práticos.
Bat: Um cat turbinado. Visualização linda e com syntax highlight.
VSCode: Meu editor principal.
Terminator: Gosto bastante da organização em painéis.
OBS Studio: Para gravações de tela e eventualmente fazer lives.
Flameshot: Meu queridinho para prints com marcações rápidas.

Terminal e produtividade

Oh My Zsh: Meu gerenciador de configurações para o Zsh.
Yazi: Um gerenciador de arquivos rápido e com interface linda.
Kitty: Meu terminal favorito atualmente, rápido e personalizável.

Extensões do VSCode que uso

Sublime Text Keymap: Deixa o VSCode com os atalhos do Sublime, que eu adoro.
VSCode Great Icons: Deixa os ícones mais bonitos e fáceis de identificar.
GitLens: Uma extensão poderosa para visualizar histórico de commits, anotações por linha etc.
Copilot: Tenho usado com moderação, mas ajuda bastante com sugestões rápidas.
Run on Save: Para automatizar tarefas quando salvo arquivos.
Docker: Para trabalhar com containers diretamente no editor.

Se você também curte organizar seu ambiente de forma prática e bonita, compartilha comigo suas ferramentas! ♥