Posts on I'm Gilmar Soares

Treating Claude Code Like a Teammate: Developing with Multica

Tue, 27 Oct 2026 10:00:00 -0300

Running Claude Code in a terminal works great for one task at a time. You open a session, describe what you want, watch it work, review the diff. But once you start juggling several tasks — a bug fix here, a refactor there, a small feature waiting in the backlog — the terminal stops being the right place to manage that work. You end up with a pile of tabs, half-finished sessions, and no clear picture of what each agent is doing.

That is the problem Multica solves. It is a source-available, self-hostable workspace where coding agents work like teammates: you assign them an issue, they pick it up, report progress, raise blockers, and hand the work back for review. It does not ship its own model — it drives the agent CLIs you already have installed, and Claude Code is one of them.

Here is how to set it up and use it day to day with Claude Code.

How Multica Fits Together

Before installing anything, it helps to know the pieces:

Workspaces — separate agents, issues and settings per team or project.
Issues — units of work. You assign an issue to an agent the same way you would assign it to a person.
Agents — named teammates, each backed by a provider (like Claude Code) and a runtime.
Runtimes — the machines where agents actually run. Each one runs a small daemon, so your code stays on your machine.
Skills — reusable playbooks that agents share, so a good way of doing something only has to be written once.
Squads — agents and people on one team, with a leader routing work.
Autopilots — scheduled jobs for things like standups, audits and reports.

The key idea: the Multica server is the board, and the daemon on your laptop is the worker that runs claude when an issue lands on it.

Step 1: Install the CLI

On macOS or Linux, Homebrew is the easiest route:

brew install multica-ai/tap/multica

Make sure Claude Code itself is installed and signed in — Multica uses your existing claude binary, it does not bring its own:

claude --version

Step 2: Connect and Start the Daemon

If you are using Multica Cloud, a single command configures the CLI, authenticates you in the browser and starts the daemon:

multica setup

Prefer to keep everything on your own infrastructure? Multica can be self-hosted with Docker. The install script can bring the server along, and setup self-host points the CLI at it:

curl -fsSL https://raw.githubusercontent.com/multica-ai/multica/main/scripts/install.sh | bash -s -- --with-server
multica setup self-host

Then confirm the daemon is running and that it found Claude Code:

multica daemon status

The daemon auto-detects agent CLIs on your PATH, so claude should show up in the list of detected agents. If it lives somewhere unusual, point the daemon at it:

export MULTICA_CLAUDE_PATH="$HOME/.local/bin/claude"

Step 3: Create a Claude Agent

In the web app, open Agents → New agent, pick your machine as the runtime and Claude Code as the provider, and give it a name. That name is how you will assign work to it. You can check it from the terminal:

multica agent list

The Daily Loop: Issues In, Reviews Out

This is where Multica changes the workflow. Instead of opening a terminal session, you write an issue:

multica issue create --title "Add pagination to the /posts endpoint" --assignee "claude"

Or assign an existing one:

multica issue assign <issue-id> --to "claude"

From there, the daemon picks up the task and runs Claude Code against your repository. Two details here matter a lot:

Every task runs in isolation. Multica keeps a cached clone of the repository and gives each task its own git worktree under ~/multica_workspaces. Two agents working on two issues never step on each other’s files.
Work goes to review, not to main. When Claude finishes, the issue moves to review. You read the diff like you would read a colleague’s pull request.

While it works, you can follow along without attaching to any terminal:

multica issue runs <issue-id> --active   # what is running right now
multica issue run-messages <task-id>     # the full message log for a run
multica issue usage <issue-id>           # how many tokens it took

The execution log records every tool call and command the agent ran, which makes reviewing how it got to a result just as easy as reviewing the result itself. If the agent gets stuck, it raises a blocker on the issue, and you answer it with a comment — in the web app or with multica issue comment add.

Tips for Getting Good Results with Claude

Keep a CLAUDE.md in your repository. Claude Code reads it on every run, so it is the best place to describe your conventions: how to run the tests, how commits should look, what not to touch. Since every Multica task starts from a fresh worktree, this file is what gives each run the same context.

Write issues like you would for a person. A clear title, the expected behavior and how to verify it. An agent that knows how to check its own work hands back much better reviews.

Tune the daemon with environment variables. A few I find useful:

export MULTICA_CLAUDE_MODEL="opus"               # model used by Claude Code tasks
export MULTICA_DAEMON_MAX_CONCURRENT_TASKS=3     # default is 20 — keep your laptop breathing
export MULTICA_AGENT_IDLE_WATCHDOG=30m           # stop runs that go quiet (default 2h)

Let the daemon start on its own. So you never forget to bring your agents online:

multica daemon autostart enable

Turn repeated instructions into Skills. If you keep writing the same guidance in issues (“always add a test”, “update the changelog”), that belongs in a skill that every agent can reuse.

The Verdict

Claude Code is already a capable developer. What Multica adds is the team around it: a board where work is visible, isolated worktrees so tasks run in parallel safely, a review step before anything reaches main, and a log of everything the agent did.

The shift in mindset is the real win. I stopped thinking “let me open Claude and do this” and started thinking “let me write a good issue and assign it.” If you already use Claude Code daily and feel the pain of managing several sessions at once, give Multica a try.

Transitioning from tmux to Herdr: Setting Up an AI-Native Workspace Manager

Mon, 13 Jul 2026 14:19:11 -0300

For years, tmux has been the undisputed king of my terminal workflow. It kept my sessions alive, let me manage tabs, and split panes effortlessly. But as AI coding agents like Claude Code and Antigravity became a daily part of my development lifecycle, I found myself needing a workspace manager that understands these agents.

Enter Herdr, a terminal-native workspace manager designed specifically for developers working alongside AI coding agents. It offers persistent sessions, workspace isolation, and native agent status tracking.

However, moving to a new tool shouldn’t mean discarding years of muscle memory. Here is how I configured Herdr to behave exactly like my tmux setup, from shortcuts to themes.

The Configuration: Mapping tmux to Herdr

Herdr’s configuration is managed via a simple TOML file located at ~/.config/herdr/config.toml. To align it with my tmux conventions, I mapped the keys under the [keys] section.

1. The Prefix Key

By default, Herdr uses ctrl+b. Just like in my .tmux.conf, I remapped this to ctrl+a:

[keys]
prefix = "ctrl+a"

2. Splitting Panes Visually

I prefer using | for splitting panes vertically (side-by-side) and - for horizontal splits (top-to-bottom) because they are much easier to remember than the defaults:

split_vertical = "prefix+|"
split_horizontal = "prefix+minus"

To move around quickly without interrupting my flow, I set up a combination of arrow keys and direct shortcuts:

Pane Switching: Focus panes using arrow keys with the prefix (ctrl-a + Up/Down/Left/Right):

focus_pane_left = "prefix+left"
focus_pane_down = "prefix+down"
focus_pane_up = "prefix+up"
focus_pane_right = "prefix+right"

Direct Tab Switching: Using direct OS-like keyboard chords to cycle tabs without pressing the prefix:
```
previous_tab = "ctrl+alt+h"
next_tab = "ctrl+alt+l"
```

4. Interactive Lists (choose-tree equivalent)

In tmux, pressing prefix + w opens a session/window list (choose-tree). In Herdr, the equivalent fuzzy finder is the goto search. I swapped the default keys to map goto to my tmux shortcut:

goto = "prefix+w"
workspace_picker = "prefix+g"

Now pressing ctrl-a + w opens a search across all workspaces, tabs, and active panes.

5. Managing Workspaces on the Fly

Renaming workspaces helps keep my active projects organized. I enabled the interactive workspace rename shortcut:

rename_workspace = "prefix+shift+w"

Pressing ctrl-a + W prompts me to rename the active space.

6. Config Reloads

To test configuration changes without stopping the server, I mapped the reload command:

reload_config = "prefix+r"
resize_mode = "prefix+shift+r" # Shifted resize_mode to avoid conflicts

Aesthetic Harmony: Bringing Nord Theme to Herdr

One of my favorite things about tmux was my Nord theme setup. Luckily, Herdr comes with a built-in Nord theme out of the box. Setting it up was as simple as changing one line in the [theme] block:

[theme]
name = "nord"

This updates the borders, status bar, highlighting, and search menus to match the clean, ice-cold Nord aesthetic.

The Verdict

Switching from tmux to Herdr didn’t require sacrificing my workflow. By mapping the configurations in config.toml, I got the best of both worlds:

My muscle memory remains intact.
I now have a workspace manager that natively tracks my AI coding agents, runs them in persistent background sessions, and integrates seamlessly with my terminal.

If you are looking to update your terminal multitasking for the AI era, I highly recommend giving Herdr a try!

My History With Technology

Wed, 04 Feb 2026 13:56:36 -0300

My history with technology

Today I was seeing my linkedin and I see that I started with programing ten years ago! It’s makes me thinking about when started my curious with technology!

A long, long time ago, my father gave me a computer with the famous turtle logo. After some years I replaced this computer with Windows 95. Here start my curious with technology!

With this curious, I started trying to see what was behind it when I ran a Windows Explorer, but since it was an EXE file, I couldn’t see the code. Since I didn’t have internet access, nor much information, only Linux magazines from newsstands, I ended up giving up for now. Some time later, I ended up changing computers again, this time with an option that could use Linux. This was a bottomless pit, because I ended up buying a lot of magazines about Linux to learn how to use it.

Some versions of Linux that I used:

Among other options that I don’t remember at the moment.

But I always ended up blocked due to lack of knowledge, and I gave up again. Later on, some friends suggested I study Computer Science. So I started researching how I could afford to go to college since I was curious but lacked the money. So I decided I wanted to study, I just lacked the money, then someone, I don’t remember who, introduced me to the “Educate for Life” project. This project had partnerships with colleges, and these partnerships offered discounts of 60%, sometimes 80%. That’s when the curious boy with computers got into this “escort” thing.

And ever since I started my Computer Science course, I’ve only thought that this was my only chance to change my life, and it was!

Today I work with programming, and I’m still the curious kid I used to be, interested in languages and performance, and now seeing AI transforming my work, but making it more fun, because now I can create things much faster!

New Year, Same Consistency

Tue, 06 Jan 2026 17:54:50 -0300

Hey everyone, welcome to the new year! Let’s make this a year of consistency and growth.

Today is January 6, 2026. I’ve been reading about creating to-do lists for yearly goals, and it has made me think about how vital it is to stay consistent in our actions. While I often read about the importance of setting “New Year’s resolutions,” I rarely see anyone talk about creating a to-do list for your life.

I don’t believe that New Year’s Eve alone can change someone, or that you can achieve something just because you start with a burst of willpower. Instead, I believe that if you have a desire—for example, learning a new language—you should create a plan, strive for weekly consistency, and refuse to give up until you reach that goal.

For this year, I hope you believe in yourself more than in a number changing on the calendar. I hope you challenge yourself, make a plan, and actually follow it. I also hope you respect your limits without putting too much pressure on yourself; simply follow the plan and learn to enjoy the journey, not just the result. I guarantee that this mindset will change your life more than the passing years ever could.

Use your schedule to organize your plan and try to respect the time blocks you’ve chosen, whether it’s 30 minutes or an hour. The most important thing is to be consistent.

It is often much harder to stick to a long-term plan than it is to do a lot at the beginning and quit a week later. But the truth is, if you can stay consistent over time, you will see incredible changes. And of course, the real secret is this: if you love the process, nothing and no one can stop you!

For 2026 and for the rest of your life, I wish you consistency.

Hugs!

How to Build a Hashmap

Thu, 06 Mar 2025 17:54:50 -0300

This week, we’re diving into one of the most powerful and fundamental data structures in programming: the Hash Map, often called a Hash Table or Dictionary. Hash maps are vital in nearly every language for quickly storing and retrieving data as key-value pairs.

What’s a Hash Map, Really?

A Hash Map is an array-based structure that gives you near-instant access to a stored value. It achieves this speed by using a special hash function to convert the key (e.g., a person’s name) into an index (a number) in the underlying array.

Think of it like a coat check:

The key is the unique ticket number you receive.

The hash function is the attendant who instantly knows which hook (the index) your coat is on.

The value is your coat itself.

For this simple example, we’ll use a fixed-size array of 10 slots. Important: To keep the code simple, this implementation does not handle collisions—a scenario where two different keys hash to the same index.

Python’s Built-in Hash Map: The dict

Before we build our own, let’s look at Python’s highly optimized, native implementation: the dict. Python

Create an empty dictionary

user_profile = {}

Store key-value pairs

user_profile["username"] = "coder_x"
user_profile["status"] = "online"

Retrieve a value instantly using its key

print(user_profile["username"]) # Output: coder_x

The final structure

print(user_profile) # Output: {'username': 'coder_x', 'status': 'online'}

Building a Custom HashMap Class

Now, let’s implement the core logic ourselves. Our HashMap will clearly show how keys are converted to array indices for storage and retrieval:

class HashMap:
    def __init__(self, size):
        self.size = size
        # Initialize the map: a list of 'None' values
        self.map = [None] * self.size

    def _hash(self, key):
        return hash(key) % self.size

    def set(self, key, value):
        index = self._hash(key)
        self.map[index] = value

    def get(self, key):
        index = self._hash(key)
        return self.map[index]

    def __str__(self):
        return str(self.map)

Practical Example and Indexing

Let’s see our custom HashMap in action and observe the indices it generates: Python

1. Initialize the hash map with 10 slots

contact_list = HashMap(10)

2. Store entries (Note: the hash index is calculated internally)

Key: “Alice” -> hash index: 3

contact_list.set("Alice", "555-0101")

Key: “Bob” -> hash index: 6

contact_list.set("Bob", "555-0202")

Key: “Charlie” -> hash index: 7

contact_list.set("Charlie", "555-0303")

3. Retrieve values using the original keys

print(f"Alice's Number: {contact_list.get('Alice')}")    # Output: 555-0101
print(f"Bob's Number: {contact_list.get('Bob')}")      # Output: 555-0202

4. View the underlying array after insertions

print("\n--- Map Array State ---")
print(str(contact_list))

Output (Indices 0-9):

[None, None, None, '555-0101', None, None, '555-0202', '555-0303', None, None]

This simplified model demonstrates the core principle: using a hash function to achieve fast O(1) (constant time) lookups by jumping directly to the correct array slot. Real-world hash maps add complexity to handle growth and collisions, but the foundational concept remains this efficient indexing strategy!

I hope this walkthrough has given you a solid understanding of how a Hash Map works at its core! While our example was simple, it demonstrates the efficient hashing and indexing that makes this data structure so powerful. Got a question or need clarification on collisions or resizing? Don’t hesitate to reach out in the comments below! Happy coding!

Using AI for Programmers

Thu, 13 Feb 2025 10:02:53 -0300

Today, I’m back from my vacation, and I’ve been thinking about writing about how we can use AI to help us with coding.

Take a Break and Recharge

First of all, I want to say this: take a moment in your life to rest. Go on vacation, visit the beach, the mountains, the countryside, or the city—go wherever you like. But make sure to take time to recharge.

Now, Let’s Talk About AI

AI tools like Copilot, ChatGPT, and DeepSeek are great for assisting with coding, but we need to use them carefully.

While AI can help us write code, the generated code isn’t truly ours, and that can become a problem in the future. If we don’t fully understand the code AI produces, debugging it later can be challenging. When an exception is thrown, we need to know why it happened and how to fix it.

So, while AI tools are helpful, we must use them with caution. We should know every line of code we write, understand its logic, and truly take ownership of it.

My Advice on Using AI

Use AI for any task you need—whether for pair programming, writing code, generating tests, or creating documentation—but always make sure you understand what you’re writing.

With this post, I want to emphasize that AI is just a tool. The code that AI generates is still your responsibility.

This is my first post after my vacation and I hope you like it!

Wishing you a great day.

See you in the next post!

Bye.

Recursion and Quick Sort

Mon, 16 Dec 2024 16:18:30 -0300

In this post, I can explain two important concepts in computer science: recursion and quick sort. I need to explain recursion before I can explain quick sort because quick sort use recursion to sort the array.

Recursion

Recursion is a technique in computer science where a function calls itself. This technique is used to solve problems that can be broken down into smaller problems of the same type.

Here is an example of a recursive function that calculates the factorial of a number:


func factorial(n int) int {
	if n == 0 {
		return 1
	}
	return n * factorial(n-1)
}

In this example, the factorial function calls itself with a smaller number until the base case is reached. The base case is when n is equal to 0, in which case the function returns 1.

It is important to reinforce the base case, without it we would have an infinite loop, and you can test it with the code below


func factorial(n int) int {
	return n * factorial(n-1)
}

You can use ctrl+c to cancel.

Quick Sort

Anyway, now let’s talk about quick sort.

Quick sort is a sorting algorithm that uses recursion to sort an array. Quick sort use the Divide and Conquer strategy to sort the array. But what would be Divide and Conquer strategy?

Divide and Conquer is a technique in computer science where a problem is divided into smaller problems of the same type.

For example, let’s say we have an array:

arr := []int{100, 5, 3, 6, 2, 10}

First, we get the pivot element, which is the first element in the array:


pivot := arr[0]

With the pivot element, we divide the array into two arrays: one with elements smaller than the pivot and another with elements greater than the pivot:


var left []int
var right []int

for i := 1; i < len(arr); i++ {
	if arr[i] < pivot {
		left = append(left, arr[i])
	} else {
		right = append(right, arr[i])
	}
}

And here, we use recursion to sort the left and right arrays:


left = quickSort(left)
right = quickSort(right)

Finally, we concatenate the left array, the pivot element, and the right array:


return append(append(left, pivot), right...)

I purposely left it for last to say that we cannot forget the base case.

The base case is when the array has only one element, in which case we return the array:


if len(arr) < 2 {
	return arr
}

When the array has only one element, we return the array because it is already sorted.

Now we can create the quickSort function:


func quickSort(arr []int) []int {
	if len(arr) < 2 {
		return arr
	}

	pivot := arr[0]

	var left []int
	var right []int

	for i := 1; i < len(arr); i++ {
		if arr[i] < pivot {
			left = append(left, arr[i])
		} else {
			right = append(right, arr[i])
		}
	}

	left = quickSort(left)
	right = quickSort(right)

	return append(append(left, pivot), right...)
}

Now we can test the function:


func main() {
	arr := []int{100, 5, 3, 6, 2, 10}
	fmt.Println(quickSort(arr))
}

When you run the code above, you will see the sorted array:


[2 3 5 6 10 100]

That’s it! I hope you enjoyed this post. If you have any questions, please let me know in the comments below.

Conclusion

In this post, I explained two important concepts in computer science: recursion and quick sort. I hope I managed to explain it in a simple way, so that most people can understand, especially those who have difficulty or even fear of algorithms!

Hugs.

Selection Sort

Thu, 05 Dec 2024 18:46:28 -0300

Continuing my study of algorithms, I can now explain the selection sort algorithm to you.

Selection sort is a simple algorithm. It works by finding the smallest element in an array, adding it to a new array, and removing it from the original array. This process is repeated until the original array is empty. Once the original array is empty, the new array will contain the elements in sorted order.

In this example, I am not focusing on performance but rather on the simplicity of the algorithm.

Here is the array we will use for our example:

arr := []int{100, 5, 3, 6, 2, 10}

For the next step I create the function that receive this arr and return the sorted array:

func orderIntArray(arr []int) []int {
	var result []int
	var min int

	for len(arr) > 0 {
		min = getSmallerItem(arr)
		result = append(result, arr[min])
		arr = remove(arr, min)
	}

	return result
}

The getSmallerItem function is responsible to get the index of the smallest element in the array:

func getSmallerItem(arr []int) int {
	var min int = arr[0]
	var pos int

	for i := 1; i < len(arr); i++ {
		if arr[i] < min {
			min = arr[i]
			pos = i
		}
	}
	return pos
}

The getSmallerItem function compare the element in the array with the min variable, if the element is smaller than the min variable, the min variable will be updated with the element value and the pos variable will be updated with the index of the element. When the loop finish, the pos variable will be returned.

The remove function is responsible to remove the element from the array:

func remove(s []int, i int) []int {
	s[i] = s[len(s)-1]
	return s[:len(s)-1]
}

The remove function receive the array and the index of the element that will be removed.

Now we can test the function:

func main() {
	arr := []int{100, 5, 3, 6, 2, 10}
	result := orderIntArray(arr)
	fmt.Println(result) // return is [2 3 5 6 10 100]
}

This algorithm is not efficient, but is a good example to understand the selection sort algorithm.

I hope you enjoy this post, see you in the next one!

Going Against the Flow of the World

Thu, 28 Nov 2024 16:40:03 -0300

In my country, this week marks the start of “Black Week,” although the correct term is “Black Friday,” traditionally a single day of discounts in stores. As you know, I’m a software engineer, and this week I’ve noticed many courses on sale, offering a variety of options for learning new things.

However, this time, I’ve been reflecting on these courses and the increasingly fast-paced world we live in—a world where everyone feels the need to learn quickly and where courses often promise accelerated learning. I’ve decided that, as a human being, I shouldn’t follow this path of speed.

Throughout history, anyone who has gained deep knowledge in a subject has done so through years of study and consistent practice. I believe this should remain the standard today.

The idea behind this post isn’t about avoiding buying courses or learning materials altogether. Instead, it’s about embracing the process of learning gradually, a little every day, and resisting the pressure to conform to the fast-paced trends of the modern world.

With that in mind, I’d like to share my decision this Black Friday week: I’ve decided not to buy any courses or materials that promise faster, easier, or miraculous results. Instead, I’ll continue reading my books, sticking to the routine I shared here, and focusing on learning slowly and deeply.

I hope you make the most of this week of discounts where you live and take the opportunity to plan ahead, focusing on a path that considers the medium and long term and that this post inspires you to reflect on your learning process and the path you’re taking.

Hugs! 🤗

Explaining Binary Search in a Simple Way

Thu, 21 Nov 2024 16:15:51 -0300

Today I try to explain binary search in a simple way. Binary search is a search algorithm that finds the position of a target value within a sorted array. Sorted array is an important point here.

To explain binary search, we need a array to exemplify.

arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

In this array, we have 10 elements, from 1 to 10. Binary search works by comparing the target value to the middle element of the array.

For example, if we want to find the number 5 in the array, we start by comparing 5 to the middle element of the array, which is 6.

Next step is to compare 5 to 6. If 5 is less than 6, we can discard the right half of the array. The new array is now:

arr := []int{1, 2, 3, 4, 5}

Now we repeat the process, comparing 5 to the middle element of the new array, which is 3.

Next step is to compare 5 to 3. If 5 is greater than 3, we can discard the left half of the array. The new array is now:

arr := []int{4, 5}

Now we repeat the process, comparing 5 to the middle element of the new array, which is 5. And we found the number 5 in the array.

In this simple example we found the number 5 in 3 steps. This is my simple explanation of binary search.

Now I can implement the binary search algorithm in Go.

package main

func search(arr []int, searchItem int) int {
	minus := 0
	max := len(arr) - 1

	for minus <= max {
		middle := (minus + max) / 2
		tryFind := arr[middle]
		if tryFind == searchItem {
			return middle
		}
		if tryFind > searchItem {
			max = middle - 1
		} else {
			minus = middle + 1
		}
	}

	return -1
}

Now I can use the search function to find the number 5 in the array.

func main() {
	arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	searchItem := 80
	pos := search(arr, searchItem)
	var message string
	message = fmt.Sprintf("Find item %d in %d position", searchItem, searchItem)
	if pos == -1 {
		message = fmt.Sprintf("Item %d not found", searchItem)
	}
	fmt.Println(message)
}

This is the output of the program:

Item 80 not found

This algorithm reminds me of a phrase I often hear: ‘divide and conquer! I hope this post, along with the others, helps you in your studies and, more importantly, helps you understand that the best path is always through deep knowledge!

See you next time! Thanks for reading my blog. Hugs!

This Post Isn't About Technology

Thu, 14 Nov 2024 17:36:05 -0300

This post is about depth of knowledge!

When I started my blog, I added Google Analytics—not to track performance, but because I was curious about how people engage with my posts.

Over time, as I’ve been writing for this blog, I’ve observed an interesting trend. People seem to gravitate toward “ready-made recipes” or practical guides. For instance, when I wrote posts about studying Golang or how Exercism helps me learn, they attracted little attention. Similarly, posts about LeetCode, study techniques, or my personal schedule and life routines didn’t generate much traffic.

However, when I shared a step-by-step guide on using Swagger in a Golang API—essentially a “recipe”—it became the most-viewed post in my blog’s history.

The image above shows a visualization of my blog’s behavior over the past week. As we can see, the post about Swagger has received more than double the views of any other post.

Reflecting on this, if I could share one piece of advice, it would be this:

Treat your life as a long journey—a marathon, not a sprint. Organize your time, study a little every day, and create a routine that helps you stay focused. Aim for deep, meaningful learning, because acquiring deep knowledge is the best way to secure a relatively stable future—free from fears and uncertainties, even about challenges like AI.

In the post where I compare life to a marathon rather than a 100-meter sprint, I share how my routine works in the hope of helping and motivating you to organize your life and focus on the long term.

This post isn’t meant as criticism—think of it as friendly advice! As the poet says, “If advice were truly valuable, it would be sold, not given away.” Yet, here I am, offering it freely in an effort to help.

I hope you enjoyed this post and that it inspires or helps you in some way!

My Strategy for Studying LeetCode

Thu, 07 Nov 2024 10:58:22 -0300

First of all, don’t put pressure on yourself. Focus on the long term by doing a little every day or fitting it into your schedule and sticking to the plan, okay?

With that in mind, here is my strategy for studying Leetcode.

1. Start with the basics

At the moment, I’m studying the basics of algorithms, focusing on string manipulation on Leetcode by filtering for easy problems. In this post, I’ll walk you through the 125. Valid Palindrome exercise on Leetcode.

2. Study the problem

At this point, you should read and understand the problem. You can view the problem here.

3. Write the code

Now, I’ll start by explaining how I study on Leetcode. First, I focus on simply solving the problem without worrying about finding the most optimized solution. The goal is just to get a working solution, okay?

In this example, I start by solving the problem with the following code:

func isPalindrome(s string) bool {
    var reversed string
	var newS string

	for _, v := range s {
		if unicode.IsLetter(v) || unicode.IsDigit(v) {
			reversed += strings.ToLower(string(v))
			newS = strings.ToLower(string(v)) + newS
		}
	}
	return reversed == newS
}

I noticed that this solution takes 1067 ms and uses 80.2 MB of memory. At this point, I start looking for ways to improve it.

4. Optimize the code

Here, I work on improving the solution to make it faster and more memory-efficient:

func isPalindrome(s string) bool {
    var stringReversed string
	var sNew string
	lenString := len(s)
	count := 0

	for count != lenString {
		if unicode.IsLetter(rune(s[count])) || unicode.IsDigit(rune(s[count])) {
			sNew += strings.ToLower(string(s[count]))
			stringReversed = strings.ToLower(string(s[count])) + stringReversed
		}
		count++
	}

	return sNew == stringReversed
}

I observed that the updated solution now takes 976 ms and uses 48.5 MB of memory. At this point, I’ll continue refining it to see if further improvements are possible.

5. Last improve solution

Then I realized that to validate a palindrome, I don’t need to store anything in memory; I only need to compare the characters at specific positions. With this approach, my solution improved significantly.

func isPalindrome(s string) bool {
    for i, j := 0, len(s)-1; i < j; {
		if !isAlphaNumeric(s[i]) {
			i++
		} else if !isAlphaNumeric(s[j]) {
			j--
		} else if strings.ToLower(string(s[i])) != strings.ToLower(string(s[j])) {
			return false
		} else {
			i++
			j--
		}
	}
	return true
}


func isAlphaNumeric(s byte) bool {
	return (s >= 'a' && s <= 'z') || (s >= 'A' && s <= 'Z') || (s >= '0' && s <= '9')
}

I saw that this optimized solution now takes 0 ms and uses only 4.5 MB of memory. At this point, I’ll see if there’s any further room for improvement, though the solution is already very efficient.

Here a printscreen of the solutions on Leetcode:

6. Conclusion

In these steps, I’ve shown you my approach to studying on Leetcode:

First, I solve the problem without worrying about finding the optimal solution—just focusing on getting it to work. Next, I try to refine the solution to use less memory and run faster. Finally, I think about further simplifications. For example, to validate a palindrome, I realized I don’t need to store anything in memory; I only need to compare specific character positions. This approach greatly improved my solution. This method has helped me write better code in my daily work, and I hope it’s helpful for you too!

Happy coding! 🚀

How to Publish Your Go Library on Pkg Go

Thu, 31 Oct 2024 14:38:09 -0300

Continue my way to learn Go in a deep way, today I’ll show to you how to publish you library in Pkg.Go

First of all, you need to have a Go library in you Github account or any other Git repository. In this example, I’ll use a simple library that I created to show how to publish it.

The library is valid-brazilian-cnpj. In Brazil we have a document called CNPJ, the next year the rules to validate it will change, so I created this library to help me to validate CNPJ.

How I create this library is not the focus of this post, but if you want to see the code, you can access the repository.

To publish your library in Pkg.Go, you need to create a release in your repository.

First Step - run go mod tidy

The first step is to run go mod tidy to make sure that all dependencies are in the go.mod file.

go mod tidy

Second Step - Run tests

The second step is to run the tests to make sure that everything is working as expected.

go test -v

This command will run all tests in the library and show the results.

Third Step - Create a tag

The third step is to create a tag in your repository.

git tag v0.1.0
git push origin v0.1.0

This command will create a tag called v0.1.0 and push it to the repository.

Fourth Step - Push this to Pkg.Go

GOPROXY=proxy.golang.org go list -m github.com/linuxsoares/valid-brazilian-cnpj@v0.1.1

Explaining the command:

GOPROXY=proxy.golang.org: This is the URL of the Pkg.Go
go list -m github.com/linuxsoares/valid-brazilian-cnpj@v0.1.1: This command will push the library to Pkg.Go

After running this command, you can access the library in Pkg.Go.

Conclusion

In this post, I showed you how to publish your library in Pkg.Go. This is a simple process, but it’s important to follow the steps to make sure that everything is working as expected.

I hope you enjoyed this post and see you in the next one.

Happy coding!

How to Document Your Go API

Thu, 24 Oct 2024 16:22:02 -0300

Today, I’m writing a technical post about API documentation in Go. I hope you find it useful!

First, we’ll create a simple CRUD API using Go and the Gin framework. Let’s get started!

package main

import (
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
)

type User struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

var users = []User{
	{ID: 1, Name: "John"},
	{ID: 2, Name: "Doe"},
}

func main() {
	r := gin.Default()

	// Change to default is /api/v1
	api := r.RouterGroup.Group("/api/v1")
	{
		api.GET("/users", getUsers)

		api.GET("/users/:id", getUser)

		api.POST("/users", createUser)

		api.PUT("/users", editUser)

		api.DELETE("/users/:id", removeUser)
	}

	r.Run(":8080")
}

func getUsers(c *gin.Context) {
	c.JSON(http.StatusOK, users)
}

func getUser(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))
	userFound, _ := findUserByID(users, id)
	c.JSON(http.StatusOK, userFound)
}

func createUser(c *gin.Context) {
	var user User
	c.BindJSON(&user)
	users = append(users, user)
	c.JSON(http.StatusCreated, user)
}

func editUser(c *gin.Context) {
	var user User
	c.BindJSON(&user)
	putUser(users, user)
	c.JSON(http.StatusOK, user)
}

func removeUser(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))
	deleteUserByID(users, id)
	c.JSON(http.StatusOK, nil)
}

func findUserByID(users []User, id int) (*User, bool) {
	for _, user := range users {
		if user.ID == id {
			return &user, true
		}
	}
	return nil, false
}

func deleteUserByID(users []User, id int) []User {
	newUsers := []User{}
	for _, user := range users {
		if user.ID != id {
			newUsers = append(newUsers, user)
		}
	}
	return newUsers
}

func putUser(users []User, newUser User) []User {
	for i := range users {
		if users[i].ID == newUser.ID {
			// Update the existing user
			users[i] = newUser
			return users
		}
	}
	// Add new user if not found
	return append(users, newUser)
}

Now that we have a simple CRUD API in Go, let’s document it.

Note: In this example, I didn’t use the best approach for a CRUD. Instead, I defined a User struct to represent a user and used a slice to store the users. In a real-world project, you should use a database to store the data. Additionally, while I used basic functions to manipulate the data, it’s recommended to follow the repository pattern in production code.

With that out of the way, let’s move on to creating our documentation.

First, we’ll create a Makefile to simplify managing the app.

run:
    go run main.go

build-swagger:
	@go run github.com/swaggo/swag/cmd/swag@latest init -g main.go -o docs

Now, we need to install some dependencies to use Swag.

    go get -u github.com/swaggo/gin-swagger
    go get -u github.com/swaggo/files

Now, I need to add some descriptions using code comments in the main function.

// @BasePath /api/v1

// PingExample godoc
// @Summary ping example
// @Schemes
// @Description do ping
func main...

We need to add a route to serve the Swagger documentation.

r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerfiles.Handler))

Now, we need to run a command to generate the documentation.

make build-swagger

With all the Swag configurations complete, we can run the app and access the documentation in the browser.

make run

Now, access the URL http://localhost:8080/swagger/index.html to view the documentation.

Below is an example of how to document a CRUD:

GET USERS:

// @BasePath /
// ShowAccount 	 godoc
// @Summary      Show a Users list
// @Description  get users
// @Tags         getUsers
// @Accept       json
// @Produce      json
// @Router       /users  [get]

GET USER:

// @BasePath /
// ShowAccount 	 godoc
// @Summary      Show a Users list
// @Description  get users
// @Tags         getUsers
// @Accept       json
// @Produce      json
// @Param        id         path      string  true  "ID"
// @Router       /users/{id}  [get]

POST:

// @BasePath /
// ShowAccount 	 godoc
// @Summary      Create a User
// @Description  create users
// @Tags         createUser
// @Accept       json
// @Produce      json
// @Param user body User true "User to create"
// @Router 		/users [post]

PUT:

// @BasePath /
// ShowAccount 	 godoc
// @Summary      Edit a User
// @Description  edit users
// @Tags         editUser
// @Accept       json
// @Produce      json
// @Param user body User true "User to edit"
// @Router 		/users [put]

DELETE:

// @BasePath /
// ShowAccount 	 godoc
// @Summary      Remove a Users list
// @Description  delete user
// @Tags         removeUser
// @Accept       json
// @Produce      json
// @Param        id         path      string  true  "ID"
// @Router       /users/{id}  [delete]

With these comments in each function, we can generate the documentation using Swag.

The result is:

You can view the project in the repository.

Conclusion

In this article, we learned how to document a Go API using Swag. We started by creating a simple CRUD API in Go and then documented it using Swag. We also learned how to generate the documentation and view it in the browser.

Swag is a powerful tool that can help you document your Go APIs easily.

I hope you found this article helpful. If you have any questions or suggestions, feel free to send me a message in my social media accounts.

Thank you for reading!

Remember Life Is Not a 100 Meter Race

Thu, 17 Oct 2024 16:59:52 -0300

In my life, I’ve often liked something and used it every day until I got sick of it. But now, I’ve started therapy, and one of the first things I’ve learned is how to use a calendar to organize my routine.

By organizing my routine, I realized that I need to plan everything in advance—whether it’s for the week, month, or year. For example, in my current routine:

I exercise for one hour every weekday.
I study English two days a week, for one hour each day.
I spend 30 minutes every day reading books outside of my profession, among other activities.

The best part about organizing your week with clear goals is understanding that progress takes time. I won’t learn English or Golang (a programming language) in a day or a week. However, by organizing my week, I can work toward these goals gradually and stay on track.

Below, I’ll show you how I organize my week. I hope it helps you organize yours too.

This is how I’ve structured my schedule:

I exercise every day of the week.
I read every day.
I study a new technology every day.
I work regularly and ensure I spend quality time with my daughter and family.

I truly hope this helps you organize your week. It has been a great tool for managing anxiety and developing a long-term mindset. After all, life is not a 100-meter race!

I hope you found this helpful and that it inspires you to organize your week too.

Duck Typing in Go

Thu, 10 Oct 2024 13:46:16 -0300

Hello everyone!

As I mentioned in a previous post, I’m currently learning Go to use in some of my work projects. In this short post, I’ll explain how to use duck typing in Go, which was quite challenging for me when I first started learning the language.

To begin, let’s look at a simple example in Python:

class Duck:
    def quack(self):
        print("Quack, quack!")


class Person(Duck):
    pass


def quack(obj):
    obj.quack()

def main():
    donald = Duck()
    john = Person()

    quack(donald) -- Quack, quack!
    quack(john) -- Quack, quack!

In this somewhat quirky example, the Person class can “quack” like a Duck because it inherits from the Duck class. In Python, we don’t need to explicitly declare the type of the object in the function; we simply call the method we want to use.

Now, let’s see how to achieve something similar in Go:

package main

import "fmt"

type Dog interface {
	Bark()
}

type Cat interface {
	Meow()
}

type Shihtzu struct {
	Name string
}

type Chartreux struct {
	Name string
}

func (s Shihtzu) Bark() {
	message := fmt.Sprintf("Type: %T - My name is %s! Bark! Bark! Bark!", s, s.Name)
	fmt.Println(message)
}

func (c Chartreux) Meow() {
	message := fmt.Sprintf("Type: %T - My name is %s! Meow! Meow! Meow! ", c, c.Name)
	fmt.Println(message)
}

func main() {
	var dog Dog
	dog = Shihtzu{Name: "Puppy"}
	dog.Bark()

	var cat Cat
	cat = Chartreux{Name: "Kitty"}
	cat.Meow()
}

The example code above is in this repository on github.

In this Go example, we have two interfaces, Dog and Cat, and two structs, Shihtzu and Chartreux. The Dog interface defines a method Bark, while the Cat interface defines a method Meow. The structs Shihtzu and Chartreux implement the Bark and Meow methods, respectively. It’s important to note that although it’s not explicitly stated in the code, these structs are implementing the interfaces.

In Go, we implement an interface by simply defining the required methods, without needing to declare that the struct is explicitly implementing the interface.

In other words, we don’t need to state that Shihtzu is a Dog—we just need to implement the Bark method for the Shihtzu struct, and Go automatically understands that Shihtzu satisfies the Dog interface.

This is quite different from languages like Python or Java, but once you get the hang of it, it’s straightforward and easy to use.

I hope this post helps you better understand Go and how duck typing works in the language!

How Can AI Change the Way We Work

Thu, 03 Oct 2024 18:50:05 -0300

The first answer is, I DON’T KNOW! Bye-bye! (Just kidding! Keep reading, please! It was only a joke!)

Today, I saw the new Canvas feature from OpenAI, and I’m feeling two things:

I’m very excited about the evolution of AI and the new possibilities it can bring.
I’m also a bit scared by the rapid advancement of AI and the potential changes it could bring.

Let’s start with the first point. I use AI daily to help me write code at work. But of course, I don’t just copy and paste the AI-generated code into my editor (I use Zed). Instead, I use AI to resolve my doubts and assist me when I need to write in programming languages I’m less experienced with. This is amazing—it’s like having a knowledgeable assistant right by my side!

Now, for the second point. I have a daughter, and I’m worried about the future that AI might create for her. What will my profession look like in the medium and long term? Will I still have a job?

The only certainty I have is that no profession will be the same after the use of AI. Whether it will improve, worsen, or cease to exist, we do not know.

Despite these concerns, I believe the key is to keep learning and staying up to date with the latest technologies. We need to be prepared for the new challenges that lie ahead. AI is a tool that can help us create and complete tasks with greater speed and quality, but it’s up to us to continue improving our skills.

And as I said in another article, don’t stop studying, stay focused and studying!

So, what do you think? How do you feel about AI and the new possibilities it brings?

Keep Studying Never Stop

Fri, 27 Sep 2024 17:43:00 -0300

Why I suggest you never stop studying!

At the start of my career, searching for a profession, I was always very curious about computers, but with a limited income, we couldn’t afford to study, buy computers, or have access to technology in general.

My first job was painting bicycle handlebars, and I had no prospects. Later, I got a job managing the inventory of a candy store. With that, I made an agreement with my family that the little money I earned would go towards paying for college, and we all agreed!

Before starting college, a friend recommended me for an infrastructure job (internship), and without a second thought, I said YES YES YES, I WANT IT! In the interview, I wasn’t truthful, FEARING I MIGHT LOSE THE ONLY CHANCE, and when they asked if I had ever swapped hard drives in servers, I said YES, OF COURSE!

In the end, it was so simple, and I managed to do it without ever having done it before.

Later in college, I simply fell in love with writing code. I always completed the projects and tasks, sometimes without sleeping, but I got them done, and with an indescribable joy.

Today, I have become a software engineer, and I continue learning new technologies as if it were my first day.

I must say, college helped my life in a way NOTHING else could have; it changed everything for the better! Sometimes I hear people say it’s not worth it, but I think the opposite—if you can or want to, do it without hesitation like I did in the past!

Lastly, I’d like to say, despite fears in this new world of GenAI and the challenges that come with it, never, NEVER stop studying.

And if you need help, any mentoring, I can try to help you, just reach out!

Hugs, and keep moving forward with your studies!

How Am I Learning Golang

Mon, 23 Sep 2024 17:34:27 -0300

In my work, I’ve started using Golang. I’m aware of AI tools like ChatGPT, which can help me complete tasks more efficiently. However, I really enjoy learning new technologies and am always open to new challenges.

In the past, I learned Scala, Python, and Java by reading books and practicing them daily. This time, I’m learning Golang using different approaches. I use Exercism to practice Golang, and now I’ll show you how to use it.

Step 1: Install Golang

First, you need to install Golang on your computer. You can download it from the official website. I won’t go into detail on how to install it because it’s straightforward. You can find the installation instructions here.

Once Golang is installed, you can check if it’s installed correctly by running this command:

go version

Step 2: Install Exercism

Now that Golang is installed, let’s install Exercism. You can find the installation instructions for your operating system on this page.

After installing Exercism, you can verify the installation by running:

exercism version

Step 3: Start Practicing

Now that everything is set up, you can start practicing Golang using Exercism. You can download exercises using the following command:

exercism download --exercise=<exercise-name> --track=go

For example:

exercism download --track=go --exercise=lasagna-master

This command will download the lasagna-master exercise for the Golang track.

After solving the exercise, you can submit it using:

exercism submit

This will upload your solution to Exercism, and you can see other people’s solutions as well.

Conclusion

This is how I’m learning Golang using Exercism. It’s a great platform to practice coding in different languages. Let’s try to solve some exercises in Golang or another language you prefer. I hope you enjoy the process!

Senior Software Engineer

Tue, 17 Sep 2024 16:37:38 -0300

Senior Software Engineers: Impacting Business Growth and Inspiring Teams

When I started as a Software Engineer, I skipped the internal steps because my initial experience in tech was with infrastructure, not programming. I transitioned into software engineering four years later, and when I finally worked as a Software Engineer, I was very fortunate. My coworkers were exceptional professionals who supported me at the beginning of my journey.

As a Senior Software Engineer now, I strive every day to be like those mentors and positively impact the people I work with. Knowing the business you work in better than anyone else enables you to help those around you and be an outstanding professional wherever you go. A phrase that I always remember to impact the people around me is, always be the senior you wish you had met when you were a junior. This phrase has helped me to be a better professional and to help others in their journey.

This text is to invite you to be the senior you wish you had met when you were a junior. Be the professional who helps others and makes a difference in the lives of those around you. And a few years later, if you follow this tip every day, you will see incredible people, being excellent professionals because in the past, they were lucky enough to meet you, who impacted them positively.

Be the best version of yourself every day!

Hugs.

First Clojure Project

Mon, 16 Sep 2024 18:04:37 -0300

Creating Our First Clojure Project

Let’s continue with our tutorial. Today, I will explain how we can create a Clojure project. I decided to split this article into two parts: we will explain how to create a regular project and a web project, where we will create an API for some service.

Let’s start by creating a regular project. It won’t be an API, a library, or anything like that. I just want to demonstrate how to create a project, explain its structure, and everything else.

Creating a project is very simple if you’ve installed Leiningen [I mentioned it in our first article]. If you haven’t installed it yet, do yourself a favor and install it. The project link is here: Leiningen — :)

Well, if you’ve done yourself this favor and have everything nicely installed, it’s time to create the Clojure project. Let’s go:

➜ hello-clojure git:(master) ✗ lein new hello-clojure

By running the above command, you get a directory named hello-clojure because that’s the name of the project we passed as a parameter to the new command of lein.

➜ creating-clojure-project git:(master) ✗ ls

hello-clojure

The Structure of a Clojure Project

Entering the directory, you’ll have a structure with many files and subdirectories. Don’t be alarmed or leave the article; I’ll explain each one of them in detail. Here’s the project structure:

We will explain each file and directory from top to bottom:

doc: In the doc folder, you can place the documentation for your project. The intro.md file comes by default when we create the project using lein.
    Just to clarify, the .md extension is for markdown, which is widely used by GitHub, for example.

resources: The resources directory is used to store any configuration files you might need.

src: Inside src is where we will store our Clojure code related to the project.

test: The name speaks for itself, containing all the project's test files.

CHANGELOG: This is usually where we record what changes in each version of the project, whether it's in Python, Java, Clojure, or Ruby.

LICENSE: Contains the legal information that we typically click "ACCEPT" without reading.

project.clj: While resources is used for configuration files, project.clj is where we actually configure our Clojure project.

Just so you don’t end up with a project that can’t run or show the famous “HELLO WORLD,” I’ll explain how to get it running. — :)

Open the project.clj file and add the following code after :dependencies. Don’t forget it needs to be inside the parentheses.

:main hello-clojure.core/foo

After that, we can run the project from the command line inside the project directory and see the result:

➜ hello-clojure git:(master) ✗ lein run Clojure
Clojure Hello, World!

And here we have our result without errors :)

To keep this article from being too long, I’ll divide it into parts. This part is about creating the project, and another will cover using namespaces, importing them into other namespaces, and so on.

The code will be available on GitHub, and we will update it with each article.

That’s it for today. Thanks to everyone who has read so far and for the great feedback!!!

Below are the other articles and those coming soon:

Hello World;
Creating our own functions;
Using existing Clojure functions;
Creating a Clojure project;
Seeing how we create functions and reuse them in our projects;
Creating a web project;
Using Java classes in Clojure functions;
And much more…

Cheers!

Posts on I'm Gilmar Soares

Treating Claude Code Like a Teammate: Developing with Multica

How Multica Fits Together

Step 1: Install the CLI

Step 2: Connect and Start the Daemon

Step 3: Create a Claude Agent

The Daily Loop: Issues In, Reviews Out

Tips for Getting Good Results with Claude

The Verdict

Transitioning from tmux to Herdr: Setting Up an AI-Native Workspace Manager

The Configuration: Mapping tmux to Herdr

1. The Prefix Key

2. Splitting Panes Visually

3. Pane & Tab Navigation

4. Interactive Lists (choose-tree equivalent)

5. Managing Workspaces on the Fly

6. Config Reloads

Aesthetic Harmony: Bringing Nord Theme to Herdr

The Verdict

My History With Technology

My history with technology

Some versions of Linux that I used:

New Year, Same Consistency

How to Build a Hashmap

Create an empty dictionary

Store key-value pairs

Retrieve a value instantly using its key

The final structure

1. Initialize the hash map with 10 slots

2. Store entries (Note: the hash index is calculated internally)

Key: “Alice” -> hash index: 3

Key: “Bob” -> hash index: 6

Key: “Charlie” -> hash index: 7

3. Retrieve values using the original keys

4. View the underlying array after insertions

Output (Indices 0-9):

Using AI for Programmers

Take a Break and Recharge

Now, Let’s Talk About AI

My Advice on Using AI

Recursion and Quick Sort

Recursion

Quick Sort

Conclusion

Selection Sort

Going Against the Flow of the World

Explaining Binary Search in a Simple Way

This Post Isn't About Technology

This post is about depth of knowledge!

My Strategy for Studying LeetCode

1. Start with the basics

2. Study the problem

3. Write the code

4. Optimize the code

5. Last improve solution

6. Conclusion

How to Publish Your Go Library on Pkg Go

First Step - run go mod tidy

Second Step - Run tests

Third Step - Create a tag

Fourth Step - Push this to Pkg.Go

Conclusion

How to Document Your Go API

Conclusion

Remember Life Is Not a 100 Meter Race

Duck Typing in Go

How Can AI Change the Way We Work

Keep Studying Never Stop

Why I suggest you never stop studying!

How Am I Learning Golang

Step 1: Install Golang

Step 2: Install Exercism

Step 3: Start Practicing

Conclusion

Senior Software Engineer

Senior Software Engineers: Impacting Business Growth and Inspiring Teams

First Clojure Project

Creating Our First Clojure Project