Here’s Vim editor thesaurus completion. This kind of completion has its various limitations that I might detail later. I mentioned thesauri in passing but my Internet connection is pitiful and writing about editor meta feels a bit bizarre.

More Vim editor meta? Since posting a video of my LaTeX/Vim shenanigans, queries for tips arrive occasionally. Completion and whole line completion are boilerplate hammers. The more buffers and windows loaded, the more “robust”.

The nmap command can enumerate SSL ciphers on the server.

nmap --script ssl-enum-ciphers -p 443 domain.example

The SSL Labs’ SSL test is similar? In debugging purgatory, there are instances where declarations in a configuration do not translate into reality and it’s not always the implementation, or the server, but sometimes exotic interactions between systems.

A quick wrapper script for normalized git commit dates. Commit dates and timezones are normalized or truncated to the day. This is useful for avoiding rebasing and/or not having to think about system or git date/time settings when on another device or in another timezone. If precise timestamps matter, then it is easily disabled.

#!/bin/sh -eu

GIT=$(which git --all | grep --invert-match "local/bin" | head --lines 1)
GIT_COMMITTER_DATE="$(date --utc --date '0' '+%a %b %d %H:%M:%S %Y %z')"

export GIT_COMMITTER_DATE

[ "${1:-}" = "commit" ] && export DATE=1 && $GIT "$@" --date="$GIT_COMMITTER_DATE"

[ "${DATE:-}" = 1 ] && exit

$GIT "$@"

Infinite scrolling is unusual. Most implementations are “almost infinite” to avoid excessive DOM length (memory).

• Infinite scrolling: Limits content to an arbitrarily large amount to avoid exhausting memory.

• Virtual scrolling: Unload everything except the visible viewport + a top and bottom offset. Pad the rest.

Virtual scrolling is infinite, but breaks auxiliary actions ( CTRL + F ) because what’s on the screen is the content.

document.addEventListener("scroll", function() {
  console.log(document.querySelectorAll('*').length)
});

The most popular library appears to be https://infinite-scroll.com.

Some SSH options are worth tweaking when directly distributing code with git to multiple remotes. ConnectTimeout and BatchMode (optionally for automation). ControlMaster enables multiplexing for session sharing via sockets.

ForwardX11 no
Compression no
ConnectTimeout 3
ServerAliveCountMax 1
ServerAliveInterval 10

Host *
  ControlMaster auto
  ControlPersist yes
  ControlPath ~/.ssh/sockets/%r@%h-%p

%r@%h-%p translates to user@hostname-22.

An actual but where did my Linux memory go command;
This program (repositories) came in handy while helping someone resolve an oom problem. Want to see memory usage and shared memory, perhaps sorted by swap?

smem -s swap -kta
smem --sort swap --abbreviate --totals --autosize

swap     (amount of swap space consumed ignoring sharing)
command  (process command line)
maps     (total mappings count)
name     (process name)
pid      (process id #)
user     (process owner)
pss      (proportional set size including sharing)
rss      (resident set size ignoring sharing)
uss      (unique set size)
vss      (virtual set size; total virtual memory mapped)

df -h | grep tmpfs
df --human-readable | grep tmpfs

Text fragments are a Chromium feature from a couple years ago. They (#:~:text=) emulate CTRL + F or window.find() from a URL. I experimented in times past with a snippet–like approach using <mark> with URL encoded terms on id + :target logic, such that clicking this link highlights the paragraph below.

https://web.dev/text-fragments/#:~:text=Text%20Fragments%20let%20you

It’s amusing the sort of easter eggs found hiding in open source code. I’ve been playing around with farzher/fuzzysort, a fast fuzzy search picked up from the Stack Overflow fuzzy search tag.

On line 27 and 40 there’s a horizontal off–screen scroll easter egg.

if(search=='farzher')return{target:"farzher was here (^-^*)/",score:0,_indexes:[0]}
if(search=='farzher')return[{target:"farzher was here (^-^*)/",score:0,_indexes:[0],obj:targets?targets[0]:NULL}]

Yes, I happen to be one of those who read the code eventually. And obviously, it goes without saying, no one person reads all the code. But it’s the Internet, can’t be too sure ;)

You can never be too sure anymore…

$ git remote -v
all             cgit@thedroneely.com:thedroneely/dotfiles (fetch)
all             git@codeberg.org:tdro/dotfiles.git        (push)
all             git@github.com:tdro/dotfiles.git          (push)
all             cgit@thedroneely.com:thedroneely/dotfiles (push)
all             git@gitlab.com:tdro/dotfiles.git          (push)
codeberg.org    git@codeberg.org:tdro/dotfiles.git        (fetch)
codeberg.org    git@codeberg.org:tdro/dotfiles.git        (push)
github.com      git@github.com:tdro/dotfiles.git          (fetch)
github.com      git@github.com:tdro/dotfiles.git          (push)
gitlab.com      git@gitlab.com:tdro/dotfiles.git          (fetch)
gitlab.com      git@gitlab.com:tdro/dotfiles.git          (push)
thedroneely.com cgit@thedroneely.com:thedroneely/dotfiles (fetch)
thedroneely.com cgit@thedroneely.com:thedroneely/dotfiles (push)