Criando um ambiente de desenvolvimento minimalista
Tags: linux, braziliandevs
Published: 2021-01-10 07:34:24

# Introdução

Quando instalamos algum sistema bem recheado de recursos (Como Ubuntu, Fedora, Mint,etc) Há muitos recursos que não usamos.

Um exemplo disso é a inteface gráfica *Gnome*. Que vem com muitos recursos e personalizações que quem está usando a interface no final, não usa.

Com isso, muitas pessoas personalizam os seus sistemas, tornando algo mais proximo delas e da forma que elas preferem trabalhar. As vezes criando um sistema mais minimalista, com menos distrações na interface, e eventualmente com menor consumo dos recursos da máquina.

Para fazer essa personalização, há **VÁRIAS** opções e combinações que podemos criar e usar. Mas todas essas combinações minimalistas tem normalmente os destaques abaixo:

- Gerenciador de Janelas (*Window Manager*). Será o programa responsável por gerenciar qualquer janela que você
- Barra de Status. A barra de status vai te ajudar a gerenciar quantas janelas estão acertas, e em qual lugar estão abertas (workspaces). E também te dar informações para você sobre o consumo de memória, processamento, horário,etc 
- Inicializador de aplicativos. Esse será o programa que irá abrir os aplicativos de maneira gráfica. Sem precisarmos de um terminal.
- Terminal. Com o uso mais minimalista, o uso de um terminal para eventualmente substituir outros programas (como gerenciadores de arquivos) é maior.

Parece algo complexo, mas vamos destrinhar e personalizar cada um para criarmos uma sugestão de um sistema minimalista para você!

A sugestão que eu irei dar é a combinação de i3wm como gerenciador de janelas, Polybar como barra de status, Rofi como inicializador de programas, e Alacritty como terminal. Mas irei primeiramente mostrar o padrão que já vem, principalmente no i3wm.

# I3wm (Gerenciador de Janelas) e I3Status (Barra de status)

O gerenciador de janelas que iremos usar será o I3wm. É um dos maiores gerenciadores de janelas minimalista, e tem uma grande liberdade de personalização via arquivos de configuração.

Por padrão, o I3wm tem uma aparência parecida com isto:

![Captura de tela da aparência padrão do I3wm](https://dev-to-uploads.s3.amazonaws.com/i/5e535r1gcj54eeoo5qqk.png)

Para instalar o I3wm no seu sistema, você pode usar alguma aplicação gráfica de sua escolha, ou ainda via terminal com os seguintes comandos:

## Ubuntu (e distribuições baseadas em Debian)

`sudo apt install i3 dmenu i3status feh`

## Fedora

`sudo dnf install i3 dmenu i3status feh`

## Arch Linux

`sudo pacman -S i3 dmenu i3status feh`

> Caso seu sistema não esteja aqui, procure pelo método de instalação dos pacotes na sua distribuição.

Neste comando, vamos instalar o i3wm como gerenciador de janelas, dmenu como inicializador de programas, i3status como barra de status (essa é a barra padrão do i3wm), e feh como utilitário que vamos usar para definir o fundo da nossa área de trabalho. Essa será a nossa configuração inicial.

Agora, entre na interface gráfica que já está instalada na máquina (Gnome, KDE, Cinnamon,etc) e encerre a sessão. Com isso você entrará em uma tela de login, onde em algum lugar (isso depende do programa que você utiliza para gerenciar logins, que é o GDM caso o seu sistema use Gnome, KDE Display Manager caso o seu sistema usa KDE,etc) terá uma parte para mudar a interface gráfica que você irá usar por padrão. Busque por essa parte e mude para `i3` ou `i3wm` dependendo do modo que está escrito.

Agora você pode continuar o seu login normalmente, e quando você entrar, já estará dentro do I3wm.
A primeira tela que você verá será essa (pode estar com um fundo diferente):

![Tela de configuração inicial do I3wm](https://dev-to-uploads.s3.amazonaws.com/i/x1l8j55ne1komv8sxiwt.png)

Essa tela pergunta se você quer criar um arquivo de configuração do I3 (com as configurações padrão) ou se você não quercriar esse arquivo. E deixar que o I3 use a configuração padrão. O recomendado é você apertar `<Enter>` para criar esse arquivo.

Logo após essa tela, outra tela referente a configuração irá aparecer:

![Tela de configuração de tecla meta](https://dev-to-uploads.s3.amazonaws.com/i/ip14b2tf617recy71cfh.png)

No I3wm precisamos de uma tecla modificadora. Essa tecla modificadora será usada pra manipular as janelas, mudar de workspaces,etc. As duas opções padrão do I3 é a tecla Super (tecla Windows)  e atecla Alt. O mais recomendado é usar a tecla Super como tecla modificadora, pois é muito raro ter atalhos em programas que usem a tecla Super. Logo, nessa parte você pode apenas apertar `<Enter>` para usar a tecla Super como tecla modificadora. Caso queria usar a tecla Alt, use a seta do teclado para baixo para selecionar a tecla Alt e `<Enter>` novamente para selecionar.

Pronto! Agora você já está no ambiente padrão do I3.

![Ambiente padrão do I3wm](https://dev-to-uploads.s3.amazonaws.com/i/15s5hyrdcib9g8yvrgj9.png)

Agora temos que aprender algumas teclas para aprendermos a sobreviver dentro do I3wm.

- Super + [NUMERO] | Muda de workspaces. No i3 podemos por padrão ir da Workspace 1 até a 9.
- Super + Shift + [NUMERO] | Move uma janela para outra workspace.
- Super + SETA | Move o foco entre janelas em um mesmo workspace.
- Super + `<Enter>` | Abre o terminal padrão
- Super + `<d>` | Abre o dmenu
- Super + `<Shift>` + `<q>` | Fecha a janela que está em foco.
- Super + `<Shift>` + `<e>` | Encerra a sessão
- Super + `<Shift>` + `<r>` | Reinicia o I3. Isso é útil para mudar a configuração e ver as mudanças sem precisar reiniciar o sistema ou encerrar a sessão.

No começo, a quantidade de atalhos pode ser algo complexo. Mas ao longo do tempo você irá se acustumar e ter isso em sua memória muscular.

# Rofi

Agora vamos instalar o [Rofi](https://github.com/davatorium/rofi). Que irá substituir o dmenu. Iremos fazer isso pois com o Rofi podemos mudar de janela, ver todas as janelas abertas, e iniciar programas (como no dmenu). Além que podemos personalizar com temas, fontes, ícones,etc.

Para instalar, siga as instruções:

## Ubuntu

```
sudo apt install rofi
```

## Fedora

```
sudo dnf install -y gcc make autoconf automake pkg-config flex bison git libasan pango pango-devel cairo cairo-devel glib2 glib2-devel librsvg2 librsvg2-devel libxkbcommon libxkbcommon-devel libxkbcommon-x11 libxkbcommon-x11-devel libxcb libxcb-devel startup-notification startup-notification-devel xcb-util xcb-util-devel xcb-util-wm xcb-util-wm-devel xcb-util-xrm xcb-util-xrm-devel check check-devel

cd /tmp
git clone https://github.com/DaveDavenport/rofi --recursive
cd rofi
autoreconf -i
mkdir build && cd build
../configure
make
sudo make install
```

Os passos anteriores vão instalar todas as dependências caso você não tenha alguma, clonar o repositório do Rofi, compilar, e fazer a instalação.

## Arch Linux

```
sudo pacman -S rofi 
```

Agora, você pode executar programas e trocar entre janelas, com o Rofi.

Para rodar programas, abra um terminal e execute:

`rofi -show drun`

![captura de tela do rofi no modo drun](https://dev-to-uploads.s3.amazonaws.com/i/8tnwxncalxpj241mraur.png)

Esse comando vai abrir o Rofi, com o modo `drun`. Por lá você irá poder executar qualquer programa ou aplicativo dentro do sistema.

E para trocar entre janelas, execute:

`rofi -show window`

![captura de tela do rofi no modo window](https://dev-to-uploads.s3.amazonaws.com/i/h015zolktif478vn1n3l.png)

Com isso, todas as janelas abertas serão listadas.

## Integrando o I3wm com Rofi

Agora teremos que modificar o arquivo de configuração do I3wm. Esse arquivo está localizado em `~/.config/i3/config`. Este arquivo guarda todas as configurações do I3, e será usado para tornarmos o nosso i3 mais proximos de nós.

Teremos que modificar o atalho atual `Super+D` que abre o Dmenu, para que abra o Rofi, com o modo `drun` para listar os programas.

Vá na linha 36, essa linha por padrão terá o seguinte conteúdo:

```
bindsym $mod+d exec dmenu_drun
```

Analisando a linha acima, podemos ver que:

- `bindsym` representa que é um atalho;
- `$mod+d` é o atalho, que é a tecla modificadora (no caso Super) mais a tecla `d`;
- `exec` para executar algo
- `dmenu_drun` para rodar o dmenu.

Para rodarmos o Rofi ao invés do Dmenu, apenas precisamos alterar o final, substituindo `dmenu_drun` para `rofi -show drun`

Com isso, essa linha ficará assim:

```
bindsym $super+d exec rofi  -show drun
```

Agora você precisa reiniciar o i3. Isso pode ser feito com o atalho `Super + <Shift> + <r>`. O seu i3 irá reiniciar, e agora, se você usar o atalho `Super + d`, o Rofi será aberto para você iniciar qualquer aplicativo ou programa do seu sistema.

# Polybar

Agora iremos trocar a barra do sistema por uma que permite maior personalização. Estavamos usando a i3status, que é a barra padrão do i3. Mas iremos troca-lá pela [Polybar](https://github.com/polybar/polybar#installation).

## Ubuntu

Se você está usando o Ubuntu 20.10, o Polybar já está nos repositórios da distribuição. Logo, você pode simplesmente usar

```
sudo apt install polybar
```

Se você está em outras versões do Ubuntu, você deverá instalar as dependências, e compilar o Polybar. Dessa maneira:

```
cd /tmp
sudo apt-get install \
  cmake cmake-data libcairo2-dev libxcb1-dev libxcb-ewmh-dev \
  libxcb-icccm4-dev libxcb-image0-dev libxcb-randr0-dev \
  libxcb-util0-dev libxcb-xkb-dev pkg-config python-xcbgen \
  xcb-proto libxcb-xrm-dev i3-wm libasound2-dev libmpdclient-dev \
  libiw-dev libcurl4-openssl-dev libpulse-dev \
  libxcb-composite0-dev xcb libxcb-ewmh2
git clone https://github.com/jaagr/polybar.git
cd polybar
git tag # see what version do you need
git checkout 3.4.1
./build.sh
```

Neste comando, primeiramente vamos para `/tmp`, que é um diretório temporário do sistema, instalamos todas as dependências, clonamos o repositório oficial do Polybar, e compilamos o Polybar.

## Fedora

```
sudo dnf install polybar
```

## Arch Linux

O Polybar está na AUR. Logo você pode instalar com:

```
yay -S polybar
```

## Integrando o Polybar no I3wm

Agora precisamos substituir a i3status pelo Polybar.

Primeiramente vamos criar o arquivo de configuração do Polybar, com a configuração padrão. Essa configuração pode ser mudada á vontade. Adicionando ou removendo informações na barra, e mudando o tema das cores da barra.

Primeiramente, vamos criar o diretório `~/.config/polybar`, para deixarmos todas as configurações neste lugar.

`mkdir .config/polybar`

Agora, vamos copiar o arquivo de configuração padrão do Polybar para este diretório:

`cp /usr/share/doc/polybar/config ~/.config/polybar`

Agora, com essa configuração copiada, você pode executar `polybar example`. Esse comando vai iniciar a barra `example`. que foi definida exatamente neste arquivo de configuração.

![captura de tela do Polybar sendo executado](https://dev-to-uploads.s3.amazonaws.com/i/2862l8snd2c0oh54dsfk.png)

Agora vamos adicionar uma linha no arquivo de configuração do I3 (`~/.config/i3/config`), de preferência em algum lugar no topo do arquivo. Essa linha vai executar o Polybar, toda vez que iniciarmos o I3.

```
exec --no-startup-id polybar exemple
```

É exatamente o mesmo comando que executamos antes para iniciar o Polybar, mas agora, executará toda vez que iniciarmos nosso I3.

Agora vamos remover a i3status, deixando apenas a Polybar.

A i3status é iniciada nas últimas três linhas do arquivo. Caso você não encontre, são essas:

```
bar {
        status_command i3status
}
```

Podemos apenas remover essas três linhas. E com isso, teremos nosso i3 apenas com a polybar, sem a i3status.

# Alacritty

[Alacritty](https://github.com/alacritty/alacritty) é um emulador de terminal que se encaixa quase perfeitamente com Window Managers. Pois ele não tem nenhuma opção ou menu na tela. E toda a sua configuração é feita através de arquivos de configuração.

A instalação do Alacritty é feita da seguinte forma:

## Ubuntu 

```
sudo add-apt-repository ppa:aslatter/ppa
sudo apt update
sudo apt install alacritty
```

## Fedora

```
dnf copr enable pschyska/alacritty
dnf install alacritty
```
## Arch Linux

```
pacman -S alacritty
```

Caso você tenha qualquer problema, você pode também usar o [Kitty](https://sw.kovidgoyal.net/kitty/) Que segue a mesma ideia. Mas neste artigo usaremos o Alacritty.

Após a instalação, você pode rodar o comando `alacritty` ou iniciar o alacritty pelo Rofi/Dmenu. E uma tela simples e básica de terminal irá aparecer.

![captura de tela do Alacritty padrão](https://dev-to-uploads.s3.amazonaws.com/i/0mgxi74v3gg14v3prxi7.png)

Caso você não tenha percebido, o Alacritty abriu de forma mais rápida que o terminal padrão da sua distro. Isso aconteceu pois a proposta do Alacritty (e do Kitty) é de ser o terminal mais rápido possível.

## Integrando Alacritty com I3wm

Agora iremos fazer a mesma integração que fizemos anteriormente, mas agora, substitindo o terminal padrão da sua distro, pelo Alacritty.

Vamos para a linha 30 do arquivo. Nela encontraremos o seguinte:

```
bindsym $mod+Return exec i3-sensible-terminal
```

Esse atalho se refere a combinação `Super + Enter` (no caso `Enter` é a mesma coisa que `Return`). E logo após o `exec`, o i3 irá usar um recurso que é o `i3-sensible-terminal`. Essa variável vai se referir ao terminal padrão do sistema.

Para mudar do terminal padrão do sistema, para o Alacritty, podemos simplesmente mudar de  `i3-sensible-terminal` para `alacritty`. Com isso, essa linha ficará assim:

```
bindsym $mod+Return exec alacritty
```

Agora, reinicie seu i3 novamente com `Super + Shift + <r>`, e agora, toda vez que você tentar abrir um terminal com `Super + Enter`, você sempre abrirá o Alacritty.

# Feh

Agora vamos usar o pacote que instalamos anteriormente, para definir um plano de fundo para o nosso i3wm, que é o `feh`.

Para definir um fundo usando o feh, você pode executar:

```
feh --bg-fill CAMINHO_ATE_O_ARQUIVO
```

Um exemplo prático é:

```
feh --bg-fill Pictures/bg.png
```

Mas, para adicionar esse fundo toda vez que o i3 é iniciado, você deverá editar o arquivo de configuração do i3 (`~/.config/i3/config`), adicionando essa linha em algum lugar do começo do arquivo:

```
exec --no-startup-id feh --bg-fill Pictures/bg.jpg
```

Claro, nessa parte você deve mudar o caminho do arquivo.

# Personalização

Agora vamos aprender a como podemos **começar** a personalizar esses quatro itens abordados (i3wm, polybar, Rofi e Alacritty).

Uma recomendação para você achar opções para personalizar estes programas, é buscar *Dotfiles*. Dotfiles são repositórios onde as pessoas guardam as suas personlizações e configurações de programas. Um exemplo é [o meu próprio repositório de Dotfiles](github.com/lissaferreira/dotfiles). Onde você pode copiar, modificar, usar,etc. os arquivos e configurações. Iremos apenas listar algumas mudanças que você pode fazer.

## I3wm

A configuração do I3 está no arquivo `~/.config/i3/config`. Lá, você pode tirar, criar ou modificar (como tinhamos feito) atalhos. Fontes,etc.

Um exemplo de configuração são os programas de *autostart*, que executam quando você inicia o i3, como o Polybar por exemplo. Um exemplo de autostart que está no [meu dotfiles](github.com/lissaferreira/dotfiles) é este:

```
#autostart
exec --no-startup-id xsettingsd &
exec --no-startup-id compton -b
exec --no-startup-id polybar main
exec --no-startup-id feh --bg-fill Pictures/bg.jpg
exec_always --no-startup-id numlockx on
```

Nesta parte, é executado alguns programas, como o `compton` para criar transparência nas janelas, o polybar, `feh` para colocar um papel de parede, e o `numlockx` para ligar a tecla numlock.

## Polybar

Temos algumas personalizações que podemos fazer no nosso Polybar, que são:

- Cores
- Posição da barra
- Módulos

Neste artigo, iremos abordar apenas a mudança das cores, e deixar a barra embaixo da tela (como provavelmente você já tem o costume)

O arquivo de configuração está em `~/.config/polybar/config`. Lá, temos uma seção no arquivo que é:

```
[bar/example]
...
```

De `[bar/example]` para baixo, estão todas as configurações da barra, e as primeiras são as gerais. Mais para baixo terá as configurações para cada módulo, como horário, barra de volume, indicador de uso de disco,etc.

Logo abaixo de `[bar/example]`, podemos colocar `bottom = true` para colocar a barra para baixo, dessa maneira:

```
[bar/example]
bottom = true
...
```

Quando você salvar o arquivo, a sua barra já estará na parte debaixo da tela.

Agora vamos mudar as cores, no começo do arquivo, estão declaradas algumas cores, como aqui:

```
[colors]
;background = ${xrdb:color0:#222}
background = #222
background-alt = #444
;foreground = ${xrdb:color7:#222}
foreground = #dfdfdf
foreground-alt = #555
primary = #ffb52a
secondary = #e60053
alert = #bd2c40
```

Podemos agora mudar as cores diretamente no hexadecimal, como por exemplo, na segunda linha desse trecho, trocar de `#222` para `#000` para deixar o fundo totalmente escuro, com o trecho final ficando assim:

```
[colors]
;background = ${xrdb:color0:#222}
background = #000
background-alt = #444
;foreground = ${xrdb:color7:#222}
foreground = #dfdfdf
foreground-alt = #555
primary = #ffb52a
secondary = #e60053
alert = #bd2c40
```

Assim, o nosso polybar ficará assim:

![captura de tela do Polybar com a barra preta](https://dev-to-uploads.s3.amazonaws.com/i/40fhioyju5bz0q2lxyf3.png)

Recomendo você buscar modificar cores, módulos, e outras configurações do Polybar, que podem ser encontradas [na sua wiki oficial](https://github.com/polybar/polybar/wiki/Configuration)

## Rofi

Na parte do Rofi, as duas coisas que mais vamos modificar será o tema das cores, e a fonte.

O tema e a fonte são criados dentro de `~/.config/rofi/[TEMA].rasi`. Dentro deste arquivo, terá as definições das cores de cada lugar, tamanhos, fontes, etc.

Um exemplo de tema é o [Dalton](https://github.com/lissaferreira/dalton-rofi). Para aplicar esse tema, você pode simplesmente clonar o repositório, pegar o arquivo `dalton.rasi`, e mover para `~/.config/rofi`

Para este tema em específico, é recomendado que você tenha a fonte `Fira Code` instalada, pois esse tema usa essa fonte. Você pode ver as instruções para várias distros [no guia de instalação](https://github.com/tonsky/FiraCode/wiki/Linux-instructions). Caso você não queria instalar ela, o Rofi usará a fonte padrão do sistema.

Agora, você pode executar `rofi -show drun -theme dalton` para abrir o rofi no modo `drun` com o tema Dalton.

![captura de tela do Rofi com o tema Dalton](https://dev-to-uploads.s3.amazonaws.com/i/721j9ge23wf2a1vxz1sg.png)

Uma outra configuração interessante é habilitar um tema de ícones. Com essa opção habitada, irão aparecer ícones ao lado dos nomes dos programas. Isso pode ser feito adicionando estes argumentos ao final do comando:

```
-icon-theme "TEMA" -show-icons
```

neste lugar que está `TEMA` você deve inserir algum tema que você utilize, como por exemplo:

```
-icon-theme "Flat-Remix-Dark-Blue" -show-icons
```

Dessa maneira, o Rofi abrirá com esse tema de ícones de sua escolha.

## Alacritty

As duas principais configurações que podemos fazer no Alacritty, é mudar o tema de cores, e a fonte.

Você precisará criar o diretório `~/.config/alacritty`, e dentro desse diretório, e depois criar o arquivo de configuração `alacritty.yml`, logo, essas configurações poderão ser mudadas em `~/.config/alacritty/alacritty.yml`

Há duas partes do arquivo que iremos escrever, há a parte de `font`, que deve ser algo por volta disso:

```
font:
  # The size to use.
  size: 12

  normal:
    family: Fira Code Medium

  # The bold font face
  bold:
    family: Fira Code

  # The italic font face
  italic:
    family: Fira Code
```

Neste caso, estamos usando a Fira Code em todos os casos, e com tamanho 12. Você pode mudar para a fonte de sua escolha, com o tamanho de sua escolha.

E logo na linha abaixo, podemos criar a seção chamada `colors`, onde iremos definir as cores do terminal. O exemplo abaixo irá gerar um tema com fundo escuro, e algumas cores fortes para textos:

```
colors:
  # Default colors
  primary:
    background: '0x000000'
    foreground: '0xffffff'
  cursor:
    text: '0x000000'
    cursor: '0xffffff'

  # Normal colors
  normal:
    black:   '0x000000'
    red:     '0xfe0100'
    green:   '0x33ff00'
    yellow:  '0xfeff00'
    blue:    '0x0066ff'
    magenta: '0xcc00ff'
    cyan:    '0x00ffff'
    white:   '0xd0d0d0'

  # Bright colors
  bright:
    black:   '0x808080'
    red:     '0xfe0100'
    green:   '0x33ff00'
    yellow:  '0xfeff00'
    blue:    '0x0066ff'
    magenta: '0xcc00ff'
    cyan:    '0x00ffff'
    white:   '0xFFFFFF'
```

Você pode procurar alguns temas para o Alacritty [nesta lista de temas](https://github.com/eendroroy/alacritty-theme). Apenas encontre o arquivo respectivo do tema que você quer, e substitua no arquivo de configuração do Alacritty.

# Adendo

Todas essas opções que foram apresentadas (i3wm, Polybar, Rofi e Alacritty) foram apenas uma escolha **minha** para apresentar. Não significa que é a melhor combinação possível, você pode usar várias outras opções. Algumas alternativas para o i3wm são:

- bspwm
- dwm
- Awesome WM
- Openbox

e muitas outras. A mesma coisa serve para o Polybar, Rofi e Alacritty. Tudo depende de qual você acha melhor unicamente para você mesmo!

# Conclusão

Criamos um ambiente de desenvolivmento mínimo. Usando i3wm, Polybar, Rofi e Alacritty. Onde cada pessoa, poderá mudar cada um desses elementos, deixando todo o sistema mais proximo de sua personalidade e praticidade.

Recomendo que você crie o seu repositório de dotfiles no seu Github, e comente neste artigo com o link dele. E sempre mantenha esse repositório atualizado, será ele que você usará de backup das saus configurações, e também como meio para você mostrar as pessoas, como você personaliza o seu sistema.

Muito obrigada por ler ❤️🏳️‍⚧️ e me segue nas redes, é tudo [@lissatransborda](https://twitter.com/lissatransborda) 👀