DEV Community: Tarcísio Giroldo

The harsh reality of doing something difficult

Tarcísio Giroldo — Fri, 07 Mar 2025 01:54:23 +0000

How many times have you tried and failed?

How many times have you focused, only to lose it minutes later—along with the hope of getting the job, the role, the prize you wanted so bad?

I’m here to tell you something:

You won’t achieve it until you’ve done something difficult in your life.

Start something hard now, and when you look back, you’ll find strength in your past struggles. Proof that you can actually do it.

You’re not dumber or smarter than the rest. Most people are average.

If I had to put a number on it, I’d say 90%.

There’s a line in Calculus Made Easy by Silvanus P. Thompson:

"What one fool can do, another can."

The difference between you and them?

They were—or are—focused. They’re used to doing hard things.

I mean really hard things.

Getting into a top university.
Finishing the damn course.
Landing a role in a big tech company.
Whatever.

But here’s the truth:

You won’t achieve it until you start doing hard things.

Forget social media. You’re just comparing yourself.

"Okay, but how do I do something difficult?"

I’ll tell you.

I grew up Catholic. Always heard about making promises.

(Not like JavaScript, relax.)

But why would doing something—or not doing something—make God grant me a wish?

That’s not the point.

You need to see it as strength.

It’s okay if you can’t do it yet.

Don’t beat yourself up.

But be real with yourself—you don’t want it as bad as you think.

That’s the deal. Commit fully to something difficult. Then tell yourself:

"I’ll reach my goal because I’m doing this hard thing."

Quit alcohol for a year. Two years.
Quit smoking.
Cut out fast food, food delivery. (Don’t wanna say DoorDash, but yeah.)

Do it for a while. No cheating. If you cheat, you’ll lose focus.

It’s simple: if you want it, you can do it.

But don’t set impossible timelines.

You won’t be a doctor in six months. That’s not how it works.

But say you want an entry-level job in the first half of next year.

Until then, you quit soda.

You still have to do your part.

This isn’t some magical bullshit.

You need to feel that you’re doing something.

If it’s painful enough—good.

You’re probably on the right path.

Do something difficult.

It’ll push you through to the next goal.

Feed on that hunger for at least a year.

That's it.

Photo by Jess Zoerb on Unsplash

Senioridade Tech: High Stakes, Still Debugging

Tarcísio Giroldo — Mon, 20 Jan 2025 13:35:47 +0000

Atividades ligadas a uma senioridade elevada são intrinsecamente dependentes do tipo de empresa.

É inegável que as demandas atreladas a profissionais sêniors variam drasticamente de acordo com o contexto empresarial.

Empresas como agências e software houses, por exemplo, têm necessidades bem diferentes de startups, fintechs ou grandes corporações.

E de forma alguma estou invalidando a experiência ou fazendo juízo de valor.

Essas são apenas observações das diferenças estruturais do mercado de trabalho em computação.

Nas agências e software houses, raramente o trabalho exige conhecimento profundo em microsserviços, sistemas distribuídos, alta disponibilidade ou escalabilidade. Se você está em uma dessas empresas e tem contato com essas áreas, saiba que você é uma exceção. Afinal, nem todas as organizações possuem demandas que justifiquem tais soluções complexas.

E com isso emerge o questionamento: o sênior de uma software house é o mesmo de uma fintech ou de uma empresa extremamente corporate?

Context matters

Empresas corporativas, como grandes fintechs, trazem demandas específicas que vão além do código. Entender o impacto de regulamentações como a LGPD, termos como GMUD e saber alinhar soluções às normas legais é uma parte fundamental do trabalho. Além disso, trabalhar em sistemas distribuídos não é apenas uma questão de quebrar monólitos em diversos microsserviços. Antes de mais nada, é essencial questionar: realmente precisamos criar microsserviços?

E essa é uma linha de pensamento (não estou dizendo que exclusivamente, mas majoritariamente) que se adquire com estudo formal e tempo prático.

A junção primordial de ter feito uma boa universidade, com tempo de prática da profissão, permite fazer a análise crítica (gerada pelo pensamento crítico que se começa na universidade) juntamente com uma predição de possíveis problemas ao implementar aquela tecnologia.

E é isso que eu vejo no pessoal mais sênior com quem lidei: antes de dar um passo em direção ao abismo, cheque se está de paraquedas.

Vejo uma pancada de pessoas sempre trabalhando com atualizações e refatorações desnecessárias, sendo que o cliente sequer sabe para o que serve.

É claro, uma refatoração sempre cai bem para aumentar a DX.

Mas também é necessário respeitar os padrões da empresa, e cada empresa tem o seu. Ser sênior significa não se incomodar com isso, pois a comunidade da linguagem vai na direção X e, no seu trabalho, estão fazendo do jeito J.

E, sim, identificar e corrigir um problema de índices mal configurados no banco de dados é WAY FAR mais importante que o colaborador saber inverter uma lista binária.

Colaborar e desenvolver um design system e o desenvolvimento mesmo é uma baita atividade de sênior, PORÉM ela só é possível em empresas que suportem tais padrões (ou que tenham essa demanda).

Monitoramento é algo que cabe em quase todos os lugares. É claro que algumas ferramentas se adaptam melhor a certos contextos que outras, mas é completamente possível escrever um log tracing para onde você está trabalhando sem usar as soluções de prateleira.

Senioridade é Contextual

A senioridade não é uma questão de ferramentas ou tecnologias específicas, mas de julgamento, experiência e adaptação ao contexto. Um profissional sênior em uma software house pode não ter experiência com escalabilidade em larga escala, mas dominará outras áreas igualmente valiosas para aquele mercado. Da mesma forma, um sênior em uma fintech provavelmente estará habituado a lidar com regulações e sistemas distribuídos, mas talvez não tenha experiência com o dinamismo de uma agência criativa.

Essas diferenças enriquecem o mercado e mostram que senioridade é muito mais sobre resolver problemas reais do que sobre uma lista de habilidades ou tecnologias.

Agora, se você leu até o final, me dá uma migalha de interação aqui. Fiquei enrolando para corrigir e postar este artigo. Se tiver algo a contribuir, deixa nos comentários. Sempre é bom estimular uma discussão saudável.

🚀 Um Guia Prático para Configurar Zsh, Oh My Zsh, asdf e Spaceship Prompt com Zinit para Seu Ambiente de Desenvolvimento

Tarcísio Giroldo — Fri, 21 Jun 2024 19:03:22 +0000

Introdução 🌟

Melhore seu ambiente de desenvolvimento com este guia sobre como instalar e configurar o Zsh, Oh My Zsh, asdf e o tema Spaceship Prompt. Também utilizaremos o Zinit para gerenciamento adicional de plugins. Vamos começar!

🛠️ Passo 1: Instalando o Zsh

O Zsh é um shell robusto que proporciona uma experiência de linha de comando poderosa. Veja como instalá-lo:

🐧 Para Linux (Ubuntu/Debian):

sudo apt update
sudo apt install zsh
chsh -s $(which zsh)

🍎 Para macOS:

O Zsh já vem pré-instalado. Para configurá-lo como seu shell padrão:

chsh -s /bin/zsh

🪟 Para Windows:

Use o WSL (Windows Subsystem for Linux) ou Git Bash. Para WSL:

Instale uma distribuição WSL (por exemplo, Ubuntu) na Microsoft Store.
Instale o Zsh como faria no Ubuntu.

Verifique a instalação:

zsh --version

⚙️ Passo 2: Configurando o Oh My Zsh

O Oh My Zsh simplifica a configuração do Zsh com temas e plugins.

Instale o Oh My Zsh:

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Este script configurará o Oh My Zsh e mudará seu shell padrão para o Zsh.

Configure o Oh My Zsh:

Abra seu arquivo .zshrc:
```
nano ~/.zshrc
```
Habilite os plugins:
```
plugins=(git asdf)
```
Recarregue sua configuração:
```
source ~/.zshrc
```

🔄 Passo 3: Instalando e Configurando o Zinit

O Zinit é um gerenciador de plugins para Zsh, oferecendo um gerenciamento de plugins flexível e rápido.

Instale o Zinit:

Adicione o trecho de instalação do Zinit ao seu .zshrc:

cat << 'EOF' >> ~/.zshrc

### Adicionado pelo instalador do Zinit
if [[ ! -f $HOME/.local/share/zinit/zinit.git/zinit.zsh ]]; then
    print -P "%F{33} %F{220}Instalando %F{33}ZDHARMA-CONTINUUM%F{220} Initiative Plugin Manager (%F{33}zdharma-continuum/zinit%F{220})…%f"
    command mkdir -p "$HOME/.local/share/zinit" && command chmod g-rwX "$HOME/.local/share/zinit"
    command git clone https://github.com/zdharma-continuum/zinit "$HOME/.local/share/zinit/zinit.git" && \
        print -P "%F{33} %F{34}Instalação bem-sucedida.%f%b" || \
        print -P "%F{160} A clonagem falhou.%f%b"
fi

source "$HOME/.local/share/zinit/zinit.git/zinit.zsh"
autoload -Uz _zinit
(( ${+_comps} )) && _comps[zinit]=_zinit

# Carregue alguns anexos importantes, sem Turbo
zinit light-mode for \
    zdharma-continuum/zinit-annex-as-monitor \
    zdharma-continuum/zinit-annex-bin-gem-node \
    zdharma-continuum/zinit-annex-patch-dl \
    zdharma-continuum/zinit-annex-rust

### Fim do trecho de instalação do Zinit

EOF

Fonte seu .zshrc:
```
source ~/.zshrc
```

🔌 Passo 4: Instalando Plugins Adicionais com Zinit

Use o Zinit para instalar plugins adicionais e enriquecer sua experiência com o Zsh.

Instale plugins usando o Zinit:

Abra seu arquivo .zshrc e adicione os seguintes comandos de plugin do Zinit:
```
nano ~/.zshrc
```

Adicione essas linhas para instalar e carregar plugins adicionais:

zinit light zdharma-continuum/fast-syntax-highlighting
zinit light zsh-users/zsh-autosuggestions
zinit light zsh-users/zsh-completions

Salve e recarregue seu .zshrc:
```
source ~/.zshrc
```

📦 Passo 5: Instalando e Configurando o asdf

O asdf é um gerenciador de versões versátil para várias linguagens.

Instale o asdf:

Clone o repositório do asdf:

git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.11.3

Adicione o asdf ao seu .zshrc:

echo -e '\n. $HOME/.asdf/asdf.sh' >> ~/.zshrc
echo -e '\n. $HOME/.asdf/completions/asdf.bash' >> ~/.zshrc
source ~/.zshrc

Instale plugins do asdf:

Adicione o plugin Node.js:

asdf plugin-add nodejs https://github.com/asdf-vm/asdf-nodejs.git

Instale uma versão específica:

asdf install nodejs 16.13.0
asdf global nodejs 16.13.0

Adicione o plugin Python:

asdf plugin-add python https://github.com/danhper/asdf-python.git

Instale uma versão específica:

asdf install python 3.9.7
asdf global python 3.9.7

Gerenciando versões específicas para projetos:

Crie um arquivo .tool-versions no diretório do seu projeto:

nodejs 14.17.6
python 3.8.10

Execute asdf install no diretório do projeto para usar essas versões localmente.

🚀 Passo 6: Configurando o Tema Spaceship Prompt

O tema Spaceship Prompt oferece um prompt elegante e informativo para o Zsh.

Instale o Spaceship Prompt:

Clone o repositório Spaceship:

git clone https://github.com/spaceship-prompt/spaceship-prompt.git "$ZSH_CUSTOM/themes/spaceship-prompt" --depth=1

Crie um link simbólico:

ln -s "$ZSH_CUSTOM/themes/spaceship-prompt/spaceship.zsh-theme" "$ZSH_CUSTOM/themes/spaceship.zsh-theme"

Defina o tema no seu .zshrc:
```
ZSH_THEME="spaceship"
```

Configure o Spaceship Prompt:

Crie um arquivo de configuração .spaceshiprc.zsh:
```
nano ~/.spaceshiprc.zsh
```

Adicione a seguinte configuração:

SPACESHIP_USER_SHOW=always
SPACESHIP_PROMPT_ADD_NEWLINE=false
SPACESHIP_CHAR_SYMBOL="λ"
SPACESHIP_CHAR_SUFFIX=" "
SPACESHIP_PROMPT_ORDER=(
  user          # Seção de nome de usuário
  dir           # Seção de diretório atual
  host          # Seção de nome do host
  git           # Seção do Git (git_branch + git_status)
  package       # Versão do pacote
  node          # Seção do Node.js
  bun           # Seção do Bun
  elixir        # Seção do Elixir
  erlang        # Seção do Erlang
  rust          # Seção do Rust
  docker        # Seção do Docker
  docker_compose # Seção do Docker Compose
  terraform     # Seção do Terraform
  exec_time     # Tempo de execução
  line_sep      # Quebra de linha
  jobs          # Indicador de trabalhos em segundo plano
  exit_code     # Seção de código de saída
  char          # Caractere do prompt
)

Fonte sua configuração no .zshrc:

echo "source ~/.spaceshiprc.zsh" >> ~/.zshrc
source ~/.zshrc

🔠 Passo 7: Adicionando uma Nerd Font para o Spaceship Prompt

Para melhorar a aparência do seu terminal com ícones e glifos adicionais, instale uma Nerd Font.

Instale uma Nerd Font:

Vá para o repositório do Nerd Fonts no GitHub e baixe uma fonte de sua preferência, como Hack ou Roboto Mono.
Siga as instruções de instalação para o seu sistema operacional.

Configure o Emulador de Terminal:

Abra as preferências/configurações do seu emulador de terminal.
Selecione a Nerd Font instalada (por exemplo, Hack Nerd Font ou Roboto Mono Nerd Font) como a fonte para o seu terminal.

Atualize sua Configuração do Zsh:

Abra o arquivo .zshrc:
```
nano ~/.zshrc
```
Atualize o SPACESHIP_CHAR_SYMBOL para usar um ícone da Nerd Font (por exemplo,  para Hack Nerd Font ou  para Roboto Mono Nerd Font):
```
SPACESHIP_CHAR_SYMBOL="" # Use o símbolo da Nerd Font apropriado aqui
```
Salve e feche o arquivo.

Fonte sua configuração:

source ~/.zshrc

🔧 Passo 8: Outras Configurações Úteis para Zsh

Personalize a História do Comando:

Armazene mais histórico e compartilhe entre sessões:

HISTSIZE=10000
SAVEHIST=10000
setopt share_history

Habilite Correções Automáticas:

Habilite correções para erros comuns de digitação:

setopt correct

🎉 Conclusão

Agora você configurou um ambiente de desenvolvimento robusto e visualmente atraente com Zsh, Oh My Zsh, asdf e o tema Spaceship Prompt, usando Zinit para plugins adicionais. Esta configuração melhorará seu fluxo de trabalho e facilitará o gerenciamento de vários projetos. Feliz codificação!

Leitura Adicional 📚:

Este artigo foi criado e personalizado com a ajuda do ChatGPT. 🤖💡

💅🏻CSS-in-JS is Making a Comeback: What’s New?

Tarcísio Giroldo — Fri, 21 Jun 2024 17:35:41 +0000

So, it looks like we are changing the direction of how we write CSS.

At first, I didn't like writing CSS-in-JS. It seemed unnecessary, but then I had a job where they only used styled-components, and I guess I adapted.

I didn't understand why we needed a library to write CSS when we could just use stylesheets directly or something like Tailwind CSS. But now that I’m a more experienced developer (I think), I kind of get why people love these libraries so much.

JavaScript frameworks are always changing direction from time to time, and now with React Server Components and React 19 supporting style hoisting, it feels like we’re heading into a new era. React 19 introduces new features that handle <script> and <style> tags inside components more intelligently, moving them to the document's head based on their precedence. This works seamlessly with concurrent rendering on the client and streaming rendering on the server, marking a significant shift in how we manage styles and scripts.

Some of these cool libraries are really embracing this change:

Inspiration

Bytes

This article was crafted and tailored with ChatGPT help. 🤖💡

👨‍💻neofetch is archived: what's next for terminal lovers?

Tarcísio Giroldo — Wed, 19 Jun 2024 23:29:11 +0000

I've been using neofetch since I don't know when but I always like of being extremely customizable.

This reminded me of when null-ls for Neovim was archived. It's a bittersweet reminder that things, even software, don't last forever.

I don't like to think of software as "dead." Instead, it's a chance to find new tools that can fill the gap. According to the Awesome Fetch repo, here are some of the best alternatives to Neofetch.

I don't like to consider the software dead (because this doesn't exists, I guess) but we need to have new cli tools to replace neofetch

Accordinly to Awesome Fetch, these are the most starred repos for fetch tools.

Fastfetch

Fastfetch is a speedy and efficient alternative. It provides quick system information without sacrificing the detail we love.

screenFetch

screenFetch is a simple Bash script that displays your system info alongside a cool ASCII logo of your OS. It’s easy to customize with options for colors, no ASCII art, and even taking screenshots right from the terminal. Perfect for those slick terminal screenshots everyone loves to share!

cpufetch

cpufetch focuses on showing off your CPU details in a clean and stylish way. It’s perfect for when you want to highlight your processor specs in a neat little package.

macchina

macchina is all about being fast, minimal, and customizable. It gives you a sleek overview of your system's specs with plenty of options to tweak things to your liking. If you’re looking for something quick and simple, this might be the tool for you.

HyFetch

HyFetch is a colorful alternative that adds pride flag colors to your system info. It’s a fun and inclusive way to spice up your terminal while still getting all the details you need.

Even though Neofetch is archived, it’s a great opportunity to try out some new tools and keep your terminal looking awesome. Whether you’re after speed, simplicity, or just a splash of color, there’s something here for everyone!

Inspired by:

Photo by Lukas on Unsplash

This article was crafted and tailored with ChatGPT help. 🤖💡

🚀 A hands-on guide to setting up zsh, oh my zsh, asdf, and spaceship prompt with zinit for your development environment

Tarcísio Giroldo — Tue, 18 Jun 2024 13:20:56 +0000

Introduction 🌟

Elevate your development environment with this guide on installing and configuring Zsh, Oh My Zsh, asdf, and the Spaceship Prompt theme. We will also leverage Zinit for additional plugin management. Let’s get started!

🚨🚨🚨 WARNING:If you like it this article please click in reaction and save, also follow me here and on my Github

🛠️ Step 1: Installing Zsh

Zsh is a robust shell that provides a powerful command-line experience. Here’s how to install it:

🐧 For Linux (Ubuntu/Debian):

sudo apt update
sudo apt install zsh
chsh -s $(which zsh)

🍎 For macOS:

Zsh is pre-installed. To set it as your default shell:

chsh -s /bin/zsh

🪟 For Windows:

Use WSL (Windows Subsystem for Linux) or Git Bash. For WSL:

Install a WSL distribution (e.g., Ubuntu) from the Microsoft Store.
Install Zsh as you would on Ubuntu.

Verify the installation:

zsh --version

⚙️ Step 2: Setting Up Oh My Zsh

Oh My Zsh simplifies Zsh configuration with themes and plugins.

Install Oh My Zsh:

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

This script will set up Oh My Zsh and switch your default shell to Zsh.

Configure Oh My Zsh:

Open your .zshrc file:
```
nano ~/.zshrc
```
Enable plugins:
```
plugins=(git asdf)
```
Reload your configuration:
```
source ~/.zshrc
```

🔄 Step 3: Installing and Configuring Zinit

Zinit is a plugin manager for Zsh, offering flexible and fast plugin management.

Install Zinit:

Add Zinit installer chunk to your .zshrc:

cat << 'EOF' >> ~/.zshrc

### Added by Zinit's installer
if [[ ! -f $HOME/.local/share/zinit/zinit.git/zinit.zsh ]]; then
    print -P "%F{33} %F{220}Installing %F{33}ZDHARMA-CONTINUUM%F{220} Initiative Plugin Manager (%F{33}zdharma-continuum/zinit%F{220})…%f"
    command mkdir -p "$HOME/.local/share/zinit" && command chmod g-rwX "$HOME/.local/share/zinit"
    command git clone https://github.com/zdharma-continuum/zinit "$HOME/.local/share/zinit/zinit.git" && \
        print -P "%F{33} %F{34}Installation successful.%f%b" || \
        print -P "%F{160} The clone has failed.%f%b"
fi

source "$HOME/.local/share/zinit/zinit.git/zinit.zsh"
autoload -Uz _zinit
(( ${+_comps} )) && _comps[zinit]=_zinit

# Load a few important annexes, without Turbo
zinit light-mode for \
    zdharma-continuum/zinit-annex-as-monitor \
    zdharma-continuum/zinit-annex-bin-gem-node \
    zdharma-continuum/zinit-annex-patch-dl \
    zdharma-continuum/zinit-annex-rust

### End of Zinit's installer chunk

EOF

Source your .zshrc:
```
source ~/.zshrc
```

🔌 Step 4: Installing Additional Plugins with Zinit

Use Zinit to install additional plugins for a richer Zsh experience.

Install plugins using Zinit:

Open your .zshrc file and add the following Zinit plugin commands:
```
nano ~/.zshrc
```

Add these lines to install and load additional plugins:

zinit light zdharma-continuum/fast-syntax-highlighting
zinit light zsh-users/zsh-autosuggestions
zinit light zsh-users/zsh-completions

Save and reload your .zshrc:
```
source ~/.zshrc
```

📦 Step 5: Installing and Configuring asdf

asdf is a versatile version manager for multiple languages.

Install asdf:

Clone the asdf repository:

git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.11.3

Add asdf to your .zshrc:

echo -e '\n. $HOME/.asdf/asdf.sh' >> ~/.zshrc
echo -e '\n. $HOME/.asdf/completions/asdf.bash' >> ~/.zshrc
source ~/.zshrc

Install asdf plugins:

Add the Node.js plugin:

asdf plugin-add nodejs https://github.com/asdf-vm/asdf-nodejs.git

Install a specific version:

asdf install nodejs 16.13.0
asdf global nodejs 16.13.0

Add the Python plugin:

asdf plugin-add python https://github.com/danhper/asdf-python.git

Install a specific version:

asdf install python 3.9.7
asdf global python 3.9.7

Managing project-specific versions:

Create a .tool-versions file in your project directory:

nodejs 14.17.6
python 3.8.10

Run asdf install in the project directory to use these versions locally.

🚀 Step 6: Configuring the Spaceship Prompt Theme

The Spaceship Prompt theme offers a sleek and informative prompt for Zsh.

Install Spaceship Prompt:

Clone the Spaceship repository:

git clone https://github.com/spaceship-prompt/spaceship-prompt.git "$ZSH_CUSTOM/themes/spaceship-prompt" --depth=1

Create a symlink:

ln -s "$ZSH_CUSTOM/themes/spaceship-prompt/spaceship.zsh-theme" "$ZSH_CUSTOM/themes/spaceship.zsh-theme"

Set the theme in your .zshrc:
```
ZSH_THEME="spaceship"
```

Configure Spaceship Prompt:

Create a configuration file .spaceshiprc.zsh:
```
nano ~/.spaceshiprc.zsh
```

Add the following configuration:

SPACESHIP_USER_SHOW=always
SPACESHIP_PROMPT_ADD_NEWLINE=false
SPACESHIP_CHAR_SYMBOL="λ"
SPACESHIP_CHAR_SUFFIX=" "
SPACESHIP_PROMPT_ORDER=(
  user          # Username section
  dir           # Current directory section
  host          # Hostname section
  git           # Git section (git_branch + git_status)
  package       # Package version
  node          # Node.js section
  bun           # Bun section
  elixir        # Elixir section
  erlang        # Erlang section
  rust          # Rust section
  docker        # Docker section
  docker_compose # Docker Compose section
  terraform     # Terraform section
  exec_time     # Execution time
  line_sep      # Line break
  jobs          # Background jobs indicator
  exit_code     # Exit code section
  char          # Prompt character
)

Source your configuration in .zshrc:

echo "source ~/.spaceshiprc.zsh" >> ~/.zshrc
source ~/.zshrc

Enable Command History Sharing:

To share command history across sessions:

HISTFILE=

~/.zsh_history
HISTSIZE=10000
SAVEHIST=10000
setopt share_history

Enable Auto-Corrections:

Enable corrections for common typos:

setopt correct

🔠 Step 7: Adding a Nerd Font for the Spaceship Prompt

Nerd Fonts provide additional icons and glyphs that enhance the appearance of your terminal, especially with themes like Spaceship Prompt.

Install a Nerd Font (e.g., Hack or Roboto Mono):

Go to the Nerd Fonts GitHub repository and download your preferred font (e.g., Hack or Roboto Mono).
Follow the installation instructions for your operating system.

Configure Your Terminal Emulator:

Open your terminal emulator's preferences/settings.
Select the installed Nerd Font (e.g., Hack Nerd Font or Roboto Mono Nerd Font) as the font for your terminal.

Now, your Spaceship Prompt should display with the Nerd Font icon you selected.

🎉 Conclusion

You’ve now set up a robust and visually appealing development environment with Zsh, Oh My Zsh, asdf, and the Spaceship Prompt theme, using Zinit for additional plugins. This configuration will enhance your workflow and make managing multiple projects a breeze. Happy coding!

Further Reading 📚:

Photo by Lukas on Unsplash

This article was crafted and tailored with ChatGPT help. 🤖💡

🐚🦀Shell commands rewritten in rust

Tarcísio Giroldo — Mon, 17 Jun 2024 13:36:54 +0000

Introduction

For every software engineer, developer, or programmer, command-line tools are essential for making life easier, especially when working with code. In recent years, with the rise in popularity of the Rust language, we have seen a growing number of these tools being rewritten in Rust, providing better performance and reliability.

But you might be wondering: Why should I use a command rewritten in Rust? The answer is simple: because it's amazing!

In this article, we will present a list of some of these tools that we use in our daily lives.

🚨🚨🚨 WARNING:If you like it this article please click in reaction and save, also follow me here and on my Github

Essential Tools

bat

"bat" is a clone of cat with syntax highlighting and Git integration. It works on Windows, MacOS, and Linux, offering syntax highlighting for a wide variety of file extensions.

bottom

"bottom" is a process and system monitoring tool. It provides graphical widgets to monitor CPU, RAM, network, disk, and other resources, making it a versatile and highly customizable choice for Linux, MacOS, and Windows.

lsd

"lsd" is an enhanced version of the ls command. It adds colors, icons, tree view, and more formatting options, making directory listing more informative and visually pleasing.

fd

"fd" is a fast and user-friendly alternative to the find command for locating entries in your file system. While it does not aim to replicate all the advanced functionalities of find, it offers opinionated defaults for most use cases.

sd

"sd" is an intuitive command-line tool for finding and replacing text. It simplifies the search and replace process with an easy-to-understand syntax, eliminating the need to deal with backslashes and other special characters.

Bonus

Here are some additional tools that we plan to start using:

xh

"xh" is a friendly and fast tool for making HTTP requests. It shares many of the great design features of HTTPie but focuses on improving performance. While we still use HTTPie out of habit, we plan to switch to "xh" soon.

joshuto

A terminal file manager inspired by Ranger. Currently, we use Ranger, but we are considering switching to "joshuto."

jql

"jql" is a JSON Query Language tool built in Rust. It provides a convenient way to query JSON data effectively.

xcp

"xcp" is a partial clone of the Unix "cp" command. It is not intended to be a complete replacement but rather a complementary utility that provides more user-friendly feedback and specific optimizations for certain tasks.

Custom Configurations

Here are some useful aliases that we have configured for "bat" and "lsd":

# Aliases
alias bat='batcat'
alias ll='lsd -la'
alias lld='lsd -la --date=relative --group-dirs=first'
alias lle='lsd -la --date=relative --sort=extension --group-dirs=first'
alias la='lsd -a'
alias l='lsd -l'
alias lt='lsd --tree'

Conclusion

These are some of the tools we love to use in our daily workflow, and we hope you find them useful as well. Additionally, we introduced some options that we plan to adopt in the future.

For more information and to explore more commands and applications rewritten in Rust, check out the following links:

Try out these tools and see how they can enhance your development and terminal experience!

🚴‍♂️Speeding up with JS one liners

Tarcísio Giroldo — Thu, 13 Jun 2024 15:01:05 +0000

I will write more, I promise.
I've been doing some leetcode and practicing my typing. So I pretend to write more about these two subjects.
I'm also not generating these stuff with ChatGPT and pretend to write more of my thoughts instead just being some random subject IA generated.
BUT I'm guiding through other articles about one liners and I know that subject is really simple and have another articles that you can search here on dev.to

But that's it, I hope y'all like it and share with your friends.

Array

Remove false values from array

arr.filter(Boolean)

Remove duplicates from array

[...new Set(input)]

Swap between 2 elements

[a, b] = [b, a]

Remove holes from array

input.flat(0)

Casting to array of numbers

input.map(Numbers)

Clone an array

input.slice(0)

[...input]

Array.from(input)

Merge multiple arrays

(...input) => input.flat(1)

Objects

Checking if the object is empty

Object.keys(obj).length === 0;

Strings

Removing whitespaces in a string

str.replace(/\s/g, '');

Generating random string

Math.random().toString(36).slice(2);

Reverse a string

input.split('').reverse().join('')

Numbers

Generate random integer

Math.floor((Math.random() * (max - min + 1)) + min)

Algumas boas práticas que utilizo diariamente

Tarcísio Giroldo — Fri, 08 Mar 2024 18:16:45 +0000

Desde 2019, minha jornada com React tem sido marcada por constantes descobertas de padrões e melhores práticas. É empolgante observar como a comunidade evolui, adotando práticas que otimizam o desenvolvimento. Claro, reconheço que as melhores práticas não são universais, variando entre empresas, mas são cruciais para a eficiência e manutenção do código.

Componentes

Priorize Componentes Funcionais

Ao tratar de componentes, a ênfase recai nos componentes funcionais. Com uma sintaxe mais simples e sem métodos de ciclo de vida ou construtores, eles promovem a clareza do código. Quando possível, proponha a refatoração de class components para functional components.

Exemplo de componente funcional:

const FunctionalComponent = () => {
  // lógica do componente
  return (
    // JSX
  );
};

Exemplo de class component:

class ClassComponent extends React.Component {
  // lógica do componente
  render() {
    return (
      // JSX
    );
  }
}

Não seja preguiçoso ao nomear seus componentes

A atribuição de nomes adequados aos componentes é fundamental. Utilize PascalCase para garantir consistência. Certifique-se de que seu ESLint aplique e faça cumprir essas regras. Coloque algum esforço nisso antes que seja tarde.

Evite Hardcoding em Filtros, Navegação e Listas

Nunca deixe itens hardcoded para filtros, navegação ou listas. Utilize constantes para esse fim e, se possível, agrupe todas em um único arquivo de constantes. Aproveite o método map() para facilitar a iteração em listas.

Comentários Estratégicos

Apesar da controvérsia em torno dos comentários, no contexto do React, onde paradigmas diferem, a prática de escrever comentários é valiosa. Comentários bem colocados podem fornecer insights cruciais sobre a lógica específica do React.

Adote JSX e TSX

Ao escrever componentes, adote JSX para React e TSX para TypeScript. Essa prática simplifica a identificação do tipo de arquivo e melhora a clareza do código.

Desestruture as Props

Desestruture as props do componente sempre que possível. Isso aprimora a legibilidade do código, a menos que seja crucial entender as diferenças entre o estado externo e interno do componente.

Exemplo de desestruturação de props:

const MyComponent = ({ prop1, prop2 }) => {
  // lógica do componente usando prop1 e prop2
  return (
    // JSX
  );
};

Gerencie o Número de Props

O cuidado com o número de props é subjetivo, mas se um componente possui mais de 4 ou 5 props, considere se ele está assumindo responsabilidades demais. Evite um excesso de props, o que pode indicar a necessidade de refatoração.

Use Objetos em Vez de Primitivos

Ao passar props, considere usar objetos em vez de primitivos. Isso simplifica a desestruturação dentro do componente, evitando torná-lo verboso e confuso.

Essas práticas visam criar código React eficiente e de fácil manutenção. Lembre-se, adaptar as práticas às necessidades específicas do projeto é crucial.

// Passando primitivos como props 
<UserProfile name={user.name} surname={user.surname} email={user.email} taxDocument={user.taxDocument} />

// Utilizando objetos como props 
<UserProfile user={user} />

Melhores Práticas Utilizando React e JavaScript

Pare de usar "var"!

Meio óbvio? Talvez não.

Use "const" e imutabilidade sempre que possível

Também meio óbvio

Mantenha ternários simples

No pior cenário, você tem dois ternários aninhados. Qualquer coisa mais longa deve ser uma instrução if ou switch por razões de legibilidade e facilidade de depuração.

// Ternários aninhados (a ser evitado)

const message =
  isMember ? "You are a member" : isVisitor ? "You are a visitor" : "Unknown status";

// Ternários simples

const displayMessage = isLoggedIn ? "Welcome back!" : "Please log in";

Simplifique com o optional chaining

Elimine essas verificações aninhadas e use o operador "?".

// Passando primitivos como props 
<UserProfile name={user.name} surname={user.surname} email={user.email} taxDocument={user.taxDocument} />

// Utilizando objetos como props 
<UserProfile user={user} />

Prefira template strings

É simples assim. As template strings permitem injetar valores na string e mantêm o formato, o que pode ser útil.

// Concatenação de strings tradicional 
const name = "John"; const greeting = "Hello, " + name + "! Welcome."; 

// Utilizando template string
const greetingTemplate = `Hello, ${name}! Welcome.`;

Evite aninhar ou encadear loops

Quando você encadeia métodos de iteração ou aninha loops, está aumentando a complexidade do código, o que pode retardar as coisas posteriormente ou à medida que seus dados crescem. Embora algumas operações possam exigir isso, avalie sempre sua estratégia de loop para garantir que você não tenha loops desnecessários ou loops que possam ser combinados.

Tenha testes unitários

Falando em boas práticas, não podemos esquecer a importância dos testes unitários. O Jest e o React Testing Library são ferramentas valiosas para garantir que sua aplicação funcione conforme o esperado. O Jest é um framework de teste completo para JavaScript, enquanto o React Testing Library fornece utilitários para testar componentes React de maneira eficaz. Integre essas ferramentas em seu fluxo de trabalho para criar uma base sólida.

⚛️Diferenças entre useMemo e useCallback

Tarcísio Giroldo — Tue, 20 Feb 2024 12:08:54 +0000

No React, useMemo e useCallback são hooks que visam otimizar o desempenho memorizando valores. No entanto, eles servem a propósitos distintos.

useMemo

useMemo é usado para memorizar o resultado de um cálculo. É necessária uma função e uma matriz de dependências e apenas recalcula o resultado quando as dependências mudam. Isto pode ser particularmente útil para cálculos caros ou ao lidar com transformações de dados complexas.

Casos de uso:

importar { useMemo } de 'react';

const MeuComponent = ({ data }) => {
   const processedData = useMemo(() => {
     // Lógica cara
     retornar processData(dados);
   }, [data]);

   return <div>{processedData}</div>;
};

Neste exemplo, processedData só será recalculado se a propriedade data for alterada, evitando cálculos desnecessários em cada renderização.

useCallback

useCallback é empregado para memorizar uma função de retorno de chamada. Também requer uma função e uma matriz de dependências. O retorno de chamada só é recriado quando as dependências mudam, o que é benéfico ao passar retornos de chamada para componentes filhos para evitar novas renderizações desnecessárias.

Casos de uso:

importar { useCallback } de 'react';

const ParentComponent = () => {
   const handleClick = useCallback(() => {
     // Lida com a lógica do clique
     console.log('Botão clicado!');
   }, []); // Sem dependências, o retorno de chamada permanece constante

   return <ChildComponent onClick={handleClick} />;
};

const ChildComponent = ({ onClick }) => {
   // Componente filho recebe retorno de chamada memorizado
   return <button onClick={onClick}>Clique em mim</button>;
};

Neste cenário, handleClick permanece o mesmo em todas as renderizações de ParentComponent porque não tem dependências, evitando novas renderizações desnecessárias de ChildComponent.

Em resumo, useMemo serve para memorizar valores, enquanto useCallback serve para memorizar funções de retorno de chamada. Entender quando usar cada gancho garante desempenho ideal em seus aplicativos React.

Cover Photo by Dan Meyers on Unsplash

🐚🦀Comandos shell reescritos em Rust

Tarcísio Giroldo — Wed, 04 Oct 2023 21:56:35 +0000

Introdução

Para todo engenheiro de software, desenvolvedor ou programador, as ferramentas de linha de comando são essenciais para tornar a vida mais fácil, especialmente quando se trabalha com código. Nos últimos anos, com o aumento da popularidade da linguagem Rust, temos visto um crescente número dessas ferramentas sendo reescritas em Rust, o que tem proporcionado melhor desempenho e confiabilidade.

Mas você pode estar se perguntando: Por que devo usar um comando reescrito em Rust? A resposta é simples: porque é incrível!

Neste artigo, vamos apresentar uma lista de algumas dessas ferramentas que utilizamos em nosso dia a dia.

Ferramentas Essenciais

bat

O "bat" é um clone do cat com destaque de sintaxe e integração com o Git. Funciona em Windows, MacOS e Linux, oferecendo destaque de sintaxe para uma ampla variedade de extensões de arquivo.

bottom

O "bottom" é uma ferramenta de visualização e gerenciamento de processos e sistemas. Ele fornece widgets gráficos para monitorar CPU, RAM, rede, disco e outros recursos, tornando-se uma escolha versátil e altamente personalizável para Linux, MacOS e Windows.

lsd

O "lsd" é um aprimoramento do comando ls. Adiciona cores, ícones, visualização em árvore e mais opções de formatação, tornando a listagem de diretórios mais informativa e agradável visualmente.

fd

O "fd" é uma alternativa rápida e amigável ao comando find para localizar entradas em seu sistema de arquivos. Embora não tenha como objetivo replicar todas as funcionalidades avançadas do find, ele oferece padrões sensíveis (baseados em opiniões) para a maioria dos casos de uso.

sd

O "sd" é uma ferramenta de linha de comando intuitiva para localizar e substituir texto. Ele simplifica o processo de busca e substituição com uma sintaxe fácil de entender, eliminando a necessidade de lidar com barras invertidas e outros caracteres especiais.

Bônus

Aqui estão algumas ferramentas adicionais que pretendemos começar a usar:

xh

O "xh" é uma ferramenta amigável e rápida para enviar solicitações HTTP. Ele compartilha muitos dos excelentes recursos de design do HTTPie, mas com foco em melhorar o desempenho. Embora ainda usemos o HTTPie por hábito, planejamos migrar para o "xh" em breve.

joshuto

Um gerenciador de arquivos de terminal inspirado no Ranger. Atualmente, usamos o Ranger, mas estamos considerando fazer a troca para o "joshuto".

jql

O "jql" é uma ferramenta de Linguagem de Consulta JSON construída em Rust. Oferece uma maneira conveniente de consultar dados JSON de forma eficaz.

xcp

O "xcp" é um clone parcial do comando Unix "cp". Não é destinado a ser uma substituição completa, mas sim uma utilidade complementar que fornece feedback mais amigável ao usuário e otimizações específicas para certas tarefas.

Configurações Personalizadas

Aqui estão alguns aliases úteis que configuramos para o "bat" e o "lsd":

#Aliases
alias bat='batcat'
alias ll='lsd -la'
alias lld='lsd -la --date=relative --group-dirs=first'
alias lle='lsd -la --date=relative --sort=extension --group-dirs=first'
alias la='lsd -a'
alias l='lsd -l'
alias lt='lsd --tree'

Conclusão

Estas são algumas das ferramentas que adoramos usar em nosso fluxo de trabalho diário, e esperamos que você também as ache úteis. Além disso, apresentamos algumas opções que pretendemos adotar no futuro.

Para obter mais informações e explorar mais comandos e aplicativos reescritos em Rust, consulte os seguintes links:

Experimente essas ferramentas e veja como elas podem aprimorar sua experiência de desenvolvimento e uso do terminal!

🦾How to automate your resume using R, R markdown, and GitHub Actions

Tarcísio Giroldo — Fri, 18 Aug 2023 14:29:37 +0000

⚡ Original repo
Please leave a star⭐ on the project and follow me on Github

Overview

Automating the creation of your resume is a smart way to save time and keep your information up to date. In this article, I will guide you through a simple process using tools like Rmarkdown and GitHub Actions to automate the generation of your resume.

Understanding the Tools 🧰

Before we dive into the process, it's important to understand the tools we'll be using:

R: A programming language focused on statistical analysis and data visualization. We'll use R to create and manipulate our resume.

Rmarkdown: An extension of R that allows combining code, text, and visual elements into a single document. We'll use Rmarkdown to create a structured resume.

GitHub Actions: An automation service provided by GitHub that allows us to create custom workflows. We'll leverage GitHub Actions to automate the resume generation.

Docker: A platform that enables packaging, distributing, and running applications in containers. We'll use Docker to create a consistent environment for executing our resume generation process.

Now that we understand the tools involved, let's proceed to the automation process:

Getting Started

First and foremost, you'll need a GitHub account. If you don't have one yet, you can create one here. You'll also need access to a web browser to configure a few things.

Step 1: Prepare the Repository 📦

Create a new repository on GitHub for your project.
Clone the repository to your computer using Git.

Step 2: Add the Resume File 📄

Create a file named data-driven-cv.Rmd (or use any name you prefer, just remember to change it in the action and it should be .Rmd) in the root of your repository.
Open the file in your favorite text editor.

The file should have this header:

---
name: Your name
surname: Your surname
address: "Your address"
profilepic: "./imgs/zero-cool.jpeg"
position: "Software Engineer | Frontend Developer"
www: "yoursite.dev"
email: "youremail@email.com"
github: yourgithub
linkedin: yourlinkedin
date: "`r format(Sys.time(), '%B %Y')`"
headcolor: 7d34eb # Here you can choose your favorite color
aboutme: "I am a software engineer with over 6 years of experience in developing modern web applications. My passion lies in creating incredible and functional user interfaces."
docname: Resume
output: vitae::awesomecv
---

Note that in the last attribute of the YAML, you have the vitae::awesomecv.

This is just one of the mentioned templates, the others are available here.

In this section, personal information and resume formatting are defined. This includes name, surname, position, website links, contact information, resume creation date, header color, and a brief description about you.

The file should follow this structure:

---
name: Your name
surname: Your surname
address: "Your address"
profilepic: "./imgs/zero-cool.jpeg"
position: "Software Engineer | Frontend Developer"
www: "yoursite.dev"
email: "youremail@email.com"
github: yourgithub
linkedin: yourlinkedin
date: "`r format(Sys.time(), '%B %Y')`"
headcolor: 7d34eb # Here you can choose your favorite color
aboutme: "I am a software engineer with over 6 years of experience in developing modern web applications. My passion lies in creating incredible and functional user interfaces."
docname: Resume
output: vitae::awesomecv
---

{r setup, include=FALSE}
knitr::opts_chunk$set(echo = FALSE,
                      warning = FALSE,
                      message = FALSE)

require(xfun)

packages <- c('vitae', 'tibble', 'magrittr', 'here', 'readr', 'glue')

xfun::pkg_attach2(packages, message = FALSE)

# In this part, we set the path and the file we want. If you're following the step-by-step tutorial, you'll need to change the second parameter to data.R
source(file = here("data","data-generic.R"))

# Experience

{r EMPLOYMENT}

work %>%
  detailed_entries(
    with = title,
    what = unit,
    why = detail,
    when = glue::glue("{startMonth} {startYear} -- {endMonth} {endYear}", .na = ""),
    where = where
  )

# Education

{r EDUCATION}

edu %>%
  detailed_entries(
    with = inst,
    what = degree,
    why = detail,
    when = glue::glue("{startYear} -- {endYear}", .na = ""),
    where = where
  )


\pagebreak

# Skills

{r SKILLS}

skills %>%
  detailed_entries(
    with = area,
    what = skills,
    why = detail
  )

\pagebreak

# Projects

{r PROJECTS}

projects %>%
  detailed_entries(
    with = accomplishment,
    what = area,
    when = glue::glue("{year}", .na = ""),
    where = where,
    why = detail
  )

# Certifications

{r CERTIFICATIONS}

certifications %>%
  detailed_entries(
    with = accomplishment,
    what = area,
    when = glue::glue("{year}", .na = ""),
    where = where,
    why = detail
  )

# Honors and Awards

{r HONORS}

honors %>%
  detailed_entries(
    with = accomplishment,
    what = area,
    when = glue::glue("{year}", .na = ""),
    where = where,
    why = detail
  )

Step 2: Creating data.R 📝

Create a folder named "data."
Create a file named data.R with the following structure:

skills <- tribble(
  ~area, ~skills, ~detail,
  "Technology", "Javascript", "Experience with Javascript in front-end projects using React",
  "Technology", "Javascript", "Redux, Redux Toolkit, and Context API for state management",
  "Technology", "Javascript", "Jest and React Testing Library for unit tests",
  NA, "Typescript", "Using Typescript with Prisma for database access.",
  NA, "Elixir", "Exploring Elixir in personal projects using Phoenix and Ecto.",
  NA, "Elixir", "Using LiveView for fullstack applications.",
  NA, "HTML", "Creating semantic and accessible web pages.",
  NA, "CSS", "Styling projects using SASS and BEM methodology.",
  NA, "Rust", "Learning Rust for secondary projects.",
  NA, "Rust", "Following the zero2prod book.",
  NA, "DevOps", "Experience with virtualization and containers using Docker.",
  NA, "DevOps", "CI/CD with Github Actions and TravisCI.",
  NA, "Databases", "Working with SQL and NoSQL databases.",
  NA, "Databases", "MongoDB for non-relational databases.",
  "Languages", "Portuguese", "Native language.",
  "Languages", "English", "Fluent.",
)

edu <- tribble(
  ~degree, ~startYear,

 ~endYear, ~inst, ~where, ~detail,
  "Bachelor's in Computer Science", 2015, 2019, "Imaginary University", "Fictional City, Fictional State, Fictional Country", "Studies in algorithms, data structures, and object-oriented programming.",
  "Master's in Software Engineering", 2020, 2022, "Fictional University", "Fictional City, Fictional State, Fictional Country", "Research in software development, focus on agile methodologies and scalable architectures.",
)

work <- tribble(
  ~title, ~unit, ~startMonth, ~startYear, ~endMonth, ~endYear, ~where, ~detail,
  "Software Engineer", "TechSoft", "January", 2020, "December", 2022, "Fictional City, Fictional State", "Worked as part of a team in developing web applications using React and Redux.",
  "Full Stack Developer", "WebTech", "March", 2018, "November", 2019, "Fictional City, Fictional State", "Participated in the development of a full stack application using Node.js, React, and MongoDB.",
  "Development Intern", "ByteCorp", "July", 2017, "December", 2017, "Fictional City, Fictional State", "Gained practical experience working on software development projects.",
)

honors <- tribble(
  ~area, ~accomplishment, ~year, ~where, ~detail,
  "Hackathon", "Best Computing Student", 2021, "Wall Street", "Awarded 1 billion dollars.",
  "Academic Recognition", "Best Computing Student", 2019, "Imaginary University", "Recognized for academic excellence in the field of Computing.",
  "Programming Competition", "1st Place in Algorithms", 2018, "Fictional Programming Event", "Achieved first place in the algorithm programming competition.",
)

projects <- tribble(
  ~area, ~accomplishment, ~year, ~where, ~detail,
  "Software Development", "Task Management System", 2022, "TechSoft", "Led the creation of a task management system using React and Redux.",
  "Software Development", "E-Commerce Platform", 2021, "Fictional Company", "Participated in the development team of an e-commerce platform.",
)

certifications <- tribble(
  ~area, ~accomplishment, ~year, ~where, ~detail,
  "Professional Certifications", "React Certification", 2021, "Fictional Online Learning Platform", "Obtained React certification to showcase skills in the library.",
  "Professional Certifications", "Docker Certification", 2020, "Fictional Online Learning Platform", "Achieved Docker certification to demonstrate container knowledge.",
)

Step 3: Setting Up Automation 🤖

On GitHub, go to the "Actions" tab in your repository.
Click on "Set up a workflow yourself" to create a workflow file.
Paste the following code into the file and save:

name: CI for CV
on:
  push:
    paths:
    - .github/workflows/ci.yml
    - 'markdowns/**'
    - 'data/**'
    branches:
      - main        
permissions: write-all

jobs:
  build:
    name: Creation of resume in en and pt-br
    runs-on: ubuntu-latest
    container:
      image: mlampros/mycvitae:rstudiodev
    steps:
      - name: Set up Git repository
        uses: actions/checkout@v3

      - name: Installing texlive
        run: |
          sudo apt-get -y update
          sudo apt-get install -y texlive-base texlive-latex-base
          sudo apt-get install -y texlive-latex-recommended
          sudo apt-get install -y texlive-xetex
          sudo apt-get install -y texlive-fonts-extra

      - name: Render the resumes
        run: |
          Rscript -e "rmarkdown::render(input = file.path(getwd(), 'data-driven-resume.Rmd'), params = list(work_dir = getwd()))"
          Rscript -e "rmarkdown::render(input = file.path(getwd(), 'data-driven-resume-pt-br.Rmd'), params = list(work_dir = getwd()))"
      - name: Commit files
        run: |
          git config --local user.email "actions@github.com"
          git config --local user.name "GitHub Actions"
          git add .
          git commit -am "add the cv in english and pt-br files to the directory of the repository"
          git push

Wrapping Up

If you've followed all the steps correctly, you'll likely see the resume with a header similar to the one above.

PS: Yeah, I know that the image is in pt-br but I'm lazy and I'm not redo all the steps just to generate one image.

Conclusion

Automating the creation of your resume using Rmarkdown, GitHub Actions, and Docker is an effective way to keep your information updated and relevant. The benefits range from saving time to showcasing your technical skills to employers.

If you have any questions, feel free to reach out!

Also, if you have any contributions, please fork the repository and open a pull request. I'll be happy to review them.

I hope this article has been helpful and that you're ready to automate your resume. Happy hacking! :)