My absolute favorite combination for when coding in nvim/tmux is to combine WezTerm with agave Nerd Font. Recently I got a new mac, and while setting it up, noticed that whenever I'd ssh into it, my fonts would all be broken.

The issue was that my mac was not correctly setting up locale on new ssh connections. The fix? On my .zshrc file I added

export LC_ALL=en_US.UTF-8  
export LANG=en_US.UTF-8

In my recent usage of RedCore Linux, a distribution based on Gentoo Linux' testing branch, I hit some quirky (to me) package dependencies and blocks when using Gentoo's emerge system. The following are some commands used to update packages.

A couple of reminders to kick things off:

• Do not update everything at once
• equery(part of app-portage/gentoolkit) for checking dependencies and/or which packages depend on the queried package, as well as qlist (part of app-portage/portage-utils) are your friends
• use qlist to update/re(build) currently installed packages with some name-based filter. For example, emerge -v $(qlist -IC|grep <NAME>), and to update, just add the u, such as emerge -vu $(qlist -IC|grep <NAME>)

Sample useful copy/paste commands:

• GCC or glibc
  • emerge -v glibc
  • emerge -v gcc
• Xorg server and xfce
  • emerge -vu xorg-server $(qlist -IC|grep x11-drivers/)
  • emerge -vu $(qlist -IC|grep xfce)
• Kernel update – here we update the new kernel headers (sys-kernel/linux-headers` ) and rebuildglibc`` if needed
  • emerge -v --nodeps sys-kernel/gentoo-sources sys-kernel/linux-headers sys-libs/glibc
• QT/KDE libraries: neither have a meta package (which would end up pulling all the QT/KDE packages), so the best way is to use qlist
  • emerge -vu $(qlist -IC|grep dev-qt|sort|uniq)
  • emerge -v $(qlist -IC|grep kde|sort|uniq)

Install imagemagick and GNU parallel.

parallel convert {} {.}.webp ::: *.@(jpg|png)

A need arose of transfering my hosting from AWS/RDS to yet-another-provider. And, while everything I have running there is a docker container (and therefore, easily transferable), I did hit an issue with dumping a pgsql database and limited disk space on the host. The solution? Dump, compress and transfer.

$ docker run -it --rm postgres pg_dump --username=<usr> --host=<hst> --dbname=postgresql://<usr>:<pwd>@<hst>/<database> | g
zip -c | ssh <other_hst> "cat - > <path_to>/<database>.sql.gz"

CalDAV and CardDAV are protocols to synchronize calendars and contacts with a remote server. At the moment, there is no carddav implementation directly accessible from the Ubuntu Touch graphical user-interface, so the only way to sync carddav is by using syncevolution + cron. The basic building blocks can be traced to here, here, here and here, but it took a little bit more before my phone was fully synced to iCloud.

Identify your user ID:

curl -s -X PROPFIND -u "$ICLOUD_LOGIN" -H "Depth: 0"  --data "<propfind xmlns='DAV:'><prop><current-user-principal/></prop></propfind>"  https://caldav.icloud.com/

After providing your app-specific password, you should get something like https://caldav.icloud.com/xxxNNNNNNNxxxxx/principal/

To reference the cluster where the actual calendars is stored:

curl -s -X PROPFIND -u "$ICLOUD_LOGIN" -H "Depth: 0"  --data "<propfind xmlns='DAV:' xmlns:cd='urn:ietf:params:xml:ns:caldav'><prop><cd:calendar-home-set/></prop></propfind>" 
 https://caldav.icloud.com/xxxNNNNNNNxxxxx/principal/

Which should kick back something like https://pNN-caldav.icloud.com:443/xxxNNNNNNNxxxxx/calendars

You can list all the calendars from your iCoud account:

curl -s -X PROPFIND -u "$ICLOUD_LOGIN" -H "Depth: 1"  --data "<propfind xmlns='DAV:'><prop><displayname/></prop></propfind>"  https://pNN-caldav.icloud.com:443/xxxNNNNNNNxxxxx/calendars/

The CardDAV home contains the CardDAV collections (aka the 'address books'), not the vCards (which contain contacts and contact groups). If you redirect the previous steps to https://contacts.icloud.com, and follow the same sequence, you need to take one more hop.

This is how you eventually arrive at

iCloud_CalDAV_URL="https://pNN-caldav.icloud.com:443/xxxNNNNNNNxxxxx/calendars/home/"

iCloud_CardDAV_URL="https://pNN-contacts.icloud.com:443/xxxNNNNNNNxxxxx/carddavhome/card/"

(or: how do I transfer my ssh public keys to a sshd server running PasswordAuthentication=no)

If you don't already have an ssh keypair, type ssh-keygen on your computer and follow the instructions to generate one.

Wherever you are running your ssh service (and assuming you've just enabled it and have no other configurations setup):

mkdir -pm700 ~/.ssh
nc -l 1234 > ~/.ssh/authorized_keys

(the last command will hang; this is expected). On your computer, then type ( replacing 192.0.2.1 with the correct IP):

nc 192.0.2.1 1234 < ~/.ssh/id_rsa.pub

If successful, the last command on your server will now succeed.

WeeChat is a free and open-source Internet Relay Chat client, which is designed to be light and fast. More info here.

Buffers:

^p		# switch buffers
/close		# same as /buffer close
^s / ^u		# Set unread marker on all windows
^p, A-left	# Switch buffer left
^n, A-right	# Switch buffer right
A-a		# Next buffer with activity
A-0...9		# Switch buffers
A-w A-Left	# Switch windows
A-w A-b		# Balance windows

Window commands:

/window splith	# Split horizontal
/window splitv	# Split vertical
/window zoom	# Zoom

Search:

^r		# Search
Enter ^j ^m	# Stop search

Dig (Domain Information Groper) is a command line utility that performs DNS lookup by querying name servers and displaying the result to you.

dig [server] [name] [type]

[server] – the IP address or hostname of the name server to query. If the server argument is the hostname then dig will resolve the hostname before proceeding with querying the name server. It is optional and if you don’t provide a server argument then dig uses the name server listed in /etc/resolv.conf.

[name] – the name of the resource record that is to be looked up.

[type] – the type of query requested by dig. For example, it can be an A record, MX record, SOA record or any other types. By default dig performs a lookup for an A record if no type argument is specified.

By default, the dig command will display the A record when no other options are specified. The output will also contain other information like the installed dig version, technical details about the answers, statistics about the query, a question section along with few other ones.

dig talm.ai +noall +answer

This queries the answers section only, and stops displaying all the section using +noall option.

dig @ns.talm.ai +nocmd talm.ai ANY +multiline +answer

This queries all the available DNS record types associated with a domain (ANY), disabled the initial comment of the version of dig (+nocmd), show records in a verbose multi-line format with human-readable comments (+multiline), using the specified dns server.

dig talm.ai +trace

Dig allows tracing the DNS lookup path. The option makes iterative queries to resolve the name lookup. It will query the name servers starting from the root and subsequently traverses down the namespace tree using iterative queries following referrals along the way.

dig -x 34.214.202.205

To perform a reverse DNS lookup using the dig command use the –x option followed by your chosen IP address.

Sometimes you want to create an offline copy of a site that you can take and view even without internet access.

wget --mirror --convert-links --adjust-extension --page-requisites 
--no-parent http://example.org

Where:
--mirror – Makes (among other things) the download recursive.

--convert-links – convert all the links (also to stuff like CSS stylesheets) to relative, so it will be suitable for offline viewing.

--adjust-extension – Adds suitable extensions to filenames (html or css) depending on their content-type.

--page-requisites – Download things like CSS style-sheets and images required to properly display the page offline.

--no-parent – When recursing do not ascend to the parent directory. It useful for restricting the download to only a portion of the site.

Alternatively, the command above may be shortened:

wget -mkEpnp http://example.org

However, wget is known to be notoriously flaky, and certain paths may not be fully followed. If you need to further grep out files, you can also try:

lynx -dump http://example.org | awk '/keyword/{print $2}' > links.txt

And then

wget -i links.txt

If you need to download just a sub-section of the site, then you can also try

wget -r -l 5 -np "full URL w/path"

The fugitive plugin is a really nice git wrapper for Vim.

Basics:

:Git # Run any arbitrary git command from inside Vim

:Gwrite # Stage the current file to the index

:Gread # Revert current file to last checked in version

:Gremove # Delete the current file and the corresponding Vim buffer

:Gmove # Rename the current file and the corresponding Vim buffer

:Gcommit # Opens up a commit window in a split window

:Ggrep keyword # Will search for 'keyword' in working copy files (excluding untracked files)

History:

:Gblame # Opens a vertically split window containing annotations for each line of the file: the last commit reference, with author and timestamp. The split windows are bound, so that when you scroll one, the other window will follow

:Gstatus # Opens a status window. Open file with an enter, jump directly between files with {ctrl-n} and {ctrl-p}

:Gedit # With no arguments from a working tree file, it will open the index version of that file. Use the optional {:index} (such as ':Gedit :1') to open the provided index

:Gdiff # Performs a vimdiff against the index version of the file. Opens a vertical split window (index file on the left, working copy on the right). Navigate through hunks using {[c} for previous and {]c} for next

:Glog # Loads all previous revisions of the current file into the quickfix list. Use it with '-- %' to load all ancestral commit objects that touched the current file into the quickfix list. Use it with '--grep=keyword --' to search for 'keyword' in all ancestral commit messages. Or '-Skeyword --' to search for 'keyword' in the diff for each ancestral commit. Jump between previous and next quickfix item with {:cprev} or {:cnext}, respectively

Marcelo Gleiser, a Brazilian (yay!) theoretical physicist currently teaching at Dartmouth College, has won this year’s Templeton Prize for his work "Science does not kill God". Gleiser's current research interests include the physics of the early Universe, the nature of physical complexity, and questions related to the origin of life on Earth and elsewhere in the Universe.

This Scientific American article has a nice summary and a bunch of very interesting discussion points (of which I quote a couple below), but I'll let you read the article yourself, and come to your own conclusions.

• "It is impossible for science to obtain a true theory of everything"

• "We cannot presume that we are going to solve all the problems of the world using a strict scientific approach. It will not be the case, and it hasn’t ever been the case, because the world is too complex, and science has methodological powers as well as methodological limitations."

• “The absence of evidence is not evidence of absence”

Vim is an IMproved version of Vi, useful for editing text files.

Startup and Exit:

:q[uit] # Quit Vim. [!] to force without writing

:wq {file} # Write to {file} and exit. [!] to exit always

:e[dit] {file} # Edit {file}. This is useful to re-edit the current file, when it has been changed outside of Vim. [!] to discard any changes to the current buffer. This is useful if you want to start all over again.

:!mv {src} {dest}, and then running :e {dest} # move {src} to {dest} and open the new buffer

Inserting and Deleting:

a # Append text after the cursor [count] times. [A] for end of line

i # Insert text before the cursor [count] times. [I] to do it before the first non-blank

o # Begin a new line below the cursor and insert text, repeat [count] times. [O] for above the cursor

:r[ead] [name] # Insert the file [name] below the cursor.

:r[ead] !{cmd} # Execute {cmd} and insert its standard output below the cursor

x # Delete [count] characters under and after the cursor. [X] to do it before the cursor

dd # Delete [count] lines

d+$ or D # Delete the characters under the cursor until the end of the line

{Visual}x or {Visual}d # Delete the highlighted text. [X] or [D] to delete the highlighted lines.

r{char} # replace the character under the cursor with {char}.

R # Enter Insert mode, replacing characters rather than inserting

~ # Switch case of the character under the cursor and move the cursor to the right. If a [count] is given, do that many characters

{Visual}~ # Switch case of highlighted text

:u[ndo] # Undo one change. Repeat for multiple

ctrl+r # Redo [count] changes which were undone

. # Repeat last change, with count replaced with [count]

:kJ # move current line, removing spaces before it, to the previous line

ctrl+V c <type> esc esc # selects column, types replacement text, apply it

ctrl+V <choose lines> :s/^/# /g # selects linex, substitute beginning of the line with #

:ciw # Quickly change word or line

Copying and Moving Text:

:reg[isters] or :di[splay] # Display the contents of all numbered and named registers (ie: where deletes and yanks are stored)

:reg[isters] {arg} # Display the contents of the numbered and named registers that are mentioned in {arg}

["x]yy # Yank [count] lines [into register x]

["x]p # Put the text [from register x] after the cursor [count] times

["x]P # Put the text [from register x] before the cursor [count] times

Moving Around:

0 # To the first character of the line (exclusive)

$ # To the end of the line and [count - 1] lines downward

:{num} # Jump to line {num}

e or w # Forward to the end of the word [count]

b # Backtrack to the previous word

h j k l # directional movement. left down up right, respectively

ctrl+D # page down

ctrl+BB # page up

} or { # Jump down or up.

Opening a terminal:

:terminal # To open a terminal on a new buffer (i to interact)

ctrl+\ ctrl+N # To end interaction

Buffers:

:e {file} # edit another {file}. An empty buffer can be created by entering :new or :vnew

:badd {file} # add a new buffer for a file without opening it

:split {file} # split window and load another {file}

ctrl+w {up arrow} # move cursor up a window

ctrl+w ctrl+w # move cursor to another window (cycle)

ctrl+w ctrl+r # swap the two parts of a split window

ctrl+w {_} # maximize current window

ctrl+w {=} # make all equal size

[c] ctrl+w {+/-} # modify window height by [c] lines

[c] ctrl+w {>/<} # modify window width by [c] lines

:vsplit file # vertical split

:hide # close current window

:only # keep only this window open

:ls # show current buffers

:b [c] # open buffer #[c] in this window

:b <minimum amount of unambiguous characters> tab # jumps to the document/buffer you want

:bd[elete] {num} # delete buffer {num}

:windo diffthis # with two split windows containing buffers, this is how to compare them

:windo diffoff # turn off diff between split buffers

:set list # whitespaces, tabs and eol characters are shown

For more references, check this or this or this out.

Tmux is a terminal multiplexer. It creates a host server on your server and connects to it with a client window. If the client is disconnected, the server keeps running. One can reattach to the tmux session and the files, processes and general activity that you were working with will still be active.

Command mode is enable via a prefix ctrl+b.

Startup and Sessions:

tmux ls # lists sessions

tmux attach -t 0 # attaches to session 0

tmux ls | grep : | cut -d. -f1 | awk '{print substr($1, 0, length($1)-1)}' | xargs kill # kills all sessions

prefix + :new # creates new session

prefix + s # lists sessions

prefix + $ # renames session

prefix + ( # switch to previous session

prefix + ) # switch to next sesssion

prefix + d # detach

prefix + ? # list shortcuts

prefix + D # gives you a list of connected clients, and which ever you select is disconnected

prefix + q # briefly flashes pane numbers in each pane

Panes (splits):

prefix + % # vertical split

prefix + " # horizontal split

prefix + :splitw -hb # horizontal split, placed before current pane (ie: left side)

prefix + :splitw -bf # full width pane, on top of window with a vertical split

prefix + :splitw -fh # full width pane, on right side of window with a horizontal split

prefix + :splitw -t 2 # splits pane number 2 vertically

prefix + o # swap panes

prefix + x # kill pane

prefix + :respawn-pane -k # respawn the pane (kill/restart shell)

prefix + + # break pane into window (e.g. to select text by mouse to copy)

prefix + - # restore pane from window

prefix + space # toggle between layouts

prefix + q # Shows pane numbers, when the numbers show up type the key to goto that pane

prefix + arrows # Navigates between panes

prefix + ALT + arrows # resizes active pane

prefix + z # toggle pane zoom (repeat to unzoom)

prefix + 'setw synchronize-panes' # sync panes

Windows (tabs):

prefix + c  # create window

prefix + w  # list windows

prefix + n  # next window

prefix + p  # previous window

prefix + 0-9 # Switch to a window using index number

prefix + f  # find window

prefix + ,  # name window

prefix + &  # kill window

Copy mode:

prefix + [ # enables copy mode

prefix + ] # pastes copied buffer

(prefix + 'setw -g mode-keys vi' # vi mode)

With this option set, we can use h, j, k, and l to move around buffer. To get out of Copy mode, just press the ENTER key. Use w to jump to the next word and b to jump back one word, and f, followed by any character, to jump to that character on the same line, and F to jump backwards on the line.

   Function                vi             emacs
----------------------    --------       -------
   Back to indentation     ^              M-m
   Clear selection         Escape         C-g
   Copy selection          Enter          M-w
   Cursor down             j              Down
   Cursor left             h              Left
   Cursor right            l              Right
   Cursor to bottom line   L
   Cursor to middle line   M              M-r
   Cursor to top line      H              M-R
   Cursor up               k              Up
   Delete entire line      d              C-u
   Delete to end of line   D              C-k
   End of line             $              C-e
   Goto line               :              g
   Half page down          C-d            M-Down
   Half page up            C-u            M-Up
   Next page               C-f            Page down
   Next word               w              M-f
   Paste buffer            p              C-y
   Previous page           C-b            Page up
   Previous word           b              M-b
   Quit mode               q              Escape
   Scroll down             C-Down or J    C-Down
   Scroll up               C-Up or K      C-Up
   Search again            n              n
   Search backward         ?              C-r
   Search forward          /              C-s
   Start of line           0              C-a
   Start selection         Space          C-Space
   Transpose chars                        C-t

Other useful hints:

export TERM="xterm-256color" # Vim doesn't detect that the terminal supports 256 colors because tmux's default TERM is screen
 
:source-file ~/.tmux.conf # If you have made changes to your tmux configuration file in the ~/.tmux.conf file, it shouldn’t be necessary to start the server up again from scratch with kill-server. Instead, you can prompt the current tmux session to reload the configuration with the source-file command

For more references, check this out.

I'm using OpenSSL's c++ library to generate a public/private tuple, following the code sample below:

EVP_PKEY* my_pkey = nullptr;
EVP_PKEY_CTX* my_ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_ED25519, nullptr);
EVP_PKEY_keygen_init(my_ctx);
EVP_PKEY_keygen(my_ctx, &my_pkey);

But needed to extract the raw (uint8_t*) array of bytes. I found the following reference which suggested:

a) To serialize the public key:

Pass the EVP_PKEY to EVP_PKEY_get1_EC_KEY() to get an EC_KEY.
Pass the EC_KEY to EC_KEY_get0_public_key() to get an EC_POINT.
Pass the EC_POINT to EC_POINT_point2oct() to get octets, which are just unsigned char *.

b) To deserialize the public key:

Pass the octets to EC_POINT_oct2point() to get an EC_POINT.
Pass the EC_POINT to EC_KEY_set_public_key() to get an EC_KEY.
Pass the EC_KEY to EVP_PKEY_set1_EC_KEY to get an EVP_KEY.

c) To serialize the private key:

Pass the EVP_PKEY to EVP_PKEY_get1_EC_KEY() to get an EC_KEY.
Pass the EC_KEY to EC_KEY_get0_private_key() to get a BIGNUM.
Pass the BIGNUM to BN_bn2mpi() to get an mpi, which is a format written to unsigned char *.

d) To deserialize the private key:

Pass the mpi to BN_mpi2bn() to get a BIGNUM.
Pass the BIGNUM to EC_KEY_set_private_key() to get an EC_KEY.
Pass the EC_KEY to EVP_PKEY_set1_EC_KEY to get an EVP_KEY

However I ended up doing this using the following code snippet. Which was was committed to openssl in June (https://github.com/openssl/openssl/pull/6394):

uint8_t* pub_key = new uint8_t[32];
std::size_t allocated_length;
EVP_PKEY_get_raw_public_key(my_pkey, pub_key, &allocated_length);
ASSET_EQ(allocated_length, 32);

EVP_PKEY_get_raw_public_key() fills the buffer provided by pub with raw public key data. The number of bytes written is populated in *len. If the buffer pub is NULL then *len is populated with the number of bytes required to hold the key. The calling application is responsible for ensuring that the buffer is large enough to receive the public key data. This function only works for algorithms that support raw public keys. Currently this is: EVP_PKEY_X25519, EVP_PKEY_ED25519, EVP_PKEY_X448 or EVP_PKEY_ED448.

And there is an equivalent EVP_PKEY_get_raw_private_key() as well.

I found David Brooks', The Road to Character, extremely interesting from the get-go. Throughout the book he examines the duel between the external- and our internal-self. But, curiously, it was the introduction that I got fixated with, where he explores the difference between the resume virtues and the eulogy virtues. The eulogy virtues are the inner traits - those found at the core of our being - which define the type of character we are. It is the "internal us" that wants to embody certain moral qualities - build a "serene inner character, a solid sense of right and wrong - not only do good - but be good. Wants to love intimately - sacrifice self in the service of others to live in obedience to some transcendent truth, to have a cohesive inner soul that honors creation and one's own possibilities." On the other hand, as the name indicates, the resume virtues are the ones you list on your resume: the skills that you bring to the job market and that contribute to external success. The strategies used to achieve successful careers. It represents our external self that "wants to build, create, produce, and discover things. That wants high status and victories."

The thing is: we spend more time on our resume-self, then on developing a profound character (!). Our society is mostly oriented around the resume virtues, and "most of us have clearer strategies for how to achieve career success than we do for how to develop a profound character". While the resume virtues want to conquer the world, savor their victories and rise the ladder; the eulogy virtues want to make the world a better place, is willing to make sacrifices (success and status) for the sake of a purpose and savor the warmth of their family. David points out that these are type of people that go unnoticed. The kind, cheerful, but reserved ones. The ones that have no need to prove anything to the world: humanity, restraint, reticence, temperance, respect, and gentle self-discipline.

The thing is: when thinking about where I was, with regards to both virtues, I noticed that I had much to grow still. I want to leave behind a legacy where I am known to get things done; to be able to deal with conflicts while radiating tranquility; to have a story which others can build upon while struggling towards maturity. Not requiring recognition, but truly solving some of life's essential problems. I've started to notice already that some things have been changing within me, in the last year: I can truly live the moment - enjoy doing the impressive work I may be involved with - and still be continuously delighted by the experiences of those that surround me. I have been more focused and more capable of recognizing what needs doing and do it; to make those around me better and to enable them to their potential when I speak with them. But the room for growth is much larger. I want to answer softly when challenged harshly, be dignified when others try to humiliate me, restrained when others try to provoke me. I want to be the kind of person that "After you've known them for a while it occurs to you that you've never heard them boast, you've never seen them self-righteous or doggedly certain. They aren't dropping little hints of their own distinctiveness and accomplishments."

I recognize the contradiction of publicly talking about this, obviously. But, to achieve my goal of building a strong inner character, I have to publicly set them.