DEV Community: Euber Alexandre Barbosa

Wes, apenas outro gerenciador de dotfiles

Euber Alexandre Barbosa — Sun, 16 Aug 2026 15:58:06 +0000

Um pouco de cultura

Dotfiles, como implicado por seu nome, são arquivos com um pontinho anterior ao nome, que configuram o estado inicial dos programas e usualmente vivem - escondidos, nos diretórios do $HOME.

Users craft their dotfiles through the years with a such a care that them can easily be the most sensible and essential files in their system, version-controlling is a must, of course.

Tem até mesmo uma cultura de orgulhosamente compartilhar publicamente suas dotfiles, que por acaso é uma ótima forma de iniciar as suas e copiar boas ideias.

Em comum, quem curte Linux adora ferramentas de uso simples e fácil de inferir como find, grep ou ls, então seria natural eu seguir esse bom exemplo.

Vamos ao que interessa

Wes creates links of all files in the target directory, perfectly mirroring them in the destination directory, $HOME by default:

wes --root /data/dotfile_folder --create

Of course you can just try it out first:

wes --root /data/dotfile_folder --pretend

To remove all linked files, it goes as:

wes -r /data/dotfile_folder --remove

It goes as easy to set a different destination:

wes -r /data/bin --to ~/.local/bin --create

Ignorando o que não importa

We don’t want that just every file to be linked, eg: LICENSE. For those files, you can pin out their location by feeding the .wesignore, that follows docker’s .dockerignore.

E os arquivos originais, como ficam?

Conflicting files found at the destination directory are moved up to $HOME/.backup.

And that is it.

For more information, check the README.md in the main repository, or the --help option.

Bacana mas qual versão uso?

Em caso de você estar imaginando qual é essa de várias main.*, quando vou brincar com uma nova linguagem, Wes é uma ótima mesa de laboratório com bons desafios para aprender essas.

Mas eu reconheço que apenas as versões em Python, Guile, e Go estão parcialmente funcionais.

Com isso tudo dito, escolha seu veneno! :)

E esse nome?

Nomeado ao grandioso Wes Montgomery.

[Boost]

Euber Alexandre Barbosa — Sun, 16 Aug 2026 15:20:18 +0000

Rafael Dutra for apsis-cc

Aug 16

Docker Compose - orquestrando múltiplos containers

#docker #containers #devops #cicd

4 min read

Debian netinst: Como conectar a Wi-Fi pela TTY

Euber Alexandre Barbosa — Sun, 23 Feb 2025 01:14:59 +0000

Então você baixou a ISO da Debian na página inicial, para depois descobrir que o sistema não está conectado? Calma não priemos canico!

Uma vez terminada a instalação com ISO mínima da Debian e o sistema subir vai apenas aparecer uma tela preta, TTY, pedindo usuário e senha.

Uma vez entrado com seu usuário, você vai perceber que não está conectado a Wi-Fi, inesperado, né?!

Como você proveu o instalador da Debian com a senha do Wi-Fi, este salva uma configuração, simples, que vai estar presente no /etc/network/interfaces.

Então você apenas precisa achar qual interface do Wi-Fi foi usada, usualmente wlan0 ou wlp2s0 e conectar com a ifup:

ip link me disse que a minha interface Wi-Fi é, sim, wlp2s0 - a usual.

Agora precisamos ativar essa interface sem fio em:

ip link set wlp2s0 up

Até o Debian 13 o wpa_supplicant é usado para configurar os paranues todo e, talvez, conectar - é antigo mas funciona.

ifup wlan0

Prontinho, confirme com ping se você ja esta conectado:

ping globo.com

Se não, então sua configuração de instalação foi como a minha, bem simples, então precisamos ainda usar o dhcp para obter um ip:

dhclient wlp2s0

Prontinho, vai pingar até a ultima gota, e agora é só instalar as delicinhas disponiveis no repo principal do debian.

Eu prefiro um combo de iwd + nmcli, do que wpa_supplicant, apesar, mas tem outras alternativas ainda mais legais.

Eu curto usar o SID por ter os pacotes mais novinhos, e recomendo para quem veio do Ubuntu e Fedora.

Boa diversão.

Mais:

Debian
Debian - Wifi
Debian SID
dhcp
WPA Supplicant
ip

Meson: Usando um projeto git sem meson.build como dependência

Euber Alexandre Barbosa — Tue, 28 Jan 2025 23:39:00 +0000

Eventualmente você vai achar um projeto bacana que não usa meson.build e o mantenedor demora anos para aceitar PR, se algum dia for.

Ou mesmo seu projeto está em contrato para sempre adicionar a LICENSE em todas as builds e o mantenedor se recusa.

Para resolver esse pepino você pode adicionar aos seus subprojects/*.wrap git patches.

Por exemplo, no meu projeto - onur - por ser uma pequena ferramenta CLI prefiro usar o ht do grande Hoyt ao invés do enorme GNOME glib, mas este projeto git não tem uma meson.build.

Uma simples wrap-git para esse projeto, que sequer tem tags também, seria usando o master:

./subprojects/ht.wrap

[wrap-git]
directory=ht
url=https://github.com/benhoyt/ht
revision=master
depth=1

Primeiro vamos pegar todos subprojetos meson subprojects download, e adicionar a meson.build na raiz deste:

./subprojects/ht

cat <<EOF | tee -a ./subprojects/ht/meson.build
project('ht', 'c', version: '1.0')

ht_sources = [
    'ht.c',
    'ht.h',
]

ht_lib = static_library('ht', ht_sources)

ht_dep = declare_dependency(
    include_directories: include_directories('.'),
    link_with: ht_lib)
EOF

cat ./subprojects/ht/meson.build

e criar o patch com:

mkdir -pv subprojects/{packagecache,packagefiles}
git -C ./subprojects/ht add meson.build
git -C ./subprojects/ht diff --cached > ./subprojects/packagefiles/ht-meson.patch
cat ./subprojects/packagefiles/ht-meson.patch

uma vez com o patch devemos apontar sua presença ao ht.wrap:

echo "diff_files = ht-meson.patch" >> ./subprojects/ht.wrap
cat ./subprojects/ht.wrap

Pronto, vamos aplicar o patch:

meson subprojects purge --confirm
meson subprojects download

e compilar o projeto para confirmar:

CC=gcc meson setup ./build --wipe -D b_sanitize=none -D buildtype=release
meson compile -C ./build

O executável vai aparecer em ./build como esperado.

Valeu!

Recomendação para leitura:

Informações gerais:

GNU Emacs: O bom e velho ido-mode

Euber Alexandre Barbosa — Mon, 27 Jan 2025 03:34:15 +0000

GNU Emacs é antigo, até mais que muitas cidades do Brasil e com isso tem uma bagagem cheia de pacotes velhos para leléu.

Dentre as várias funções desse velhinho, existem os completadores das várias partes desse editor, uma dessas é o Interactive do things ou ido-mode, que vai um pouco além do modesto completing-read.

ido é um pacote incluído no editor, mas não ativado por padrão, então pode ser ativado sem precisar baixar nada.

Nesse ponto, eventualmente você vai perceber que o Emacs tem vários pacotes alternativos em hibernação a alguns poucos códigos para sua ativação, como:

(require 'ido)
(ido-mode t)

Pronto, ido esta ativado e com isso vai consumir qualquer lista de string, mas provendo uma interface mais limpa e moderna, testa isso no scratch buffer:

(let ((trapalhoes '("mussum" "zacarias" "didi" "dede")))
  (ido-completing-read "Qual seu trapalhão favorito: " trapalhoes t))

ou algo mais apropriado:

  (defun e/ido-load-theme ()
    "Carregue um tema usando Ido."
    (interactive)
    (let* ((themes (mapcar (lambda (x) (symbol-name x)) (custom-available-themes)))
       (theme (ido-completing-read "Choose recent file: " themes nil t)))
      (when theme
    (load-theme (intern theme) nil))))

Bacana não?! haha, mas tem como realçar ainda mais o comportamento de ido com alguns pacotes externos adicionais:

Uma ótima novidade do Emacs 30 é a opção de poder instalar pacotes de forma reproduzível via use-package com a nova prop :vc:


(use-package ido-completing-read+
  :ensure t
  :vc (:url "https://github.com/DarwinAwardWinner/ido-completing-read-plus")
  :config
  (require 'ido-completing-read+)
  (ido-ubiquitous-mode 1))

E por coerência aqui vai minha configuração final:

(use-package ido
  :init
  (setq ido-enable-flex-matching t
    ido-everywhere t)
  (ido-mode 1)
  :custom
  (ido-create-new-buffer 'always
             ido-enable-prefix nil
             ido-enable-regexp t
             ido-decorations (quote ("\n-> " "" "\n " "\n ..." "[" "]" " [No match]" " [Matched]" " [Not readable]" " [Too big]" " [Confirm]"))
             ido-file-extensions-order '(".lisp" ".py" ".org" ".el")
             ido-max-directory-size 100000
             ido-use-filename-at-point t
             ido-enable-dot-prefix t
             ido-use-url-at-point t
             ido-use-filename-at-point 'guess
             ido-use-virtual-buffers t)
  :config
  (defun e/ido-bookmark-jump (bname)
    "Switch to bookmark BNAME interactively using `ido'."
    (interactive
     (list (ido-completing-read "Bookmark: " (bookmark-all-names) nil t)))
    (bookmark-jump bname))

  (defun e/recentf-ido-find-file ()
    "Find a recent file using Ido."
    (interactive)
    (let ((file (ido-completing-read "Choose recent file: " recentf-list nil t)))
      (when file
    (find-file file))))

  (defun e/ido-load-theme ()
    "Load theme using Ido."
    (interactive)
    (let* ((themes (mapcar (lambda (x) (symbol-name x)) (custom-available-themes)))
       (theme (ido-completing-read "Choose recent file: " themes nil t)))
      (when theme
    (load-theme (intern theme) nil))))

  (defun e/mx-ido ()
    "Open Mx in ido-fashioned way."
    (interactive)
    (call-interactively
     (intern
      (ido-completing-read
       "M-x "
       (all-completions "" obarray 'commandp)))))

  (define-key (cdr ido-minor-mode-map-entry) [remap write-file] nil)
  :bind (("C-c r" . 'e/recentf-ido-find-file)
     ("C-x C-f" . 'ido-find-file)))

Recomendação para leitura:

Informações gerais:

GNU Emacs 30
GNU Guix/SwayWM/Waybar/Firefox
https://gitlab.com/easbarba/lar

GNU Readline: Uma experiência Shell mais agradável no seu terminal

Euber Alexandre Barbosa — Wed, 22 Jan 2025 04:58:04 +0000

O usual de iniciantes usando Shell em terminais, como o GNU Bash, após errar comandos, é usar bastante o mouse para correção.

Por exemplo, para editar a lista de repositórios do Debian você usaria esse comando:

nano /etc/pat/source.list |

Então nota que o nome do diretório era apt não pat, e para corrigir puxa o mouse e clica em cima do p, seguido de DELETE e novamente o mouse, agora após o a e escrever p e voilà:

nano /etc/apt/source.list |

Mas você poderia meramente usar os atalhos do GNU Readline para essa edição.

Como usar o alt+b 3 vezes para voltar o cursor até o pat então usar o ctrl-f para ir para o a:

nano /etc/p|at/source.list

e então ctrl-t para inverter o a e p de posição para finalmente:

nano /etc/apt/source.list

Pronto!

Bem mais simples e sem usar o mouse.

Não curte os atalhos GNU Emacs, também tem os de vi. ;)

Para conhecer mais atalhos, consulte a Wikipédia do GNU Readline:

https://en.wikipedia.org/wiki/GNU_Readline

E também o seu manual: https://tiswww.cwru.edu/php/chet/readline/rltop.html

Debian: Easily upgrading to the SID distribution

Euber Alexandre Barbosa — Tue, 28 Feb 2023 11:04:27 +0000

Developers usually stick with the latest version of the shiniest software out there, be it editors, browsers, stream players and office tools.

Some Linux Distributions are famous for its rolling-release model with all bleeding-edge/night packages in the main repo, that goes for Arch, Manjaro, Nix.

Not as famous as those there is a distribution of Debian named by SID, with all unstable packages, meaning packages not as tested as those in the Stable branch.

Do not be confused by its name, it has an as solid experience as Arch, but with the advantage of having all .deb packages that most companies and OSS developers always target.

Upgrading from Stable, or Testing, is about changing one word, its nickname if you will - bullseye, in the /etc/apt/source.list file, from this:

deb http://deb.debian.org/debian/ bullseye main deb-src http://deb.debian.org/debian/ bullseye main

to:

deb http://deb.debian.org/debian/ sid main deb-src http://deb.debian.org/debian/ sid main

From there on, prepare yourself for one big upgrade of all packages installed with:

sudo apt update && sudo apt dist-upgrade

There is only one catch on the SID distribution, as Debian changes from one big version to a new one, usually 2 years, there will be a whole month that most packages are frozen, and you may not receive any update.

Usually I just go distro-hopping for the shiniest and newest Distros, and after that, I go back to my beloved Debian in its newest version.

Nonetheless, do not frail from moving up to SID, it’s a rather worth effort.

Wes, apenas outro gerenciador de dotfiles

Euber Alexandre Barbosa — Tue, 28 Feb 2023 11:02:02 +0000

Dotfiles, como implicado por seu nome, são arquivos com um pontinho anterior ao nome, que configuram o estado inicial dos programas e usualmente vivem - escondidos, nos diretorios do $HOME.

Users craft their dotfiles through the years with a such a care that them can easily be the most sensible and essential files in their system, version-controlling is a must, of course.

There is even a culture of proudly publicly sharing dotfiles, and that’s a good way to grab some cool snippets.

We all love how frugal and simple to use are the Linux tools as find, grep or ls, so I kept that in mind on cooking up Wes.

Wes creates links of all files in the target directory, perfectly mirroring them in the destination directory, $HOME by default:

wes --root /data/dotfile_folder --create

Of course you can just try it out first:

wes --root /data/dotfile_folder --pretend

To remove all linked files, it goes as:

wes -r /data/dotfile_folder --remove

It goes as easy to set a different destination:

wes -r /data/bin --to ~/.local/bin --create

We don’t want that just every file to be linked, eg: LICENSE. For those files, you can pin out their location by feeding the .wesignore, that follows docker’s .dockerignore.

Conflicting files found at the destination directory are moved up to $HOME/.backup.

And that is it.

For more information, check the README.md in the main repository, or the --help option.

Mas eu reconheço que apenas as versões em Python, Guile, e Go estão parcialmente funcionais.

Com isso tudo dito, escolha seu veneno! :)

PS: Em caso você está imaginando qualé essa de varias main., quando vou brincar com uma nova linguagem **Wes* é uma otima mesa de laboratorio com bons desafios para aprender essas.

Em homenagem ao grandioso Wes Montgomery.