At work, we use Doppler to manage our secrets. It injects environment variables before running commands. I thought, why can’t I do the same with a simple script?

The following script evaluates all password files with env in their names. I keep my environment variables in files named env-aws, etc., in the following format:

export AWS_ACCESS_KEY_ID="123456...."

The following script, which I called rws (short for run-with-secrets), allows me to run a command like rws s3cmd and use pass to inject the variables. So far, I’m happy with it.

#!/bin/zsh

cmd="$@"

fd -F env $HOME/.password-store | while read file ; do
  bb="${file:t:r}"
  eval $(pass show ${bb})
done

exec $cmd

function CreateTimestampedFile()
  local zkdir = os.getenv("HOME") .. "/github.com/iesahin/garden/zk/"
  local timestamp = os.date("%Y%m%d%H%M%S")
  local filename = zkdir .. "/" .. timestamp .. ".md"
  vim.cmd("edit " .. filename)
end

vim.api.nvim_set_keymap("n", "<leader>F", ":lua CreateTimestampedFile()<CR>", { noremap = true, silent = true })

Now, I can just hit <leader>F (which is <Space>F in my setup) and immediately start adding a note to my zettelkasten.

vim.keymap.set({ "n", "i" }, "<F2>", '<esc><esc>yy:r!<c-r>"')

I type a command, like ls, on a line and hit <F2>. That line is copied, executed, and the output is read into the buffer just below it.

I use it for all sorts of tasks, from listing open PRs with gh to fetching website text with w3m. It has significantly improved my workflow, allowing me to use the shell effectively within textual notebooks.

I needed a way to quickly open URLs in the Kagi Summarizer from my terminal. I wrote a small shell function to do that:

ksum() {
  local urlenc=$(jq -rn --arg x "$1" '$x|@uri')
  open "https://kagi.com/summarizer/index.html?target_language=&summary=takeaway&url=${urlenc}"
}

Add the following to your .tmux.conf:

set-hook -g window-unlinked 'last-window'

" Save undo trees in files
set undofile
set undodir=~/.vim/undo

" Number of undo levels saved
set undolevels=10000

For more information on intermediate Vim usage, see this guide.

I am currently using Dart to rewrite the entire application, which is fundamentally simple. It receives words in Turkish or Ottoman and translates them to Ottoman or Turkish. However, the parsing module needs more rules to divide the words (and phrases) into roots and suffixes. There are hundreds of rules, and using only code to describe the reasoning behind parsing seems to be the main reason I spend so much time trying to understand my own work.

I decided that I can just use knot to write the rules in a document and generate the code from it. It will surely take more time than just writing the code, but in the end, I will have a document describing the analysis and parsing rules that even I can understand.

First, you need to register a new bot with @BotFather and get an API token. Then, run pip3 install --user telegram-send and prepare a config file at ~/.config/telegram-send.conf:

[telegram]
token = <TOKEN_YOU_GET_FROM_BOT_FATHER>
chat_id = <CHAT_OR_USER_ID>

You’ll need to start a conversation with the bot and find your user ID (which is identical to the chat ID for the conversation you start with the bot).

After that, you can send yourself messages from the CLI like this:

telegram-send "Hello Telegram."

You can also send Markdown-formatted messages, audio, stickers, and more using various command-line options:

usage: telegram-send [-h] [--format {text,markdown,html}] [--stdin] [--pre]
                     [--disable-web-page-preview] [--silent] [-c]
                     [--configure-channel] [--configure-group]
                     [-f FILE [FILE ...]] [-i IMAGE [IMAGE ...]]
                     [-s STICKER [STICKER ...]]
                     [--animation ANIMATION [ANIMATION ...]]
                     [--video VIDEO [VIDEO ...]] [--audio AUDIO [AUDIO ...]]
                     [-l LOCATION [LOCATION ...]]
                     [--caption CAPTION [CAPTION ...]] [--config CONF] [-g]
                     [--file-manager] [--clean] [--timeout TIMEOUT]
                     [--version]
                     [message [message ...]]

I’ve started using aerc as my command-line email client. Initially, I used its archived GitHub repository, but I found the software to be buggy. Switching to the active repository provided me with the fastest IMAP client I’ve ever used. Its asynchronous operations make the workflow incredibly smooth, as you don’t have to wait for the server after deleting or archiving each email.

goneovim

I’ve also begun using a Neovim GUI called goneovim. I previously used Neovim-GTK, but encountered issues—possibly due to Fira Code’s ligatures or other incompatibilities—that resulted in poor visuals and noticeable lag. I’m giving this new GUI a try, and so far, Fira Code and its ligatures are working perfectly.

Software written in Go is occupying more mindshare than I previously anticipated. Alongside Hugo, the Miniflux self-hosted RSS client, and the Mouthful comment server, these tools demonstrate that Go has truly taken off for system and performance-related tasks.

I used to use Emacs for this—the One True Editor. Yet, it has one flaw that disrupted my writing routine: it has too many features. When I encountered writer’s block or an idea I couldn’t quite articulate, I would start tinkering with the editor instead. Emacs is like a friend, and one should keep friends away from the workplace; otherwise, no work gets done.

For this reason, I began writing with ed some time ago. ed is not my friend; it’s the standard editor. It’s also the grandfather of vi, but fathers should not bear the vices of their sons.

Note from 2024: Ten years after writing this post, I’m editing it with Neovim, the grandson of all these tools.

ed was very nice to write with. It doesn’t have many features. It prints a 0 when it opens, I type i to insert text, and then I write whatever I like. When I put a lonely . on a line, it understands that I’ve finished my words. Then, with w, I save the file to disk and see its length—length in bytes, as every true writer nowadays should know.

ed is minimal, and while I occasionally get frustrated by its modal behavior, that’s exactly why I was happy to write with it.

However, I eventually decided that even pressing those few command keys was too much. i, ., and w—one can forget them easily. And it seemed I had a tendency to learn more of its commands, which are passed down to its grandchildren. God save us from the vices of vi.

Then, I decided to concoct a script that uses cat. Everyone knows writers like cats, and I like cat too; it concatenates text into files and is also used to print their content. It’s much simpler than ed—much simpler. It is not an ambiguous dork like ed; it’s a simple animal that writes into files whatever I type into it.

It was easy to check the file size in words after I finished. I wrote a while loop to continue until I reached my daily quota. The script creates a new file, adds an Org-mode header, and includes the contents of the clipboard just after the title so I can include notes. cat exits with Ctrl-D, and when it finishes, the script checks the word count. If I’m still short of my daily target, it appends a ----- separator and opens the file again. You have to finish your words, whether your brain bleeds or your cat dies.

The effect? I began using it today, so I’m still not sure about the long-term impact, but there’s certainly nothing to distract me. When I used Emacs, the info pages were highly entertaining—I was just finishing the command-line options of GNU Backgammon when I decided to switch. Modern programs are so customizable that I can’t even finish reading their manuals.

The script is shown below. It asks for a filename; if you don’t provide one, it creates one based on the date. It has some minor changes from the version I use, as I tend to name my files differently and I haven’t tested this specific version thoroughly, but here it is. Copy and paste it into a file named write-with-cat, make it executable with chmod +x write-with-cat, and run it. You’ll need a Unix-like system (even my mom uses Debian, you know).

The second part of the script, which I’ve commented out, copies the written material to a repository and commits it using Mercurial.

#!/bin/bash

WORDSIZE=600

echo "Please set a (tentative) name?"
read response
if [ -z "$response" ] ; then
    dirname=work-`date +%y-%m-%d`-$RANDOM
else
    dirname=work-${response}
fi

tempdirname="/tmp/$dirname"
mkdir $tempdirname
docname="$tempdirname/index.org"

selection=`xsel -ob`
cat > $docname <<EOF
#+TITLE: $response
#+AUTHOR:
#+DATE: `date`

$selection
EOF

clear
cat $docname

while [ `wc -w "$docname" | cut -f 1 -d ' '` -le $WORDSIZE ] ; do
    cat >> $docname
    echo "\n-----" >> "$docname"
    wc -w "$docname"
done

Therefore, I decided that a small Bash script using rsync and find would work better. It monitors my entire home directory and backs up recent files.

The following script does exactly that:

#!/bin/bash

if [ "x$1" = "x" ] ; then
    TARGET=/media/augustus/backup-recent-`hostname`
else
    TARGET=$1
fi

PERIOD=15

mkdir -p $TARGET

# Delete files older than $PERIOD days
find $TARGET -ctime +$PERIOD -print -delete

# Copy files newer than $PERIOD under ~. Ignore files under .hg
for d in ~/*/ ; do
    find $d -path '*/.hg/*' -prune -o -type f -ctime -$PERIOD -print  -exec rsync -aRv {} $TARGET/ \;
done

It checks whether a command-line option is provided as the target; otherwise, it sets a default target. /media/augustus/ is an NFS mount in my case, but you can specify any path.

PERIOD is the number of days that the script considers recent. Currently, it backs up files changed in the last 15 days.

The script deletes older files from the backup. Since I use other solutions for long-term storage, I don’t want to keep them here, especially since this script runs via cron every two hours.

Note that the script only checks directories under the home directory, so files located directly in the home directory are not backed up.

It also skips files under .hg directories. You can add more -prune options to the find command to exclude other irrelevant directories from your backup.