@aninhasalesp

Recursion

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

Third chapter of my study series on Grokking Algorithms by Aditya Y. Bhargava.

If you’ve been following along, I’ve already summarized the previous chapters 👀, go back if you have any questions:

Chapter 1 - Introduction and Binary Search
Chapter 2 - Arrays, Linked Lists and Selection Sort
Chapter 3 - Recursion 📍 you are here

Hey everyone! Another little summary of our beloved book 😊

This was one of the chapters that did the most to take away the feeling that programming is magic. Ready to understand recursion and stacks without fear?

In this chapter, the author explains the concept and use of recursion in a simple way, breaking it down into base case and recursive case. He suggests that at least once, you trace through a recursive function with pen and paper, step by step that’s how you truly understand how it works.

Recursion

It’s the technique where a function calls itself to solve a problem, breaking it down into smaller subproblems. Because a recursive function calls itself, it’s easy to write it incorrectly and end up in an infinite loop. For recursion to work correctly, it must have a base case to stop the calls, and a recursive case that moves the problem closer to the final solution.

How recursion works

Before showing an example, let’s understand how it works.

Base case: defines when the function should stop calling itself. Without it, the recursion would go on forever and cause an error.
Recursive case: the part where the function calls itself again, getting one step closer to the final solution each time.

A classic example is calculating the factorial of a number:

def factorial(n):
    if n == 0 or n == 1:  # Base Case
        return 1
    else:  # Recursive Case
        return n * factorial(n - 1)

print(factorial(5))  # Output: 120

In this example:

Base Case: n is 0 or 1, so the factorial is 1
Recursive Case: if n is greater than 1, the factorial is n * factorial(n-1)

See how it’s almost poetic each number calls the next until 1 says “okay, stop, now go back.” Then the multiplication happens on the way back up.

Stack

Imagine you’re hosting a barbecue for your friends. You have a to-do list in the form of a stack of sticky notes. When you add an item, it goes on top of the stack. When you read an item, you only read the one on top and it gets removed. So your to-do list has only two actions: push (add) and pop (remove and read).

This data structure is called a stack. It’s a simple structure and we use it all the time without even realizing it.

The call stack

Every time a function is called, the computer needs to “remember” where it left off so it can continue later. This temporary memory is organized in a call stack.

Here’s how it works:

With each new function call, the computer pushes information about that execution (like parameters and local variables) onto the stack.
When the function finishes, the computer pops that data and returns to the previous point.

The book’s metaphor is great think of a stack of plates in the kitchen. You can only grab (or remove) the plate on top. Functions work the same way: the last one in is the first one out (LIFO: Last In, First Out).

We can visualize this with a simple Python example:

def greet(name):
    print("Hi,", name)
    farewell()

def farewell():
    print("Goodbye!")

greet("Ana")

Execution order on the stack:

greet("Ana") is called → pushed onto the stack.
Inside it, farewell() is called → sits on top.
farewell() runs and is popped from the stack.
greet("Ana") finishes and is popped from the stack.

Everything organized, one plate at a time.

This example already shows that it’s not just recursion that uses a stack any function does. The difference is that recursion forces the stack to grow much faster.

The call stack with recursion

With recursion, the stack can grow quite a bit, because the function keeps calling itself until it hits the base case.

Simplified example with factorial(3):

The program calls factorial(3)
    - pushes factorial(3)

To solve it, it needs factorial(2)
    - pushes factorial(2)

To solve that, it needs factorial(1)
    - pushes factorial(1)

factorial(1) hits the base case and returns 1
    - pops factorial(1)

Now factorial(2) can calculate 2 × 1 = 2
    - pops factorial(2)

Finally, factorial(3) calculates 3 × 2 = 6
    - pops factorial(3)

In the end, each call can only finish after the smaller one returns. That’s why defining the base case well is so important without it, the function never stops stacking calls and eventually crashes the memory (stack overflow).

That “stack overflow” is literally where the Stack Overflow website got its name.

When I first saw this process, it felt like some kind of magic as if the computer just knew where to go back to.

That’s when I realized that understanding programming is a lot about demystifying things. It’s not a gift, it’s not genius it’s just pushing and popping, calmly. Now whenever I see a recursive function, I try to picture that stack running in the background. It brings clarity and turns “I wasn’t born for this / I’ll never get this” into “hehe, that’s actually cool” 😎

So next time you get lost in a recursive piece of code breathe. Draw the stack, follow the steps, and remember: it’s not magic, it’s just practice!!!

Fun facts 💡

A very common recursion outside of programming: Russian dolls (matryoshkas). Each doll holds another inside it, until the smallest one (the base case) holds nothing at all.
Some languages apply tail call optimization, which reuses stack frames to avoid memory overflow in very deeply recursive functions. Python, however, does not do this.
The call stack is invisible most of the time but you’ve already seen it working: when Python shows a traceback (that error full of arrows, showing which function the execution was in).
Many recursive functions can be rewritten iteratively (using for or while loops). This avoids the risk of stack overflow in cases with very deep calls.
To understand recursion, you must first understand recursion. 😅

Recommended exercises 👩🏻‍💻💞

Here are some practical challenges to reinforce what you learned:

LeetCode

Merge Two Sorted Lists can be solved recursively, treating the base case as when one list reaches the end.
Climbing Stairs a classic recursion + optimization problem (similar to Fibonacci).

Exercism

Flatten Array receives a list that may contain sublists and needs to return everything “flattened” into a single list.
Recursion with Python reinforces the concept and includes the “Luhn” exercise, which works well with a recursive approach.

Extra challenge

Write a recursive function that walks through folders and files on your computer (or just a simulated nested list). That’s literally how many file systems work.

I hope you enjoyed the content! ✨💕

If you have any exercise suggestions or improvements for the explanation, let me know 🫂🌻

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 e Busca Binária
- Capítulo 2 - Arrays, Listas e 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 🫂🌻

Selection Sort, Arrays and Linked Lists

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

Second chapter of my study series on Grokking Algorithms by Aditya Y. Bhargava.

Chapter 1 - Introduction and Binary Search
Chapter 2 - Arrays, Linked Lists and Selection Sort 📍 you are here
Chapter 3 - Recursion

I hope you enjoyed the structure from chapter 1 I’ll be keeping the same vibe here. If you have any exercise suggestions or improvements for the explanation, let me know! I’d love the feedback 🫂💕

In chapter 2, the author dives deeper into two fundamental concepts: data structures (like arrays and linked lists) and algorithm efficiency (Big O notation). To illustrate this, he introduces the selection sort algorithm.

Arrays and Linked Lists

Before talking about sorting, it’s important to understand how data can be stored in memory. 👀

The author brings an analogy that makes everything muuuch easier to understand. The idea goes something like this:

Imagine you’re going to a concert and need to leave your things at the coat check (I didn’t even know that was a thing 🤔). Only a few slots are available and you can store one item per slot. You drop your stuff off, close up, and you’re ready to enjoy the show.

Computer memory works a lot like this. The computer is like a huge set of slots, and each slot has an address. Every time you store an item in memory, the computer gives you an address to put it in.

Now, if you want to store multiple items, there are two main ways to do it: arrays and linked lists.

Arrays

Contiguous blocks of memory each slot is right next to the other.
Each element can be accessed directly by its index, which makes reading fast.
- This means the lookup-by-position operation is O(1) constant time.

arr = [10, 20, 30]
print(arr[1])  # direct access to 20

The downside of arrays is that if you want to add one more item and the next slot is taken, the computer has to find a bigger block of memory and move all existing items there.
So adding items to an array can be very slow.
Deleting an element is just as costly all following elements need to be shifted.

Linked Lists

Items can be stored anywhere in memory.
Each item stores the address of the next item in the list.
Kind of like a treasure hunt each clue tells you where the next one is.
Adding an item is simple: just put it anywhere in memory and update the previous item’s pointer.
Deleting is just as easy: just change the previous item’s pointer to skip over the one you want to remove.
The downside of linked lists is that to access a specific element (say, the last one), you can’t jump straight to it you have to walk through the list one item at a time.

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

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

# Traversing
n = a
while n:
    print(n.value)
    n = n.next

Breaking down the code above: 1. I create the Node class, which stores a value (value) and a pointer to the next node (next). 2. I create two nodes: a with value 10 and b with value 20. 3. I link a to b with a.next = b. 4. I traverse the list with while n:, printing n.value until I reach the end (None).

Output:

10
20

I don’t know about you, but understanding the difference between arrays and linked lists was a real lightbulb moment for me. Since I learned Python first, I kind of used these structures on autopilot… 🥲 It might seem obvious or even unnecessary after all, we deal with arrays and lists all the time but it was incredible to finally understand why things work the way they do. My brain finally started connecting the dots and seeing the logic behind it all. I was kind of like:

Here are the running times for the most common operations on arrays and linked lists:

I think it’s important to have this table handy to reinforce Big O notation and help everyone understand the impact of our choices in different situations.

A more explicit breakdown:

Reading:
- Array → O(1): In an array, each position has a fixed address in memory. So if you want the 5th element, the computer goes straight to it super fast, constant time.
- Linked List → O(n): In a linked list, each element only knows who comes next. So to find the 5th element, you have to start from the 1st, then the 2nd, then the 3rd… all the way to the 5th. The bigger the list, the longer it takes.
Insertion:
- Array → O(n): If the array is full and you want to insert a new item in the middle, you have to “push” all other elements one position forward. That can take a while.
- Linked List → O(1): If you already know the position, inserting into a linked list is quick just change who points to whom, and you’re done.
Deletion:
- Array → O(n): If you remove an item from the middle of an array, you have to “pull” all the elements after it one position back to close the gap.
- Linked List → O(1): Just like insertion, you just update the pointers to skip the item you want to remove. Nothing else needs to move.

Selection Sort

The author presents the Selection Sort algorithm simple to implement, but not very efficient. Understanding the difference between arrays and linked lists makes it important to see how the algorithm traverses and manipulates elements.

How it works

Find the smallest element in the list
Place it in the first position
Repeat for the remaining positions until the whole list is sorted

Python implementation:

def find_smallest(arr):
    """
    Finds the index of the smallest element in an array.

    Parameters:
    arr (list): A list of comparable elements.

    Returns:
    int: Index of the smallest element found.
    """
    smallest = arr[0]
    smallest_index = 0
    for i in range(1, len(arr)):
        if arr[i] < smallest:
            smallest = arr[i]
            smallest_index = i
    return smallest_index

def selection_sort(arr):
    """
    Sorts a list using the selection sort algorithm.

    The function creates a new list by removing the smallest element
    from the original list at each iteration and appending it to the sorted list.

    Parameters:
    arr (list): A list of numbers to sort.

    Returns:
    list: A new list sorted in ascending order.
    """
    new_arr = []
    for i in range(len(arr)):
        smallest = find_smallest(arr)
        new_arr.append(arr.pop(smallest))
    return new_arr

print(selection_sort([5, 3, 6, 2, 10]))  # Output: [2, 3, 5, 6, 10]

Complexity and Big O

Selection sort needs to traverse all elements multiple times.
For n elements, it performs roughly n × n operations.
This means its performance is O(n²).

This is a classic example of how different algorithms can solve the same problem with different efficiencies, highlighting the importance of choosing the right algorithm based on the size and structure of your data.

Fun facts

Lists in Python are actually arrays.
The append method (adding to the end) is considered O(1) on average. That’s because adding to the end is cheap: just place the item in the next available slot.
The “expensive” part shows up with operations like insert or remove in the middle. Those require shifting all following elements, which can be O(n).
A good way to visualize: think of a stack of plates. Putting or taking a plate from the top (append and pop) is easy. But if you want to insert or remove one from the middle (insert or remove), you have to move all the plates above it first.

Recommended exercises 👩🏻‍💻💞

Here are some practical challenges to reinforce what you learned:

LeetCode

Two Sum classic array problem
Best Time to Buy and Sell Stock traversing an array with time analysis
Merge Sorted Array sorted list manipulation

Exercism

Isogram traverses strings/arrays checking for duplicates

And that wraps up chapter 2! I hope it was useful and easy to read 💁🏻‍♀️✨

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 💁🏻‍♀️✨

Binary Search and Introduction to Algorithm Analysis

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

Start of a study series on the book Grokking Algorithms by Aditya Y. Bhargava.

Chapter 1 - Introduction and Binary Search 📍 you are here
Chapter 2 - Arrays, Linked Lists and Selection Sort
Chapter 3 - Recursion

This book was recommended by a friend, Ana Paula Mendes, and I had no idea how much I’d love it. The writing is light, clear, and very accessible. If you, like me, have a hard time staying consistent with technical reading, this book is a gem easy to understand, great for learning or revisiting concepts.

It presents computer science ideas that show up in our everyday lives, often without us even noticing.

One of the things I love most about this book is how the author teaches always through examples. Instead of overwhelming you with symbols and formulas, he wants you to visualize the concepts. He believes and I agree that we learn better when we can connect new content to something we already know. And examples are the best way to do that.

And the best part? He literally draws 🤩! You know when someone says “do you want me to draw it for you?” I always say “yes, please!” and he actually does. It’s wonderful ✨.

You can feel that everything was thought through carefully: the content, the illustrated examples, and the recap at the end of each chapter.

With that intro out of the way, let’s see what chapter 1 is all about!

Binary search in a nutshell

Imagine a phone book with 1 million names. Going page by page would be a nightmare, right? Now, what if I told you that you can find any name in at most 20 tries? 👀

The trick is simple: at each step, you eliminate half the options. Start with the element right in the middle of the sequence. In a phone book, that would be opening it right in the middle. In a list of 10 items, that’s picking the 5th one. Now compare that middle item with what you’re looking for: if they match congrats, you found it! If the middle item is GREATER than what you’re looking for (think alphabetical order for names), the item must be in the first half. Otherwise, it’s in the second half. This way, you cut the list in half with just one comparison. Then you take the selected half and repeat the same strategy.

Note: This only works if the list is sorted!

And the coolest part? Even if the list doubles in size, you only need one more step to find the result. 🤓

Example: Let’s use a smaller list of 128 names and calculate the maximum number of steps to find a specific one. Then we double the list and see it only adds one more step:

def max_steps(n):
    steps = 0
    while n > 1:
        n //= 2
        steps += 1
    return steps

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

Important note: with a physical phone book, we already know to jump almost directly to the right letter which is more like how a hashmap (or Python dict) works, finding an item in constant time. But in a computer, when you only have a sorted list (like [1, 3, 5, 7, 9, 11, 13]), there’s no such “magic jump” that’s where binary search helps, cutting the list in half systematically until it finds the item (or confirms it’s not there).

Pretty cool, right? That’s computer science!! 💁‍♀️✨

Basic binary search examples

Think of a number between 1 and 100. You can guess it in at most 7 tries:

My first question: “Is it 50?”

If you say “higher”, I know it’s between 51 and 100
If you say “lower”, it’s between 1 and 49

Second question: Let’s say it’s higher than 50. “Is it 75?” (midpoint between 51 and 100)

Higher? It’s between 76 and 100
Lower? It’s between 51 and 74

And so on always cutting the possibilities in half.

Let’s see how it scales with larger numbers:

Items in list	Linear search (tries)	Binary search (tries)
1,000	up to 1,000	up to 10
1,000,000	up to 1,000,000	up to 20

Yes 20 tries to find something among 1 million options! 🚀

This “miracle” happens because of a concept called logarithms and I’ll show you why in just a moment.

Now that you understand binary search, let’s look at three things that go hand in hand with it: logarithms, running time, and Big O notation.

Here’s a quick summary of each, broken down the way that made sense to me. If something gets confusing, no worries just check the book, it’s great 🫂💖

Logarithms

The maximum number of tries in binary search is given by log₂(n) the base-2 logarithm of n.

If the name sounds scary, think of it this way:

log₂(n) is how many times you need to divide n by 2 until you reach 1

Example:

log₂(128) = 7 7 halving steps until 1 item remains
log₂(256) = 8 just one more step, even though the list doubled

The base “2” comes from the fact that at each step we cut the list in half.

Running time

Whenever we talk about an algorithm, it’s important to think about running time how much effort (or how many steps) it needs to reach a result.

With linear search (simple search), we check item by item:

List with 100 numbers → up to 100 tries
List with 4 billion numbers → up to 4 billion tries

The running time grows in direct proportion to the list size. We call this linear time.

Binary search is a different story:

List with 100 numbers → at most 7 tries
List with 4 billion → at most 32 tries

This happens because binary search cuts the possibilities in half at every step. This type of growth is called logarithmic time.

Big O Notation

Big O notation is a way to measure the efficiency of an algorithm showing how running time grows as the input size increases.

O(log n) logarithmic time (e.g. binary search)
O(n) linear time (e.g. simple search)
O(n * log n) a fast sorting algorithm, like quicksort (Chapter 4)
O(n²) a slower sorting algorithm, like selection sort (Chapter 2)
O(n!) an extremely slow algorithm, like the traveling salesperson (Chapter 1)

The book illustrates this in a very visual and intuitive way: grows linearly, grows in log, grows a lot, grows slowly… and so on.

Now that we’ve seen how binary search works, it’s worth noting that it’s not just for phone books it shows up in many real-life situations:

Search systems (Google, WhatsApp, Spotify): under the hood, they use variations of binary search on sorted lists or indexes.
Data filtering: quickly finding a specific record in large spreadsheets or databases.
Debugging: reducing the problem space by half at each test to find where the bug is.

Note: for binary search to work, the data must be sorted.

Quick practice?

Here’s a sorted list of numbers: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32]

Try to find the number 22 in two ways:

Linear search: go one by one starting from 2.
Binary search: start in the middle, eliminate half at each step.

Compare how many steps each method took!

Fun facts

Git has a feature called git bisect that uses binary search to help developers find bugs
If the item we’re looking for is the first in the list, that’s the best case for linear search and the worst case for binary search
The sortedcontainers implementation uses binary search (via the bisect module) see here

Recommended exercises 👩🏻‍💻💞

Here are some practical challenges to reinforce what you learned:

LeetCode

Binary Search straightforward implementation.
Search Insert Position variation to find where to insert a number.
First Bad Version binary search applied to an API.

Exercism

Binary Search (Python Track) implementation and tests.

Tip: try to solve the problem before looking at any solution, then compare your approach with optimized implementations.

And so begins my study roadmap: each chapter of the book comes with exercises to reinforce the content.

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.

How I built my blog 💁‍♀️✨

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

Having a space of my own away from social media, away from algorithms was something I’d wanted for a long time. A little corner to write about what I love, in my own way, without rushing. And that’s how my blog was born. 💛

In this post, I’m sharing how I went from idea to live site from choosing the stack all the way to deploying it.

The stack I chose

I went with Pelican, a static site generator written in Python. It won me over for a few reasons:

It’s built with Python 🐍
It generates pure HTML (lightweight, fast, and easy to host)
- Meaning: nothing is processed dynamically on the server. That makes the site faster, more secure, and cheaper/easier to host (like on GitHub Pages, which only serves static files).
The structure is simple to customize
Posts are written in Markdown 📝
The documentation… is a bit confusing, but I pushed through anyway 😅

I also used uv as my package and virtual environment manager it’s fast, practical, and has replaced my old manual venv + pip workflow.

🛠️ Step by step

1. Setting up the environment and installing Pelican

I used uv to create my virtual environment:

uv venv

Then I activated it manually:

source .venv/bin/activate

uv venv creates the environment with isolation, but doesn’t activate it automatically. I did it out of habit it’s the traditional way most of us learned with venv.

That said, uv also offers a more modern (and practical!) way to handle virtual environments. You can skip uv venv and source entirely and just let uv manage everything:

uv add pelican[markdown] # declares `pelican` as a project dependency

uv run pelican-quickstart # runs `pelican-quickstart` inside the automatically managed virtual environment

This way, uv creates the environment and runs commands inside it automatically no manual activation needed.

One note: if you prefer using uv add ... and uv run ..., you’d need to update the Makefile, replacing PELICAN=pelican with PELICAN=uv run pelican or all make <rule> calls would need to become PELICAN="uv run pelican" make <rule>.

2. Project structure

I followed the setup prompts and had a basic structure ready in no time. From there, I organized the repo with a clear focus:

content/ → where the Markdown posts live
output/ → the generated HTML site
theme/ → theme files and customizations

The repository is available here: github.com/aninhasalesp/meublog

I created the pelican-themes/ folder manually to clone the theme and make my own modifications.

3. Choosing and customizing the theme 🎨

I used the notmyidea-cms theme that comes with Pelican and customized it little by little.

In pelicanconf.py:

THEME = "pelican-themes/notmyidea-cms"

The changes I made:

Footer with my name and a link to my GitHub ❤️
Comments with Utterances
Share buttons (LinkedIn, WhatsApp and Telegram)
CSS tweaks for spacing, layout, and colors

4. Comments with Utterances 💬

I used Utterances to enable comments on posts. It’s lightweight, uses GitHub issues, and it’s simple and efficient:

<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. Writing posts ✍️

Posts live in content/ and are written like this:

Title: First post
Date: 2025-07-20
Category: personal
Summary: A short welcome text for the blog.

---

This is the first post! 🎉

6. Theme customizations

I edited files inside pelican-themes/notmyidea-cms/ to give the blog more of its own identity.

In CSS:

Adjusted padding and margins
Better alignment of elements
Added icons and visual links

In HTML (like base.html):

Added the footer
Positioned the share buttons

💡 Editing the theme directly worked well for me, even if it’s not the ideal long-term approach.

7. Generating the static files

To compile the blog and generate the HTML:

make html

During development, I used the local server to preview changes:

pelican --listen

8. Deploy to GitHub Pages 🚀

I used GitHub Pages to host the blog. The process was:

Generated the files with pelican content or make html
Pushed the output/ folder to the gh-pages branch
Set up the custom domain on GitHub and pointed the DNS to GitHub’s servers

The Makefile made things easier, I published with:

make github

This command handles the whole thing. Here’s roughly what it does:

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

On GitHub, I went to Settings > Pages and:

Configured it to serve the site from the gh-pages branch, root folder (/)
Added a CNAME file with my custom domain (anapaula.org)
Pointed the DNS from my registrar to GitHub Pages
Enabled HTTPS

You can automate this with GitHub Actions too. But since this is a personal blog I don’t update every day, I preferred the manual approach.

9. Custom domain 🌐

I registered the anapaula.org domain and configured it for the blog hosted on GitHub Pages.

What I did: In the registrar’s panel, I added the following DNS records:

A records (IPv4): pointing to GitHub Pages’ IPs:

185.199.108.153
185.199.109.153
185.199.110.153
185.199.111.153

CNAME (if you want a subdomain): pointing to youraccount.github.io

Inside the output/ folder (which goes to the gh-pages branch), I created a CNAME file with just:

anapaula.org

This tells GitHub which domain to link to your site. This file is included automatically in every deploy when I run make github.

On GitHub, under Settings > Pages:

I checked “Use a custom domain” and entered anapaula.org
Enabled HTTPS for secure browsing

I followed the official GitHub Pages documentation for all of this: 👉 GitHub Pages docs

Wrapping up

The process had its bumps (Pelican’s docs could really use some love 😅), but it was totally worth it. Having a space of my own with my name, my style was a long-time wish that finally became real.

If you’re also thinking about starting a blog, whether technical or personal, I really recommend it! And if I can help in any way, just reach out. 💛

The blog’s source code is on GitHub: aninhasalesp/meublog 🌱

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 🌱

Career vs. Kids

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

I saw a LinkedIn post recently (I lost the link, unfortunately) about a job applicant who had written, boldly highlighted on her résumé: (NO CHILDREN).

For those who don’t know me, I’m a mom to a 9-year-old girl. That catches people off guard, because apparently I’m ‘too young’ to be a mom.

This is my daughter, Maria Eduarda 💕:

For a long time, I blamed myself for becoming a mom so young, for not following the timeline that seems “correct” for most people:

study ➜ graduate ➜ work ➜ get married ➜ save money ➜ have kids

I also felt bad for not having the same technical experience as many of my friends. The truth is, while they were in college or doing a master’s degree, I was learning how to be a mom, learning how to keep a child alive, while being pretty much a child myself.

But what does that say about me professionally?

When we become mothers, life doesn’t stop for us to figure out motherhood, life goes on, it happens in parallel with it. While I was learning to be a mom, I was also a student, a woman switching careers, moving to a different state in search of better opportunities for me and my daughter. I found support in the local PyLadies community. I was looking for something anything that would prove to me I was capable of working outside the home, not just inside it.

Today, I’m a mom who works, studies, trains, helps her daughter with schoolwork, contributes to the Python community, cooks, speaks at events, travels for work, and keeps the house running (more or less) through all of it.

Okay, but… what does that have to do with my professional profile?

I’m a professional with excellent time management and a focus on productivity someone who knows how to prioritize what matters, stay organized, and never stop learning. I’m someone who graduated with a kid running around the house, who can communicate clearly, and who, even with some insecurities, knows how to reinvent herself when needed. When I need to study something deeply, I create a talk and submit it to events. That’s how I learn and share.

I’m not Wonder Woman. I’m not good at everything. I’m a human being in constant change, someone who adapts, who dives headfirst into whatever she commits to, and that adds a lot to who I am professionally.

Today, I don’t blame myself anymore for becoming a mom young. Today, I’m grateful. Without my daughter, I might not have the drive, or the ability to juggle obligations in the middle of chaos, under time pressure, and most importantly, I might not have learned so early how to ask for help instead of waiting for things to magically work out.

Hire moms. Even if their number one priority isn’t your company, they still make it a priority. And what they deliver is incredibly valuable. 💖

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. 💖

Customizing your GitHub 🤌🏻💕

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

Hey, have you ever visited someone’s GitHub profile that seemed to tell their whole story, what they do, who they are, without even opening a single repository? Or one that just felt cute and super organized?

I find it amazing how people can bring that little corner of the internet to life, giving it personality, care, and sometimes even warmth. ✨

In this post, I’ll show you how to customize your GitHub profile. Let’s go?

1. Creating your profile README

Go to GitHub and click “New repository”
In the name field, type exactly your username
Check the “Add a README file” option
Click “Create repository”

Done! You now have your own space, right at the top of your profile.

2. What to put in your README? 💁‍♀️✨

There’s no right formula, but here are some ideas that work well:

About you:
- A sentence that represents you
- Fun facts, where you are, what you do
- A personal touch (hobbies, side projects, favorite playlists)
Technologies:
- Tools and libraries you use every day
- Languages you know or have been learning
Links:
- Your blog, LinkedIn, personal site, email
Highlights:
- Pin your most important repositories to your profile
- You can even briefly explain what they do or why they’re special to you

3. A few tips 🌿

Write with simplicity and honesty
Organize with headings, spacing, and lists
Use emojis if you want, but keep it balanced

4. It doesn’t have to be perfect

The most important thing is that it says something about you. It’s totally fine to start simple and grow it over time. The goal isn’t to impress, it’s to express 💜

Oh, if you want to see mine, it’s right here!

If you have any questions getting started, just reach out, I’d love to help 🌷

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 🌷.

My dev environment

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

I decided to share how I set up my development environment, from the OS installation to the tools and extensions I use every day.

Operating System

I start with a Linux installation. I have a personal guide I follow whenever I need to configure a new machine, maybe I’ll share it in another post someday.

Tools and utilities I install

Here are some of the programs and libraries I install and use frequently:

Cursor: Haven’t really used it yet. Despite looking promising, I don’t think it’s ideal for work since it involves sensitive data.
UV: Perfect! Super fast, I use it a lot in my day-to-day Python work.
1Password: It’s been great for managing passwords securely.
Bottom: BEAUTIFUL and easy to understand. A system monitor that’s a joy to use.
Lazygit and Lazydocker: Both lazy tools are great, lightweight and practical.
Bat: A turbocharged cat. Beautiful output with syntax highlighting.
VSCode: My main editor.
Terminator: I really like the panel layout.
OBS Studio: For screen recordings and eventually live streams.
Flameshot: My favorite for quick annotated screenshots.

Terminal and productivity

Oh My Zsh: My configuration manager for Zsh.
Yazi: A fast file manager with a beautiful interface.
Kitty: My current favorite terminal, fast and customizable.

VSCode extensions I use

Sublime Text Keymap: Gives VSCode the Sublime shortcuts I love.
VSCode Great Icons: Makes icons more beautiful and easy to identify.
GitLens: A powerful extension for visualizing commit history, line annotations, etc.
Copilot: I use it with moderation, but it helps a lot with quick suggestions.
Run on Save: To automate tasks when I save files.
Docker: For working with containers directly in the editor.

If you also enjoy organizing your environment in a practical and beautiful way, share your tools with me! ♥

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! ♥