Lourenci's Notes

Importing Yubikey's SSH/GPG key into a new computer

Fri, 23 May 2025 11:34:59 +1000

Importing the SSH key

# Mac Sequoia's `openssh` doesn't support FIDO2 resident keys.
brew install openssh

# Import the SSH key from Yubikey into the current path.
ssh-keygen -K

# Move the private key to the ssh default location for keys.
mv id_ecdsa_sk_rk ~/.ssh/id_ecdsa_sk

Importing the GPG key

# Mac doesn't include gpg by default.
brew install gnupg

# Create the stub for the secret key in your machine.
gpg --card-status

# Import the GPG key using the public file.
gpg --import key.pub

Some SQL tips I've learned over the last few years

Sun, 27 Apr 2025 10:52:07 +1000

…even though I spent part of my career writing SQL queries in corporations.

Temporary tables with `with`

with can be used to create temporary tables that can be used in the main query.

with cities as (
    select name, state, population
    from city
)

select *
from cities
where population > 1000000;

`filter` in aggregated columns

having is not the only way to filter aggregated columns. filter is much simpler and doesn’t require creating subqueries for multiple aggregated columns.

select state
      ,count(*) as qty_cities
      ,count(*) filter (where population > 1000000) as qty_big_cities
from cities

Vim tricks

Mon, 14 Apr 2025 17:36:14 +1000

Q in normal mode to execute the last recorded macro.
Use \{-} as non-greedy regex symbol.
Use \_. to match any character including newline (multi-line).
Use \Vpattern (very non-magic) to match the pattern literally, only ^ and $ will have special meaning.
Use \vpattern (very magic) to match the pattern as a regex.
Classic negative/positive lookahead/behind (example in very magic):

	lookbehind	lookahead
positive	`(atom)@<=`	`(atom)@=`
negative	`(atom)@<!`	`(atom)@!`

Use \L (eg.: s/.*/\L&/) to lowercase the match; use \U (eg.: s/.*/\U&/) to uppercase it.

How to backup and restore Docker volumes

Fri, 01 Sep 2023 10:31:52 +1000

Recently, I had to update a major version of Debian. One of their “before starting updating” steps is to remove all non-Debian installed packages . Docker is one of them. Uninstalling Docker is as simple as $ sudo apt-get purge docker if I was not relying heavily on external volumes.

But, it turns out backup-ing an external volume is very straightforward:

# Backup the output command's path
docker volume inspect {volume} | jq -r ".[].Mountpoint"

# You can use tar for that
tar czf backup.tar.gz {mount-point}

Once you have Docker installed again, all you need to do is copy the backup file to the new Docker volume:

# Create your new volume
docker volume create {volume}

# Get the new volume's path
docker volume inspect {volume} | jq -r ".[].Mountpoint"

# You can use tar for that
tar xf backup.tar.gz --directory={mount-point}

Creating a partition larger than 2TB on Debian

Tue, 28 Feb 2023 20:01:10 +1100

Debian (fdisk) doesn’t support creating a partition larger than 2TB due to using the MBR partition table. You’ll need to use GPT instead:

sudo apt-get install parted

# Check the disk you want to format
sudo fdisk -l

# Replace /sdx for the disk you want to format
sudo parted /dev/sdx
mklabel gpt
quit
sudo parted -a optimal /dev/sdx mkpart primary '0%' '100%'

Now you can format the partition with the file system you want:

sudo mkfs.ext4 /dev/sdx1

You should be able to replace the mkfs.ext4 command with mkfs.exfat if you want that file system (see section below )

Which partition type to choose?

As a rule of thumb:

Use ext4 if you plan to use the disk only on linux.
Use exFAT if you plan to share between multiples OS. Linux, Windows and MacOS support it.

Debian out-the-box does not support exFAT. You’ll need to install fuse:

sudo apt-get install exfat-fuse exfat-utils

How to stash only some files?

Thu, 14 Jul 2022 19:25:51 +1000

Since Git 2.13 , we’re able to stash only some specific files from your working tree. 🙏🏻

In order to do that:

git stash [--patch] -- {files...} # or
git stash push [--patch] {files...}

Using two-way merge/conflict tool in (n)vim

Thu, 05 May 2022 20:15:00 +1000

I don’t like 3-ways merge. For a long time, I’ve been using this plugin to solve my merge conflicts in a 2-way way.

🤢

In a Reddit comment today, someone posted that Git has built-in support to 2-ways in (n)vim since 2021 🤯.

To activate it, first check if your Git version supports it:

# (n)vimdiff1 is what you are looking for
git mergetool --tool-help

After checking the support, enable it with:

git mergetool --tool=nvimdiff1
git config --global mergetool.hideResolved true

Amazon AWS

Mon, 02 May 2022 20:30:00 +1000

RDS

It’s the amazon service to use a relational database.

There are lots of databases available for usage: Postgres, aurora…

SQS

Simple Queue Service is used to implement a queue to deliver messages.

You put a message in the queue, which is available for some service to poll (get) it.

Note that the message is removed¹ from the queue as soon as some service polls the message. Thus you cannot “get” this message in multiple services. Note that the queue does not keep the arrival order of the messages, although you can specify that you want to keep this order on the queue creation.

¹Technically, the message is not removed from the queue until the consumer deletes it. When the message is polled, AWS hides the message and it will be back again after the visibility time-out times out. It’s up to the consumer to delete the message. When consuming it via Lambda, Lambda will automatically delete the message if no error is thrown or returned.

SNS

Simple Notification Service is a service from Amazon used implement a notification system.

The SNS is like an implementation of a PubSub. You put a message into the SNS Topic, and the SNS will notify all the systems listening to this topic.

The SNS retries to deliver the message whenever it fails to be delivered (this is configured, and by default, to this date, it’s three). When the number of retries is exhausted, the SNS will either discard the message or sends it to a dead-letter queue (DLQ)

DynamoDB

DynamoDB Streams

Unlike a queue, a stream is a persistent data structure. Streams buffer messages from the producers in an append-only file to be read by the consumers. Consumers can read the stream multiple times, and they need to know which messages they have already read or want to read.

DynamoDB streams are used to capture changes in the DynamoDB tables. You can use it as a trigger to a lambda. The lambda polls the stream for changes four times for seconds, and by default, it keeps retrying the batch until it processes it successfully or the batch expires.

VPC

Logical isolated network.

NAT Gateway

It allows a VPC network to connect to external devices. NAT could be either:

Public: to allow the VPC to access the public internet.

Public NAT does not allow unsolicited inbound requests.

Private: to allow the VPC to access other VPCs.

*: I got it from the internet, and I don’t remember the source. Sorry for that. Just give a hint if it’s yours, and I’ll update the refs.

Your computer has two clocks

Fri, 29 Apr 2022 20:12:00 +0000

You may not realise this, but your computer has a battery inside it only to get your computer clock running. Back in the 90s, when the rechargeable (lithium-ion) battery was not cheap, we used to disassemble our computers to replace their clock battery when the computer could not keep the clock “on time” anymore. Yeah, your computer clock is a “thing”.

Like your old wall-clock, it’s impossible to get the computer ones ticking at the precise time. Your OS tries its best to put it in sync, bringing a more accurate time from the internet (NTP servers), but it is its best after all.

NTP Servers

Once in a while your OS goes to the internet to prevent your computer’s clock from falling (much) behind or ahead of time. Those servers are called NTP servers.

NTP servers are explicitly designed to tell other computers the “right” time. They, generally, have specific timer devices attached to them, like atomic clocks and GPS receivers. The communication your computer does with them is over a particular protocol called Network Time Protocol.

When your computer tries to reach an NTP server to its clock, other things have to be taken into account:

Your computer could take several seconds to talk to the server, so this “delay” (latency) should be considered.
The server can potentially have the wrong time, like your computer.

NTP protocol is designed with specific algorithms to solve those (and more) issues.

NTP servers trying to get the most accurate time

With that in mind, your OS provides you with two different clocks: the real-time clock and the monotonic clock.

Real-time clock

The real-time clock is that one you stare at your computer when you are hungry and eagerly waiting for noon to have your lunch. When your computer clock gets out of sync, and the OS detects that through the NTP servers, the clock will be adjusted automatically.

Note that your clock could be ahead (or behind) of that time returned by the NTP server. The OS will adjust your computer clock accordingly.

Monotonic clock

This is the clock that led me to write this post in the first place. I had no idea of this concept until I came across recently on it in the excellent book Designing Data-Intensive Applications by Martin Kleppmann.

This clock is a relative time since some base date that you get from your OS. The most popular is the Epoch one: number of seconds since 1 January 1970 (UTC).

When your OS detects through the NTP servers that its clock is ahead (or behind), the OS will not adjust its clock jumping directly to that time but, instead, it will start to adapt its pace slower/faster to get it in sync with the more accurate date. This clock is guaranteed to never get back in time.

Why is this important?

Your code should never rely on clocks, let alone the real-time ones! The problem is even worst in a distributed system when multiple machines are involved where each one has its concept of “now”.

Remember: clocks are not stable and precise. The real-time clock can even go back in time.

Cleaning up not-used Docker images/containers/volumes

Wed, 27 Apr 2022 18:10:06 +1000

Docker has a built-in command to prune all the dangling (not-used) Docker images/containers/volumes:

docker system prune --volumes

How to remove a Brew package and all its dependencies?

Thu, 14 Oct 2021 08:47:14 -0300

TIL You can use the autoremove command to remove the leftovers from a package previously installed by brew.

List all the installed packages:

brew leaves

Remove an installed package:

brew uninstall [package]

Remove all the leftovers from an uninstalled package:

brew autoremove

When executing this command, pay attention to stdout. Brew does not clear some (config) files left from the autoremove command and it warnings you about that.

What is the difference between a Component and a PureComponent?

Mon, 05 Aug 2019 20:50:00 +0000

In the class components land, you can define a component either by extending it from React.Component or from React.PureComponent.

Whatever component you use, when it changes its state or it receives a new prop from its parent, React will call the render lifecycle method of the component and of the all children of the component, the famous VDOM (kind of DOM in memory) will be generated and React will compare the generated VDOM to the previous generated VDOM (render phase), if any changes are detected React will apply them to the real DOM (commit phase). It’s much cheaper and faster to deal with the VDOM than to the real DOM, that’s the magic behind the “modern” front-end libs to be very fast.

Even React doing a lot of work under the hood to keep this process fast, the render method is the most expensive “routine” in it. We should avoid it whenever it’s possible.

`shouldComponentUpdate` lifecycle method

Just before to call the render method, React will call the shouldComponentUpdate lifecycle method passing the prevProps and the prevState as parameters. You can use this hook to prevent your component to be rendered. If you return false on it, React will not perform the render, thus it will not call the render lifecycle method. The <Counter /> below will never be shown updated:

class Counter extends React.Component {
  constructor (props) {
    super(props)
    this.state = { value: 0 }
  }

  shouldComponentUpdate (_prevProps, _prevState) {
    // This will make the render to never be called.
    return false
  }

  render () {
    return (
      <div>
        <span>{this.state.value}</span>
        <button
          type='button'
          onClick={() => this.setState(({ value }) => ({ value: value + 1 }))}
        >
          Increment
        </button>
      </div>
    )
  }
}

Where does the `PureComponent` differ from the `Component`?

When a component receives a new value for the prop or for the state, React will call the render method even when the change is to the same value.

With that in mind, the PureComponent has an implementation of the shouldComponentUpdate hook that performs a shallow comparison between the prevProps with the new props and the prevState with the new state . When the change is to the same values, the React shouldComponentUpdate implementation will return false preventing the render method to be called.

To demonstrate that, I made the component below that keeps a state for a value and it renders two components to show this value: one through the PureComponent and another with the Component. When the button is clicked, the state is changed to the same value. Every time the render is called on these components, a log appears in the console to show their updates. Click on the button and look at the console.

A shallow comparison is about to not be deep in some array or object comparison. If an object has others objects inside it, this inner objects will not be compared. Furthermore, objects (including arrays and functions) are compared by their references and primitives values by their values. You can see the shallow code on React’s github .

The use of the PureComponent is a good strategy to get a better performance on your project.

Leveraging the `PureComponent`

Don’t mutate

You shouldn’t mutate any parent’s object that you pass through a prop to its pure children, once they will perform a shallow comparison before to call the render, your UI children won’t get updated.

Try to bind functions in constructor whenever it’s possible

Every time the render of the parent of this PureComponent

<PureCounter
  fn={this.callback.bind(this, 'arg')}
  value={1}
/>

is called, a new function will be created and the shouldComponentUpdate will fail. This happens with arrow functions too.

In order to avoid that, you could pass the handle as one prop and its argument as another prop. Something like that:

// this.callback is binded in constructor.
<PureCounter
  fn={this.callback}
  fnArg='arg'
  value={1}
/>

// PureCounter/index.js
onClick () {
  this.props.fn(this.props.fnArg)
}

What about the functional components?

Now after one year that Hooks are around, you have been asking yourself: what is the functional component way for PureComponent?

`React.memo`

React.memo is a high order component that receives a component and returns you another component. This new component will be able to do a shallow comparison on its props then the rerender will not take place if nothing has changed.

const MyCleverComponent = React.memo(function MyComponent(props) {})

Note that React.memo doesn’t prevent a rerender from a state change, whereas the PureComponent does, but you can also use “memo” on its children too.

How to update the Jest's jsdom to the latest version

Mon, 29 Jul 2019 11:12:00 +0000

Jest comes with jsdom to mount your components. When you mount your component with render libs like @testing-library or enzyme, this component will be mounted on jsdom.

jsdom is a JavaScript implementation of a “browser”. It tries to implement both DOM and HTML standards capabilities to make sure you’ll be able to mount and test your components in memory like it was running in a browser.

Like your browser, you need to keep jsdom up-to-date to get the last implementations of it.

Unfortunately, Jest@24 comes with jsdom’s 11 version for compatibility reasons:

Note: Jest comes with JSDOM@11 by default. Due to JSDOM 12 and newer dropping support for Node 6, Jest is unable to upgrade for the time being.

At the time of writing this, jsdom is already on 15 version. There are lots of new features over the version 11.

For install the most recent version, all you have to do is:

Install the most recent jsdom environment:

yarn add jest-environment-jsdom-fifteen --dev

Configure Jest to use it. In in your jest.config.js:

{
  testEnvironment: 'jest-environment-jsdom-fifteen'
}

How to wrap long lines when writing markdown on Vim

Sun, 21 Jul 2019 14:17:00 +0000

If you have Vim optimized for coding, probably you’ll have some problem for writing on it. The first one that comes out for me as soon as I started to writing markdown files in Vim was the word wrap question, any sentence comes longer easily and you can’t read it anymore if you have set Vim to not wrap your code.

If you want to configure your Vim to wrap long lines only in markdown files, all you have to do is to create a ftplugin for markdown files:

" after/ftplugin/markdown.vim
setlocal wrap

My Favorite Vim Plugins

Tue, 16 Jul 2019 23:22:03 +0000

It had been a long time using a heavy IDE from the JetBrains family (e.g. PhpStorm, Rubymine) and I wanted to switch to something more light and as keyboard oriented as JetBrains’ IDEs. I tried VSCode, but the lack of essential shortcuts (e.g. navigate through the tree files) was the last straw for me. So, I decided to adventure in the Vim world.

I started in the Vim world without any Vim bootstrap generator, I wanted to start by the Vim way and going to include some plugins as needed. I knew I’ll end up with a lot of plugins, but I really wanted to miss a feature in Vim before to include it through a plugin. I think this is the best way to really understand and learn Vim.

Now, after a year of daily usage of Vim for Web development (JS and Ruby primarily), I really end up with a list of plugins and I want to share with you some of my favorite ones and how I use them in my development routine.

You can see the full list on my github . None of them change the way the Vim works (there is only one exception), I try very hard to avoid these kind of plugins (e.g. vim-targets adds a very nice list of text objects, but some of them, changes the behaviour of the existing ones).

The below list isn’t in any particular order.

junegunn/fzf.vim

For those who don’t know what fzf is, it’s a command-line fuzzy where basically you can pass any list to it and it will filter (using fuzzy) that list while you typing.

This plugin provides a lot of “lists” to send to fzf.

I use some of those “lists” mapped in my Vim:

:fzf

A list of every file in your project.

:GFiles?

A list of every git dirty file in your project.

:BTags

A list of every buffer’s tags.

:History

The MRU (most recent used) files.

:Buffers

All the buffers opened.

:Ag

In file project-wide search.

:Filetypes

A list of all file types supported by Vim.

tpope/vim-surround

Tim Pope is famous by your Vim plugins. There are a lot of plugins out there made by him. Any vimmer probably use some of them.

Surround is a plugin that adds some operators to Vim to work with text objects. If you don’t know what text objects are, I recommend you to read about it .

In a nutshell, with Surround, you can “surround” any text with () or [] or {} (or a lot more) with some keystrokes.

michaeljsmith/vim-indent-object

This one add a text object by the indentation of your code/text. You can delete, change, select, do any action with a block of code with some keystrokes.

tpope/vim-fugitive

Another must have by Tim Pope. Fugitive is a plugin that allows you to work with git in Vim. You can execute basically any git command in Vim. In my daily usage, I use only a few commands though:

:Gread

It is the same to git checkout [file].

:Gwrite

It is the same to git add [file].

:Gdiff

It opens a vim-diff with the buffer changes relative to the HEAD.

:Gblame

To blame your coworker.

:Ggrep

In file project-wide search. It’s faster than vimgrep. I use it over fzf’s Ag when I want to populate a quickfix list and work on this list.

mbbill/undotree

Any change to the buffer file is kept by the Vim, you can view it with the :undolist command.

Undotree gives you a tree view with the buffer changes where you can navigate through them.

I really recommend you to set the persistent undo: all the changes are always kept by the Vim, even when you close it. You can activate the persistent undo in your dotfile:

set undodir=~/.vim/undo/
set undofile

junegunn/vim-peekaboo

Vim has a concept of registers. Basically, when you copy a text that text goes to a fixed register. You can copy a text to a specific register and use it after accessing that register. A macro goes to a register. The last search goes to another register…

When you press a key that waits for a register, Peekaboo will automatically open an unobtrusive splitted window with all registers and its content.

janko-m/vim-test

I make a lot of tests in my day. With vim-test, I can go to a specified spec’s context and run it with the :TestNearest command. Vim-test will automatically detect my test IDE and run only that context on that IDE. It’s beautiful.

I’ve some commands mapped in my Vim:

:TestNearest

It runs the context where your cursor is over.

:TestFile

It runs the entire test file.

:TestLast

It runs the last executed test.

This is very useful, you can run a specific context and goes to the code to make that context to be green. You can run the last test without head over to it, directly in the code.

:TestVisit

It heads your over to the last executed test.

nelstrom/vim-visual-star-search

I said earlier that I don’t like plugins that change the Vim way, its behaviour of working. This plugin is the exception.

I can’t understand why the Vim doesn’t do this by default. When you visual select a text and press the * (or #), Vim’ll search for the word where the cursor is over. With this plugin, you change the Vim behaviour to find by the entire selected text.

neoclide/coc.nvim

Coc is the best auto complete for Vim out there. First, it simple works: easy to install it and easy to update it. Second, it has full LSP support. Third, it’s very extensible.

The source for the auto complete is powered by the extensions that you have to install in Coc. I’ve removed a few plugins with these extensions. I don’t need more Ale. I don’t need more vim-gitgutter…

Some commands I’ve mapped in my Vim:

<Plug>(coc-rename)

It renames a method or a var. As Coc has support to LSP, it can rename even when the var is on another buffer.

<Plug>(coc-definition)

It goes to the method definition wherever it’s.

Some extensions that I use:

coc-tsserver

IntelliSense for JavaScript and Typescript.

coc-eslint

It runs eslint on buffer file and can run --fix on it on save.

coc-html

For html.

coc-solargraph

For ruby.

coc-git

It substitutes the vim-gitgutter and add some git capabilities that support vim-fugitive. With some mapped commands, I can diff a chunk, I can undo a chunk, I can see the git history of a buffer file and diff it with the local, I can go to the next or previous change…

coc-tabnine

For tabnine. TabNine is a kind of IntelliSense with AI. It doesn’t complete only methods or vars, It completes all the expression. It’s very hard to live without it once you get the hang of it.

BONUS: Github colorscheme

Don’t judge me, I use light theme. I think it’s less stressful for my eyes because I can use it with less display brightness than dark themes and it reduces the light reflection on my screen.

I think that a colorscheme must have a nice soft fold color and it has to take care of the diff colors. I have to see the diff and immediately spot what is going on in my code. This colorscheme has these very well implemented.

Debian installation and first steps

Wed, 10 May 2017 00:00:00 +1100

Installation

Debian doesn’t come with non-free firmwares, so it might be necessary to install them. There is a link for the firmwares in Debian’s downloads page (page with the .iso files).

You can use the same USB with the bootable Debian for those firmwares: after restoring the Debian’s ISO into a USB, you can create a new partition with fdisk /dev/sdb and change it to FAT16 with mkdosfs /dev/sdbX. Those firmwares have to be unpacked to /firmware path in the new USB partition.

Another much more straightforward way to do it, it’s to download the already built ISO image with the non-free firmwares .

Before installing

Don’t forget to ensure the .iso you downloaded is not tampered with by any third party. As Debian includes the signatures in the same folder you got the iso, you can easily check this via gpg:

# Check the integrity of the file containing the SHASUM (you may need to import the keys from Debian's keyserver)
gpg --verify SHA512SUMS.sign SHA512SUMS

# Get the shasum of the downloaded iso
shasum -a 512 file.iso

# Check if the shasum generated by Debian matches with the `iso` one
cat SHA512SUMS

First steps

Comment deb cd-rom: repos in /etc/apt/sources.list file (you may need superuser permissions su).
Install and configure sudo (not necessary if you left the root password empty on installation).
1. su
2. apt-get update
3. apt-get install sudo
4. usermod -a -G sudo your_user
5. Restart
Depending on how old your .iso are, you may want to upgrade the Debian:

sudo apt-get update
sudo apt-get upgrade
sudo apt-get dist-upgrade

Some extras

Install the Microsoft fonts.
- echo 'deb http://ftp.us.debian.org/debian jessie main contrib' >> /etc/apt/sources.list (not necessary in some mirrors: US, for example)
- sudo apt-get install ttf-mscorefonts-installer
Rearrange window buttons (close, minimize…) to the left.
- gsettings set org.gnome.desktop.wm.preferences button-layout "close,minimize,maximize:"
Show only applications from the current workspace in Alt+Tab.
- gsettings set org.gnome.shell.app-switcher current-workspace-only true
Disable alt+f1 shortcut key.
- gsettings set org.gnome.desktop.wm.keybindings panel-main-menu "[]"
Install some excellent extensions from Gnome Extensions :
- Frippery move clock: it moves the centered clock to the right of the gnome bar.
- Lock keys: useful for keyboards that don’t have a status LED for Caps lock and Num lock keys.
- No topleft hot corner: it prevents the default gnome’s behaviour from showing up in the activity view when the mouse points in the window’s top left corner.
- Panel osd: to customize the notification’s position on the screen.
- Random Walls: it changes the wallpaper and lock screen image automatically and randomly.
- Topicons plus: changes the tray icons to the top.
- Workspace indicator: shows the active workspace.
- Docker integration: hides veth networks from gnome interface.
- ESC to close overview from applications list: when in the overview screen, close it without show the application list.
- Dash to Dock: A mac dock style for Linux.
- Workspace Isolated Dash: Isolate each workspace as if it was the only workspace.
Install a beautiful theme for Gnome:
- sudo apt install numix-gtk-theme numix-icon-theme

Updating git

There is a git-core team ppa for Debian, for install the latest version of git: Git-core PPA .

You have to add the PGP key available on the site. The key can be exported to a file and added to Debian with the sudo apt-key add command.

Printing in an HP

Install the printer drivers:
- sudo apt-get update
- sudo apt-get install cups hplip
Configure the printer through the hp plugin:
- sudo hp-setup -i

Troubleshooting

Brazilian accentuation in American keyboards

You must use English (US, international with dead keys).

Ć instead of Ç

You need to put GTK_IM_MODULE=cedilla in /etc/environment file. After that, logout and login again.

Creating a partition with more than 2TB

Please, head over to this post .