The last few years I’ve enjoyed keeping a paper journal of some kind for both personal and work related things. The separation is good so that private work stuff can stay at work, and also so that I’m not looking at work when I should be relaxing or doing other things.

For 2021, I’ve landed on using a Hobonichi Techo (A6) for my personal planner, and a Hobonichi Cousin (A5) for work. The larger size is helpful for work because it gives me room to take notes and sketch out ideas, where for home, I think the smaller size will be nice since I can more easily take it with me.

Another benefit of the Cousin is the integrated weeks pages — the smaller planner has weeks as an add-on book — which I hope will be good for planning out my work tasks. A week at a time is feels like about the right resolution for me to be thinking about work, so I’m hoping it’ll work out well.

Congratulations to everyone on electing Joe Biden President of the United States. No one knows what happens next, but a lot of people worked incredibly hard for this, and all of us have suffered in one way or another under the evil and malice of the last four years.

We all deserve to celebrate today, and then it’s time to win those Senate seats in Georgia.

I’ve been reading all of John Scalzi’s Old Man’s War series of books — of which there are six — and was interested to read this article on his writing process.

I’ve been writing books now for 20 years and my experience really is that it’s not complicated, it’s just mostly sitting down and doing it, one day after another. Inspiration for me happens because I’m writing, not the other way around. In talking with other long-time writers, I’ve learned that’s how it works for most of us.

This reminds me a lot of when I read Stephen King’s autobiography or Anne Lamont’s Bird by Bird. I guess the “sit down each morning and write for a set amount of time“ method is a pretty common one among successful writers.

Just watched the trailer for Hyrule Warriors: Age of Calamity, and I’ll definitely be playing this. I enjoyed the first game, but it felt disconnected from the world of Zelda. It’s exciting that the third-party developer that makes Warriors games are working closer with Nintendo this time to make something that ties into Breath of the Wild.

I feel like I just looked up and realized it was already September? I haven’t even blogged sine May. I could have sworn it was more recent than that. This whole year has been a blur.

What a time to be alive.

Next week will be my third working from home, and there’s no clear date when it will end. I’m still not used to it, but I’m trying to do what I can to stay healthy while we’re all stuck at home. My time has consisted of at least a few of these each day.

1. Going on at least one thirty minute walk a day.
2. Trying to get my father to stay home.
3. Playing guitar.
4. Reading old books about old computers.
5. Blogging and tweeting more.
6. Trying to reassure people who are more worried than I am (and I’m pretty worried).
7. Buying books from my favorite bookstore online so that hopefully they don’t go away forever.
8. Realizing I have to keep in touch with friends better.

This is pretty rough. I have a lot thoughts, and a lot of feelings. It’s hard not to feel anxious all the time, and I can feel things like sleep quality decline.

I know that I’m incredibly lucky to have the kind of job I do and to be in the position I am in. I can’t stop thinking about all the people who aren’t so lucky though. It hurts to think about so many people suffering as much as I’m afraid they might.

BitBar is a free app for macOS which — essentially — lets you create custom menu bar apps from shell scripts or other command line tools. If you can write a program or script (in Shell, Python, C, Swift) and print, you can put something in the menu bar. BitBar also lets you define how often it should automatically refresh each specific script.

My favorite thing I’ve made uses the speedtest-cli tool to refresh what my current download and upload speeds are and show colorized output based on the results.

The script might look strange if you’re not used to awk, but the main thing to know is that $2 (the second space separated for the line) represents the result number and $0 represents the whole line. So I’m grabbing the number and then printing the whole line with a color based on the value. Also, awk is cool and you should learn it.

#!/usr/bin/env zsh

echo "⏱"
echo "---"

/opt/local/bin/speedtest-cli |
awk '/Download/ {
        if ($2 < 25) {
            print $0, "|", "color=red"
        } else if ($2 < 90) {
            print $0, "|", "color=orange"
        } else {
            print $0, "|", "color=green"
        }
    }
    /Upload/ {
        if ($2 < 4) {
            print $0, "|", "color=red"
        } else if ($2 < 9) {
            print $0, "|", "color=orange"
        } else {
            print $0, "|", "color=green"
        }
    }'

Since reading Unix: A History and a Memoir by Brian Kerninghan (of K&R), I’ve been a little enamored with the idea of writing small command line tools. This article titled Hints for Writing Unix Tools hits on a bunch of things, and is worth reading, but one that really jumped out at me was this:

Output should be simple to parse and compose. This usually means representing each record as a single, plain-text formatted line of output whose columns are separated by whitespace. (No JSON, please.) Most venerable Unix tools—grep, sort, and sed among them—assume this.

Trying to parse the output of something like this on the command line is incredibly frustrating:

{
    myThing = "Blah"
    percent = 0.5
    ...
}

However, if the output is tab delimited:

myThing     blah
percent     0.5

Parsing it with Awk, sed, or other Unix filter tool can usually be done as easily as awk '/myThing/ { print $2 }'. I wish more tools paid attention to this. Maybe if you were writing Unix from scratch today, you’d have processes communicate using structured data (I think this is what PowerShell does?), but you have to work with the system you have.

Everyone knows that regular expressions are terrible, but what my theory presupposes, is that a large percentage of the “how can I parse …” questions on places like Stack Overflow that are solved by a crazy regex wouldn’t exist if more tools had sane output.

This post shows the growth of arguments for a bunch of the most common Unix commands over time. The author demonstrates how we went from 99 in 1979 (Version 7 Unix), to 393 in 1996 (Slackware), to 700+ today (Ubuntu). After that, they make the argument that maybe that isn’t inherently a bad thing? Super thought provoking if you think about design or use a shell all day.

If you’re on macOS, you can open man pages in a separate, nicely formatted, window by using the x-man-page URL scheme.

Typing x-man-page://ls, however, isn’t super convenient. This script lets you type xman command_one two... and open each page in a separate window. If it can’t find the command you asked for, it prints a message to stderr. Enjoy!

#!/usr/bin/env zsh

function xman() {
    for i in "$@"; do
        if [ $(command -v $i) ]; then
            open x-man-page://$i
        elif; then
            printf "Can't find command: %s\n" "$i" >&2
        fi
    done
}

I’ve used BBEdit for a long time, but only recently started digging into the scripting side of it. If you’re willing to write your script against it’s scripting dictionary in AppleScript or JavaScript, you can do a lot, including attaching a script to every menu command in the app. You do however have to write a script and put it in the right place before you can use it. Sometimes I’d rather pipe my text through grep 'foo' | sort -u like you can on the command line, and have it format my text for me.

TextMate has exactly this command, so emulating that seemed like a good place to start:

I figured out that I could build most of what TextMate has as a BBEdit Text Filter:

Dr Drang had already done pretty much exactly the same thing, but I wanted my script to remember at least the last command I ran, which won’t work with his approach. To get that, I needed to make a proper AppleScript so that I could take advantage of persistent properties (which is a super useful thing AppleScript can do if they’re saved as an scpt file).

You can copy the script below into Script Editor and save it in script format to BBEdit’s Text Filters folder:

property default_command : "sort"

on RunFromBBEdit(_range)
	set shell_command to the text returned of (display dialog "Enter a shell command:" with title "Filter Through Command" default answer default_command)
	
	if shell_command is "" then
		quit
	end if
	
	set default_command to shell_command
	
	if _range as text = "" then
		set text_content to text of front document
		set results to executeCommand(shell_command, text_content)
		set text of front document to results
		return ""
	else
		set text_content to _range as text
		set results to executeCommand(shell_command, text_content)
		return results
	end if
	
end RunFromBBEdit

on executeCommand(shell_command, text_content)
	set AppleScript's text item delimiters to {ASCII character 13}
	set results_text to text items of (do shell script "echo " & quoted form of text_content & " | " & shell_command)
	set AppleScript's text item delimiters to {ASCII character 10}
	set return_text to text items of results_text as text
	set AppleScript's text item delimiters to {""}
	return return_text
end executeCommand