So I built Notes CLI: a small Go tool that sits on top of the file store and gives it structure without changing the format.

Every note is still just a markdown file (2026/04/20260405_9522.md). No database, no proprietary format. The CLI handles creation, lookup, filtering, search, and append — all from the terminal or a script.

The scope is deliberately small:

• Capture — get text into a file quickly (echo "..." | notes new)
• Retrieve — find it again by ID, type, tag, or full-text search
• Integrate — pipe notes into other tools, scripts, and AI agents

This is the part that matters most to me now: integration. The CLI is how my AI coding assistant reads and writes notes, generates reports, and pulls context from the archive. It's the glue between a dumb file store and the smart tools that consume it.

Think Obsidian or Logseq, but stripped down to just the storage layer and a terminal-friendly interface. The files are yours; the CLI is optional convenience.

github.com/dreikanter/notescli

• You keep correcting AI mid-task instead of front-loading intent
  • Specs are undercooked
• You accept "close enough" output and manually patch it
  • Acceptance criteria are vague
• You can't tell if output is correct without running it
  • Lost architectural grip on the area

Context Management:

• You re-explain the same project context across sessions
  • Missing a persistent briefing doc
• You forget where a parallel thread left off
  • No re-entry protocol
• You hold task state in your head instead of externalizing it
  • Doesn't scale past ~3 threads

Delegation:

• You do a task manually because "it's faster than explaining it to AI"
  • Avoiding the spec investment (fine if one-off, smell if recurring)
• You micromanage AI output token-by-token instead of reviewing at the outcome level
  • Haven't let go of the maker identity
• You can't walk away from a running agent session
  • Trust/verification pipeline isn't set up

Verification:

• You approve AI PRs faster than you'd approve a junior's
  • Calibration drift
• You review diffs line-by-line when you should be checking behavior
  • Wrong verification level
• You skip testing because "it looked right"
  • False fluency problem

Prioritization:

• You start new AI tasks before verifying completed ones
  • Generation is more fun than review
• You optimize tooling instead of shipping
  • Meta-work trap
• You can't articulate what you're blocked on
  • Planning debt

Energy:

• You feel busy but can't point to what you shipped
  • Motion vs. progress
• You're fatigued from reading, not writing
  • Verification exhaustion (needs different recovery than creative fatigue)

Quick fix: add Ruby env init to ~/.zshenv (or officially recommended ~/.zprofile). Here is mise example:

if [[ -x "/opt/homebrew/bin/mise" ]]; then
  eval "$(/opt/homebrew/bin/mise activate zsh --shims)"
fi

Unlike ~/.zshrc, ~/.zshenv loads for non-interactive context. And the --shims flag is specifically designed for cases like that. It just prepends the shims directory to PATH without hooking into the shell, so it's safe for non-interactive contexts.

Alternative solution for Lefthook-managed git callback:

# lefthook-local.yml
rc: eval "$(/opt/homebrew/bin/mise activate bash --shims)"

How to test:

# Before (system default Ruby)
$ zsh -lc "which ruby"
/usr/bin/ruby

# After (proper override)
$ zsh -lc "which ruby"
/Users/alex/.local/share/mise/installs/ruby/<version>/bin/ruby

For findability:

Could not find 'bundler' ... required by your .../Gemfile.lock. Gem::GemNotFoundException

Modes:

• i - insert mode
• esc - normal mode
• v/V - visual mode
• :- command mode

Motions:

• h, j, k, l
• 0 - home, ^ - first chr, $ - eol
• w/W - next word
• e/E - next word-end
• b/B - backward

Insert mode:

• i - insert before chr
• I - beginning of line
• a - append after chr
• A - EOL

Horsing around:

• zz/zt/zb - scroll rel cursor
• H/M/L - jump to first/mid/last line on screen
• ZZ - quick exit

Text modification:

• d - delete
• dd - delete line
• D - delete till EOL
• diw - "delete in word"
• ciw - "change in word" (delete word + INS)
• x - delete chr
• r - replace
• . - replay

Clipboard:

• y - yank
• yy - yank line
• p - paste before, P - paste after
• "1y - yank to register 1
• "1p - paste from register 1
• "+y/"+p - system clipboard
• "%p - current file name
• * - select current word matches → n/N - jump to next/prev
• viw - select word

Macros:

• q1 - record macro to reg 1
• q - stop recording
• @1 - replay macro

Time travel:

• u - undo
• Ctrl+r - redo

Commands:

:w - save :q/:q! - quit :noh - reset search highlights :%s//NEW/gc - replace *-selected substring with confirmation :reg - show registers

The script lives in my $PATH and works like this:

# Save a new learning
til "You can use git log --oneline --graph for a nice commit tree"

New note gets appended to ~/notes/til.md with a timestamp.

- 2024-12-16 09:12: vim ggVG selects all text
- 2024-12-16 11:30: Rob Pike: A little copying is better than a little dependency
- 2024-12-16 14:15: Private methods in Rails helper models are still available in views
- 2024-12-16 16:42: Stimulus auto-typecasts action parameters that look like JSON
- 2024-12-17 08:05: One can't just cd "~/New folder". It should be cd "$HOME/New folder" or cd $HOME/"New folder" instead.

I’ll probably change it to a random one if the initiative survives the test of time.

The script expects a NOTES_PATH environment variable and fails fast if it's not set or doesn't exist. When called without arguments, it shows the last 10 entries with timestamps stripped for cleaner reading.

It's not meant to be a sophisticated knowledge management system. Just a frictionless way to capture small discoveries before they disappear. Sometimes the best tools are the simplest ones.

Start using it consistently when referring to the subject of your work.

Recognize that initially, the name may seem insignificant and lacking meaningful associations with what it represents. Allow it to settle and take hold. As the new name matures, it will gradually take shape to fit the subject.

git checkout main && rails routes > before.txt && git checkout internal/commentable-communication && rails routes > after.txt && diff -u -b before.txt after.txt | diff-so-fancy

(diff-so-fancy is optional.)

class Base
  def test
    "original result"
  end
end

And a descendant that overrides base class method:

class Descendant < Base
  def test
    "overridden result"
  end
end

How to call Base#test in the Descendant instance context, outside from the Descendant#test? In other words, how woud you access super for some secific instance method outside from the override?

There is a way:

class Descendant < Base
  def test
    "overridden result"
  end

  def original_test
    super_test = Base.instance_method(:test).bind(self)
    super_test.call
  end
end

Descendant#original_test will call the Base#test:

Descendant.new.original_test
# => "original result"

Same approach works for module methods: ImportedModule.instance_method(:method_name).bind(self).call

git diff --name-only main HEAD

Comparing with the current branch:

git diff --name-only main..

Okay, let's make the images publishing process less tedious for a generic static site.

There are two primary use cases involved:

1. Capturing an image from an arbitrary external source to some interim storage.

This is already an automated operation. There are tools for that. My recent favorite is CleanShot X, which can take screenshots and upload arbitrary images from a file or clipboard to the cloud, providing a quick short link for sharing. Silky-smooth UX. Do recommend.

2. Adding images on a page.

Generally, adding an image to a Markdown page is as easy as pasting its URL into contents like so: ![](https://example.com/image.jpg). Let's make this work with CleanShot short URLs.

CleanShot URLs open an HTML page that downscales your screenshot to fit the browser window, adds your branding, etc.

So here is the flow:

• Download the image file from the CleanShot share page.
• Replace CleanShot URLs with local image paths during HTML generation.

Turn ![](https://share.cleanshot.com/gnNSXtJx) into <img src="/image.jpg" alt="">.

The following example demonstrates how to use redcarpet gem, a popular Markdown parser for Ruby, for this purpose:

# Markdown renderer class with a custom processing logic for image tags
class CustomMarkdownRenderer < Redcarpet::Render::HTML
  include Rouge::Plugins::Redcarpet

  attr_reader :images_cache

  def initialize(images_cache:, extensions: {})
    super(extensions)
    @images_cache = images_cache
  end

  def image(link, title, alt_text)
    file_name = images_cache.fetch(link)
    "<img src=\"#{file_name}\" alt=\"#{alt_text}\" title=\"#{title}\">"
  end
end

class ImagesCache
  def fetch(url)
    # If URL is not found in the local cache
    #   Download the image file from CleanShot
    #   Save the image to a local directory
    # Return relative path to the local image copy, suitable for <img> tag
  end
end

# Rendering HTML for a sample page
Redcarpet::Markdown.new(
  CustomMarkdownRenderer.new(images_cache: ImagesCache.new),
  fenced_code_blocks: true,
  highlight: true
).render(File.read("site-content/page.md"))

ImagesCache class suppose to build an arbitrary local directory structure to keep image files with unique URL-friendly names:

$ tree ~/Dropbox/Images
.
├── 20230720_4288
│   └── 43688db1c5851f1a8382a311bd0dc72b.jpg
├── 20230730_4361
│   └── 6c53cf2f2916480f9374471f64a7640b.jpg
│   └── e28f897f968246d1bd45c25aabc32bf8.jpg
└── index.json

And an index for quick look-up for the cached files using the original URL from the Markdown source as the key. DB table, or a CSV, or JSON file, whatever:

$ cat index.json
{
  "https://share.cleanshot.com/Yp166HDZ": "20230720_4288/43688db1c5851f1a8382a311bd0dc72b.jpg",
  "https://share.cleanshot.com/qZ5T6q7g": "20230730_4361/6c53cf2f2916480f9374471f64a7640b.jpg",
  "https://share.cleanshot.com/35WJDTGz": "20230730_4361/e28f897f968246d1bd45c25aabc32bf8.jpg"
}

The example above explains how the images appear on this site pages. So far, so good.

Typically this workflow requires some preparation and a bunch of manual operations.

Prep work:

• Create a directory in the site source tree.
• Ideally, develop a naming convention for image files to keep them associated with the related pages and maintain findability.

Adding an image:

• Add an image file to the source tree.
• Ensure the file has a conventional and unique URL-friendly name.
• Reference this file from the Markdown page source, minding the correct relative path to the image file.

Subjectively, this workflow is quicker and more robust than dragging things with a mouse over some WYSIWYG web UI. But imagine you need to add ten images this way. It is still tedious and boring 🚢 Not automated enough if you will.

Let's make this flow less boring.

Good apps, sites, and services don't make you wait. And this is why assets bloat in the recent web history royally sucks.

The situation is not going to change anytime soon. Though when it is up to me, I always mind web page performance, as I was one of the end-users.

It won't "change the world." But it will make the user experience a little better. Performance is good developer karma.

If you have a choice, please don't make users wait. 400 ms is a buttload of time to display a web page.

This site joined 512kb.club today. It's mostly a symbolic gesture. Not a petition or a campaign of any kind, god forbid.

References:

• Laws of UX: Doherty Threshold
• Recommended Web Performance Timings: How long is too long? at developer.mozilla.org
• 512kb.club

This one introduce s command that opens current directory in a new Sublime Text window:

alias s="subl ."

And this one does the same thing, but it will add current directory to an existing Sublime Text window if it is already open:

alias ss="subl --add ."

In this scenario, RSpec's method stubbing comes in handy:

# spec/support/env_helpers.rb
module EnvHelpers
  def stub_env(variable_name, value)
    allow(ENV).to receive(:[]).and_call_original
    allow(ENV).to receive(:[]).with(variable_name).and_return(value)
    allow(ENV).to receive(:fetch).and_call_original
    allow(ENV).to receive(:fetch).with(variable_name).and_return(value)
  end

  RSpec.configure { |config| config.include self }
end

Require this module from spec/spec_helper.rb for new helpers availability in the specs:

require_relative "./support/env_helpers"

Usage example with custom configuration file in a Rails project:

# config/external_api.yml
development:
  api_key: "non_secret_api_key"
test:
  api_key: <%= ENV["API_KEY"] %>
production:
  api_key: <%= ENV["API_KEY"] %>

The spec:

# specs/configuration/external_api_spec.rb
RSpec.describe "external api configuration" do
  subject(:configuration) { Rails.application.config_for("external_api") }

  context "with sample configuration" do
    before { stub_env("API_KEY", "test_api_key") }

    it { expect(configuration.api_key).to eq("test_api_key") }
  end

  context "with no configuration" do
    it { expect(configuration.api_key).to be_nil }
  end

  context "with direct environment variables access" do
    before { stub_env("SAMPLE", "value") }

    it { expect(ENV["SAMPLE"]).to eq("value") }
    it { expect(ENV.fetch("SAMPLE")).to eq("value") }
  end
end

References:

• rspec-mocks gem
• The Twelve-Factor App: Store config in the environment

Error message example:

ActiveRecord::UnknownMigrationVersionError:
No migration with version number 20230815162103.

That means Rails can't find a migration file matching specific record in the schema_migrations table.

To fix this error, open DB console:

rails dbconsole

Drop the missing migration:

delete from schema_migrations where version = '20230815162103';

Type quit to exit.

Done!

Tracking missing migration:

$ bin/rails db:migrate:status

...
up     20230801199444  Create users table
up     20230801223219  Create Messages table
up     20230802211438  ********** NO FILE **********
up     20230802210508  Update users table

References:

• Active Record Migrations - Old Migrations

Create User/insert_date.py

import datetime
import sublime_plugin


class InsertDateCommand(sublime_plugin.TextCommand):
    def run(self, edit):
        timestamp_str = datetime.datetime.now().strftime("%Y-%m-%d:\n")
        for r in self.view.sel():
            self.view.insert(edit, r.begin(), timestamp_str)

Add new key binding to the keymap file: Quick menu → Preferences: Key Bindings

{
  "keys": ["super+k", "super+t"],
  "command": "insert_date"
}

This example defines Cmd+K, Cmd+T sequence to call the new command.

Done!

Official example:

class Person
  include ActiveModel::Validations

  validates_with MyValidator
  validates_with OtherValidator, on: :create
  validates_with StrictValidator, strict: true
end

Person.validators
# => [
#      #<MyValidator:0x007fbff403e808 @options={}>,
#      #<OtherValidator:0x007fbff403d930 @options={on: :create}>,
#      #<StrictValidator:0x007fbff3204a30 @options={strict:true}>
#    ]

There is also #validators_on(:attribute) to fetch attribute-specific validators.

References:

• ActiveModel::Validations::ClassMethods

sudo pkill coreaudiod

git tag -a TAG_NAME -m "Optional tag message"
git push origin TAG_NAME

Pushing all tags (may cause a mess):

git push --dry-run --tags origin

Preview tags push with dry run:

git push --dry-run --tags origin

References:

• Git Basics - Tagging

If you didn't push your working branch to the upstream, there is an easy fix.

First, create a new feature branch from the HEAD:

git checkout -b new-branch-name

Then move your integration branch to the past (assuming the branch name is main, and you want to start new-branch-name 3 commits ago from the HEAD):

git branch -f main HEAD~3

HEAD~3 means "third last commit from the HEAD" (if HEAD is your current checked-out commit, HEAD~1 is the previous one, etc.).

The alternative syntax for this example is HEAD~~~. It can be easier to type unless you must go too deep into the past.

It becomes more tricky if you merge something in the recent commit history. Git provides a ^ (caret) shortcut for ancestry reference in the case of multiple parent revisions. But I'd prefer ordinary commit ids. It is not as easy to mess up compared to caret syntax.

References:

• Git Tools - Revision Selection

Before the migration finds its way to the integration branch, fixing it in place is okay. It is much better than creating more follow-up migrations turning some trivial DB table creation into an unreadable mess.

Here is a bash oneliner to re-apply the last migration. It will revert one most recent migration and then execute db:migrate again for development and test environments:

rails db:rollback db:migrate && RAILS_ENV=test rails db:rollback db:migrate

It can live in bin/reapply_last_migration and occasionally save you a minute.

• Over time, your writing will become outdated, just like your knowledge and opinions. It will start looking irrelevant and useless even to yourself.
• Writing likely won't bring you immediate rewards, especially if you don't already have an established following. And let's be honest. If you're considering reasons not to start, you probably don't have an audience yet.
• Someone with more expertise might read your post and make fun of you.
• Once you understand a topic well enough, writing about it will seem like a waste of time. You might think that most people who need the information already have it or that there are already good resources for learning about it, so why bother adding your take?

I'm going to integrate CleanShot with my notes publication script to embed screenshots to Markdown pages.

My desired workflow is to plug CleanShot short URL into my notes using Markdown image markup, letting a script to extract actual image URL and do further processing.

Here is a quick example on how to download image file from CleanShot URL:

require "http"
require "cgi"

cleanshot_url = "https://share.cleanshot.com/35WJDTGz"

# Fetch direct image URL
direct_image_url = HTTP.get("#{cleanshot_url}+").headers["Location"]

# Extract image file name from the CleanShot query string
query = URI.parse(direct_image_url).query
param = CGI.parse(query).fetch("response-content-disposition").first
file_name = CGI.unescape(param.split("=", 2).last)

# Download the image to a file
image_contents = HTTP.get(direct_image_url).body.to_s
File.open(file_name, "wb") { _1.write(image_contents) }

(Yes, it is possible to avoid third party dependency here by using Ruby's native Net::HTTP instead of the http gem, but I don't enjoy pain.)

Let's add some errors handling and refactor it into a service class:

require "http"
require "cgi"

class CleanshotDownloader
  attr_reader :cleanshot_url

  def initialize(cleanshot_url, file_name: nil)
    @cleanshot_url = cleanshot_url
    @file_name = file_name
  end

  def download
    response = HTTP.get(direct_image_url)
    raise "error downloading image" unless response.status.success?
    File.open(file_name, "wb") { _1.write(response.body.to_s) }
    file_name
  end

  private

  def direct_image_url
    @direct_image_url ||= begin
      response = HTTP.get("#{cleanshot_url}+")
      raise "error getting image URL" unless response.status.redirect?
      response.headers["Location"]
    end
  end

  def file_name
    @file_name ||= begin
      query = URI.parse(direct_image_url).query
      param = CGI.parse(query).fetch("response-content-disposition").first
      CGI.unescape(param.split("=", 2).last)
    end
  end
end

Usage example:

CleanshotDownloader.new("https://share.cleanshot.com/35WJDTGz").download
# => "CleanShot 2023-08-06 at 15.27.35.jpeg"

And a spec with fancy WebMock stubs:

RSpec.describe CleanshotDownloader do
  subject(:service_call) { described_class.new(cleanshot_url).download }

  let(:cleanshot_url) { "https://share.cleanshot.com/80085" }

  let(:direct_image_url) do
    "https://media.cleanshot.cloud/media/1334/itkYgfyMGKeaUT.jpeg?" \
    "response-content-disposition=attachment%3Bfilename%3DCleanShot" \
    "%25202023-08-06%2520at%252015.27.35.jpeg&Expires=1691367016"
  end

  let(:image_contents) { file_fixture("banana.jpg").read }

  context "with explicit file name" do
    subject(:service_call) { described_class.new(cleanshot_url, file_name: file_name).download }

    let(:file_name) { Tempfile.new(described_class.name) }

    before do
      stub_cleanshot_url.to_return(status: 302, headers: {"Location" => direct_image_url})
      stub_direct_image_url.to_return(headers: {"Content-Type" => "image/jpeg"}, body: image_contents)
      service_call
    end

    it { expect(File.read(file_name)).to eq(image_contents) }
  end

  context "with implicit file name" do
    before do
      stub_cleanshot_url.to_return(status: 302, headers: {"Location" => direct_image_url})
      stub_direct_image_url.to_return(headers: {"Content-Type" => "image/jpeg"}, body: image_contents)
    end

    it { expect(service_call).to eq("CleanShot 2023-08-06 at 15.27.35.jpeg") }
  end

  context "with redirect error" do
    before do
      stub_cleanshot_url.to_return(status: 500)
    end

    it { expect { service_call }.to raise_error("error getting image URL") }
  end

  context "with image downloading error" do
    before do
      stub_cleanshot_url.to_return(status: 302, headers: {"Location" => direct_image_url})
      stub_direct_image_url.to_return(status: 500)
    end

    it { expect { service_call }.to raise_error("error downloading image") }
  end

  def stub_cleanshot_url
    stub_request(:get, "#{cleanshot_url}+")
  end

  def stub_direct_image_url
    stub_request(:get, direct_image_url)
  end
end

References:

• CleanShot: https://cleanshot.com
• Markdown reference (CommonMark): https://commonmark.org/help/

It is possible to filter out specified paths to reduce noise in the Recents:

1. Open System Settings → Siri & Spotlight → Spotlight Privacy...
2. Add ~/Library/Mobile Documents/com~apple~CloudDocs/Arc App to the Privacy list.
3. Click Done.

(I've added ~/Library/Mobile Documents/ since in my opinion, this folder is an ephemeral files dumpster that does not contain anything valuable in general.)

lsof -t -i:PORT_NUMBER

You can use it to kill processes:

kill -9 (lsof -t -i:PORT_NUMBER)

Here is a Bash function making this command easier to use:

killport() { kill -9 $(lsof -t -i:$1) }

Usage example:

killport 3000

You can use PostgreSQL array_position function to specify the required sorting order like so:

SELECT * FROM accounts ORDER BY array_position(array['enabled', 'suspended', 'disabled'], accounts.state)

The same query in Rails:

Account.order(Arel.sql("array_position(ARRAY['enabled' 'suspended', 'disabled'], state::text)"))

Account.pluck(:state).tally
# => {"enabled"=>45, "disabled"=>21, "suspended"=>5}

Account.order(Arel.sql("array_position(ARRAY['disabled', 'suspended'], state::text)")).pluck(:state)

References:

• array_position()

References:

• Irrigation Water Management: Training Manual No. 2 - Elements of Topographic Surveying

brew update
asdf plugin update ruby
asdf install ruby 3.2.2

In case asdf was installed manually, use this instead of the brew commend to update to the lates stable release:

asdf update

References:

• asdf

CustomError = Class.new(StandardError)

def raise_error
  raise StandardError, "Original error" # line 4
end

def call_the_error_raiser
  raise_error # line 8
rescue => e
  raise CustomError, "Error message"
end

begin
  call_the_error_raiser # line 14
rescue StandardError => e
  puts e.inspect
  puts e.backtrace.join("\n")
end

Output (the cause of the original error is lost):

#<CustomError: Error message>
preserve_error_backtrace.rb:10:in `rescue in call_the_error_raiser'
preserve_error_backtrace.rb:7:in `call_the_error_raiser'
preserve_error_backtrace.rb:14:in `<main>'

You can still access the "Original error" backtrace via Exception#cause, but it may be better to preserve the original while raising the custom error, instead of generating a new non-helpful backtrace:

raise CustomError, "Error message", e.backtrace

Output (the cause of the original error is on the first line):

#<CustomError: Error message>
preserve_error_backtrace.rb:4:in `raise_error' ← The cause of the error
preserve_error_backtrace.rb:8:in `call_the_error_raiser'
preserve_error_backtrace.rb:14:in `<main>'

References:

• Nested errors in Ruby with Exception#cause at Honeybadger blog
• Exception#cause docs

curl --data "deploy[revision]=$(date -u +%Y%m%d%H%M%S)_$(git rev-parse --short HEAD)&api_key=$HONEYBADGER_API_KEY" "https://api.honeybadger.io/v1/deploys"

Params:

• $REVISION - revision id. can be an arbitrary string value. In this example revision id is based on current timestamp (presumable date and time of deployment) and head revision id for the current working copy. Example: 20230723092717_00a9703.
• $HONEYBADGER_API_KEY - Honeybadger API key.

Getting Honeybadger API key:

Project page → Settings → API keys

Ansible task:

- name: clone or update sources
  ansible.builtin.git:
    # ...
  register: git_result

- name: notify honeybadger.io about the deployment
  community.general.honeybadger_deployment:
    token: "{{lookup('env', 'HONEYBADGER_API_KEY')}}"
    environment: "production"
    user: "ansible"
    revision: "{{git_result.after}}"
    repo: "{{git_url}}"

References:

• Honeybadger docs

It requires github-backup to be installed:

brew install github-backup

#!/usr/bin/env bash

set -e -x

# Github repos will be cloned in subdirectories here
GITHUB_BACKUP_PATH=~/github-backup

# Archived repo snapshots will live here
ARCHIVE_PATH=~/Yandex.Disk.localized/

CURRENT_DATE=$(date +%Y%m%d-%H%M%S)

function backup() {
  echo "---> $1/$2"

  github-backup \
    --incremental \
    --repository $2 \
    --repositories \
    --token $GITHUB_BACKUP_TOKEN \
    --output-directory $GITHUB_BACKUP_PATH/$1/$2 \
    --starred \
    --followers \
    --following \
    --issues \
    --issue-comments \
    --pulls \
    --pull-comments \
    --pull-commits \
    --pull-details \
    --labels \
    --wikis \
    --gists \
    --private \
    --fork \
    --releases \
    $1

  ARCHIVE_FILE=$ARCHIVE_PATH/$CURRENT_DATE/$CURRENT_DATE-$1-$2.tar.gz
  mkdir -p $ARCHIVE_PATH/$CURRENT_DATE
  tar --verbose -cz -f $ARCHIVE_FILE $GITHUB_BACKUP_PATH/$1/$2
}

# Usage: backup <username-or-organization> <repo-name>

backup dreikanter notes
# Add more repos here

Upload backup files to the cloud with rclone:

rclone sync --verbose=3 --interactive $ARCHIVE_PATH remote:github-backup

<snippet>
  <content><![CDATA[
RSpec.describe ${1:subject_class} do
  subject(:${2:subject_name}) { described_class }
end
]]></content>
  <tabTrigger>spec</tabTrigger>
  <scope>source.ruby</scope>
</snippet>

pg_dump --username=DB_USER --format=custom --compress=9  --file=DB_NAME.dump  DB_NAME

(To generate dump file name dynamically, use --file=$(date +%Y%m%d)_DB_NAME.dump. Could be helpful for backup scenarios.)

Download the dump to the target DB server:

scp -i ~/.ssh/PRIVATE_KEY USER@HOST:DB_NAME.dump ~/

Restore the dump on the new server:

pg_restore --username=DB_USER --create --dbname=DB_NAME DB_NAME.dump

sudo apt-get update
sudo apt-get install software-properties-common
sudo add-apt-repository ppa:canonical-chromium-builds/stage
sudo apt-get update
sudo apt-get install chromium-browser

Creating screenshot:

chromium-browser --headless --hide-scrollbars --no-sandbox --window-size=1280,1024 --screenshot=screenshot.pdf http://example.org/

Saving a page to PDF:

chromium-browser --headless --hide-scrollbars --print-to-pdf=page.pdf https://example.com/

References:

• https://chromium.woolyss.com/
• https://gist.github.com/addyosmani/5336747
• https://askubuntu.com/questions/79280/how-to-install-chrome-browser-properly-via-command-line
• https://chromium.googlesource.com/chromium/src/+/lkgr/headless/README.md

ansible all --inventory INVENTORY_FILE --user REMOTE_USER --module-name ping

Short version:

ansible all -i INVENTORY_FILE -u REMOTE_USER -m ping

Drop --user if it present in the Ansible configuration file.

Example:

ansible all -i ./inventory/production -m ping

Sample output:

X.X.X.X | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
Y.Y.Y.Y | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

References:

• Using Ansible hosts pattern
• Ansible inventory
• Ansible Ping module

It merges the class names list into a string, supporting optional conditions. Very similar to the classNames JS function.

The example from the PR demonstrates the way a new helper improves readability for a conditional class names generation in a view:

Before:

<div class="<%= item.for_sale? ? 'active' : '' %>">

After:

<div class="<%= class_names(active: item.for_sale?) %>">

class_names is an alias to the more generic token_list that must be a semantic generalization for non-CSS use cases.

References:

• Rails API docs: ActionView::Helpers::TagHelper#class_names

git -C ~/public_notes rev-parse HEAD

Output example:

bf27c74435e836ef3ef43ccc4e01d3e4fd708201

Short id:

git -C ~/public_notes rev-parse --short HEAD

Output example:

bf27c74

Updating Bundler:

bundle update --bundler

Note:

• Gemfile.lock may lock Bundler version with BUNDLED WITH value.
• Gemfile.lock may cause an alternative bundler version installation during bundle install.

Update system gems:

gem update --system

Getting gem paths and other environment variables:

gem env

Updating rbenv with Homenrew:

brew update
brew upgrade rbenv

Installing new Ruby version with rbenv:

rbenv install 3.2.2
bundle install

• make your writing more thoughtful,
• motivate fact checking and adding references,
• get deeper understanding of the subject,
• and proofread everything thoroughly.

If you make your knowledge public, you learn better. This alone is a sufficient reason for the personal notes publication.

user = User.find(1)
user.update!(password: "new password")