Eu sou Gilmar Soares

Tratando o Claude Code como Colega de Time: Desenvolvendo com o Multica

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

Rodar o Claude Code em um terminal funciona muito bem para uma tarefa por vez. Você abre uma sessão, descreve o que quer, acompanha o trabalho e revisa o diff. Mas, quando começa a equilibrar várias tarefas — uma correção de bug aqui, um refactor ali, uma pequena feature esperando no backlog —, o terminal deixa de ser o lugar certo para gerenciar esse trabalho. Você acaba com uma pilha de abas, sessões pela metade e nenhuma visão clara do que cada agente está fazendo.

É esse o problema que o Multica resolve. Ele é um workspace source-available e self-hostable em que agentes de código trabalham como colegas de time: você atribui uma issue, eles pegam a tarefa, informam o progresso, sinalizam bloqueios e devolvem o trabalho para revisão. Ele não traz um modelo próprio — usa as CLIs de agentes que você já tem instaladas, e o Claude Code é uma delas.

Veja como configurar e usar no dia a dia com o Claude Code.

Como o Multica se organiza

Antes de instalar qualquer coisa, vale conhecer as peças:

Workspaces — agentes, issues e configurações separados por time ou projeto.
Issues — unidades de trabalho. Você atribui uma issue a um agente do mesmo jeito que atribuiria a uma pessoa.
Agents — colegas de time com nome, cada um com um provedor (como o Claude Code) e um runtime.
Runtimes — as máquinas onde os agentes realmente rodam. Cada uma roda um pequeno daemon, então seu código fica na sua máquina.
Skills — playbooks reutilizáveis que os agentes compartilham, para que uma boa forma de fazer algo só precise ser escrita uma vez.
Squads — agentes e pessoas em um mesmo time, com um líder distribuindo o trabalho.
Autopilots — tarefas agendadas para coisas como standups, auditorias e relatórios.

A ideia central: o servidor do Multica é o quadro, e o daemon no seu notebook é o trabalhador que roda o claude quando uma issue chega até ele.

Passo 1: instale a CLI

No macOS ou no Linux, o Homebrew é o caminho mais fácil:

brew install multica-ai/tap/multica

Garanta que o próprio Claude Code esteja instalado e com login feito — o Multica usa o binário claude que você já tem, ele não traz o dele:

claude --version

Passo 2: conecte e inicie o daemon

Se você usa o Multica Cloud, um único comando configura a CLI, faz a autenticação no navegador e inicia o daemon:

multica setup

Prefere manter tudo na sua própria infraestrutura? O Multica pode ser self-hosted com Docker. O script de instalação pode trazer o servidor junto, e o setup self-host aponta a CLI para ele:

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

Depois, confirme que o daemon está rodando e que encontrou o Claude Code:

multica daemon status

O daemon detecta automaticamente as CLIs de agentes no seu PATH, então o claude deve aparecer na lista de agentes detectados. Se ele estiver em um lugar incomum, aponte o daemon para ele:

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

Passo 3: crie um agente Claude

No app web, abra Agents → New agent, escolha sua máquina como runtime e o Claude Code como provedor, e dê um nome a ele. É por esse nome que você vai atribuir trabalho. Dá para conferir pelo terminal:

multica agent list

O ciclo do dia a dia: entram issues, saem revisões

É aqui que o Multica muda o fluxo de trabalho. Em vez de abrir uma sessão no terminal, você escreve uma issue:

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

Ou atribui uma que já existe:

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

A partir daí, o daemon pega a tarefa e roda o Claude Code no seu repositório. Dois detalhes importam muito aqui:

Cada tarefa roda isolada. O Multica mantém um clone em cache do repositório e dá a cada tarefa seu próprio git worktree em ~/multica_workspaces. Dois agentes trabalhando em duas issues nunca mexem nos arquivos um do outro.
O trabalho vai para revisão, não para a main. Quando o Claude termina, a issue vai para revisão. Você lê o diff como leria o pull request de um colega.

Enquanto ele trabalha, você acompanha sem se conectar a nenhum 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

O log de execução registra cada tool call e cada comando que o agente rodou, o que torna revisar como ele chegou a um resultado tão fácil quanto revisar o próprio resultado. Se o agente travar, ele sinaliza um bloqueio na issue, e você responde com um comentário — no app web ou com multica issue comment add.

Dicas para ter bons resultados com o Claude

Mantenha um CLAUDE.md no seu repositório. O Claude Code lê esse arquivo em toda execução, então ele é o melhor lugar para descrever suas convenções: como rodar os testes, como os commits devem ser, o que não deve ser mexido. Como toda tarefa do Multica começa de um worktree novo, é esse arquivo que dá o mesmo contexto a cada execução.

Escreva issues como escreveria para uma pessoa. Um título claro, o comportamento esperado e como verificar. Um agente que sabe conferir o próprio trabalho entrega revisões muito melhores.

Ajuste o daemon com variáveis de ambiente. Algumas que acho úteis:

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)

Deixe o daemon iniciar sozinho. Assim você nunca esquece de colocar seus agentes online:

multica daemon autostart enable

Transforme instruções repetidas em Skills. Se você vive escrevendo as mesmas orientações nas issues (“sempre adicione um teste”, “atualize o changelog”), isso merece virar uma skill que todos os agentes podem reutilizar.

O veredito

O Claude Code já é um desenvolvedor capaz. O que o Multica adiciona é o time em volta dele: um quadro em que o trabalho fica visível, worktrees isolados para as tarefas rodarem em paralelo com segurança, uma etapa de revisão antes de qualquer coisa chegar à main e um log de tudo o que o agente fez.

A mudança de mentalidade é o verdadeiro ganho. Parei de pensar “vou abrir o Claude e fazer isso” e passei a pensar “vou escrever uma boa issue e atribuir”. Se você já usa o Claude Code todos os dias e sente o peso de gerenciar várias sessões ao mesmo tempo, experimente o Multica.

Migrando do tmux para o Herdr: Configurando um Gerenciador de Workspaces Feito para IA

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

Por anos, o tmux foi o rei absoluto do meu fluxo de trabalho no terminal. Ele mantinha minhas sessões vivas, me deixava gerenciar abas e dividir painéis sem esforço. Mas, conforme agentes de código com IA como Claude Code e Antigravity passaram a fazer parte do meu dia a dia de desenvolvimento, senti falta de um gerenciador de workspaces que entendesse esses agentes.

É aí que entra o Herdr, um gerenciador de workspaces nativo do terminal, feito especificamente para desenvolvedores que trabalham junto com agentes de código com IA. Ele oferece sessões persistentes, isolamento de workspaces e acompanhamento nativo do status dos agentes.

Mas trocar de ferramenta não deveria significar jogar fora anos de memória muscular. Veja como configurei o Herdr para se comportar exatamente como meu tmux, dos atalhos ao tema.

A configuração: mapeando o tmux para o Herdr

A configuração do Herdr fica em um arquivo TOML simples, em ~/.config/herdr/config.toml. Para alinhá-lo às minhas convenções do tmux, mapeei as teclas na seção [keys].

1. A tecla de prefixo

Por padrão, o Herdr usa ctrl+b. Assim como no meu .tmux.conf, remapeei para ctrl+a:

[keys]
prefix = "ctrl+a"

2. Dividindo painéis de forma visual

Prefiro usar | para dividir painéis na vertical (lado a lado) e - para divisões horizontais (um em cima do outro), porque são muito mais fáceis de lembrar que os padrões:

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

3. Navegação entre painéis e abas

Para me mover rápido sem interromper o fluxo, configurei uma combinação de setas e atalhos diretos:

Troca de painel: foco nos painéis usando as setas com o prefixo (ctrl-a + Cima/Baixo/Esquerda/Direita):

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

Troca direta de abas: atalhos diretos, como os do sistema operacional, para alternar entre abas sem apertar o prefixo:
```
previous_tab = "ctrl+alt+h"
next_tab = "ctrl+alt+l"
```

4. Listas interativas (o equivalente ao choose-tree)

No tmux, prefix + w abre uma lista de sessões e janelas (choose-tree). No Herdr, a busca equivalente é o goto. Troquei as teclas padrão para mapear o goto para o meu atalho do tmux:

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

Agora ctrl-a + w abre uma busca em todos os workspaces, abas e painéis ativos.

5. Gerenciando workspaces na hora

Renomear workspaces ajuda a manter meus projetos ativos organizados. Ativei o atalho interativo para renomear workspaces:

rename_workspace = "prefix+shift+w"

Com ctrl-a + W, ele pede um novo nome para o workspace ativo.

6. Recarregando a configuração

Para testar mudanças de configuração sem parar o servidor, mapeei o comando de recarregar:

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

Harmonia visual: levando o tema Nord para o Herdr

Uma das coisas de que eu mais gostava no tmux era meu tema Nord. Felizmente, o Herdr já vem com um tema Nord embutido. Configurar foi tão simples quanto mudar uma linha no bloco [theme]:

[theme]
name = "nord"

Isso atualiza as bordas, a barra de status, os destaques e os menus de busca para combinar com a estética limpa e gelada do Nord.

O veredito

Trocar o tmux pelo Herdr não exigiu sacrificar meu fluxo de trabalho. Mapeando as configurações no config.toml, fiquei com o melhor dos dois mundos:

Minha memória muscular continua intacta.
Agora tenho um gerenciador de workspaces que acompanha nativamente meus agentes de código com IA, roda esses agentes em sessões persistentes em segundo plano e se integra perfeitamente ao meu terminal.

Se você quer atualizar seu multitarefa no terminal para a era da IA, recomendo muito experimentar o Herdr!

Minha História com a Tecnologia

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

Minha história com a tecnologia

Hoje eu estava vendo meu LinkedIn e percebi que comecei a programar há dez anos! Isso me fez pensar em quando começou minha curiosidade pela tecnologia!

Há muito, muito tempo, meu pai me deu um computador com o famoso logo da tartaruga. Alguns anos depois, troquei esse computador por um com Windows 95. Aqui começou minha curiosidade pela tecnologia!

Com essa curiosidade, comecei a tentar ver o que havia por trás quando eu abria o Windows Explorer, mas, como era um arquivo EXE, eu não conseguia ver o código. Como eu não tinha acesso à internet nem muita informação, só revistas de Linux de banca, acabei desistindo por um tempo. Algum tempo depois, troquei de computador de novo, desta vez por um que podia usar Linux. Isso virou um poço sem fundo, porque acabei comprando muitas revistas de Linux para aprender a usá-lo.

Algumas versões de Linux que usei:

Entre outras opções de que não me lembro agora.

Mas eu sempre acabava travando por falta de conhecimento e desistia de novo. Mais tarde, alguns amigos sugeriram que eu estudasse Ciência da Computação. Então comecei a pesquisar como poderia pagar uma faculdade, já que tinha curiosidade, mas faltava dinheiro. Decidi que queria estudar, só faltava o dinheiro. Foi quando alguém, não lembro quem, me apresentou o projeto “Educar para a Vida”. Esse projeto tinha parcerias com faculdades, e essas parcerias ofereciam descontos de 60%, às vezes 80%. Foi assim que o garoto curioso com computadores entrou nessa jornada.

E, desde que comecei o curso de Ciência da Computação, só pensava que aquela era minha única chance de mudar de vida, e foi!

Hoje trabalho com programação e continuo sendo o garoto curioso que eu era, interessado em linguagens e performance, e agora vendo a IA transformar meu trabalho, mas deixando tudo mais divertido, porque agora consigo criar coisas muito mais rápido!

Ano Novo, Mesma Consistência

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

Olá, pessoal, bem-vindos ao ano novo! Vamos fazer deste um ano de consistência e crescimento.

Hoje é 6 de janeiro de 2026. Tenho lido sobre criar listas de tarefas para os objetivos do ano, e isso me fez pensar em como é essencial manter a consistência nas nossas ações. Embora eu leia com frequência sobre a importância das “resoluções de Ano Novo”, raramente vejo alguém falar sobre criar uma lista de tarefas para a vida.

Não acredito que a virada do ano, sozinha, mude alguém, nem que você consiga algo só porque começou com uma explosão de força de vontade. Acredito que, se você tem um desejo, por exemplo aprender um novo idioma, deve criar um plano, buscar consistência semanal e se recusar a desistir até alcançar esse objetivo.

Para este ano, espero que você acredite mais em si mesmo do que em um número mudando no calendário. Espero que você se desafie, faça um plano e realmente o siga. Também espero que respeite seus limites, sem se pressionar demais; simplesmente siga o plano e aprenda a aproveitar a jornada, não só o resultado. Garanto que essa mentalidade vai mudar sua vida mais do que a passagem dos anos jamais poderia.

Use sua agenda para organizar seu plano e tente respeitar os blocos de tempo que escolheu, sejam 30 minutos ou uma hora. O mais importante é ser consistente.

Muitas vezes é bem mais difícil manter um plano de longo prazo do que fazer muito no começo e desistir uma semana depois. Mas a verdade é que, se você conseguir manter a consistência ao longo do tempo, vai ver mudanças incríveis. E, claro, o verdadeiro segredo é este: se você ama o processo, nada nem ninguém pode te parar!

Para 2026 e para o resto da sua vida, desejo consistência.

Abraços!

Como Construir um Hashmap

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

Esta semana, vamos mergulhar em uma das estruturas de dados mais poderosas e fundamentais da programação: o Hash Map, também chamado de Hash Table ou Dicionário. Hash maps são essenciais em praticamente toda linguagem para armazenar e recuperar dados rapidamente como pares chave-valor.

O que é, de fato, um Hash Map?

Um Hash Map é uma estrutura baseada em array que dá acesso quase instantâneo a um valor armazenado. Ele alcança essa velocidade usando uma função hash especial, que converte a chave (por exemplo, o nome de uma pessoa) em um índice (um número) do array interno.

Pense em um guarda-volumes:

A chave é o número único do tíquete que você recebe.

A função hash é o atendente que sabe na hora em qual gancho (o índice) está seu casaco.

O valor é o próprio casaco.

Neste exemplo simples, vamos usar um array de tamanho fixo com 10 posições. Importante: para manter o código simples, esta implementação não trata colisões, ou seja, o caso em que duas chaves diferentes geram o mesmo índice.

O Hash Map nativo do Python: o dict

Antes de construir o nosso, vamos ver a implementação nativa e altamente otimizada do Python: o dict. Python

Crie um dicionário vazio

user_profile = {}

Armazene pares chave-valor

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

Recupere um valor na hora usando a chave

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

A estrutura final

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

Construindo uma classe HashMap própria

Agora, vamos implementar a lógica principal nós mesmos. Nosso HashMap vai mostrar claramente como as chaves são convertidas em índices do array para armazenar e recuperar valores:

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)

Exemplo prático e indexação

Vamos ver nosso HashMap em ação e observar os índices que ele gera: Python

1. Inicialize o hash map com 10 posições

contact_list = HashMap(10)

2. Armazene entradas (o índice hash é calculado internamente)

Chave: “Alice” -> índice hash: 3

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

Chave: “Bob” -> índice hash: 6

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

Chave: “Charlie” -> índice hash: 7

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

3. Recupere os valores usando as chaves originais

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. Veja o array interno depois das inserções

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

Saída (índices 0-9):

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

Este modelo simplificado demonstra o princípio central: usar uma função hash para conseguir buscas rápidas em O(1) (tempo constante), pulando direto para a posição certa do array. Hash maps do mundo real adicionam complexidade para lidar com crescimento e colisões, mas o conceito fundamental continua sendo essa estratégia eficiente de indexação!

Espero que este passo a passo tenha dado a você uma boa compreensão de como um Hash Map funciona por dentro! Embora nosso exemplo seja simples, ele demonstra o hashing e a indexação eficientes que tornam essa estrutura de dados tão poderosa. Ficou com alguma dúvida ou quer saber mais sobre colisões ou redimensionamento? Não hesite em perguntar nos comentários abaixo! Bons códigos!

Usando IA na Programação

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

Hoje voltei das férias e fiquei pensando em escrever sobre como podemos usar IA para nos ajudar a programar.

Faça uma pausa e recarregue as energias

Antes de tudo, quero dizer o seguinte: reserve um momento na sua vida para descansar. Tire férias, vá à praia, à montanha, ao interior ou à cidade, vá para onde quiser. Mas garanta um tempo para recarregar as energias.

Agora, vamos falar de IA

Ferramentas de IA como Copilot, ChatGPT e DeepSeek são ótimas para ajudar na programação, mas precisamos usá-las com cuidado.

Embora a IA possa nos ajudar a escrever código, o código gerado não é realmente nosso, e isso pode virar um problema no futuro. Se não entendermos completamente o código que a IA produz, depurá-lo depois pode ser difícil. Quando uma exceção é lançada, precisamos saber por que aconteceu e como corrigir.

Então, embora as ferramentas de IA sejam úteis, precisamos usá-las com cautela. Devemos conhecer cada linha de código que escrevemos, entender sua lógica e realmente assumir a responsabilidade por ela.

Meu conselho sobre o uso de IA

Use IA para qualquer tarefa que precisar, seja para programar em par, escrever código, gerar testes ou criar documentação, mas sempre garanta que você entende o que está escrevendo.

Com este post, quero reforçar que a IA é só uma ferramenta. O código que a IA gera continua sendo responsabilidade sua.

Este é meu primeiro post depois das férias e espero que você goste!

Tenha um ótimo dia.

Até o próximo post!

Tchau.

Recursão e Quick Sort

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

Neste post, vou explicar dois conceitos importantes da ciência da computação: recursão e quick sort. Preciso explicar recursão antes de explicar o quick sort, porque o quick sort usa recursão para ordenar o array.

Recursão

Recursão é uma técnica da ciência da computação em que uma função chama a si mesma. Essa técnica é usada para resolver problemas que podem ser divididos em problemas menores do mesmo tipo.

Este é um exemplo de função recursiva que calcula o fatorial de um número:


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

Neste exemplo, a função factorial chama a si mesma com um número menor até chegar ao caso base. O caso base é quando n é igual a 0, situação em que a função retorna 1.

É importante reforçar o caso base: sem ele, teríamos um loop infinito, e você pode testar isso com o código abaixo


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

Você pode usar ctrl+c para cancelar.

Quick Sort

Enfim, agora vamos falar do quick sort.

O quick sort é um algoritmo de ordenação que usa recursão para ordenar um array. Ele usa a estratégia de Dividir para Conquistar para ordenar o array. Mas o que seria essa estratégia?

Dividir para Conquistar é uma técnica da ciência da computação em que um problema é dividido em problemas menores do mesmo tipo.

Por exemplo, digamos que temos um array:

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

Primeiro, pegamos o elemento pivô, que é o primeiro elemento do array:


pivot := arr[0]

Com o pivô, dividimos o array em dois: um com os elementos menores que o pivô e outro com os elementos maiores que ele:


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])
	}
}

E aqui usamos recursão para ordenar os arrays da esquerda e da direita:


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

Por fim, concatenamos o array da esquerda, o pivô e o array da direita:


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

Deixei de propósito para o final para dizer que não podemos esquecer o caso base.

O caso base é quando o array tem só um elemento, situação em que retornamos o próprio array:


if len(arr) < 2 {
	return arr
}

Quando o array tem só um elemento, retornamos o array porque ele já está ordenado.

Agora podemos criar a função quickSort:


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...)
}

Agora podemos testar a função:


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

Ao rodar o código acima, você vai ver o array ordenado:


[2 3 5 6 10 100]

É isso! Espero que você tenha gostado deste post. Se tiver alguma dúvida, me conte nos comentários abaixo.

Conclusão

Neste post, expliquei dois conceitos importantes da ciência da computação: recursão e quick sort. Espero ter conseguido explicar de forma simples, para que a maioria das pessoas entenda, principalmente quem tem dificuldade ou até medo de algoritmos!

Abraços.

Selection Sort

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

Continuando meus estudos de algoritmos, agora consigo explicar o algoritmo selection sort (ordenação por seleção).

O selection sort é um algoritmo simples. Ele funciona encontrando o menor elemento de um array, adicionando esse elemento a um novo array e removendo-o do array original. Esse processo se repete até o array original ficar vazio. Quando isso acontece, o novo array contém os elementos em ordem.

Neste exemplo, não estou focando em performance, e sim na simplicidade do algoritmo.

Este é o array que vamos usar no exemplo:

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

No próximo passo, crio a função que recebe esse array e retorna o array ordenado:

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
}

A função getSmallerItem é responsável por obter o índice do menor elemento do 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
}

A função getSmallerItem compara cada elemento do array com a variável min. Se o elemento for menor que min, a variável min é atualizada com o valor do elemento, e a variável pos é atualizada com o índice dele. Quando o loop termina, a variável pos é retornada.

A função remove é responsável por remover o elemento do array:

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

A função remove recebe o array e o índice do elemento que será removido.

Agora podemos testar a função:

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

Este algoritmo não é eficiente, mas é um bom exemplo para entender o selection sort.

Espero que você tenha gostado deste post, até o próximo!

Indo Contra o Fluxo do Mundo

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

No meu país, esta semana marca o início da “Black Week”, embora o termo correto seja “Black Friday”, tradicionalmente um único dia de descontos nas lojas. Como você sabe, sou engenheiro de software, e nesta semana notei muitos cursos em promoção, oferecendo várias opções para aprender coisas novas.

Desta vez, porém, fiquei refletindo sobre esses cursos e sobre o mundo cada vez mais acelerado em que vivemos, um mundo em que todos sentem a necessidade de aprender rápido e em que os cursos muitas vezes prometem aprendizado acelerado. Decidi que, como ser humano, não devo seguir esse caminho da pressa.

Ao longo da história, quem conquistou conhecimento profundo em algum assunto fez isso com anos de estudo e prática constante. Acredito que esse deve continuar sendo o padrão hoje.

A ideia deste post não é deixar de comprar cursos ou materiais de estudo. É abraçar o processo de aprender aos poucos, um pouco a cada dia, e resistir à pressão de seguir as tendências aceleradas do mundo moderno.

Pensando nisso, quero compartilhar minha decisão nesta semana de Black Friday: decidi não comprar nenhum curso ou material que prometa resultados mais rápidos, mais fáceis ou milagrosos. Vou continuar lendo meus livros, seguindo a rotina que compartilhei aqui e focando em aprender devagar e com profundidade.

Espero que você aproveite bem esta semana de descontos onde mora e use a oportunidade para se planejar, focando em um caminho que considere o médio e o longo prazo, e que este post inspire você a refletir sobre seu processo de aprendizado e o caminho que está seguindo.

Abraços! 🤗

Explicando Busca Binária de Forma Simples

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

Hoje vou tentar explicar a busca binária de forma simples. A busca binária é um algoritmo de busca que encontra a posição de um valor dentro de um array ordenado. O array ser ordenado é um ponto importante aqui.

Para explicar a busca binária, precisamos de um array como exemplo.

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

Neste array, temos 10 elementos, de 1 a 10. A busca binária funciona comparando o valor procurado com o elemento do meio do array.

Por exemplo, se quisermos encontrar o número 5 no array, começamos comparando 5 com o elemento do meio do array, que é 6.

O próximo passo é comparar 5 com 6. Se 5 for menor que 6, podemos descartar a metade direita do array. O novo array fica assim:

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

Agora repetimos o processo, comparando 5 com o elemento do meio do novo array, que é 3.

O próximo passo é comparar 5 com 3. Se 5 for maior que 3, podemos descartar a metade esquerda do array. O novo array fica assim:

arr := []int{4, 5}

Agora repetimos o processo, comparando 5 com o elemento do meio do novo array, que é 5. E encontramos o número 5 no array.

Neste exemplo simples, encontramos o número 5 em 3 passos. Essa é minha explicação simples da busca binária.

Agora posso implementar o algoritmo de busca binária em 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
}

Agora posso usar a função search para encontrar o número 5 no 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)
}

Esta é a saída do programa:

Item 80 not found

Este algoritmo me lembra uma frase que ouço com frequência: dividir para conquistar! Espero que este post, junto com os outros, ajude você nos seus estudos e, mais importante, ajude você a entender que o melhor caminho é sempre o do conhecimento profundo!

Até a próxima! Obrigado por ler meu blog. Abraços!

Este Post Não É Sobre Tecnologia

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

Este post é sobre profundidade de conhecimento!

Quando comecei meu blog, adicionei o Google Analytics, não para acompanhar desempenho, mas porque tinha curiosidade de saber como as pessoas interagem com meus posts.

Com o tempo, escrevendo para este blog, percebi uma tendência interessante. As pessoas parecem preferir “receitas prontas” ou guias práticos. Por exemplo, quando escrevi posts sobre estudar Golang ou sobre como o Exercism me ajuda a aprender, eles chamaram pouca atenção. Da mesma forma, posts sobre LeetCode, técnicas de estudo ou minha agenda e rotina pessoal não geraram muito tráfego.

Mas, quando compartilhei um passo a passo de como usar Swagger em uma API em Golang, basicamente uma “receita”, ele se tornou o post mais visto da história do blog.

A imagem acima mostra o comportamento do meu blog na última semana. Como dá para ver, o post sobre Swagger teve mais que o dobro de visualizações de qualquer outro post.

Refletindo sobre isso, se eu pudesse dar um conselho, seria este:

Trate sua vida como uma longa jornada, uma maratona, não uma corrida de velocidade. Organize seu tempo, estude um pouco todos os dias e crie uma rotina que ajude você a manter o foco. Busque um aprendizado profundo e significativo, porque adquirir conhecimento profundo é a melhor forma de garantir um futuro relativamente estável, livre de medos e incertezas, inclusive diante de desafios como a IA.

No post em que comparo a vida a uma maratona, e não a uma corrida de 100 metros, mostro como funciona minha rotina, na esperança de ajudar e motivar você a organizar sua vida e focar no longo prazo.

Este post não é uma crítica, encare como um conselho de amigo! Como diz o poeta: “Se conselho fosse bom, não se dava, se vendia.” Mesmo assim, aqui estou eu, oferecendo de graça na tentativa de ajudar.

Espero que você tenha gostado deste post e que ele inspire ou ajude você de alguma forma!

Minha Estratégia para Estudar LeetCode

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

Antes de tudo, não se pressione. Foque no longo prazo, fazendo um pouco todos os dias ou encaixando isso na sua agenda e seguindo o plano, combinado?

Com isso em mente, esta é minha estratégia para estudar LeetCode.

1. Comece pelo básico

No momento, estou estudando o básico de algoritmos, com foco em manipulação de strings no LeetCode, filtrando pelos problemas fáceis. Neste post, vou mostrar passo a passo o exercício 125. Valid Palindrome do LeetCode.

2. Estude o problema

Neste ponto, você deve ler e entender o problema. Você pode ver o problema aqui.

3. Escreva o código

Agora vou começar a explicar como estudo no LeetCode. Primeiro, foco em simplesmente resolver o problema, sem me preocupar em encontrar a solução mais otimizada. O objetivo é só ter uma solução que funcione, combinado?

Neste exemplo, começo resolvendo o problema com o seguinte código:

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
}

Percebi que esta solução leva 1067 ms e usa 80,2 MB de memória. Nesse ponto, começo a procurar formas de melhorá-la.

4. Otimize o código

Aqui, trabalho para deixar a solução mais rápida e mais eficiente em memória:

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
}

Notei que a solução atualizada agora leva 976 ms e usa 48,5 MB de memória. Nesse ponto, continuo refinando para ver se ainda dá para melhorar.

5. A última melhoria

Então percebi que, para validar um palíndromo, não preciso guardar nada em memória; só preciso comparar os caracteres em posições específicas. Com essa abordagem, minha solução melhorou muito.

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')
}

Vi que esta solução otimizada agora leva 0 ms e usa apenas 4,5 MB de memória. Nesse ponto, vejo se ainda há espaço para melhorias, embora a solução já seja muito eficiente.

Aqui está um print das soluções no LeetCode:

6. Conclusão

Nestes passos, mostrei minha forma de estudar no LeetCode:

Primeiro, resolvo o problema sem me preocupar em encontrar a solução ideal, focando só em fazê-lo funcionar. Depois, tento refinar a solução para usar menos memória e rodar mais rápido. Por fim, penso em simplificações adicionais. Por exemplo, para validar um palíndromo, percebi que não preciso guardar nada em memória; só preciso comparar posições específicas dos caracteres. Essa abordagem melhorou muito minha solução. Esse método tem me ajudado a escrever código melhor no dia a dia, e espero que ajude você também!

Bons códigos! 🚀

Como Publicar Sua Biblioteca Go no Pkg Go

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

Continuando minha jornada para aprender Go com profundidade, hoje vou mostrar como publicar sua biblioteca no Pkg.Go.

Antes de tudo, você precisa ter uma biblioteca Go na sua conta do GitHub ou em qualquer outro repositório Git. Neste exemplo, vou usar uma biblioteca simples que criei, para mostrar como publicá-la.

A biblioteca é a valid-brazilian-cnpj. No Brasil temos um documento chamado CNPJ, e no ano que vem as regras de validação vão mudar, então criei esta biblioteca para me ajudar a validar CNPJs.

Como criei a biblioteca não é o foco deste post, mas, se quiser ver o código, é só acessar o repositório.

Para publicar sua biblioteca no Pkg.Go, você precisa criar uma release no seu repositório.

Primeiro passo: rode go mod tidy

O primeiro passo é rodar go mod tidy para garantir que todas as dependências estejam no arquivo go.mod.

go mod tidy

Segundo passo: rode os testes

O segundo passo é rodar os testes para garantir que tudo funciona como esperado.

go test -v

Esse comando roda todos os testes da biblioteca e mostra os resultados.

Terceiro passo: crie uma tag

O terceiro passo é criar uma tag no seu repositório.

git tag v0.1.0
git push origin v0.1.0

Esses comandos criam uma tag chamada v0.1.0 e a enviam para o repositório.

Quarto passo: envie para o Pkg.Go

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

Explicando o comando:

GOPROXY=proxy.golang.org: é a URL do Pkg.Go
go list -m github.com/linuxsoares/valid-brazilian-cnpj@v0.1.1: este comando envia a biblioteca para o Pkg.Go

Depois de rodar esse comando, você já pode acessar a biblioteca no Pkg.Go.

Conclusão

Neste post, mostrei como publicar sua biblioteca no Pkg.Go. É um processo simples, mas é importante seguir os passos para garantir que tudo funcione como esperado.

Espero que você tenha gostado deste post, e até o próximo.

Bons códigos!

Como Documentar Sua API em Go

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

Hoje vou escrever um post técnico sobre documentação de APIs em Go. Espero que seja útil!

Primeiro, vamos criar uma API CRUD simples usando Go e o framework Gin. Vamos começar!

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)
}

Agora que temos uma API CRUD simples em Go, vamos documentá-la.

Observação: neste exemplo, não usei a melhor abordagem para um CRUD. Defini uma struct User para representar um usuário e usei um slice para armazenar os usuários. Em um projeto real, você deve usar um banco de dados para armazenar os dados. Além disso, embora eu tenha usado funções básicas para manipular os dados, o recomendado em código de produção é seguir o padrão repository.

Esclarecido isso, vamos criar nossa documentação.

Primeiro, vamos criar um Makefile para facilitar o gerenciamento da aplicação.

run:
    go run main.go

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

Agora, precisamos instalar algumas dependências para usar o Swag.

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

Agora, preciso adicionar algumas descrições usando comentários no código da função main.

// @BasePath /api/v1

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

Precisamos adicionar uma rota para servir a documentação do Swagger.

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

Agora, precisamos rodar um comando para gerar a documentação.

make build-swagger

Com todas as configurações do Swag prontas, podemos rodar a aplicação e acessar a documentação no navegador.

make run

Agora, acesse a URL http://localhost:8080/swagger/index.html para ver a documentação.

Abaixo está um exemplo de como documentar um 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]

Com esses comentários em cada função, podemos gerar a documentação com o Swag.

O resultado é:

Você pode ver o projeto no repositório.

Conclusão

Neste artigo, aprendemos a documentar uma API em Go usando o Swag. Começamos criando uma API CRUD simples em Go e depois a documentamos com o Swag. Também aprendemos a gerar a documentação e a visualizá-la no navegador.

O Swag é uma ferramenta poderosa que ajuda a documentar suas APIs em Go com facilidade.

Espero que este artigo tenha sido útil. Se tiver dúvidas ou sugestões, fique à vontade para me mandar uma mensagem nas minhas redes sociais.

Obrigado pela leitura!

Lembre-se: a Vida Não É uma Corrida de 100 Metros

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

Na minha vida, muitas vezes gostei de algo e usei todos os dias até enjoar. Mas agora comecei a fazer terapia, e uma das primeiras coisas que aprendi foi a usar um calendário para organizar minha rotina.

Ao organizar minha rotina, percebi que preciso planejar tudo com antecedência, seja para a semana, o mês ou o ano. Por exemplo, na minha rotina atual:

Faço uma hora de exercício todos os dias úteis.
Estudo inglês dois dias por semana, uma hora por dia.
Passo 30 minutos por dia lendo livros fora da minha área, entre outras atividades.

A melhor parte de organizar a semana com objetivos claros é entender que o progresso leva tempo. Não vou aprender inglês ou Golang (uma linguagem de programação) em um dia ou em uma semana. Mas, organizando minha semana, consigo avançar nesses objetivos aos poucos e manter o foco.

Abaixo, mostro como organizo minha semana. Espero que ajude você a organizar a sua também.

Foi assim que estruturei minha agenda:

Faço exercício todos os dias da semana.
Leio todos os dias.
Estudo uma tecnologia nova todos os dias.
Trabalho normalmente e garanto tempo de qualidade com minha filha e minha família.

Espero de verdade que isso ajude você a organizar sua semana. Tem sido uma ótima ferramenta para lidar com a ansiedade e desenvolver uma visão de longo prazo. Afinal, a vida não é uma corrida de 100 metros!

Espero que este post tenha sido útil e que inspire você a organizar sua semana também.

Duck Typing em Go

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

Olá, pessoal!

Como contei em um post anterior, estou aprendendo Go para usar em alguns projetos do trabalho. Neste post curto, vou explicar como usar duck typing em Go, algo que foi bem desafiador para mim quando comecei a aprender a linguagem.

Para começar, vamos ver um exemplo simples em 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!

Neste exemplo um pouco excêntrico, a classe Person consegue “grasnar” como um Duck porque herda da classe Duck. Em Python, não precisamos declarar explicitamente o tipo do objeto na função; simplesmente chamamos o método que queremos usar.

Agora, vamos ver como fazer algo parecido em 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()
}

O código de exemplo acima está neste repositório no GitHub.

Neste exemplo em Go, temos duas interfaces, Dog e Cat, e duas structs, Shihtzu e Chartreux. A interface Dog define um método Bark, enquanto a interface Cat define um método Meow. As structs Shihtzu e Chartreux implementam os métodos Bark e Meow, respectivamente. É importante notar que, embora isso não esteja escrito explicitamente no código, essas structs estão implementando as interfaces.

Em Go, implementamos uma interface simplesmente definindo os métodos exigidos, sem precisar declarar que a struct implementa explicitamente a interface.

Em outras palavras, não precisamos dizer que Shihtzu é um Dog; basta implementar o método Bark para a struct Shihtzu, e o Go entende automaticamente que Shihtzu satisfaz a interface Dog.

Isso é bem diferente de linguagens como Python ou Java, mas, quando você pega o jeito, é direto e fácil de usar.

Espero que este post ajude você a entender melhor o Go e como o duck typing funciona na linguagem!

Como a IA Pode Mudar a Forma Como Trabalhamos

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

A primeira resposta é: EU NÃO SEI! Tchau, tchau! (Brincadeira! Continue lendo, por favor! Era só uma piada!)

Hoje vi o novo recurso Canvas da OpenAI e estou sentindo duas coisas:

Estou muito animado com a evolução da IA e com as novas possibilidades que ela pode trazer.
Também estou um pouco assustado com o avanço rápido da IA e com as mudanças que ela pode causar.

Vamos começar pelo primeiro ponto. Uso IA todos os dias para me ajudar a escrever código no trabalho. Mas é claro que não copio e colo o código gerado pela IA direto no meu editor (uso o Zed). Uso a IA para tirar dúvidas e para me ajudar quando preciso escrever em linguagens de programação com as quais tenho menos experiência. Isso é incrível, é como ter um assistente que entende do assunto bem ao meu lado!

Agora, o segundo ponto. Tenho uma filha e me preocupo com o futuro que a IA pode criar para ela. Como vai ser minha profissão no médio e no longo prazo? Ainda vou ter emprego?

A única certeza que tenho é que nenhuma profissão vai ser a mesma depois da IA. Se ela vai melhorar, piorar ou deixar de existir, não sabemos.

Apesar dessas preocupações, acredito que o segredo é continuar aprendendo e se manter atualizado com as tecnologias mais recentes. Precisamos estar preparados para os novos desafios que vêm por aí. A IA é uma ferramenta que pode nos ajudar a criar e concluir tarefas com mais velocidade e qualidade, mas cabe a nós continuar melhorando nossas habilidades.

E, como eu disse em outro artigo, não pare de estudar, mantenha o foco e continue estudando!

E você, o que acha? Como você se sente em relação à IA e às novas possibilidades que ela traz?

Continue Estudando, Nunca Pare

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

Por que sugiro que você nunca pare de estudar!

No começo da minha carreira, procurando uma profissão, eu sempre fui muito curioso com computadores, mas, com uma renda limitada, não tínhamos condições de estudar, comprar computadores ou ter acesso à tecnologia em geral.

Meu primeiro emprego foi pintando guidões de bicicleta, e eu não tinha perspectivas. Depois, consegui um emprego cuidando do estoque de uma loja de doces. Com isso, fiz um acordo com minha família: o pouco dinheiro que eu ganhava iria para pagar a faculdade, e todos concordamos!

Antes de começar a faculdade, um amigo me indicou para uma vaga de infraestrutura (estágio) e, sem pensar duas vezes, eu disse SIM SIM SIM, EU QUERO! Na entrevista, não fui totalmente sincero, COM MEDO DE PERDER A ÚNICA CHANCE, e quando perguntaram se eu já tinha trocado discos rígidos em servidores, eu disse SIM, CLARO!

No fim, era tão simples que consegui fazer sem nunca ter feito antes.

Mais tarde, na faculdade, simplesmente me apaixonei por escrever código. Eu sempre concluía os projetos e as tarefas, às vezes sem dormir, mas concluía, e com uma alegria indescritível.

Hoje me tornei engenheiro de software e continuo aprendendo tecnologias novas como se fosse meu primeiro dia.

Preciso dizer: a faculdade ajudou minha vida como NADA mais poderia ter ajudado; mudou tudo para melhor! Às vezes ouço pessoas dizendo que não vale a pena, mas penso o contrário. Se você pode ou quer, faça sem hesitar, como eu fiz no passado!

Por fim, quero dizer que, apesar dos medos neste novo mundo de IA generativa e dos desafios que vêm com ele, nunca, NUNCA pare de estudar.

E, se precisar de ajuda ou de alguma mentoria, posso tentar ajudar, é só me chamar!

Abraços, e siga em frente com seus estudos!

Como Estou Aprendendo Golang

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

No meu trabalho, comecei a usar Golang. Conheço ferramentas de IA como o ChatGPT, que podem me ajudar a concluir tarefas com mais eficiência. Mas eu gosto muito de aprender tecnologias novas e estou sempre aberto a novos desafios.

No passado, aprendi Scala, Python e Java lendo livros e praticando todos os dias. Desta vez, estou aprendendo Golang de outras formas. Uso o Exercism para praticar Golang, e agora vou mostrar como usá-lo.

Passo 1: instale o Golang

Primeiro, você precisa instalar o Golang no seu computador. Dá para baixar pelo site oficial. Não vou entrar em detalhes sobre a instalação, porque é bem simples. As instruções de instalação estão aqui.

Com o Golang instalado, confira se a instalação deu certo rodando este comando:

go version

Passo 2: instale o Exercism

Agora que o Golang está instalado, vamos instalar o Exercism. As instruções de instalação para o seu sistema operacional estão nesta página.

Depois de instalar o Exercism, confira a instalação rodando:

exercism version

Passo 3: comece a praticar

Com tudo configurado, você já pode praticar Golang com o Exercism. Baixe exercícios com o seguinte comando:

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

Por exemplo:

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

Esse comando baixa o exercício lasagna-master da trilha de Golang.

Depois de resolver o exercício, envie sua solução com:

exercism submit

Isso envia sua solução para o Exercism, e você também pode ver as soluções de outras pessoas.

Conclusão

É assim que estou aprendendo Golang com o Exercism. É uma ótima plataforma para praticar programação em várias linguagens. Que tal resolver alguns exercícios em Golang ou na linguagem que você preferir? Espero que você aproveite o processo!

Engenheiro de Software Sênior

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

Engenheiros de Software Sênior: impactando o crescimento do negócio e inspirando times

Quando comecei como Engenheiro de Software, pulei as etapas internas, porque minha primeira experiência em tecnologia foi com infraestrutura, não com programação. Fiz a transição para engenharia de software quatro anos depois e, quando finalmente trabalhei como Engenheiro de Software, tive muita sorte. Meus colegas eram profissionais excepcionais, que me apoiaram no começo da minha jornada.

Hoje, como Engenheiro de Software Sênior, me esforço todos os dias para ser como esses mentores e impactar positivamente as pessoas com quem trabalho. Conhecer o negócio em que você atua melhor do que ninguém permite ajudar quem está ao seu redor e ser um profissional excepcional onde quer que você vá. Uma frase que sempre lembro para impactar as pessoas ao meu redor é: seja sempre o sênior que você gostaria de ter conhecido quando era júnior. Essa frase me ajudou a ser um profissional melhor e a ajudar outras pessoas em suas jornadas.

Este texto é um convite para você ser o sênior que gostaria de ter conhecido quando era júnior. Seja o profissional que ajuda os outros e faz diferença na vida de quem está ao seu redor. E, alguns anos depois, se você seguir essa dica todos os dias, verá pessoas incríveis se tornando excelentes profissionais, porque no passado tiveram a sorte de conhecer você, que as impactou positivamente.

Seja a melhor versão de si mesmo todos os dias!

Abraços.

Primeiro Projeto em Clojure

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

Criando nosso primeiro projeto Clojure

Vamos continuar nosso tutorial. Hoje vou explicar como criar um projeto Clojure. Decidi dividir este artigo em duas partes: vamos ver como criar um projeto comum e um projeto web, em que vamos criar uma API para algum serviço.

Vamos começar criando um projeto comum. Não vai ser uma API, uma biblioteca nem nada do tipo. Só quero mostrar como criar um projeto, explicar sua estrutura e todo o resto.

Criar um projeto é muito simples se você instalou o Leiningen [comentei sobre ele no nosso primeiro artigo]. Se ainda não instalou, faça um favor a si mesmo e instale. O link do projeto está aqui: Leiningen — :)

Bom, se você fez esse favor a si mesmo e está com tudo bem instalado, é hora de criar o projeto Clojure. Vamos lá:

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

Ao rodar o comando acima, você ganha um diretório chamado hello-clojure, porque esse é o nome do projeto que passamos como parâmetro para o comando new do lein.

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

hello-clojure

A estrutura de um projeto Clojure

Entrando no diretório, você vai encontrar uma estrutura com muitos arquivos e subdiretórios. Não se assuste nem abandone o artigo; vou explicar cada um deles em detalhes. Esta é a estrutura do projeto:

Vamos explicar cada arquivo e diretório, de cima para baixo:

doc: na pasta doc, você pode colocar a documentação do seu projeto. O arquivo intro.md vem por padrão quando criamos o projeto com o lein.
    Só para esclarecer, a extensão .md é de markdown, muito usado pelo GitHub, por exemplo.

resources: o diretório resources é usado para guardar qualquer arquivo de configuração de que você precise.

src: dentro de src é onde vamos guardar o código Clojure do projeto.

test: o nome já diz tudo, contém todos os arquivos de teste do projeto.

CHANGELOG: normalmente é onde registramos o que muda em cada versão do projeto, seja em Python, Java, Clojure ou Ruby.

LICENSE: contém as informações legais em que normalmente clicamos "ACEITO" sem ler.

project.clj: enquanto resources é usado para arquivos de configuração, o project.clj é onde de fato configuramos nosso projeto Clojure.

Para você não ficar com um projeto que não roda nem mostra o famoso “HELLO WORLD”, vou explicar como colocá-lo para funcionar. — :)

Abra o arquivo project.clj e adicione o código abaixo depois de :dependencies. Não esqueça que ele precisa ficar dentro dos parênteses.

:main hello-clojure.core/foo

Depois disso, podemos rodar o projeto pela linha de comando, dentro do diretório do projeto, e ver o resultado:

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

E aqui está nosso resultado, sem erros :)

Para este artigo não ficar longo demais, vou dividi-lo em partes. Esta parte é sobre criar o projeto, e outra vai tratar do uso de namespaces, de como importá-los em outros namespaces e assim por diante.

O código vai estar disponível no GitHub, e vamos atualizá-lo a cada artigo.

Por hoje é isso. Obrigado a todos que leram até aqui e pelo ótimo feedback!!!

Abaixo estão os outros artigos e os que vêm por aí:

Hello World;
Criando nossas próprias funções;
Usando funções existentes do Clojure;
Criando um projeto Clojure;
Vendo como criamos funções e as reutilizamos nos nossos projetos;
Criando um projeto web;
Usando classes Java em funções Clojure;
E muito mais…

Até mais!

Busca

Mon, 01 Jan 0001 00:00:00 +0000