DEV Community: Oliver Burn

Emacs 2024 Changes

Oliver Burn — Wed, 01 Jan 2025 09:16:08 +0000

Wow, it has been nearly two years since I have blogged - time to see if I can still do it. Let's blog about how my Emacs configuration has changed over the last year (2024).

I have now been using Emacs for over thirty years. It used to be the main IDE I wrote code with, but I have long since moved to a dedicated IDE, these days being IntelliJ and VSCode. But, I still using Emacs heavily into two contexts:

Work - I use org-mode heavily for my personal project management and note keeping.
Home - I use ledger-mode for managing my personal finances.

Across both contexts, I lean heavily on:

Dired as a cross-platform file manager. I used to use Midnight Commander but I found it buggy in the end (on MacOS). Since investing time in learning dired it's good enough.
Magit for using Git - I would be lost without this.

As a friend of mine said when I asked why he kept working on his zsh configuration, "it's my version of golf!". Similarly I am often looking to improve my Emacs configuration. I keep up to date by tracking the blogs of Sacha Chua and Irreal, and seeing what takes my fancy.

In the last year I did 25 commits to my .emacs file (yes, it's under Git source control). Here are the major changes I made over the last year:

For my templating needs, I moved to tempel (from yasnippet). I have found it to be way more powerful and grok-able.
For completions, I finally embraced using corfu, which is nice (especially the integration with tempel). I almost gave up until I realised that I needed to also install cape.
I gave up on trying to use a terminal emulator in Emacs, and instead now use terminal-here to open a proper terminal in the current working directory. This approach works much better for me.
I improved my dired setup by installing dired-single, dired-collapse and dired-subtree. I also learned about wdired-mode which makes the dired buffer editable (a game changer). 🤯
I use asdf and direnv to manage my toolchain at the project level, so to improve the integration with Emacs I installed envrc.

This blogpost was originally posted at https://puppycrawl.com/blog/2024/01/01/emacs-changes.html.

Using asdf to manage my development tools

Oliver Burn — Thu, 12 Jan 2023 06:39:47 +0000

Today I was reminded again of the tool asdf which can manage multiple runtime versions with a single CLI tool. I have been a long-time user of Sdkman for managing my JVM related tool chain (JDK, Kotlin, Gradle, etc), but then I use Homebrew for managing Nodejs, Python, Poetry.

I don't like that this approach as it is not cross-platform (by which I mean Linux and MacOS), and uses a combination of tools - asdf and homebrew.

So I have decided to try out asdf in anger. It's quite easy to get started following the documentation, but the main things to annoy me are:

By default it does not respect existing files like .nvmrc when picking a version of a tool. You need to add legacy_version_file = yes to the file ~.asdfrc to enable this behaviour.
When installing a new tool, it does not immediately register it as the global default. For example, installing gradle requires two commands: asdf install gradle latest and asdf global gradle latest.
It does not handle JDK distributions as well as sdkman, which is hardly a surprise. The support for upgrading multiple versions (11 and 17) is clunky.

So I have written the following script that works around these limitations, and can be used to boostrap and update my asdf installation. Sharing in case it's useful for others.

#!/usr/bin/env zsh
#
# Updates my asdf install. Very basic for now.
#
# Fail quickly
set -e

# Ensure sensible configuration file
rcfile=~/.asdfrc
echo Checking $rcfile...
test -f $rcfile || touch $rcfile
if [[ $(grep -c legacy_version_file $rcfile) = 0 ]]; then
    echo ...adding 'legacy_version_file = yes'
    echo 'legacy_version_file = yes' >> $rcfile
fi

# Update installed plugins
echo Updating installed plugins...
asdf plugin-update --all > /dev/null

# Ensure all the plugins are installed
echo Checking plugins are installed...
for n in java kotlin gradle python poetry nodejs; do
    if asdf plugin-list | grep -cq $n; then
        true # Already installed
    else
        echo ...installing $n
        echo asdf plugin-add $n
    fi
done

echo Updating versions...
# Special Java logic
asdf install java latest:temurin-11
asdf install java latest:corretto-17
asdf global java latest:corretto-17

# Special Nodejs logic
asdf install nodejs lts
asdf global nodejs lts

# The nice ones
for n in gradle kotlin python poetry; do
    asdf install $n latest
    asdf global $n latest
done

echo ...done
echo -------------
echo 'Need to run `asdf uninstall <tool> <old-version>` as necessary'

This blogpost was originally posted at https://puppycrawl.com/blog/2023/01/12/asdf.html.

Using Finicky to handle URLs

Oliver Burn — Tue, 03 Jan 2023 09:00:12 +0000

Context

Let me share the biggest productivity hack I made in 2022. For a while I have been frustrated at the handling of opening URLs on both my work and personal MacBook laptops. I want the ability to open certain URLs in different applications.

For example:

Zoom/Miro/Spotify links in the corresponding native applications.
Specific URLs, like news websites, in the Chrome browser under my personal profile.
Open all URLs in the Signal Desktop using the Chrome browser under my personal profile.
Everything else using my default browser, which is Vivaldi.

Solution

Enter Finicky

Enter Finicky which provides a way to programmatically (in JavaScript) describe how URLs are to be handled. It works by being registered as the default URL handler on MacOS. When it is invoked, it consults the file ~/.finicky.js to determine which application will handle the URL.

The following diagram gives an overview of how the flow works.

I installed Finicky using brew install --cask finicky, and found the documentation to be excellent. I will now describe my current configuration.

Defining a default handler

Since I use Vivaldi as my default browser, the following snippet defines how a URL will be handled by default.

module.exports = {
  defaultBrowser: "Vivaldi"
}

Defining specific native handlers

The following snippet shows how to define handlers for different native applications.

module.exports = {
  handlers: [
    {
      match: "open.spotify.com/*",
      browser: "Spotify"
    },
    {
      match: [
        /miro.com\/app\/board\//,
      ],
      browser: "com.electron.realtimeboard"
    },
    {
      match: [
        /zoom.us\/j\//,
      ],
      browser: "us.zoom.xos"
    },
    {
      match: [
        /https:\/\/atlassian.slack.com\/archives\//,
      ],
      browser: "Slack"
    }
  ]
}

Opening specific URLs in Chrome

The following snippet shows how to open specific URLs in my Google Chrome browser, using my personal profile.

module.exports = {
  handlers: [
    {
      match: [
        finicky.matchHostnames([
          /abc.net.au$/,
          /news.com.au$/,
          /smh.com.au$/
        ]),
      ],
      browser: {
        name: "Google Chrome",
        profile: "Profile 2"
      }
    }
  ]
}

Opening all URLs from Signal Desktop

Since I use the Signal Desktop for personal use only, I want to open all URLs from Signal using the Chrome browser under my personal profile. The following snippet shows how to achieve this.

module.exports = {
  handlers: [
    {
      match: ({ opener }) =>
        opener.bundleId === "org.whispersystems.signal-desktop",
      browser: {
        name: "Google Chrome",
        profile: "Profile 2"
      }
    }
  ]
}

Complete configuration

Here is what my ~/.finicky.js configuration looks like.

// See https://github.com/johnste/finicky

module.exports = {
  defaultBrowser: "Vivaldi",
  handlers: [
    {
      match: ({ opener }) =>
        opener.bundleId === "org.whispersystems.signal-desktop",
      browser: {
        name: "Google Chrome",
        profile: "Profile 2"
      }
    },
    {
      match: "open.spotify.com/*",
      browser: "Spotify"
    },
    {
      match: [
        /miro.com\/app\/board\//,
      ],
      browser: "com.electron.realtimeboard"
    },
    {
      match: [
        /zoom.us\/j\//,
      ],
      browser: "us.zoom.xos"
    },
    {
      match: [
        /https:\/\/atlassian.slack.com\/archives\//,
      ],
      browser: "Slack"
    },
    {
      match: [
        finicky.matchHostnames([
          /abc.net.au$/,
          /news.com.au$/,
          /smh.com.au$/
        ]),
      ],
      browser: {
        name: "Google Chrome",
        profile: "Profile 2"
      }
    }
  ]
}

Footnote

This blog was originally posted on my personal blog. I have decided to start writing my non-work blog posts here and then cross posting to either my work or dev.to blogs.

Since I joined Atlassian I have publicly stopped blogging, but in reality I have been blogging more than ever. In 2023 I am experimenting with making certain blogs more widely visible.

Advent of Code and Dash API Browser

Oliver Burn — Tue, 06 Dec 2022 23:44:37 +0000

Each year when I do the Advent of Code challenge I use it as an opportunity to learn a new language or tool chain. This year I am writing in Java 17 (I have not used Java since Java 8), along with Eclipse Collections, and using VS Code as my IDE.

Since I have never used Eclipse Collections before, I have installed the API documentation into Dash for macOS, which is an API Documentation Browser and Code Snippet Manager. I have used Dash for a long time, and love the integration with Alfred to quickly lookup documentation for a method/class.

Despite using Dash for years, I only just discovered the search profiles feature, which allows you to define a custom collection of docsets search, rather than all documentation. Very handy when wanting to filter down and ignore other large docsets like Spring or Kotlin. The custom docset can be triggered by multiple things like a keyword, or the fact that an application like VS Code is open.

Another nice touch is that the keyword is integrated into Alfred.

The only frustration I have with Dash is that it does not understand inherited methods for Java types. So for a while there I was struggling to understand the true power of Eclipse Collections, as I could not see all the available methods on a type. The only workaround I have is search on the page to find "Methods Inherited". It is rather sub-optimal.

eom.

My toolchain changes in 2020

Oliver Burn — Sun, 20 Dec 2020 03:08:11 +0000

This page describes the changes I made to my toolchain in the last year. True to my writing style, this will be short and (hopefully) sweet.

The changes in (roughly) decreasing significance:

Switched to using Zsh along with the Oh My Zsh framework. I have used Bash for about 30 years, so this was not done lightly. The killer plugin is zsh-autosuggestions, which provides Fish-like suggestions. Very addictive.
Moved away from Firefox to the Vivaldi Browser. It took a bit of getting used to, but it seems to come with almost all the plugins/extensions that I require built in. The Quick Commands capability is excellent. I feel a bit sad as I realise that this is just Google Chrome re-skinned.
For my personal machine, I switched to running Fedora Linux, as I have a love/hate relationship with Ubuntu. So far I am coping just fine, and it feels more developer friendly.
I learnt to use the Org Capture extension for Vivaldi/Chrome and Firefox. This was a game changer for me at work, as I can use it to track what web pages I need to review. I use Org Mode to run my work life.
I switched to Counsel from Helm. I was motivated when Helm was discontinued for a short period of time, and I found that Counsel felt faster and worked for my use-cases. Note, I have not found a replacement for helm-org-rifle to search my Org files.
I learn to use the Hydra package to create my own contextual menus in Emacs.
I use Ledger for tracking my finances. This year I embraced using the reporting capabilities in ledger-mode, which dramatically improved my work-flow.

That's it.

My Firefox Add-ons in 2019

Oliver Burn — Wed, 09 Jan 2019 04:40:27 +0000

This is the current list of Firefox Add-ons that I am using at work. Sharing here out of (possible?) interest (and so I can have a backup). They are all available via https://addons.mozilla.org/en-US/firefox/.

Auto Tab Discard - Automatically discard inactive tabs to free up resources
Gesturefy - Mouse gesture addon, which supports over 60 different commands and additional features like rocker and wheel gestures.
HTTPS Everywhere - encrypts your communications with many major websites, making your browsing more secure.
Privacy Badger - automatically learns to block invisible trackers. Be warned - it's good at breaking sites!
Shorten me - URL Shortener - shortens links and current tab's url using goo.gl service.
Tree Style Tab - provides tree-style tab bar, like a folder tree of Windows Explorer. New tabs opened from links (or etc.) are automatically attached to the parent tab. If you often use many many tabs, it will help your web browsing because you can understand relations of tabs.
uBlock Origin - an efficient blocker. Easy on CPU and memory.
YouTube High Definition - let's you play all YouTube videos in HD and change video player size automatically.

fzf is my tool discovery of 2018

Oliver Burn — Sat, 29 Dec 2018 12:08:22 +0000

This year I discovered the command-line tool fzf by accident while experimenting with Vim plugins (long story).

In the words of the website:

It's an interactive Unix filter for command-line that can be used with any list; files, command history, processes, hostnames, bookmarks, git commits, etc.

It very quickly become an indispensable tool that I use on Linux and macOS. Examples of how I use it are:

Search my command history.
Combined with z it makes it trivial to navigate around previous directories.
I use the following script to select an account from the file accounts.ledger before running ledger.

#!/bin/bash
account=$(sed 's/^account //' accounts.ledger | fzf)
if [[ $account != "" ]]; then
    ledger reg $account "${@}"
fi