DEV Community: Euber Alexandre Barbosa

Debian netinst: Conectar na 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, wlan0, - culpa da Gentoo.

Então conecto com:

ifup wlan0

Prontinho, confirme com ping e continua a instalação do sistema:

ping globo.com

Consulte a documentação da Debian para mais informação sobre ferramentas de Wi-Fi: https://wiki.debian.org/WiFi/HowToUse

Eu prefiro um combo de iwd + nmcli, do que wpa_supplicant.

Boa diversão.

Debian

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.

Dut, yet another simple dotfile manager!

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

Dotfiles, as implied by its nickname, are files named prepended with a dot, that configure software initial settings and usually resides hidden on $HOME directories.

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 Dut.

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

dut --from /data/dotfile_folder --create

Of course you can just try it out first:

dut --from /data/dotfile_folder --pretend

To remove all linked files, it goes as:

dut -f /data/dotfile_folder --remove

It goes as easy to set a different destination:

dut -f /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 .dutignore, 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.

PS: In case you are wondering what’s with all those main.* files, as I pick a new language to learn, Dut is a good initial project as it offers a good set of challenges.

But I reckon that only the Ruby, Guile and PHP versions are fully functional.

With that said, pick your poison! :)