← Home

How I Do My Computing

Last updated: 2024-09

Computers are both an interest of mine and part of the everyday equipment I use for my work and my hobbies/other interests. As a result, I use them a lot. I also have opinions about how I like to use them and I have deep beliefs about the role of computing in everyday life and how computers a politicised space; despite the fact they’re not often seen as such. This page gives a detailed overview of how I go about using computers and computing devices.

Table of Contents

Priorities, goals, and values

I have the following goals, values, and priorities when using computers:

The result of these goals is that I tend to do my computing in a particular way. I like small, minimal, pieces of software that are very good at one thing and are composable into larger workflows. This is basically what the Unix Philosophy is.

I prioritise applications that are lightweight and don’t rely on many external libraries, or at least rely on standard libraries that I will most likely have installed. I have a slight preference for things which are compiled rather than interpreted due to not needing an interpreter installed. I do have Python installed on my system but won’t install something like Ruby just to use one or two tools; I’ll string something together in Bash using curl and jq if I need to.

When producing work, I like a separation between the ‘source’ of something and the end result and it’s even better if I can write something and then turn it into many different formats/things. This means that a lot of my workflow involves ‘compiling’ documents from sources formatted in Markdown or LaTeX.

I use the commandline a lot as it better matches how I think of computing as a conversation between myself and the machine and I can work better in it. It took me a while to get into the commandline but as I grew to use it more and more I found that it’s much more suited to my brain – it’s much less distracting to me and feels nice and cosy.

I don’t think I’m cool for using the commandline, or that everyone else is a ’noob’. Computers should help people do their work. When I get frustrated at other people’s systems and applications, it’s because the software is generally either: non-free software locking people into a particular workflow; ‘cloud’ applications that are running on a browser and making the entire machine chew up resources; or badly produced heavy, bloated, applications that run really slowly and make people think they need to buy a new machine. Or all of the above. I do not get frustrated at humans wanting to use their systems how they want.

In terms of hardware, I try my best to only purchase used machines/devices, I have no strict rules around how old the device is but “new-to-me” is more than good enough and I usually set a budget of ~£100 for smartphones/peripherals and ~£500 for desktops and laptops. As a rule of thumb, I’ve found this gets me hardware that’s around five years old and in good condition at any given time.

After purchasing them used, I try to use machines and devices myself for as long as possible. In an ideal scenario I only replace a machine or device when it’s beyond my ability to repair and ideally I use some computing machinery for at least five years. I do deviate from this sometimes when a friend/loved one would benefit from one of my machines and I can use the opportunity to swap out for something else if I’ve had my eye on it for a while.

My Machines and Devices

In brief:

I regularly use two machines for my computing as well as some smaller devices for specific tasks. My main machine is a small-footprint desktop workstation which balances power, electricity-consumption, and is reasonably user-repairable/upgradeable. I mostly use my laptop in specific circumstances such as if I’m wanting to write/do work on a comfy sofa or in a library, or if I’m travelling.

You can find more details of these machines on my “Uses page”:

Other than my real computers, I own a smartphone for doing phone things which mostly consists of messaging these days. It runs a de-googled version of Android. I also use my e-reader a lot and it is the device I’ve owned the longest (since 2012).

I also have a few games consoles. I don’t play video games very much but I do enjoy the odd game. I have various PlayStations (PS2–PS4) stored in my loft, as I don’t use them a lot or they’re broken but I want to keep them around to play with my daughter when she’s old enough. Our house also has a Nintendo Switch which floats slowly between my wife and I. Most of these consoles were bought second hand.

Device breakdown and history

This section contains a list of my computing machines and devices both current and historical.

My attitude to computing machines and devices has changed over the years, and now I value purchasing second-hand machines and trying to service/repair/use them for as long as possible before replacing them. This wasn’t always the case. I will occasionally ’treat’ myself to an upgrade which I don’t technically need, but only if I can pass on the incumbent device onto someone who can legitimately benefit from it. These days, I ensure that even my upgrades are used machines unless there it’s impossible to find something appropriate in secondhand markets.

The following entries contain a model’s release year where possible, the year I purchased it, and where/how I purchased it. This will hopefully help me understand, track, or confront cases where I’m deviating from my principles. They are ordered in ascending order of purchase date.

Current devices (including back-ups). These are machines and devices which I currently own and can expect to use on a regular or semi-regular basis. I’ve included back-up devices in this category because I maintain the software installs on these to ensure they’ll be useful if needed.

Survivors. These are the machines and devices which I no longer own or can expect to use often but which I sold or gave to others and therefore did not throw them away or recycle them. Sadly, doesn’t guarantee that these devices are still functioning, only that they survived me and that the new owner intended to use them long-term.

Graveyard. These are the machines and devices which I cannibalised, threw away, or recycled myself because I could not repair them and saw them (rightly or wrongly) as being at the end of their serviceable life.

GNU/Linux

This sort of deserves its own section because I couldn’t quite figure out where else to put it.

I’ve been a GNU/Linux user since early in 2008 when I was 16. I started using Ubuntu 7.10 and then Ubuntu 8.04 soon afterwards. It’s an understatement to say that this changed the course of my life. I’ve always had a GNU/Linux machine in my possession since then and I’m now at the point where I pretty much don’t know how to operate a Windows machine. This also, sadly, isn’t an exaggeration. I find modern Windows computers to be incredibly unintuitive and not very user friendly at all. I really don’t know how people use them on a daily basis, but I suppose they mostly just open up a web browser these days. It could just be that I’ve not kept pace with the evolution of the Windows UI and I’m out of touch.

In any case, except for my wife’s employer-issued laptop — which does run Windows — all of the machines in our house run GNU/Linux. I don’t really take part in the tribalism surrounding distros but I like Debian-based distros due to a combination of cosy nostalgia, package stability, Debian’s commitment to Free Software, and liking the software that’s in the repositories.

My desktop and laptop each run Devuan Stable. I migrated from Ubuntu to Debian because Ubuntu started making changes I didn’t like, and I started using Devuan fairly soon after this because the initial switch reignited my passion for GNU/Linux and I ended up reading a bunch of stuff about systemd and forming an opinion on it.

My installations are relatively minimal as far as Debian-based distros go because I choose no graphical environment during system installation. Once up-and-running with wifi on the tty, I install X.org and my window manager of choice and then I’m away.

My wife’s laptop runs on Linux Mint which she finds very usable, and when it comes time to refresh the installation I will probably migrate her to the Linux Mint Debian Edition mostly so that I know how the machine works as I’m less familiar with Ubuntu these days.

Keyboard Warrior

I mostly use a keyboard to accomplish tasks where I can and I am always trying to find ways to reduce my need for a mouse. This has been the result of about a decade-long shift into my current style of computing; I didn’t consciously decide to start this journey but it’s one I’m glad I ended up on.

My main motiviations for this are ultimately that I find keyboards to be much more ergonomic, user-friendly, and work-appropriate than using a mouse. Obviously there are some tasks which require the use of a mouse such as graphical editing software etc., however I find that 9 times out of 10, I can accomplish what I need more comfortably and much quicker using a keyboard.

This isn’t me being snarky. I don’t look down upon people who want to use or feel more comfortable using modern GUIs and interfaces. My increased useage of CLI tools for work and pleasure meant that I was living partially in a unified, keyboard-driven, computing environment and every time I had to reach for the mouse or trackpad it broke me out of that space. This felt like — and still feels like — velco ripping in my brain. I also find that my wrists hurts the more I use the mouse so I try to avoid it now (getting old is fun). The more I can tip the balance in favour of keeping my hands on the keyboards, the happier and healthier I am.

I drive my workflow using the keyboard with a few key tools and decisions:

I have a few nemeses when it comes to keyboard-driven workflows. These are areas where I’m liable to get ripped out of my cosy environment into the harsh and painful world of mouse-usage.

Keeping $HOME organised

I like to keep a tidy Home folder. I mostly use the XDG Base Directory specification where possible for things like config files and data shared between programs:

Other than that, I like to organise my files into a hierarchy that makes sense and that I can use to find things very quickly. I tend to use the type of file first e.g. “audio”, “image”, “literature” etc. and then get narrower. I also distinguish between “documents” i.e. “paperwork” or things I will need to refer to later, and pieces of work that I’ve written.

I do not like to use capital letters or spaces in my folder or file names to minimise keyboard faff, and also because I think it’s easier to read in terminal output.

Here’s the output of running tree -d -L 2 in my home folder:

├── audio
│   ├── audiobooks
│   ├── music
│   ├── podcasts
│   └── recordings
├── data
│   └── gps-traces
├── documents
│   ├── _archive
│   ├── clubs-and-memberships
│   ├── education
│   ├── employment
│   ├── family
│   ├── finance
│   ├── health
│   ├── home-and-property
│   ├── insurance
│   ├── legal
│   └── travel
├── downloads
│   ├── firefox
│   ├── signal
│   ├── transmission
│   └── youtube-dl
├── games
│   ├── gb
│   ├── gba
│   ├── gbc
│   ├── n64
│   ├── ps1
│   └── ps2
├── images
│   ├── photos
│   ├── screenshots
│   └── wallpaper
├── literature
│   ├── articles
│   ├── books
│   ├── comics
│   ├── dissertations
│   ├── magazines-and-journals
│   ├── manuals
│   ├── newspapers
│   └── pamphlets
├── opt
│   └── [ … some additional software ]
├── planner
│   ├── logs
│   ├── money
│   ├── todo
│   └── workbooks
├── videos
│   ├── home-video
│   └── media
└── workspace
    ├── odsc
    └── personal

I also have my dotfiles available at ~/.dotfiles, which means they’re instantly available but hidden by default when I open my file browser. The same is true of ~/.scripts. My dotfiles are all symlinked using stow.

My ~/data folder currently only contains GPS traces of my runs, hikes, and cycling commutes. I have some data hoarding tendencies so I am toying with the idea of downloading and archiving open data sets here. Otherwise, I may delete this folder and move my GPS traces into my planner folder. You can read more about my ~/planner folder in a blog post I wrote a while ago.

I have each ~/images/photos and ~/video/home-video organised via date inspired by the ISO 8601 format. For example a photo taken on the 1st of October 2024 will be available at ~/images/photos/2024/10/01/name-of-file.jpg.

The ~/opt folder contains software that I have to download manually because it’s not in my distro’s repos. This will be things like the Tor Browser, tremc, some AppImages if necessary, or the latest version of Blender.

I have $XDG_DESKTOP_DIR set to ~/workspace. This means I don’t waste the folder and can make use of it for work. Luckily, my window manager doesn’t render any of the contents as icons on the desktop (I’ve always turned this feature off anyway). This folder contains all of my productive work in both professional and personal contexts, and is subdivided based on organisation/context — currently just my employer and myself — and then based on project area. One can expect to find such things as git repos and folders of vector art or working documents here.

Doing Work

In brief:

I try to do the majority of my work locally on my machine where possible. Besides the obvious benefit of actually using the computing power in my possession, it means that I can continue to work without a network connection. This minimises disruption if my home internet goes down but also allows me to travel to cosy spaces such as libraries and cafés to do work if I want.

Most of my computing revolves around reading and manipulating text, or working with data. This encompasses things such as writing prose, writing code, etc. For these things I use my trusty local text editor where possible alongside some appropriate tools to compile my work into a more finished state. For example I use a static site generator to generate websites from Markdown files, use Pandoc to convert Markdown or LaTeX to PDF (or other formats), or a programming language’s compiler to produce a binary (not very often these days).

In my day-job I’m often required to use crappy non-free software, or bloated cloud applications to collaborate. However horrid they may be, these are a reality of the world we currently live in. I use these applications to do do videoconferencing and shared documents with others. Where possible, I try to write the first versions of the documents myself in Markdown on my machine and upload these later.

I don’t do productive work on my phone, but I use a notes app occasionally to jot something down.

Programming and Scripting

I love programming and scripting but I don’t get to do it much these days. Despite having a Computing Science degree which was mostly geared towards Software Engineering, I have never worked as a professional programmer. My job and hobbies do afford me opportunities to do programming and I relish these, but most of my programming these days consists of building tools for myself to support my workflows or simply for the joy of code.

You can find a list of my software projects on the Projects page:

I have a soft preference for compiled and strongly typed languages since I like the speed of compiled binaries and it means I don’t need an interpreter installed to run particular programs. I like a strong type system because it helps me keep data types straight in my brain when I’m reading or writing code.

Despite this my tools of choice appear to be Bash and Python at the moment, although I am experimenting with Rust. I prefer to try things in Bash first as it means I have a nice ecosystem of pre-built tools to play with and all I need to do is make them work with each other UNIX-style. I usually turn to Python when I need to build CLIs as there’s some libraries which make this a lot nicer, although I always feel a little bit sad that I didn’t try harder in Bash.

When using Python for projects I try to only use libraries that are available in my distro repos rather than requiring things in PyPi because I trust my distro repos a lot more than PyPi.

I’m currently experimenting with Rust although my time is limited so I’m taking things slowly working through the Rust Book when I can. I turned to Rust because I wanted to learn a compiled language to write tools which ran faster and saw that the given thing these days is to learn a “C Replacement” language. I looked at Zig, Go, and Rust and landed on Rust mostly because it looked the easiest to approach due to its expansive library/package ecosystem. That it’s sponsored by Mozilla rather than Google may have also played a factor.

I’m still forming an opinion on whether I trust crates.io as I have the same apprehension about it that I do about PyPi – namely that I like to have things like libraries installed via my system’s package manager. I don’t know enough about its internals to pre-judge it and I still use it because while I’m learning the language I will do things “the Rust way” rather than complicate things for myself.

In the past I have used Java and PHP a lot. My undergraduate degree used Java as a teaching language and then I used it to write Android applications during my PhD. Looking back, I like Java a lot in terms of readability and features but I don’t like that running Java code requires a runtime environment. In an ideal world, I would be able to write Java code and then use a compiler to produce a single platform binary like with C or Rust etc.

Java is also famously very Object-Oriented and this isn’t how I want to program all of the time. I like imperative programming with simple structs and passing these to functions as I like a separation between data and logic, however I don’t strictly dislike Object-Oriented stuff. I like the theory of functional programming a lot but I’ve yet to sit down and learn to program this way. I might do this as part of my Rust journey.

I have also written some PHP applications for the web. During my PhD I built several web tools in PHP, and when this website was an Indieweb site I built it in PHP as well. I used the Symfony PHP framework to do most of this, although it’s been a long time since I used it and Symfony has moved on a lot since then.

Other than this, I will use whatever language I am required to for a given task. For example I have written a few Minetest/Luanti mods which required me to use Lua. I have no strong opinions about Lua but it was pleasant enough to write in and I didn’t really use any Lua-specific features other than tables.

Some example workflows

A lot of people blog about the tools they use and how they use them at a high level but I thought I’d share some examples of relatively low-level workflows for various tasks to demonstrate how I go about accomplishing them.

I’ll add to this section as and when I can.

Adding music to my library

  1. If necessary, create a folder for the artist underneath ~/audio/music.
  2. If necessary, create a folder for the album/EP underneath the artist and either studio-albums/, live-albums/, eps/, compilation-albums/ etc. appropriately.
  3. Copy the files/directories to the artist folder
  4. Run nnn manually from the terminal to open in the working directory, then hit r to open batch-rename mode using my text editor.
  5. Rename all the albums/EPs etc. using my preferred name convention (YYYY-name-of-album) and exit nnn
  6. Run detox -r * to remove all spaces and silly characters from file names.
  7. Run dir2ogg -r to convert everything to OGG Vorbis format, if necessary
  8. Run find . -name "*.mp3" | xargs rm to remove all MP3 format files.
  9. Repeat the above command with different file extensions to get rid of album art which may have been included in the download.
  10. Inspect and change/set ID3 tags using id3 and id3v2 if necessary.
  11. Change workspace to my ncmpcpp instance and hit u to rebuild the database. Inspect the new albums for errors in the tags.
  12. If necessary, do any final tweaking to the tags via easytag.

Checking my assigned CRM tickets at work

At ODSC, we use a CRM ticketing system to manage work and tasks as well as interact with a few clients. It’s web-based, but it has an API.

  1. Hit Ctrl+Alt+P to run a bash script which uses curl to query our CRM’s API for all tickets assigned to me, parses the JSON using jq to get the titles and ticket number, and presents them to me via dmenu and then opens the resultant URL in my browser.

Updating my website

  1. I open a terminal and navigate to the project folder. I open another terminal at the same location using an alias and then make the first terminal take up approx 75% of the screen on the left.
  2. The smaller right-hand column gets another terminal added to it, vertically this time, in which I run hugo server -D.
  3. I do my writing/editing in my text editor using the larger left-hand terminal, and use the upper right one for git and coreutils operations e.g. grep, git status etc.
  4. When I’m done I close my editor and run aspell on the file. I remove the old file when I’m finished in aspell.
  5. On another workspace, I check my work in the browser. This is either a terminal browser for blog posts or Firefox for stuff like CSS.
  6. Repeat steps 3–5 as necessary to iterate on the work.
  7. At the end of the session, run git add and git commit appropriate to the work. Push. If necessary, merge my feature branch onto the main branch (usually for sitewide changes such as changing structures and CSS).
  8. If work is ready to upload, cancel hugo server and run rm -rf public/* as a precaution to ensure there are no links pointing to localhost. Run hugo to generate the site.
  9. Open up filezilla, make it fullscreen on this workspace, and upload appropriately.
-----------------
|          |term|
| nvim     |    |
| aspell   |----|
|          |hugo|
|          |    |
-----------------

Watching Youtube

When searching for a video:

  1. Use an Invidious instance to perform searches in Firefox.
  2. Use the Tridactyl command ;y to yank the url of the “Watch on YouTube” link to my clipboard.
  3. Run yt-dlp with the URL in a new terminal window.
  4. Watch the video using mpv.

When selecting a video of a channel I’m “subscribed” to via RSS:

  1. Open newsboat and navigate to the channel feed, and then the video I’m interested in.
  2. Hit ,+y to tell newsboat to use yt-dlp as a “browser”.
  3. Hit o to “open” the video in the “browser”.
  4. Watch the video using mpv.