TILs on Leon Mika

Sun, 12 Jul 2026 09:39:07 +1000

I saw someone strapping a hockey stick with a unicycle beside them the other day. It was a little odd, but I didn’t think much of it, until today when I saw a few other people with hockey sticks pushing unicycles towards a gym. It’s when I realised that Unicycle Hockey is a thing. TIL.

Vibelog: Weatherpatch - UI Improvement

Sat, 04 Jul 2026 16:13:28 +1000

A few weeks ago, I vibe-coded a web-app called Weatherpatch. This is an app that is designed to receive email newsletters and produce them as an RSS feeds: basically what Feedbin does, but without needing to use Feedbin. The app was vibe-coded with Opus, and while functional, it is hardly an example of good design (unless you’re a fan of Cubism). To wit:

Yeah, Opus just threw the feed management controls all over the place. And I tolerated it for a time. I was more interested in having something functional, rather than pretty. But the thing about a bad UI is that it makes using the app feel bad. Sure I’m not in there managing feeds, but I would like to go in there are copy-paste the email address when setting a new one up.

Seeing that Fable is available again (thanks, US government, I guess?) and that I haven’t given it a proper shakedown test last time, I figured it was worth throwing it at the problem, and seeing if it could fix the design Opus threw together. I also wanted to try out the frontend-design plugin. Here’s the initial prompt:

The UI design of this webapp is quite primitive. While functional it doesn’t make it pleasant to use. Can you propose an improved design? Don’t change the underlying technology: just the UI and styling.

It took a while, but came up with the following diagnosis:

Fable’s diagnosis of the issue

What makes the current UI feel primitive

Looking at the templates, three things stand out:

It’s stock Pico. Default palette, default type — it looks like every Pico demo, with no identity of its own.
Every feed card shows its full management UI all the time. Each card carries a rename input, rename button, delete button, merge dropdown, and merge button — with ten feeds that’s fifty always-visible controls for actions you perform maybe once a month. The thing you actually want from a feed (its URL) is buried among them.
Raw 60-character URLs dominate every card. The random slugs are unguessable by design, which means they’re also unreadable — printing them in full conveys nothing.

Proposed direction: “Synoptic chart”

The name weatherpatch is a gift — the app is essentially a weather station for newsletters, with feeds as stations reporting in. The direction leans into meteorological chart vernacular, kept quiet and instrument-like, since this is a tool you visit briefly, not a marketing page.

Palette — cool “chart paper” background (#F4F7F6), slate ink (#22303A), isobar blue for links (#33636F), and one accent: RSS orange (#D95B10). The orange is subject-grounded — the whole point of the app is producing RSS — and it’s used sparingly: the logo dot, the copy button, focus rings, the RSS chip.
Type — IBM Plex Sans for UI, IBM Plex Mono for everything machine-ish: the inbound address, URLs, section labels. Monospace is load-bearing here, not decorative — the app’s most characteristic artifacts are random strings. (In production I’d embed the woff2 files in static/ alongside the CSS so the single-binary, no-CDN property holds; system-font fallbacks if you’d rather add zero bytes.)
Signature element — the inbound address as a station call-sign: a hero panel at the top of the dashboard with the address in large mono type, one prominent “Copy address” button, and a faint set of isobar contour lines etched behind it (inline SVG, centre labelled “1013”). One place of boldness; everything else stays disciplined.

The UX changes (bigger win than the styling)

Progressive disclosure. Rename/merge/delete move behind a native <details> “Manage” disclosure per card — no JavaScript needed, and each card collapses to one line: title + two chips.
URLs become copy chips. RSS and JSON chips copy the URL on click (your existing data-copy handler works unchanged — the chips just carry the attribute). The full URLs remain visible as plain links inside the Manage panel for the times you want to open or inspect them. Copying is the primary use of a feed URL, so it gets the primary affordance.
A real empty state and a properly styled login card with a styled error alert (currently an inline style=“color:#b00020”).
Microcopy tightened throughout: “Give this address to every newsletter you subscribe to. New senders show up below as feeds.”

What stays and what changes

Everything server-side stays as-is: Go templates, Fiber, embedded assets, POST-redirect-GET forms, app.js patterns. The change is replacing pico.min.css (~80 KB) with a hand-rolled weatherpatch.css (~8 KB) — same delivery mechanism, and at three pages the custom stylesheet is small enough to own outright. Template edits are modest (the <details> structure, chips, hero panel).

Two optional extras that would touch Go code lightly (no technology change, just flagging since you said UI-only): per-feed item count and last-received date — the data is already in SQLite and would make the dashboard feel like stations actually reporting — and a favicon route using the RSS-arcs logo mark.

It also produced a mockup in a static HTML file, which was quite an improvement over what was there. I then went back and forth with it a couple of times, asking it to move command arguments to modals, and have it produce a mock with more than a handful of items:

Okay, that’s a good start. I do wonder if it’d be worth merging the actions onto a single line. Maybe have “Rename, Merge” on the left and “Delete” on the right. The Rename and Merge buttons will display modal dialogs prompting for the input: a text field rename, and a select list (not a drop-down) for the merge. Delete will be on the right, and show a confirmation dialog as a modal. Use HTML dialog elements for this. Add any JavaScript you need, but keep it vanilla JavaScript.

[…]

Can you demonstrate how this would look with 30 feeds? I just want to make sure the Merge feed can handle that many feed items in the modal. I’m think we need to make sure the list doesn’t grow too large.

I include in this gallery various screenshots in how the mocks evolved during this time.

First version of the mock which, while prettier, was quite similar to the old UI in that the controls were just present on each card.

The mock after I asked Claude to place input items in modals.

The rename modal.

The merge feed modal.

The delete confirmation modal, which previously used the browser's 'confirm' function.

A modified merge feed modal after I asked Claude to consider a large number of feeds.

After about half an hour of this, it was good enough to get Claude to implement it. I deployed the changes, and now the UI looks pretty decent.

So all in all, I’m impressed. I would like to know how much of this was down to Fable, and how much of it was the frontend-design plugin. I don’t expect to be using Fable often, given how expensive it is. But for a large job like this, it did a good job.

Vibelog: Show As Table - A DSL In a Hurry

Sun, 28 Jun 2026 11:36:12 +1000

I was asked to make a couple of diagrams for the purpose of showcasing a database design. These diagrams were mainly used to show the relationship between entities, so I chose to use TLDraw for this. But there was a need to add some example rows, which TLDraw does not make easy. Furthermore, there was a bit of a push to get this done quickly, as these were to be shown to various stakeholders the next day.

Given all this, I thought it was worth asking Claude to make a tool to generate a table as an image from a DSL.

The initial prompt

Please generate for me a Go application which takes a DSL of the following form:

```
Title

Name Value
“Name2” “Value2”
```

It is to render this as a “card” with Title appearing above a box which contains two columns: the left containing the name and the right containing the value. The columns are to be presented as two columns of a table that will rendered as this: [Image #1]

The result should be a PNG that I can include in another diagram.

In short, I was to provide the data in the form of a table, and the tool Claude wrote is to generate it as an image, that I could import into TLDraw. Here’s an example:

Key Value
First John
Last Smith
Address "123 Fake St."
City Melbourne

This was my first attempt at using the image upload for Claude Code, with the intent of producing something that that mimics it. I don’t have it handy with me but the image was of a table rendered in a GUI of a database client of some sort (I didn’t pick the table, someone else took a screenshot and said “make it look like this”). And Claude managed to get it looking pretty close. It originally chose to use the builtin Golang fonts, but switched Jetbrains Mono for the headers and Inter for the table cells, after I asked it to use a more “professional” font.

From there, the DSL evolved as the needs of the task arise, without any grand vision of it’s design. The diagram title was dropped, comments in the form of lines beginning with hash were added, and a row could be highlighted by prefixing it with a *. How Claude did this was up to it. It was given pretty-much free reign in many of details, including how to highlight a row (it chose to do so using a yellow background):

Key Value
First John
# Middle None
Last Smith
Address "123 Fake St."
City Melbourne
* Registered Yes

The DSL eventually extended to include tables with multiple columns.

Prompt to add multiple columns and highlights

Please also add support for multiple columns, i.e. more than 2. And any row that begins with a * should be highlighted, e.g *name value (do not include the leading star)

Key          "Person 1"      "Person 2"
First        John            Mary
Last         Smith           Smith
Address      "123 Fake St."  "456 Fake Rd."
City         Melbourne       Sydney
* Registered Yes             No

And multiple tables stacked vertically, with matching cell widths.

Prompt to stack multiple tables

Okay. I would also like you to support dividers between subsequent tables. When I have a line of the form “—”, it will indicate that I want two tables, positioned vertically, with a transparent gap between the two of about 1.5 times [since updated to be 1/2 that] the row height. The column sizes of both tables should be the same, in that they should be wide enough to fit whatever the widest cell of both tables.

Key          "Person 1"
First        John
Last         Smith
Address      "123 Fake St."
City         Melbourne
* Registered Yes
---
Key          "Person 2"
First        Mary
Last         Smith
Address      "456 North Fake Road, South"
City         Sydney
Registered   No

Finally, a dark-mode was added. The colours were taken from a fork of this where someone added a dark mode directly. I wanted the ability to invoke dark mode via a switch, and simply adopting the fork meant I would loose the multi-table features I asked Claude to add. So I copied their version of the source, and asked Claude to crib the colours from it:

Prompt to add dark mode

Okay. Someone has forked a version of this tool and implemented a dark version. They have shared with me the code located in @dark-version/main.go. Can you please adopt the colour scheme of this tool, and apply it when the flag “-dark” is present.

Key          "Person 1"
First        John
Last         Smith
Address      "123 Fake St."
City         Melbourne
* Registered Yes
"Dark Mode"  Yes

The results were decent, although you can guess that I didn’t actually run this tool in dark mode with a highlighted row.

So, why do I write about this? Not that I need a reason, but I always find these badly designed, hacked together DSLs fascinating. You can learn a lot about using something that’s truly terrible. Using this particular DSL for the task at hand is fine, but I can’t really see myself using it for anything else. Having the table cells defined as white-spaced table columns is not the easiest thing to maintain, let alone something easy to review when checked into Git. Yet it is obvious, and maybe with some better tooling it could be made to work better.

Sat, 20 Jun 2026 11:24:03 +1000

It’s not a proper trip to Canberra without a visit to Tuggeranong. Went to my favourite cafe and walked around the lake, this time in a clockwise direction. Was a lovely morning for it.

Sat, 13 Jun 2026 07:41:04 +1000

It’s hard finding places in the Belconnen area that are opened early, at least during the weekend. Settled on coming here which is more geared towards takeaways. So that does mean sitting outside in the cold air, but the coffee is warm, and the barista just turned on the outdoor heaters.

Thu, 04 Jun 2026 17:12:56 +1000

Touché, Metro. I can understand why you kept us outside of Clifton Hill for 15 minutes. That was some legitimate flooding.

07:15 Although I would add that 10-15 mm hardly constitues a torrential downpour.

Wed, 20 May 2026 08:00:00 +1000

Some minor teething issues with my new headphones. While trying to turn off noise cancelling I pushed a button which paired it with someone’s device, and started hearing their music. Had to resort to getting the app, which doesn’t thrill me, but it’s better than randomly pressing buttons.

Thu, 14 May 2026 15:10:02 +1000

TIAL that sleep is actually not available on the Distroless Docker images, at least from what I can see from Stack Overflow. So if you’re going to use Pod Lifecycle events to wait for requests to finish up, you’ll need some other means of sleeping.

Mon, 13 Apr 2026 20:43:09 +1000

TIL that moon towers, a thing I saw in an episode of Rick and Morty that I thought was completely fictional, are actually a real thing, or at least were. I guess Rick and Morty live in Austin, Texas. 😏

Sun, 22 Feb 2026 08:40:13 +1000

Sometimes a TIL (today I learnt) should really be classified as a WTTMT (wish they told me this).

Wed, 28 Jan 2026 12:23:08 +1000

TIL you can Option drag things that have a MacOS URL scheme into Obsidian to create a link to them. Managed to do this for both a file and an email.

Thu, 15 Jan 2026 05:47:40 +1000

Good morning, everyone. This is a reminder that the orange seats are priority for passengers with special requirements.

Oh, so the orange coloured seat fabric indicates that it’s a priority seat?! I had no idea. I just thought it was because the seats are different. TIL.💡

First Impressions Of Google Antigravity

Sat, 22 Nov 2025 13:03:33 +1000

Well, as predicted, I had a go at using Google Antigravity.

I downloaded last Wednesday to try out the editor and agent. I didn’t have a good idea for it so I simply asked it to produce an additional tool for my suite of online tools: one for dealing with timestamps and timezone conversions. I had plans for this one for a while, although they were relatively vague, it seemed like a good test of Gemini as a coding agent.

I started with a bit of vibe-coding to see how much it could produce on it’s own. Here the prompt I used:

Note the tools located in “site”. I would like another one made that will process timestamps.

The tool will consist of two text boxes side-by-side. The text box to the left will be user input: the user will use this to enter timestamps of various types, with one timestamp per line. On the right will be the output. It is not designed to be editable, but the user should be able to scroll, copy, and otherwise get the text from this pane.

Above the two should be a select picker of operations. Beside that are two radio buttons: “UTC” and “Local”. This is for selecting the given timezone, where Local is the browser’s local timezone.

The way this works is that the user will enter a line of input in the text area in the left. When changed, as long as the line of input is valid, the tool will apply the operation and display the result on the same line as the input in the text area on the right. The operation to apply will depend on the picker. Blank lines and any line beginning with “#” are valid and are to be copied as is. Timestamps are to be displayed in ISO 8601 within the selected timezone.

The picker should have the following options, which do the following operations:

“Convert from Unix”: converts the input in seconds from the Unix epoch into a timestamp on the right.

“Convert from Unix Micro”: converts the input in milliseconds from the Unix epoch into a timestamp on the right.

“To UTC”: converts the input in ISO 8601 in the selected timezone into UTC, regardless of what timezone is chosen. “From UTC”: converts the input in ISO 8601, which is assumed to be in UTC, into the selected timezone.

This should be implemented as a static HTML page with vanilla JavaScript.

The agent did crash a few times: probably launch day, go-live teething problems. At one point it stopped halfway, and I had to ask it to “continue with the implementation plan.”

In the end it did manage to produce a decent-looking HTML UI, plus a working JavaScript implementation of what I described. The quality of the generated code was… fine. The JavaScript worked, but it wasn’t as neat as something produced by Claude Code, and definitely not as neat as something I would’ve written myself (the HTML was fine).

I had ideas of going further, so I asked the agent to port the JavaScript to Go and to produce a WSDL target, like many of the other tools. The agent had no issues doing so.

Please port the main logic defined in “main.js” to Go targetting WASM, in a new directory located in “cmds”. You can use the other WASM files found in “cmds” as a guide.

In it’s place, please change “site/timestamps/main.js” to be a WASM launcher, much like ther other launchers defined in “site/clocks” and “site/templates”. Add the new Go target to the Makefile

I then “started driving” by extending the Go code by adding a parser for a potential mini-language. And from this I got to experience Antigravity as a code editor. And it’s essentially VS Code, which honestly is not my favourite IDE. In fact, with all the LLM-powered code completion, it’s a little closer to Cursor, which I only tried once before. I was turned off by Cursor due to all the suggestions getting in the way, and Antigravity is a bit like that too. I kind of wish there’s more prioritising of suggestions: those that fix an compile error, or can be inferred by a refactor should have more weight than those that lack the context to be more than just mere guesses. The latter is rarely what I want, and I usually have to leave the home row to reach for the Escape, or I’ve accidentally pressed tab and have to back-out of the unwanted insert. Maybe that’s something that I can adjust: I haven’t looked, but I would prefer it if it just did nothing if it couldn’t be sure of what I want.

I also tried the testing agent, where it spun up Chrome and drove it to test the UI. The agent did have some issues launching the service — probably because I had the dev server already running — but it did successfully test the UI out. The tests were unsuccessful, and I had to go in and debug it, but hey, that’s something, I guess.

So, would I use Antigravity again? I mean, it’s a decent IDE (or maybe it’s better to say that it’s built on a decent IDE), and I think the agents work quite well. But I probably wouldn’t use it again, mainly because it’s now how I like to interact with agents. I’ve grown accustom to how Claude Code works, where the agent takes instruction from you on your terms. Otherwise it stays out of the way. And to be fair, that’s sort of how the agent in Antigravity works too. If they just toned down the suggestions in the editor itself, it may be something for me in the future. We’ll see.

Github FOMO

Wed, 19 Nov 2025 07:29:49 +1000

We’re coming up to about a year-and-a-half of moving my code to a self-hosted Forgejo instance. So far it’s been great, but I will admit that I am suffering from a bit of Github FOMO. So much of the technical world assumes your code lives on Github. Many tools assume you’re either pushing code, or distributing binaries via Github. None of the AI coding assistances work with anything other than Github.

Even when you’re considering whether you should advertise where the source code of your open-source projects, it feels a little funny posting a link to an SCM that is not Github. Open-source development is a social activity, and I doubt it helps the appeal of your project in the eyes of potential contributors if your code is not where they tend to be. Doubly so when when you consider that they’ll need to create an account on your SCM service to contribute.

There are other costs that I haven even considered, like the stability of external services your open-source SCM relies on. I found I wasn’t able to run any CI/CD builds last night because Codeberg was down and the pipelines were unable to fetch the Git checkout action. The idea of relying on services hosted by volunteers is a nice one, but I can imagine Microsoft’s SLAs being a lot stricter when it comes to keeping Github online.

So yeah, it’s cold and lonely out here. I’ll keep at it though: I think the benefits that come from having my own place for my code is worth it. But I do wonder if I should move some projects back, at least some of the “big” ones. Not that any of the projects I’m working on need contributors, but just to be where others are. There’s still value in that.

Tue, 11 Nov 2025 16:28:33 +1000

TIL that ⎋ is the symbol for the Escape key. HT @jason@social.lol

Fri, 24 Oct 2025 10:19:41 +1000

It’s funny how I approach certain features in the tools I make, such as adding UCL to Dynamo Browse. It’s been several months since I’ve done this, and I haven’t really used it for anything substantial until today. I guess because I get the sense that it’s half-finished (mainly due to the fact that it is half-finished) I tend to approach such features gingerly: in a careful way so as to avoid any problems. That’s probably not the best way to approach these features though. They need to be taken through the ringer, and just used, lest I never find their limitations or bugs that need to be fixed.

Anyway, this is a long winded way of saying that I’m glad I actually replaced the old scripting engine in Dynamo Browse with UCL. It was added to be used, and it actually came in useful today.

Devlog: Godot Game - A Trigger That Reveals Secrets

Sun, 12 Oct 2025 10:09:40 +1000

Okay, I think I need something to hide secret areas from the player and reveal it to them when they approach it. I’ve lived without this mechanic for a while, placing secret areas a fair distance from the main game area, so that they’re not visible. But such distances make it difficult to place time-limited things within those secret areas, like the invulnerability power-up, since travelling back to the main area to use it would eat up into the player’s power-up time. I could add ways for the player to return to the main play area quickly, like doors, but that complicates the level geometry and I need to place them out of the way, like in the sky.

So, I’ll add a new element to do this. It will be an Area2D node with an associated tile layer as a child. When the player enters the Area2D, the tile layer is hidden away and the player can see the revealed secret. The player leaving the Area2D will make the tile layer visible again.

Okay, the new SecretReveal scene has been built. The root node is an Area2D which takes, as children when added to the main scene, a CollisionShape2D to act as the trigger space, and a tile layer to act as the tiles to hide/show. The tile layer needs to be in the foreground, which is Z Index 10 and with collision turned off, so that it’ll reveal the mid and background layers. The script simply tracks entering bodies (it monitors layer 2, which is dedicated to the player).

Now, the next question is how to fade the tile map in and out. I could just toggle the visibility but that’s way too jarring. What I hope to achieve is to add an animation player to SecretReveal which will play a fade transition as the player enters or exits the Area2D. But how to do that without using scripting? I rather use the primitives offered to me as I’m guessing they’ll be more efficient than throwing events around in GDSscript.

One possibility is the Modulate option in the CanvasItem properties. After quickly playing around with this in the editor, it looks like it’s possible to adjust the alpha channel on this property, and that would adjust the visibility of the tile layer:

So this looks viable. I’m actually glad that Area2D has this property, despite not actually rendering itself in any way (outside of the editor) Let’s give it a try.

Okay, that works. Hooking it up to an animation player playing an animation that fades out and fades in the tiles when the player enters and leaves the trigger area works. It needs some improvement though. If the player were to enter and leave the target area quickly, the visibility would quickly “jump” from partially visible to fully visible. I suspect the reason for this is that the animation is always starting from the start.

One technique I used in the past is to preserve the current timestamp of the animation when I change it. But the animations here are using non-linear easing as it makes for a better transition.

So what I’ll try is a single animation that will be played forwards and backwards. When there’s a need to play the animation, the logic will detect whether the animation player is currently playing, and will resume playback from it’s current position in the desired direction.

Okay, so this is what I settled with:

func _on_body_entered(body: Node2D) -> void:
	candidate_body = body
	if animation_player.is_playing():
		animation_player.play_section("reveal_secret", \
		    animation_player.current_animation_position)
	else:
		animation_player.play("reveal_secret")
	

func _on_body_exited(body: Node2D) -> void:
	if body == candidate_body:
		candidate_body = null
		if animation_player.is_playing():
			animation_player.play_section("reveal_secret", 0.0, \
			    animation_player.current_animation_position, -1, -1.0, true)
		else:
			animation_player.play_backwards("reveal_secret")

What I’m doing is when the player enters the trigger space, I’ll play the “reveal secret” animation, either from the start or from the current position, depending if the animation player is playing. If the player leaves the trigger space, and the animation player is not playing, I’ll play the “reveal secret” in reverse from the end. When it is playing, I do something similar but I need to set the end position to the current animation position, rather than the start position. I’m guessing the animation player will take the initial position as the end when it’s playing in reverse, which makes sense.

Here’s how the transition looks now:

Much smoother.

Now to try it out in level 3-1. And yeah, this is a much better way to do secrets. I can build them close to the play area and the player no longer needs to navigate them blindly, or walk a million miles just to get to the bonus. I won’t overdo it though. I’m going to keep some of the large secrets that are naturally out of the way as they were. The player will need to react fast to enter them so I want to make sure they have the opportunity to see them.

I am wondering whether to merge this with the “You found a secret” trigger, but I think I’ll keep them separate for now.

Devlog: Blogging Tools - Podcast Clip Favourites

Sun, 05 Oct 2025 16:52:30 +1000

Inspired by the way Ron Jeffries writes about his work, as well as by Martin Hähnel attempt at this, I thought for this instalment of Devlog I’ll try a more “lab notes” approach. This means a potentially more mundane and less satisfactory description of project work today: less showing of what was accomplished, and more of a running commentary. I wanted to see if I liked this style of writing, and if it helped me or slowed me down. Preliminary results were mixed: it did slow me down, but I found it enjoyable. I’ll try this a few more times to see how I feel about it.

Today’s coding session is to continue the work of adding saved favourite podcast clips from Blogging Tools. Previously this was a standalone application connected to a database, but along with the tech stack used to build this falling out of active support, along with the feeds no longer working for reasons I rather not look into, I want to replace this with a static site that takes nothing to maintain. One other thing is that I want to move away from referencing links to the podcast clips and saving actual audio. Since I’m dealing with copyrighted material, some of it that is for pay, this site will be kept private.

I’m choosing to use Blogging Tools for this as it has a relatively decent podcast clipper that I use for clips I publish to my site. For the static site itself, I’m choosing to look at Hugo, given that I’m comfortable with this approach too. Although I do have some concerns about the long term viability of this for sites I don’t touch that often. An initial attempt at this used another site I use to track audio that used a template that fell out of maintenance and broke when I moved to Hugo 0.151. The Hugo maintainers really need to clean up their versioning act.

Anyway, the current status of this is a temporary Hugo site with a new template. At this stage, I’ve got Blogging Tools running a new job type that will take the clipped audio and image thumbnail, save them as static data to Hugo, and publish a new post.

At the moment, the template isn’t including the thumbnail or audio HTML. This is now a point of committing to this site and template: moving it out of the temp directory and into a proper workspace. So let’s start that now. I’m using the Hugo Flex theme as it provides a nice clean canvas to start with, and it seems to be in active maintenance (something to watch out for when dealing with Hugo themes). Added the git module, and setting Goldmark unsafe to true (once again) and now the new Hugo site is ready:

Now testing this with Blogging Tools. I’ve already got an ATP clip ready to go. And after remembering to change the target directory from the temp Hugo site to the real one, I am ready to test the extract. All that involves is clicking “Save”:

Okay, that didn’t work for a very stupid reason. I set the target directory to Blogging Tools repo, not the Hugo site. Made the change (Blogging Tools is being run using Air which gives me file watching capabilities one would see in the frontend world) and can now see that the new post was written to the new Hugo site.

Now to adjust the template a little, just to add the audio and thumbnail. The Markdown files produced by Blogging Tools have all the clip information in the front matter:

---

title: "449:  An Unclean Mouse"
episode:

  guid: some-random-id
  url: "https://atp.fm/449"
  title: "449:  An Unclean Mouse"
  date: 2021-09-23 12:27:49 +1000 AEST
  image_src: "https://cdn.atp.fm/artwork-bootleg"
  audio_src: "https://example.com/file.mp3"
show:
  title: "Accidental Tech Podcast: Unedited Live Stream"
clip:
  start: 0s
  duration: 60ms
date: 2021-09-23 12:27:49 +1000 AEST
thumbnail: images/DQkt_Lk5QRjXVHE0rdR09.jpg
audio: audio/5fFX8m0BqqFqTwlVAtb2Y.mp3
---
Test thing

Oh, before I do that. Let me fix the dates should that they’re in UTC and formatted as ISO 8601. This is a quick change to the template used by Blogging Tools:

date: {{.Clip.EpisodeDate.UTC.Format "2006-01-02T15:04:05Z07:00"}}

Another quick test… perfect. The dates are coming through again. Oh, and a quick aside: because the front matter is all included in one Go template, I had to make sure to properly quote the string values, lest they contain colons and other constructs YAML doesn’t like. Easy way to do that is pipe them through printf "%q", which quotes them as if they’re Go strings. May not be perfect but it’s good enough for now:

title: {{.Clip.EpisodeTitle | printf "%q"}}

So, lets fix the template. I’ll start by creating a new template in layouts/clips/singles.html which is a copy-and-paste of the existing theme post. I’ll then add details of the front matter, such as the thumbnail and audio player. This I can get using the Params template construct. I’ll start by just printing it:

{{ define "main" }}

  {{ $context := dict "page" . "level" 1 "isdateshown" true }}
  {{ partial "heading.html" $context }}
  
  Audio = {{.Params.audio}}, image = {{.Params.thumbnail}}
  
  {{ .Content }}
  {{ partial "tags.html" . }}
  {{ partial "comments.html" . }}

{{ end }}

I had to restart Hugo, but that’s coming through. I need to convert these into proper URLs though. I’ll start by trying the absurl template function:

Audio = {{ absURL .Params.audio}}, image = {{ absURL .Params.thumbnail}}

Okay, getting better. Let’s try and turn them into proper HTML elements:

  <img src="{{ absURL .Params.thumbnail}}">
  <audio src="{{ absURL .Params.audio}}" controls></audio>

Good, the image and audio is coming through. Image looks a little large but I’ll fix that at little later. Oh, and it looks like the clips are showing up in the home page already. That’s a nice touch. I do want to change the clip paths though. At the moment, they’re saved using the auto-incrementing clip ID, which is not ideal. Clip metadata is stored in an Sqlite database and the library I’m using — which is a Go port of Sqlite3 that doesn’t need CGO — has a nasty habit of reusing row IDs. I really should replace this with an auto-generated primary key. But that’s for later.

Right now, I think I’ll use a hash of the episode Guid for the path. ATP seems to have randomly generated hashes but I know that some RSS feeds choose to use URLs, which won’t do for a path. Why the Guid? Well, I want to be able to regenerate a clip if need be, replacing the existing one.

Actually, no, that won’t do. I want to be able to create multiple clips from the same episode. So maybe I’ll use a hash that includes the Guid and clip timestamp. So let’s try that.

clipPathRaw := fmt.Sprintf("%v:%v", clip.EpisodeGUID, clip.ClipStart)  
clipPathHash := md5.Sum([]byte(clipPathRaw))  
clipPath := hex.EncodeToString(clipPathHash[:])  
  
postFilename := filepath.Join(postDir, fmt.Sprintf("%v.md", clipPath))

MD5 should be fine: these don’t need to be cryptographically safe. Also, md5.Sum returns an [16]byte array, and I keep forgetting how to return this as a []byte slice. Apparently it’s array[:].

Another quick test. Yeah, it works. The clip paths now look like this: http://localhost:1313/clips/210da5b665c38c809eb1ea481b1b22de/ Not great, but I tend to browse this visually so I think I can live with this.

Okay, next thing is having Blogging Tools generate the clips and commit them to Git. The goal is to have the Hugo site stored in a Git repository and built to a private, undisclosed website. I did this for Nano Journal, which synchronised journal entries to a Git repo after saving it locally. Looking at the code, though, I have no idea how I setup the credentials. There’s nothing in the config hinting at a certificate so I may have done it manually.

I’m also wondering if I can use Go Git for this. I didn’t use this for Nano Journal, as I wanted to use LFS; which Go Git doesn’t support (instead I just shelled out to git). But I’m wondering if I can live without LFS for this.

Okay, let’s try this. I’ll push the current Hugo site to a test repo on my Forgejo instance and see whether I can check it out from Blogging Tools. This will be done as a user that I’ll configure Blogging Tools to act as.

Then I added Go Git to blogging tool and created a new provider for Git. Added a method to either pull or clone a remote repository, checkout a branch, and pull updates from the repo. I’ve chosen to use the file system for keeping the local workspace so that Blogging Tools doesn’t need to keep cloning the repo whenever there’s a need to add a clip. This I’m just going to keep in ephemeral storage so that when the Docker container gets cycled and the workspace lost, it’ll just recreate it.

func (p *Provider) CloneOrPull() error {  
    var (  
       repo *git.Repository  
       err  error  
    )  
  
    if !isDir(p.workspace) {  
       // Workspace doesn't exist. Pull from repo.  
       repo, err = git.PlainClone(p.workspace, &git.CloneOptions{  
          URL:               p.repoURL,  
          RecurseSubmodules: git.DefaultSubmoduleRecursionDepth,  
          Auth: &http.BasicAuth{  
             Username: p.username,  
             Password: p.password,  
          },  
       })  
    } else {  
       repo, err = git.PlainOpen(p.workspace)  
    }  
    if err != nil {  
       return fault.Wrap(err)  
    }  
  
    worktree, err := repo.Worktree()  
    if err != nil {  
       return fault.Wrap(err)  
    }  
  
    if err := worktree.Pull(&git.PullOptions{  
       RemoteURL:         p.repoURL,  
       RecurseSubmodules: git.DefaultSubmoduleRecursionDepth,  
       ReferenceName:     plumbing.ReferenceName(p.branch),  
       Auth: &http.BasicAuth{  
          Username: p.username,  
          Password: p.password,  
       },  
    }); err != nil {  
       return fault.Wrap(err)  
    }  
  
    if err := worktree.Checkout(&git.CheckoutOptions{  
       Branch: plumbing.ReferenceName(p.branch),  
    }); err != nil {  
       return fault.Wrap(err)  
    }  
  
    return nil  
}

Quick test of this, and I’m seeing a “repository doesn’t exist” error.

Actually, no. That was because of an earlier use of the repository URL when I actually wanted the workspace. But now I’m seeing a “reference not found” error when I try to pull from the origin:

Ah, okay. I should’ve used plumbing.NewBranchReferenceName here. That’s fix that. Now it’s an already up-to-date error. That’s fine, I’ll just add an ignore case here:

if err := worktree.Pull(&git.PullOptions{  
    RemoteURL:         p.repoURL,  
    RecurseSubmodules: git.DefaultSubmoduleRecursionDepth,  
    ReferenceName:     plumbing.NewBranchReferenceName(p.branch),  
    Auth: &http.BasicAuth{  
       Username: p.username,  
       Password: p.password,  
    },  
}); err != nil {  
    if !errors.Is(err, git.NoErrAlreadyUpToDate) {  
       return fault.Wrap(err)  
    }  
}

Another test:

And that worked. I managed to pull changes from remote.

Deleting the workspace and trying a clone. Hmm, that’s strange. I’m seeing an authentication required error, yet it looks like the repository was cloned successfully. Let me try and ignore that error.

if repo == nil && err != nil {  
    return fault.Wrap(err)  
} else if repo != nil && err != nil {  
    log.Printf("warn: error received alongside repo: %v", err)  
}

Okay, that worked. It’s not pretty, but I think it’s fine for now.

Now to commit the new files to the repository. Although partial failures from staging multiple files — one file is stage but the second one fails for some reason — may introduce some problems where the state is not completely settled, so I may also need a method of ensuring the workspace is pristine: no files should exist after cloning or pulling that is not staged. So need to add that first. I don’t see a method to do this on the Workspace type, so basically what I’ll do is reset hard, and then iterate over the untracked files and remove them:

if err := w.Reset(&git.ResetOptions{  
    Mode: git.HardReset,  
}); err != nil {  
    return fault.Wrap(err)  
}  
  
status, err := w.Status()  
if err != nil {  
    return fault.Wrap(err)  
}  
for f, s := range status {  
    if s.Worktree == git.Untracked {  
       if os.Remove(f) != nil {  
           return fault.Wrap(err)
		}
	}
}

Well, that’s the plan eventually. I’ll just log them for now.

Then it’s just a matter of adding files and commit the changes. First attempt at this failed with an entry not found error. That was just a bad path. Adding files now working, along with committing, and now we’re failing at the push. Reason is that unlike all the other Go Git methods, which were pretty high level, this one leaks a bit of the mechanics of Git, requiring the use of a Ref Spec. I’ve just hard coded it to a version which will push the local main branch to the origin main branch.

if err := repo.Push(&git.PushOptions{  
    RemoteURL: p.repoURL,  
    Auth: &http.BasicAuth{  
       Username: p.username,  
       Password: p.password,  
    },  
    RefSpecs: []config.RefSpec{  
       config.RefSpec(fmt.Sprintf("+refs/heads/%v:refs/remotes/origin/%v", p.branch, p.branch)),  
    },  
}); err != nil {  
    return fault.Wrap(err)  
}

Oh, before that, I finding a cannot create empty commit: clean working tree. I’m opening the work tree between staging the files and committing. Is that the problem?

Hmm, no. It might be that I’m adding the full path of the file to the index. Running git status in that repository yielded full path entries, which is very uncharacteristic. Furthermore, trying to unstage them did nothing. I’ll remove the repo directory and change the logic to get the relative path of the file before they’re added:

for _, f := range files {  
    relPath, err := filepath.Rel(p.workspace, f)  
    if err != nil {  
       return fault.Wrap(err)  
    }  
  
    if _, err := w.Add(relPath); err != nil {  
       return fault.Wrap(err)  
    }  
}  
  
if _, err := w.Commit(msg, &git.CommitOptions{}); err != nil {  
    return fault.Wrap(err)  
}

Oh, it was because the files I was trying to add were already added to the repository from earlier in the day, and they weren’t being changed by the job. Let me remove them from the repository and try again.

Okay, it was that. Commits are now working, although pushes don’t seem to be synchronising the commits. When I look at recent changes in Forgejo, it only shows my commits, not the ones created by the service user I made for Blogging Tools. Will try adjusting the refspec to push all heads:

RefSpecs: []config.RefSpec{  
    "+refs/heads/*:refs/remotes/origin/*",  
},

Nah, that didn’t help. The method is returning no error, yet it doesn’t seem to be synchronising the branches. Will need to learn more about how this all works. But I think that’s something for later.

Wed, 03 Sep 2025 08:37:24 +1000

Can humanity create an AI so intelligent, that it knows not to interrupt with a marketing interstitial when I’ve started typing out the prompt? One of the greatest questions of our time, apparently. 😒

Wed, 13 Aug 2025 13:07:41 +1000

Upgraded my Obsidian plan which gives me 10 vaults to sync. I’m currently using 2: one for my personal notes and one for TIL Computer. I’m contemplating moving my journal to a 3rd. Just need to find uses for the other 7.

Tue, 05 Aug 2025 08:21:56 +1000

Some follow-up on moving TIL Computer to Quartz. I mentioned that I wanted to eventually set-up a hot-key for activating search. Well, Quartz comes out of the box with that already: press Cmd+K to open the search. Very nice!

Sat, 02 Aug 2025 08:16:22 +1000

There was something about the appearance of iOS 26 Safari WebViews I wasn’t too sure about, and now I know: there’s a material transition between the header and the web-page, but there’s nothing separating the two. No edge, no gradient. This looks unnatural and, dare I say, a little amateur.

08:24 It may not be so egregious if there’s a mark difference in colour between the two, but with something like this that’s effectively transparent, it just looks broken.

Brief Look At Microsoft's New CLI Text Editor

Mon, 23 Jun 2025 08:09:38 +1000

Took a look at Microsoft’s new CLI text editor. There’s no MacOS version yet but Simon Willison has made a Docker image for it, and once I satisfied MacOS’ insatiable fear that I don’t know what I’m doing regarding Terminal and Docker’s access to other files¹, I managed to launch it.

And yeah, works well. Reminds me of EDIT.EXE from my DOS using days.

Since I was running this in Docker, I knew my experience may be slightly off from what’s expected. But one thing I would suggest Microsoft doing if they do want to bring this to the Mac is to have a version that works with terminals with light backgrounds: the grey body text is readable but a bit more contrast would be welcome. Also, adding some Emacs/Readline keyboard bindings would be nice. I found myself pressing Option+Left, which I’ve mapped to Ctrl+W, to try and go back a word, and I kept getting asked if I wanted to close and save the file. Seems like the keyboard bindings are mapped to what is typical on Windows, which I can understand.

I think the colours shown on the menu are little buggy.

But on the whole, I can see this being useful for Windows users that need to duck into a text file when they’re using the CLI. I don’t think it’ll be useful to me — I do know how to quit from Vim — but I frequently need to do this myself whenever I’m using the Terminal, and having to switch modes from CLI to GUI always includes a risk of loosing context. So I could imagine appreciating this if I were a Windows users.

One last thing: I like how they managed to get it down to less than 250kB. A worthy goal for any editor that is not aiming to be feature rich enough to replace your daily driver.

Four prompts in total today. Four! ↩︎

Tue, 22 Apr 2025 07:15:36 +1000

Podcasters, I’m begging you: if you mention an article in your show, no matter how trivial it may be, put a link to it in the show notes. Take a page from your YouTube making cousins, who fill their video descriptions with links, even to things that seem inconsequential to the topic of the video.

07:48 Mea culpa: the link that I thought was missing from the show notes was actually there. The author was read out on the show but not the title, which is why I didn’t recognise it. So my apologies: I was wrong.

The post still stands though, for those podcasts that refuse to put any links in the show notes. But most tech/tech adjacent shows do this really well, so I hope you know this post doesn’t apply to you. 🙂

Airing Of Draft Posts

Mon, 07 Apr 2025 20:52:38 +1000

I was going through my drafts this evening and I found that I had a number of them. Around 26 in total, created over the last year or so, many of them half-finished or almost finished thoughts. Some are not worth keeping around, and will be going straight to the big /dev/null in the sky. But I found a few that are worth preserving, at least in some form. And since they’re no longer worth publishing as separate posts in-and-of-themselves — which is probably why they were kept as drafts — I’d thought I’d just list them here.

So here they are:

Feb 2024: Tried the popover API for the first time today, and was quite impressed as to how easy it was to use. I needed to add a new modal for Photo Bucket¹, and to be able to do so using only HTML is great.
Feb 2024: B-movie idea: Two mystical titans — Gozilla and Kong — team up to fight the biggest villain of them all: humanity.
Mar 2024: I read a blog post about travel tips, and the poster recommend “tak[ing] one week trips. Turns out, two weeks is just too long.” This is where the tannery of distance places a role. Being ask to travel half-way round the world for five or six days at a time is not a great feeling. By the time I recover from jet-lag it’s time to head back home again. So I think a week is too short a time for me. Experience has taught me that I can probably go up to three weeks before I start feeling homesick, so I think 2-3 weeks would do it.
Apr 2024: Forgot how much of a pain configuring Linux audio using the command line actually is. Got there in the end with some old hardware that I know works with Ubuntu.²
May 2024: I think the secret to sustainable mocking is to avoid trying to litter your tests with hard-coded inputs and outputs, and instead implement mocks which satisfies the contract with the function under test with naive, in-memory implementations of dependent services.³
Sept 2024: I don’t know how this came about, but there seems like there’s an approach to Go code which shuns writing a lot of little private functions that in favour of big ones that inline all the logic. The problem is that this results in a lot of noise. Go’s naturally a boiler-plate heavy language, and if a large routine contains both the business logic and all the low-level mechanics of, say, trying get a unique list of things in a slice, it’s hard to work out whether that if statement is handling control logic, business logic, or a mixture of the two. It becomes difficult trying to follow what the routine’s trying to accomplish. That’s why I still prefer to write a lot of small methods that break up these large routines. It means a deeper stack and more jumping around a file, which does make it easier to loose your place, but what it gives me is the ability to abstract things out so that the business logic is clearer to others.
Sept 2024: Sometimes I wonder if I should work towards something that can be a good enough showcase of my professional self that can replace my LinkedIn profile. To have something akin to inessential.com. Not sure what that could be, but I don’t feel like I’ve got that something just yet.
Sept 2024: I may have found a potential use for GitHub Copilot after all. It’s not to give insight or ask questions about my own code. After all, I like to think I know my own code. No, it’s to provide insight or ask questions about some other open-source project, especially when the documentation is unclear or incomplete.⁴
Oct 2024: I’m not a blogger, but I play one on the Internet.
Oct 2024: Upgraded Bike to the latest release which has a caret “bounce” animation when you deselect something, probably to indicate where the carat is at any point. And I absolutely do not like it.⁵
Feb 2025: How much did the Vic government pay to host the NFL for a showcase game at the MCG? If they paid more than $0.00, they paid too much.
Feb 2025: Someone at worked asked if I missed working in Java. I don’t think I’d say I hate working in Java. I think the language itself is pretty decent. What got me frustrated working it it was all the non-Java aspects of working on enterprise applications intended for application containers. Many of these technologies involved a lot of configuration — usually XML — that provided no easy way to troubleshoot should applications fail to deploy, an almost near certainly when spinning up a new project.
Mar 2025: Complaining about excessive pop-overs and chat assistants on websites is a perennial topic, but good grief… do these site owners ever use these sites themselves?
Mar 2025: It seems to me like people are expecting too much from LLMs. I see take-down posts from people using them to get suggestions on how to do something, mocking the suggestions, then concluding that LLMs lack the nuance decision making that comes from an expert. Yeah, of course they do. They’re statistics-based averaging machines. They’re not following the same thought process that a human will go through.

And that’s it. Hope this wasn’t a significant waste of time.

Since abandoned. ↩︎
I forget what the hardware was, but I got there, apparently. ↩︎
I’ve got a whole draft post about mocking that I’ve yet to publish, and I’m not certain that I will since I don’t want to be talking about mocking on this site all the time. ↩︎
I’ve yet to verify this. ↩︎
I haven’t used Bike recently, but I probably will still find this distracting. ↩︎

Sun, 30 Mar 2025 12:47:15 +1000

TIL: CR2420 button batteries are not the same as CR2032, no matter what your eyes say to you.

Idea for UCL: Methods

Sun, 02 Feb 2025 14:46:00 +1000

I’m toying with the idea of adding methods to UCL. This will be similar to the methods that exist in Lua, in that they’re essentially functions that pass in the receiver as the first argument, although methods would only be definable by the native layer for the first version.

Much like Lua though, methods would be invokable using the : “pair” operator.

strs:to-upper "Hello"
--> HELLO

The idea is to make some of these methods on the types themselves, allowing their use on literals and the result of pipelines, as well as variables:

set h "Hello"
$hello:to-upper
--> HELLO

"Hello":to-upper
--> HELLO

(cat "Hello " "world"):to-upper
--> HELLO WORLD

The use of methods would be purely conveience. One could conceive of a type, like a CSV table, where there’s a need to perform a series of operations over it.

The potential downside of using : is that it may make defining dictionaries more ambiguous. When the parser sees something that could either be a list or a dictionary, it does a scan to search for any pairs that may exist. If so, it treats the literal as a dictionary. But would this work with using : as the method separator?

["Hello":to-upper]
--> Is this a dictionary {"Hello":"to-upper"}, or the list ["HELLO"]?

So that would require something. Might be that I need to require method invocations to occur within parenthesis for list literals.

Ambiguities like this aside, I’m planning to keep it simple for now. Methods will not be user definable within UCL out of the gate, but would be effectively another interface available to native types. For the builtin ones that exist now, it’ll most likely be little more than syntactic sugar over the standard library functions:

$hello:to-upper

# equivalent to

strs:to-upper $hello

Speaking of the standard library, the use of : as a module-function separator may need some changes. A the moment it’s a bit of a hack: when a module is loaded, any procs defined within that module is stored in the environment with the operator: strs:to-upper for example. The parser is sophisticated enough to recognised : as a token, but when it parses two or more identifiers separated with :, it just joins them up into a single identifier.

What’s needed is something else, maybe using something based on methods. The current idea is to define modules as being some special form of object, where the “methods” are simply the names of the exported symbol.

I was curious to know whether the language was capable of doing something similar now. It’s conceivable that a similar concept could be drafted with procs returning dictionaries of procs, effectively acting as a namespace for a collection of functions. So a bit of time in the playground resulted in this experiment:

proc fns {
  return [
    upper: (proc { |x| strs:to-upper $x })
    lower: (proc { |x| strs:to-lower $x })
  ]
}

(fns).upper "Hello"
--> HELLO

(fns).lower "Hello"
--> hello

A good first start. This is theoretically possible in the language that exists at the moment. It’s not perfect thought. For one thing, the call to fns needs to be enclosed in parenthesis in order to invoke it. Leaving them out results in an error:

fns.upper "Hello"
--> error: command is not invokable

The same is true when using variables instead of procs. I tried this experiment again using variables and it came to the same limitations:

set fns [
  upper: (proc { |x| strs:to-upper $x })
  lower: (proc { |x| strs:to-lower $x })
]

($fns).upper "Hello"
--> HELLO

$fns.upper "Hello"
--> error: command is not invokable

Obviously the parser needs to be changed to add additional support for the : operator, but I also need to fix how strong . binds to values too. But I think this may have legs.

Sat, 01 Feb 2025 08:55:11 +1000

🧑‍💻 New post on TIL Computer: Local Values In Fiber

Tue, 07 Jan 2025 13:33:20 +1000

🧑‍💻 New post on TIL Computer: A Way To Resolve Redelivered Messages Stuck In A NATS Jetstream

2024 Year In Review

Wed, 01 Jan 2025 10:55:48 +1000

It’s a few minutes to 12:00 PM on the 1st January 2025 when I published this. Thanks to time-zones, that means it’s just about to turn 12:00 AM one hour to the west of Greenwich, meaning that it’s still 2024 in much to the west of the prime meridian. So I’m technically still within the window of time where I could say I got a year in review post out for 2024.

Turns out it’s not the first time I’ve used this excuse. Looking at other posts I’ve published on the 1st of January, I’ve done this twice before. And I guess this pattern of posting a year in review on the first of the next year makes some sense: it’s usually a quiet day, with nothing open, and I’m usually a little tired and listless¹.

That means there’s usually a large block of time available to me, and despite what I wrote yesterday, it is a good practice to do some reflecting, however brief it may be.

So I’d figured I’d might as well drag iA Writer out and scribble out a brief review of the year that was.

Online Presence

I made a point of wanting to cut down the number of domains I acquire in my year in review for 2023. This is still an ongoing progress, but year-on-year, I’m down 2 domains on net, which is an improvement. 2024 saw the acquisition of 7 new domains, of which 2 I’m using for something, and 1 I plan to keep around:

Domains	2024	2023
Registered	23	25
With auto-renew turned on	17	16
Currently used for something	15	13
Not currently for something but worth keeping	2	3
Want to remove but stuck with it because it’s been shared by others	0	1

I’m still trying to keep this blog alive by posting regularly here. I’ve must’ve felt more comfortable with doing so as it’s been a record breaking year, with 840 posts, beating the previous record by 594 posts. The initial fear of falling out the practice has subsided to one where I find joy in posting here. That’s probably why the post count is so much higher.

Of course the quality of a blog doesn’t correlate with one’s ability to “post the most”, and I do feel like there have been times where I felt a little blasé about what I write here. I do want to be better here, or at least be a little more conscious about it. But not at the expense of turning this into solely a soapbox/marking/punditry site: there’s plenty of those out there already. So you’ll probably continue to see the cringey, irrelevant, lame, and potentially disposable posts here. I’ll just try to make sure that it’s balanced out with posts that are actually good.

Some notable posts of the year:

Detecting A Point In a Convex Polygon: the subject matter is a little dry, but one thing that’s notable about this one was the interactive elements. This took a few weeks to get right and I’m quite happy with how they turned out.
Goland Debugger Not Working? Try Upgrading All The Things: notable as it seems to be the post that got the most traffic from Google.
BASIC.HTM: notable as it was the first post of mine that appeared on Hacker News.
A Tour Of My New Self-Hosted Code Setup: longest post to date, with probably the longest bit of spoken audio I’ve published on this site. Getting my hands dirty with editing the narration was an interesting experience.
Micro-fiction: Get A Horse: notable in that this was my first post that was a work of fiction.

One other thing about blogs: I still have that wandering eye for other blogging CMSs. I did start three other blogs, of which two I shut-down and rolled into this one. That just leaves one new blog created this year that I’m planning to keep separate, mainly because I feel the subject matter warrants a dedicated site.

Projects

2024 didn’t feel like a big project year, probably because most of the projects I’ve started I kept to myself. But I did manage to release a couple this year:

Sidebar For Tiny Theme: This came with the additions for recommendations to Micro.blog, and the addition of sidebars listing those recommendations in a couple of the themes. I use Tiny Theme, which didn’t have a way to do this, so what started as a blog-post eventually became a Micro.blog plugin. It’s been good seeing this adopted by other bloggers.
Cyber Burger: A Pico-8 game, which I hoped would’ve only taken a few weeks to build. Overall it took 3 months, largely because I spent large stretches of time not working on it. But I’m glad I actually got this finished and released.

The other things I’ve worked on that I built mainly for myself:

UCL: A tool-command language, similar to TCL, that I’ve built for work. The state of this is smack-bang in the middle of “sort-of-usable” and I’ll need to spend some effort cleaning this up and documenting this if I ever want this to see wide release. I’m not sure that I want that though. at least not yet.
Blogging Tools: A set of tools that help me post here. What started as something to assist with making photo galleries has grown to a suite of tools dealing with images, audio and video. Really useful for my needs.
Tape Playback Site: A private site for browsing old cassette tapes that have been digitised. I still have a pile of tapes I need to digitise though (are you getting a sense that I find it hard to finish things? 😀).
Nano-Journal: My version of Kev Quirk’s web-based journalling app. After adding Git synchronisation and attachment support, I’ve use this now for all my journalling. It doesn’t do everything that Day One does (off-line support’s a big one) but it does enough.

Finally, some of the projects that have been abandoned:

Photo Bucket: My third attempt at making something to publish image galleries online. I think the need for this has been made somewhat redundant with Blogging Tools.
I also started two interactive fiction stories in Evergreen that I haven’t finished yet. One is close, and I probably should get it done. The other is about halfway finished and probably won’t see the light of day.

Books And Media

Given that I exceeded my reading goal for 2023, I thought I could push myself a bit more for 2024 and go for finishing 10 books. Sadly, I was nowhere near meeting it. I only got to finishing 4 this year:

(not pictured: Twenty Bits I Learned about Making Websites)

I think I probably started more books than I’ve finished. Not that I have to finish every book I’ve started, but I think my problem is one of focus. The books I have started could be interesting, and I have plans to finish some of them. I just need to spend more time reading.

I’m not a movie person but I did manage to watch a few this year. Here are the ones I’ve posted reviews for:

There was a period of time where I felt burnt out by scripted TV shows, favouring YouTube over much else. I eventually got back into watching a few “high production value” shows, some of which I enjoyed:

And some that I enjoyed far less:

Onwards To 2025

I know it’s cliché to look back on the last year and feel pretty crappy about it. And yeah, not every day of your life is going to be great. They’ve been some rotten days in 2024 that I haven’t included in this review (I have written about them so check out the archive if your curious).

So, was 2024 a good year? Well, I’ll start by saying that it hasn’t been wholly a remarkable year. There’s no one event that I can point to and say “this is what made 2024 great.” Maybe this past year was like that to others, but such events didn’t happen to me². And recency bias has made it difficult for me to say there were more good days then bad (the last few months have been rough).

But I wouldn’t say 2024 was a bad year. Certainly a busy one, with a lot going on. But on balance, I’d say it’s been one of the better ones.

So that’s it, year in review for 2024 done. Have a happy new year and onwards to a great 2025.

I don’t do much on New Years Eve, electing to go to bed early. Yet, I usually get awaken at midnight for various reasons: fireworks, messages from people wising me a Happy New Year. Last night was no exception. ↩︎
Well, that’s not entirely true. Becoming an uncle was an example of such an event. But again, such personal news, is currently outside the scope of this post. ↩︎

Fri, 29 Nov 2024 12:37:31 +1000

We might be seeing the end of the tunnel with our performance woes at work. I did some profiling with pprof this morning, and saw that a large amount of time was spent in context.Value(). Which is strange, given that this is just a way of retreving values being carried alongside context instances.

My initial suspicion was that tracing may have been involved. The tracing library we’re using carries spans — like method calls — in the context. These spans eventually get offloaded to a a service like Jaeger for us to browse.

We never got tracing working for this service, so I suspect all these spans were building up somewhere. The service wasn’t memory starved, but maybe the library was adding more and more values to the context — which acts like a linked list — and the service was just spending time traversing the list, looking for a values.

This is just speculation, and warrents further investigation, maybe (might be easier just to spend that effort getting tracing). But after we turned off tracing, we no longer saw the CPU rise to 100%. When we applied load, the CPU remained pretty constant at around 7%.

So it’s a pretty large signal that tracing not being offloaded is somewhat involved.

Wed, 27 Nov 2024 08:05:30 +1000

🧑‍💻 New post on TIL Computer: Link: Probably Avoid Relying On Error Codes To Optimistically Insert In Postgres

Mon, 25 Nov 2024 07:24:23 +1000

🧑‍💻 New post on TIL Computer: Don’t Use ‘T’ RDS Instance Types For Production

Wed, 20 Nov 2024 20:51:16 +1000

🧑‍💻 New post on TIL Computer: Feedback Of Conditional Updates In PostgreSQL

Tue, 29 Oct 2024 13:21:36 +1000

🧑‍💻 New post on TIL Computer: Slow NATS Go Subscribers

Sat, 26 Oct 2024 08:00:23 +1000

🧑‍💻 New post on TIL Computer: psql Techniques

Weekly Update - 20 Oct 2024

Sun, 20 Oct 2024 20:57:17 +1000

Yeah, I know, it’s been a while… again. A lot has been happening in life and there’ve been many days that I haven’t done any work on anything. Things are starting to settle down now, although I am expecting a few more bumpy days ahead, so we’ll see how we go with project work.

Cyber Burger

Yeah, I’m getting pretty tired of this one. I’m right in the trough of despair here, where the initial excitement has worn off and I just want to finish it. All the remaining work for it has been defined, which I think helps, and now it’s just a matter of plowing through the tasks.

Recent work done on this is the addition of power-ups and power-downs, which does things like bump the remain time remaining, give the player a “tractor beam” weapon, and clearing the play-area of items, amongst other things. I’m about 2/3 through this one: most of the these power-ups have been implemented, including the tractor beam. After that, the remaining work on this project is adjusting the difficulty curve, improving the main menu, and finally finishing off the website.

Despite how fatigued I feel about this, it has been fun learning how to build for the Pico-8. The expect fidelity of the pixel art is within my skillset, and it’s quite impressive what it offers in terms of audio effects. I haven’t explored the music options, and I probably won’t for this game, but something to look at for the next one (if there will be a next one).

Coasters

This was a bit of a side tangent to get my mind off working on Cyber Burger. It was a long weekend, and I was passively scrolling through the sample of Vintage Logos when I thought about recreating a game that was published in the weekend newspaper we read while I was growing up. You’ll be presented with two images and a clue, and you’d have to guess the word or phrase these alluded to. For example, if the clue was “insect” and the images were:

Then one possible answer would be “butterfly”.

The newspaper used stock photos, like the example above, but I was hoping to creates logos for fake companies as they would appear as if printed on cardboard coasters you’d find in pubs. The idea is that a new puzzle would be shown to the user a day, much like the word games you find online.

I coded up most of this in a single day and had a working version by the end of the weekend. I had a very simple Go server which served up a new puzzle every day at 00:00 UTC. The web frontend was mainly HTML, with some JavaScript for handling the player’s guesses. The puzzles themselves were defined in a CSV file which was imported into a Sqlite DB on server startup. This was a strange way of doing things, and was more of an accident as I was deploying this as a Docker container and I didn’t setup a persistent volume that survived restarts. I had plans of adding an admin section to the Go server so that I could design puzzles in advanced.

Fortunately I resisted this as I ended up only producing twelve puzzles. Once the original run was completed, I basically bundled them all on a static site. I was able to keep most of the original HTML and JavaScript as it was, with only the Go backend being junked. It’s still online, and maybe I’ll come back to it in the future, maybe using stock images in place of logos I have to create myself.

The new home page, made after the daily puzzles were at an end.

Example of one of the puzzles.

So although this was not a long lived side tangent, it was good to be able to get something finished. I was feeling quite dispirited with projects that I was just not finishing or releasing. Doing something small like this, and seeing it through, helped a lot. Maybe that’s the secret in how I can see through something from conception to completion: get the bulk of it done quickly, deploy it as soon as you can, and keep it small. That would limit the types of project I can deliver, but hey, at least I would deliver them.

Other Stuff

I added a few things to Ted, my terminal CSV editor, this past week. Like many of the other features of this project, this was driven mainly by needs that arise at work. I finally bit the bullet and embraced the support for headers. The first row of the CSV file is now treated as a header and is now fixed above the column, instead of the column numbers which were much less helpful. It should, in theory, be possible to read a CSV file without headers, but I hardly deal with those files that it’s probably just better to make headers the default.

TED with a very simple CSV file showing the headers.

I am also exploring ways to do more actions in bulk, such as add columns which are derived from the value of other columns. These are all quite experimental at the moment, and are more or less added in a quick and dirty fashion; just the bare minimum for what I’m trying to achieve. So not much to say here. A few other changes to other projects:

Nano Journal now keeps the current draft post in browser local storage, so that it’ll no longer get clobbered when you’re redirected to the login screen when trying to post an entry. This was a source of anxiety for me and meant I was less likely to write something off the cuff, so I’m glad this is now fixed.
Blogging Tool now has a new app which takes a clip videos produced by Pocketcasts — which is currently generated in an Instagram-style vertical video — and crops it as either a square or a letterbox.

The new "Post Podcast Clip" app in Blogging Tools.

Also, the app list has been styled a little better. Much more interesting than the bulleted list.

So, a lot of little things done this past month. Nothing worthy of a report on it’s own, but still, it’s something.

Tue, 08 Oct 2024 13:00:22 +1000

🧑‍💻 New post on TIL Computer: Exporting a Query as a CSV File From PostgreSQL

Mon, 23 Sep 2024 20:53:21 +1000

🧑‍💻 New post on TIL Computer: HTMX And POST Redirects

Project Updates

Sun, 08 Sep 2024 17:14:51 +1000

Well, it’s been three weeks since my last post here, and as hard as it was to write this update, not writing it would’ve been harder. So let’s just skip the preamble and go straight to the update.

Cyber Burger (That Pico-8 Game)

I’m terrible at being coy, I’ll just spill the beens. That game I’ve been working on is call Cyber Burger. It’s based on a DOS game I saw on YouTube, and it seemed like a fun project to try and work on, with some tweaks to the gameplay that I think would make it more forgiving.

In the weeks since my last update, I finished with the prototypes and started working on the game itself. The initial set of art is done and a very simple “Game A” mode has been implemented. In this mode, you are shown a burger you’ll need to make in your basket. You do so by shooting down the items flying across the screen and catching them in order. When you do, you get a “tip”, which basically amounts to points. If you make a mistake, you’re given a demerit. There are five rounds in total, and once the round is complete, you move on to the next one, with maybe slightly different items, or different item speeds, etc.

An example play session, with the new graphics.

I managed to make a HTML version of this which plays through round 1. I gave it to someone at work to play test and the results were… well, they weren’t bad but it didn’t set the world on fire.

I think I’m okay with that, but I do need to keep working on it. I think one thing that would help is adding sound. And I think it might help me deliver this earlier if I abandoned Mode A and start working on Mode B, which is closer to an arcade style of game that would allow for continuous play. These two things, I’ll aim to work on this next week.

Oh, and I’ll need to fix the item spawner. Waiting ages for an item you need is no good.

If you’re interested in giving it a try, you can do so by following this link (it runs in the browser). Feel free to send any feedback you may have.

UCL

The other thing I’ve been spending some time on over the last week or so was UCL. I’ve been using that work tool which has this language quite often recently and I’ve been running against a number of bugs and areas where quality of life changes could be made. Just small things, such as allowing the foreach command to be called with a proc name instead of requiring a block, much like the map function. Those have been addressed.

But the biggest thing I’ve been worked on was building out the core library. I added the following functions:

The `seq` function, used for generating a sequence of integers. I like how I built this: it’s effectively a virtual list — that can be indexed, iterated over, or calculated the length of — but does not take up linear space.
Comparator functions, like `eq`, `ne`, `gt`, etc. plus settling on a type system much like Python, where values are strongly type (can’t compare ints to strings) but are also dynamic.
Arithmetic functions, like `add`, `sub`, etc. which operate on integers, and the `cat` function use to concatenate strings (these functions do try to cohere values to the correct type)
Logical functions, like `and`, `or`, and `not`.

Along with this, I’ve started working through the strings package, which would add the various string functions you see, like trimming whitespace, splitting, joining, etc. I’ve got trimming and converting to upper and lower case, and my goal for next week is to add splitting to and joining from string lists. Once that’s done I’ll probably put this on the back-burner again so I can finish off Cyber Burger or work on something else.

Just a reminder that there’s also a playground for this too, although I apologise for the lack of documentation. I’ll need to get onto that as well.

Simplifying UCL

Tue, 23 Apr 2024 08:21:44 +1000

I’ve been using UCL for several days now in that work tool I mentioned, and I’m wondering if the technical challenge that comes of making a featureful language is crowding out what I set out to do: making a useful command language that is easy to embed.

So I’m thinking of making some simplifications.

The first is to expand the possible use of pipes. To date, the only thing that can travel through pipes are streams. But many of the commands I’ve been adding simply return slices. This is probably because there’s currently no “stream” type available to the embedder, but even if there was, I’m wondering if it make sense to allow the embedder to pass slices, and other types, through pipes as well.

So, I think I’m going to take a page out of Go’s template book and simply have pipes act as syntactic sugar over sequential calls. The goal is to make the construct a | b essentially be the same as b (a), where the first argument of b will be the result of a.

As for streams, I’m thinking of removing them as a dedicated object type. Embedders could certainly make analogous types if they need to, and the language should support that, but the language will no longer offer first class support for them out of the box.

The second is to remove any sense of “purity” of the builtins. You may recall the indecision I had regarding using anonymous procs with the map command:

I’m not sure how I can improve this. I don’t really want to add automatic dereferencing of identities: they’re very useful as unquoted string arguments. I suppose I could add another construct that would support dereferencing, maybe by enclosing the identifier in parenthesis.

I think this is the wrong way to think of this. Again, I’m not here to design a pure implementation of the language. The language is meant to be easy to use, first and foremost, in an interactive shell, and if that means sacrificing purity for a map command that supports blocks, anonymous procs, and automatic dereferencing of commands just to make it easier for the user, then I think that’s a trade work taking.

Anyway, that’s the current thinking as of now.

Imports And The New Model

Sat, 20 Apr 2024 15:53:06 +1000

Well, I dragged Photo Bucket out today to work on it a bit.

It’s fallen by the wayside a little, and I’ve been wondering if it’s worth continuing work on it. So many things about it that need to be looked at: the public site looks ugly, as does the admin section; working with more than a single image is a pain; backup and restore needs to be added; etc.

I guess every project goes through this “trough of discontent” where the initial excitement has warn off and all you see is a huge laundry list of things to do. Not to mention the wandering eye looking at the alternatives.

But I do have to stop myself from completely junking it, since it’s actually being used to host the Folio Red Gallery. I guess my push to deploy it has entrapped me (well, that was the idea of pushing it out there in the first place).

Anyway, it’s been a while (last update is here) and the move to the new model is progressing. And it’s occurred to me that I haven’t actually talked about the new model (well, maybe I have but I forgot about it).

Previously, the root model of this data structure is the Store. All images belong to a Store, which is responsible for managing the physical storage and retrieval of them. These stores can have sub-stores, which are usually used to hold the images optimised for a specific use (serving on the web, showing as a thumbnails, etc). Separate to this was the public site Design which handed properties of the public site: how it should look, what the title, and description is, etc.

The "Store" model

There were some serious issues with this approach: images were owned by stores, and two images can belong to two different stores, but they all belonged to the same site. This made uploading confusing: which store should the image live on? I worked around this by adding the notion of a “primary store” but this was just ignoring the problem and defeated the whole multiple-store approach.

This is made even worse when one considers which store to use for serving the images. Down the line I was hoping to support virtual domain hosting, where one could setup different image sites on different domains that all pointed to the same instance. So imagine how that would work: one wanted to view images from alpha.example.com and another wanted to view images from beta.example.com. Should the domains live on the store? What about the site designs? Where should they live?

The result was that this model could only really ever support one site per Photo Bucket instance, requiring multiple deployments for different sites if one wanted to use a single host for separate photo sites.

So I re-engineered the model to simplify this dramatically. Now, the route object is the Site:

The "Site" model

Here, the Site owns everything. The images are associated with sites, not stores. Stores still exist, but their role is now more in-line with what the sub-stores did. When an image is uploaded, it is stored in every Store of the site, and each Store will be responsible for optimising it for a specific use-case. The logic used to determine which Store to use to fetch the image is still in place but now it can be assumed that any Store associated with a site will have the image.

Now the question of which Store an image should be added to is easy: all the them.

Non-image data, such as Galleries and Designs now live off the Site as well, and if virtual hosting is added, so would the domain that serves that Site.

At least one site needs to be present at all time, and it’s likely most instances will simply have a single Site for now. But this assumption solves the upload and hosting resolution issues listed above. And if multiple site support is needed, a simple site picker can be added to the admin page (the public pages can will rely on the request hostname).

This has been added a while ago, and as of today, has been merged to main. But I didn’t want to deal with writing the data migration logic for this, so my plan is to simply junk the existing instance and replace it with the brand new one. But in order to do so, I needed to export the photos from the old instance, and import them into the new one.

The export logic has been deployed and I’ve made an export it this morning. Today, the import logic was finished and merged. Nothing fancy: like the export it’s only invokable from the command line. But it’ll do the job for now.

Next steps is to actually deploy this, which I guess will be the ultimate test. Then, I’m hoping to add support for galleries in the public page so I can separate images on the Folio Red Gallery into projects. There’s still no way to add images in bulk to a gallery. Maybe this will give me an incentive to do that next.

UCL: First Embed, and Optional Arguments

Thu, 18 Apr 2024 08:39:12 +1000

Came up with a name: Universal Control Language: UCL. See, you have TCL; but what if instead of being used for tools, it can be more universal? Sounds so much more… universal, am I right? 😀

Yeah, okay. It’s not a great name. But it’ll do for now.

Anyway, I’ve started integrating this language with the admin tool I’m using at work. This tool I use is the impetus for this whole endeavour. Up until now, this tool was just a standard CLI command usable from the shell. But it’s not uncommon for me to have to invoke the tool multiple times in quick succession, and each time I invoke it, it needs to connect to backend systems, which can take a few seconds. Hence the reason why I’m converting it into a REPL.

Anyway, I added UCL to the tool, along with a readline library, and wow, did it feel good to use. So much better than the simple quote-aware string splitter I’d would’ve used. And just after I added it, I got a flurry of requests from my boss to gather some information, and although the language couldn’t quite handle the task due to missing or unfinished features, I can definitely see the potential there.

I’m trying my best to only use what will eventually be the public API to add the tool-specific bindings. The biggest issue is that these “user bindings” (i.e. the non-builtins) desperately need support for producing and consuming streams. They’re currently producing Go slices, which are being passed around as opaque “proxy objects”, but these can’t be piped into other commands to, say, filter or map. Some other major limitations:

No commands to actually filter or map. In fact, the whole standard library needs to be built out.
No ability to get fields from hashes or lists, including proxy objects which can act as lists or hashes.

One last thing that would be nice is the ability to define optional arguments. I actually started work on that last night, seeing that it’s relatively easy to build. I’m opting for a style that looks like the switches you’d find on the command line, with option names starting with dashes:

join "a" "b" -separator "," -reverse
--> b, a

Each option can have zero or more arguments, and boolean options can be represented as just having the switch. This does mean that they’d have to come after the positional arguments, but I think I can live with that. Oh, and no syntactic sugar for single-character options: each option must be separated by whitespace (the grammar actually treats them as identifiers). In fact, I’d like to discourage the use of single-character option names for these: I prefer the clarity that comes from having the name written out in full (that said, I wouldn’t rule out support for aliases). This eliminates the need for double dashes, to distinguish long option names from a cluster of single-character options, so only the single dash will be used.

I’ll talk more about how the Go bindings look later, after I’ve used them a little more and they’re a little more refined.

Adding A Sidebar To A Tiny Theme Micro.blog

Thu, 14 Mar 2024 07:27:45 +1000

This is now a standalone Micro.blog Plugin called Sidebar For Tiny Theme which adds support for this out of the box. The method documented below no longer works, but I'm keeping it here for posterity reason.

I’d though I’d write a little about how I added a sidebar with recommendations to my Tiny Theme’ed Micro.blog, for anyone else interested in doing likewise. For an example on how this looks, please see this post, or just go to the home page of this site.

I should say that I wrote this in the form of a Micro.blog plugin, just so that I can use a proper text editor. It’s not published at the time of this post, but you can find all the code on Github, and although the steps here are slightly different, they should still work using Micro.blog’s template designer.

I started by defining a new Hugo partial for the sidebar. This means that I can choose which page I want it to appear on without any copy-and-paste. You can do so by adding a new template with the name layouts/partials/sidebar.html, and pasting the following template:

<div class="sidebar">
    <div class="sidebar-cell">
        <header>
            <h1>Recommendations</h1>
        </header>
        <ul class="blogroll">
            {{ range .Site.Data.blogrolls.recommendations }}
                <li><a href="{{ .url }}">{{ .name }}: <span>{{ (urls.Parse .url).Hostname }}</span></a></li>
            {{ else }}
                <p>No recommendations yet.</p>
            {{ end }}
        </ul>
    </div>
</div>

This creates a sidebar with a single cell containing your Micro.blog recommendations. Down the line I’m hoping to add additional cells with things like shoutouts, etc. The styling is not defined for this yet though.

The sidebar is added to the page using Tiny Theme’s microhooks customisation feature. I set the microhook-after-post-list.html hook to the following HTML to include the sidebar on the post list:

{{ partial "sidebar.html" . }}

In theory it should be possible to add it to the other pages just by adding the same HTML snippet to the other microhooks (go for the “after” ones). I haven’t tried it myself though so I’m not sure how this will look.

Finally, there’s the styling. I added the following CSS which will make the page slightly wider and place the sidebar to the right side of the page:

@media (min-width: 776px) {
    body:has(div.sidebar) {
        max-width: 50em;
    }

    div.wrapper:has(div.sidebar) {
        display: grid;
        grid-template-columns: minmax(20em,35em) 15em;
        column-gap: 60px;
    }
}

div.sidebar {
    font-size: 0.9em;
    line-height: 1.8;
}

@media (max-width: 775px) {
    div.sidebar {
        display: none;
    }
}

div.sidebar header {
    margin-bottom: 0;
}

div.sidebar header h1 {
    font-size: 1.0em;
    color: var(--accent1);
}

ul.blogroll {
  padding-inline: 0;
}

ul.blogroll li {  
  list-style-type: none !important;
}

ul.blogroll li a {
  text-decoration: none;
  color: var(--text);
}

ul.blogroll li a span {
  color: var(--accent2);
}

This CSS uses the style variables defined by Tiny Theme so they should match the colour scheme of your blog. A page with a sidebar is also wider than one without it. It doesn’t change with width of pages that don’t have the sidebar (if this isn’t your cup of tea, you can remove the :has(div.sidebar) selector off the body tag) and the sidebar will not appear on small screens, like a phone in portrait orientation. I’m not entirely sure if I like this, and I may eventually make changes. But it’s fine for now.

So that’s how the sidebar was added. More to come as I tinker with this down the line.

Photo Bucket Galleries and Using the HTML Popover API

Mon, 19 Feb 2024 22:05:48 +1000

Spent a bit more on Photo Bucket this evening. Tonight I started working on galleries, which’ll work more or less like albums.

At the moment you can create a gallery and add a photo to it. Most of the work so far has been backend so the UI is pretty rough. Eventually you’ll be able to do things like rearrange photos within galleries, but for the moment they’ll just be added to the end.

I did need to add some modals to the UI, such as the New Gallery model that’s shown for the gallery name. This gave me the opportunity to try out the new popover API. And yeah, it does exactly what it says on the tin: add the popover attribute to an element and it becomes a working popover (at least in the latest version of Vivaldi). Must say it’s impressive that this is now possible with HTML alone.

The initial version of the modals used a <div> for the popover target. And while that worked, there were some small annoyances. First was that the form within the popover didn’t get focus when the popover was displayed. It would be nice to click “New” and start typing out the gallery name. But this is a small thing that’s easily solvable with JavaScript, so it’s no big deal.

The second, slightly larger one, was that dismissing the popover by clicking outside of it will not eat the input. If you were to click a sidebar link while the New Gallery model is opened, you’ll end up on that newly selected page. I’m not a fan of this. Dismissing the popover feels like its own user gesture, and I fear the user accidentally activating things when all they’re trying to do is dismiss the popover (it’s not in place now, but I am planning to dim the background when the Create Gallery modal is visible).

Fortunately, there’s a simple solution to this. It turns out that replacing the <div> element with a <dialog> element would solves both problems. It works seamlessly with the new popover attributes, yet showing the dialog will give focus to the form, and will eat the click when the user dismisses it.

Perfect. Looks like I’ve delayed the need for JavaScript a little longer (it will come eventually; it always will).

Wed, 27 Dec 2023 06:33:20 +1000

🔗 Apple Watch Series 9 and Ultra 2 Ban Takes Effect; Apple Appeals

The ITC’s ruling was subject to a potential veto by U.S. President Biden by December 25th, but today, the Office of the U.S. Trade Representative issued a statement that it has decided against vetoing the ITC ruling, meaning that the ruling is now final.

It seems odd to me that Apple was expecting a reprieve from the White House over this patient dispute with Masimo. Issuing a veto looks like choosing one US company over another. Doesn’t seem like good political optics to me. Maybe it seemed to Apple it was worth a shot. 🤷‍♂️

Mon, 03 Apr 2023 16:35:07 +1000

Overhead someone say, in not so many words, that my UI design for something was sub-par. 😔 Sad, but can’t deny that it’s true to a degree. Acknowledged area of potential development, I guess.

Mon, 13 Mar 2023 15:26:26 +1000

It’s amazing what a difference going to the gym can make. This afternoon I was feeling so lethargic, like all I wanted to do was crawl into bed. But I decided to crawl to the gym instead. I really didn’t want to, and I usually don’t go Mondays so I had an excuse not to. But I’m so glad I did because afterwards I got my energy back and I was eager to just do stuff.

Partial credit goes to coffee. It also helped with getting over the slump.

To Wordpress Or Not To Wordpress

Sat, 04 Mar 2023 09:52:55 +1000

I’m facing a bit of a dilemma.

I’ve been asked to setup a new website for someone who wants to stand up a new business. In therory this is something that I can do quite easily. I know HTML and CSS. I’ve made a living building backends for web-apps. I do have an undeveloped eye for design, but I like to think I have an idea of the principal of good website usability; and as long as I’m not too ambitious, and aim for a minimal usable site, I can probably put together a simple static website.

The only problem is that this may not work for the person that I’m building a site for. This is someone that has no experience with putting together websites, and if I were to go down the static HTML road, I’d probably be on the hook to make changes going forward.

So the alternative is to use a CRM like Wordpress. That way, once I hand ownership of the site to the client, he could either contract someone else to maintain it going forward or even learn to do it himself.

Only problem with that is that my experience with Wordpress is quite minimal. I can get around the dashboard no problem, but when it comes to designing or customising themes or (sigh) using the Block editor, I’m just as much as a novice as he is. And I’m not sure to what degree I can leverage my HTML and CSS skills to style the site. I may be able to change a few things but I’d have to do so within the confines of the block templating system.

So, what to do?

Maybe the best way forward is to get a sense of how often this person would need the site changed. That’s by far the biggest variable here. I only know what he wants at a very superficial sense at this moment. I don’t believe it’ll need any sort of blog or product catalogue; just a simple landing page with contact details.

In that case, I’m wondering if a static site with just plain HTML and CSS would be enough. That’ll be easy enough to put together. It can probably scale with some basic dynamic aspects as well, maybe powered with a simple backend that can regenerate the site. Maybe something like Carrd could work here as well.

But the danger is that he’ll be locked into using a static site. Any changes would require someone who’s versed in HTML and CSS. Even worse would be a static site with a bit of backend “sprinkled in”. Then he’d be locked into using me. Not sure I like that for his sake or for mine. You read about those developers in The Daily WTF who’ve put together a custom backend for a “simple website” that has grown unwieldily and become a huge mess that someone who inherits it needs to cleanup or take responsibility for. The prospect of being such a developer is not a great one.

Which is why I’m looking at Wordpress, and wondering the pain of learning how to work with it is worth it. I guess it’s offsetting the potential future pain (and embarrassment) of transitioning a static site to a proper CRM later.

So, Leon, which pain is worse?

Thu, 02 Mar 2023 07:41:03 +1000

I was listening to an episode of Sharp Tech the other day. When the conversation moved on to AI and Ben Thompson’s experience with Sydney, an idea for a game came to me.

It’ll essentially be a text adventure, but the goal is to try to get a GPT AI to play it. The AI would give you a description of what it “sees” on their screen, and you have to tell it how to proceed. You can’t enter the commands yourself. Except, you have to use natural language to guide the AI through the game.

Maybe in the harder difficulty levels the AI could disagree with you and you’ll need to convince it to do what you say. Or maybe it’ll give you partial information about what it “sees”. It can say that it sees a castle, but doesn’t explain that there’s a gate-house as well, and you have to tease this information out of it in order to move forward.

This sort of harkens back to the time when you’re playing a game for the first time with someone that’s experienced, and they’re telling you what to do¹. Here, you’re that experienced player giving assistance, even though you’ve never played the game yourself.

Anyway, free idea for anyone who wants it.

Or maybe those times when you’re trying to give tech support over the phone. Those are fun, right? Well, what better way to spend your downtime than playing a simulation of that. 😛 ↩︎

Spotify Video Follow-up

Sun, 12 Feb 2023 06:27:37 +1000

Some follow-up from my post about Spotify videos. I looked into this a little and from what I understand they’re not full videos but “short looping video clips that play during certain songs,” at least according to this website.

So I guess my initial belief is incorrect. Spotify might have music videos (they’re a bunch of articles about them thinking about it in 2020-21) but this looks to be completely different.

Furthermore, you can turn them off. They’re called “Canvas Video Clips”, and if you go into the preferences of the Android mobile app, sure enough there’s a switch for them.

Not sure why I missed that when I was looking for that option earlier. I guess because I was looking for a preference with the name “video” in the label. But this switch seems to work and after I turned it off, this visuals stopped.

Still toying with the idea of cancelling my subscription for other reasons but at least this is one less concern I have for using the service.

Sat, 14 Jan 2023 08:21:55 +1000

Finally bit the bullet and got scripting working in Dynamo-Browse. It’s officially in the tool, at least in the latest development version. It’s finally good to see this feature implemented. I’ve been waffling on this for a while, as the last several posts can attest, and it’s good to see some decisions made.

In the end I went with Tamarin as the scripting language. It was fortunate that the maintainer released version 1.0 just as I was about to merge the scripting feature branch into main. I’ve been trying out the scripting feature at work and so far I’ve been finding it to work pretty well. It helps that the language syntax is quite close to Go, but I also think that the room to hide long-running tasks from the user (i.e. no promises everywhere) dramatically simplifies how scripts are written.

As for the runtime, I decided to have scripts run in a separate go-routine. This means they don’t block the main thread and the user can still interact with the tool. This does mean that the script will need to indicate when a long running process is occurring — which they can do by displaying a message in the status line — but I think this is a good enough tradeoff to avoid having a running script lock-up the app. I still need to add a way for the user to kill long-running scripts (writing a GitHub ticket to do this now).

At the moment, only one script can run at any one time, sort of like how JavaScript in the browser works. This is also intentional, as it will prevent a whole bunch of scripts launching go-routines and slowing down the user experience. I think it will help in not introducing any potential synchronisation issues with parallel running scripts accessing the same memory space. No need to build methods in the API to handle this. Will this mean that script performance will be a problem? Not sure at this stage.

I’m also keeping the API intentionally small at this stage. There are methods to query a DynamoDB table, get access to the result set and the items, and do some basic UI and OS things. I’m hoping it’s small enough to be useful, at least at the start, without overwhelming script authors or locking me into an API design. I hope to add methods to the API over time.

Anyway, good to see this committed to.

Sun, 01 Jan 2023 07:57:42 +1000

First post of 2023. If current trends are to be maintained, I better get posting right away. 😉

Happy new year.

Audax Toolset Version 0.1.0

Sat, 22 Oct 2022 10:20:36 +1000

Audax Toolset version 0.1.0 is finally released and is available on GitHub. This version contains updates to Dynamo-Browse, which is still the only tool in the toolset so far.

Here are some of the headline features.

Adjusting The Displayed Columns

Consider a table full of items that look like the following:

pk           S    00cae3cc-a9c0-4679-9e3a-032f75c2b506
sk           S    00cae3cc-a9c0-4679-9e3a-032f75c2b506
address      S    3473 Ville stad, Jersey , Mississippi 41540
city         S    Columbus
colors       M    (2 items)
  door       S    MintCream
  front      S    Tan
name         S    Creola Konopelski
officeOpened BOOL False
phone        N    9974834360
ratings      L    (3 items)
  0          N    4
  1          N    3
  2          N    4
web          S    http://www.investorgranular.net/proactive/integrate/open-source

Let’s say you’re interested in seeing the city, the door colour and the website in the main table which, by default, would look something like this:

There are a few reasons why the table is laid out this way. The partition and sort key are always the first two columns, followed by any declared fields that may be used for indices. This is followed by all the other top-level fields sorted in alphabetical order. Nested fields are not included as columns, and maps and list fields are summarised with the number of items they hold, e.g. (2 items). This makes it impossible to only view the columns you’re interested in.

Version 0.1.0 now allows you to adjust the columns of the table. This is done using the Fields Popup, which can be opened by pressing f.

While this popup is visible you can show columns, hide them, or move them left or right. You can also add new columns by entering a Query Expression, which can be used to reveal the value of nested fields within the main table. It’s now possible to change the columns of the table to be exactly what you’re interested in:

Read-only Mode And Result Limits

Version 0.1.0 also contains some niceties for reducing the impact of working on production tables. Dynamo-Browse can now be started in read-only mode using the -ro flag, which will disable all write operations — a useful feature if you’re paranoid about accidentally modifying data on production databases.

Another new flag is -default-limit which will change the default number of items returned from scans and queries from 1000 to whatever you want. This is useful to cut down on the number of read capacity units Dynamo-Browse will use on the initial scans of production tables.

These settings are also changeable from while Dynamo-Browse using the new set command:

Progress Indicators And Cancelation

Dynamo-Browse now indicates running operations, like scans or queries, with a spinner. This improves the user experience of prior versions of Dynamo-Browse, which gave no feedback of running operations whatsoever and would simply “pop-up” the result of such operations in a rather jarring way.

With this spinner visible in the status bar, it is also now possible to cancel an operation by pressing Ctrl-C. You have the option to view any partial results that were already retrieved at the time.

Other Changes

Here are some of the other bug-fix and improvements that are also included in this release:

Audax toolset is now distributed via Homebrew. Check out the Downloads page for instructions.
A new mark command to mark all, unmark all, or toggle marked rows. The unmark command is now an alias to mark none.
Query expressions involving the partition and sort key of the main table are now executed as a DynamoDB queries, instead of scans.
The query expression language now supports conjunction, disjunction, and dot references.
Fixed a bug which was not properly detecting whether MacOS was in light mode. This was making some highlighted colours hard to see while in dark mode.
Fixed the table-selection filter, which was never properly working since the initial release.
Fixed the back-stack service to prevent duplicate views from being pushed.
Fixed some conditions which were causing seg. faults.

Full details of the changes can be found on GitHub. Details about the various features can also be found in the user manual.

Finally, although it does not touch on any of the features described above, I recorded a introduction video on the basics of using Dynamo-Browse to view items of a DynamoDB table:

No promises, but I may record further videos touching on other aspects of the tool in the future. If that happens, I’ll make sure to mention them here.¹

Or you can like, comment or subscribe on YouTube if that’s your thing 😛. ↩︎

Thu, 25 Aug 2022 15:32:40 +1000

Here’s today’s instalment of Why Didn’t I Think of This Sooner™.

I’ve got into the habit of squashing commits before I push them as part of a pull request. In order to run the command I use to do this — git rebase -i HEAD~n — I need to know the number of commits I want to squash (this will be the value of n).

Fortunately, I’ve got into the habit of prefixing each commit message with the Jira task number. For example, I may write a commit message with the first line being ABC-123: fixed a bug in the thing, followed by a more detailed list of changes. I do for every commit, even for those “checkpoint commits” I make before changing branches.

So all I need to do to get the number of commits I need to squash is to simply count up all the commits that start with the Jira task number. For all this time, the way I do this is to run git log to open up the history in Vim, and manually count the number of commit messages that began with the particular Jira task number.

Today, I remembered that I could use a shell pipeline to do the same thing:

git log | grep ABC-123 | wc -l

which would save me stack-loads of time and potential mistakes.

Wish I thought of this sooner. 🤦

Adding A Back-Stack To Dynamo-Browse

Sun, 14 Aug 2022 10:21:47 +1000

Spent some more time working on dynamo-browse, this time adding a back-stack. This can be used to go back to the previously viewed table, query or filter by pressing the Backspace key, kind of like how a browser back button works.

This is the first feature that makes use of a workspace, which is a concept that I’ve been thinking about since the start of the project. A workspace is basically a file storing various bits of state that could be recalled in future launches of the tool. A workspace is always created, even if one is not explicitly specified by the user. The workspace filename be set by using the -w switch on launch, or if one is not specified, then a new workspace filename within the temp directory is generated. The workspace file itself is a Bolt database, which is a very simple, embeddable key/value store that uses B-Trees and memory-mapped data access. I’m actually using StormDB to access this file, since it provides a nice interface for storing and querying Go structs without having to worry about marshalling or unmarshalling.

The back-stack consist of view-snapshots, which are essentially records of the currently view table, filter, and query. The view-snapshots are stored as a linked list, and the back-stack simply pushes new snapshots as the view changes (because this is stored on file, the backlinks are actually ID references and not physical pointers). I had a bit of trouble getting this right at first. The initial version actually pushed a snapshot of the previous view before it changed (i.e. a new table was selected or the filter was changed). But this resulted in a bit of messy implementation, with push calls copied and pasted across the various controllers with various special cases, etc.

So I went back and reimplemented it so that the top of the back-stack is actually a snapshot of the current view. Pressing the Backspace key will actually pop the current snapshot, then read the head of the stack and use that to update the view. This means that there will always be one item in the stack, which bothered me a little at first, but that did make the code easier to implement.

There is another benefit to this arrangement which just came to me while I was writing this. Since the current state of the view is always at the top of the stack, I could add the ability to restore the last view when launching dynamo-browse with an existing workspace, saving the user from selecting a table and running their last query. This will come a bit later. For the meantime, I need to get this back-stack working with user scripts, so that when a script changes the view, the user can still go back.

Finally, a shoutout to boltcli which is a useful CLI tool for browsing a Bolt database. This tool has come in handy for debugging this feature.

Release Preparation & Next Steps

Sat, 30 Jul 2022 10:19:56 +1000

Finally finished the website for the Audax toolset and cut an initial release (v0.0.2). I’ve also managed to get binary releases for Linux and Windows made. I’ve started to work on binary releases for MacOS with the intention of distributing it via Homebrew. This is completely new to me so I’m not sure what progress I’ve made so far: probably nothing. For one thing, I’ll need a separate machine to test with, since I’ve just been installing them from source on the machine’s I’ve been using. Code signing is going to be another thing that will be fun to deal with.

I’ll slip that into a bit of a background task for the moment. For now, I’d like to start work on a feature for “dynamo-browse” that I’ve been thinking of for a while: the ability for users to extend it with scripts.

Some might argue that it may be a little early for this feature, but I’m motivated to do it now as I have a personal need for this, which is navigating amongst a bunch of DynamoDB tables that all store related data. This is all work related, so can’t say too much here. But if I were just to say that doing this now is a little annoying. It involves copying and pasting keys, changing tables, and running filters and queries manually: all possible, but very time consuming. Having the ability to do all this with a single command or keybinding would be so much better. And since this is all work related, I can’t simply modify the source code directly as it will give too much away. Perfect candidate for using an embedded scripting language.

So I think that’s what I’ll start work on next.

I also need to think about starting work on “sqs-browse”. This would be a complete rewrite of what is currently there: which is something that can be used for polling SQS queues and viewing the messages there. I’m hoping for something a little more sophisticated, involving a workspace for writing and pushing messages to queues, along with pulling, saving and routing them from queues. I haven’t got an immediate need for this yet, but I’ve come close on occasion so I can’t leave this too late.

Time and Money

Wed, 02 Mar 2022 09:36:00 +1000

Spending a lot of time in Stripe recently. It’s a fantastic payment gateway and a pleasure to use, compared to something like PayPal which really does show its age.

But it’s so stressful and confusing dealing with money and subscriptions. The biggest uncertainty is dealing with anything that takes time. The problem I’m facing now is if the customer chooses to buy something like a database, which is billed a flat fee every month, and then they choose to buy another database during the billing period, can I track that with a single subscription and simply adjust the quantity amount? My current research suggests that I can, and that Stripe will handle the prorating of partial payments and credits. They even have a nice API to preview the next invoice which can be used to show the customer how much they will be paying for.

But despite all the documentation, test environments, and simulations, I still can’t be sure that it will happen in real life, when real money is exchanged in real time. I guess some real life testing would be required. 💸

On Apple's Media Release Gymnastics

Mon, 06 Sep 2021 08:02:00 +1000

I started listening to the latest Talk Show, where John Gruber and MG Siegler discuss Apple’s media release of the class action settlement. Releasing it to the major media outlets in such a way as to spin the guideline clarification as a concession to developers, even though nothing has actually change, is genius if true. I imagine that’s why Apple’s PR department get the big bucks.

But I wonder if Apple has considered the potential blowback of this approach. I might be naive here, but I can’t help wonder whether these media outlets publishing that Apple hasn’t actually conceded anything will eventually realised that they have been had. Would that affect the relationship between the two in any way? Say Apple wants to publish some good news and expect these outlets to maintain the favourable air of their release. Would they do it?

Then again, it’s most likely that nothing will really change. There’s little trust lost between the two anyway, and if this gymnastics actually happened, Apple knows it. Also, it sounds like Apple’s media release has had the desired effect of reaching those in the US government applying anti-trust pressure on the company. They probably think it’s worth the credibility they have burned with these outlets, if any¹.

One thing that seems clear though: this is doing no favours in addressing the trust lost between Apple and their developers, no matter how much clarifying this release does.

I realise that I’m probably so far removed from how much the general zeitgeist knows or cares about the relationship between Apple and their developers, so even expecting that these outlets know that they have been had is a huge assumption. ↩︎

Seeking Out Bad News

Thu, 22 Jul 2021 09:59:16 +1000

Sometimes I wonder if I’m just going out of the way to seek bad news. Maybe it’s because I think that if I don’t, then a problem will go unaddressed as no-one else is aware of it.

There’s probably some evolutionary trait to this. Being the one that hears a predator, and reacts to it before anyone else, is an advantage. But in this day and age, many of the problems that I have anxiety about is pretty much known by everyone, and addressing it in any meaningful way is beyond my direct control.

So in the interest for my own mental health, I should cut down on seeking out these stories, do what I can to help with the problem, and just hope that someone who does have the ability to do something substantial knows about it, and can address it in some way.

While total ignorance is probably not ideal, being up to speed with the woes of the world is probably not healthy either.

Sun, 28 Feb 2021 12:42:38 +1000

The interesting thing about technology breakthroughs is how quickly the shift from the impossible to the banal actually is. An example of this is machine learning. This was something that was being researched on since the 1950s, with very little to show for it in terms of practical applications. This changed very recently, thanks to the growth of computing power. Now, many of these same techniques are used in many things that are taken for granted, like language translation, image recognition, and surfacing content in algorithmic timelines of social networks (not all utilisation of this technology is good).

This was one of the first thoughts I had when I heard about the announcement of a potential vaccine for malaria, which uses very similar technology to the mRNA Covid-19 vaccines.

Empty HTTP Headers in Go

Tue, 09 Feb 2021 20:00:00 +1000

Here is a technique for checking for the presence of a HTTP header in a Go request, even if the header has no value.

If there’s a header in a HTTP request that has no value, the parser used by Go will store the header against an empty string value. This string value is available using the Values() method: using the Get() method will not work as that will return an empty string if the header is not present in the request, make it ambiguous for existential tests if empty header values are allowed.

The Values() method can be used to return all the values of a header. This is useful for cases when a header appears multiple times in a request, but it’s also useful here as an empty slice is returned if the header does not appear. In which case, the way to test for the presence of a header can be done using the following line of code:

len(req.Header.Values("My-Header")) > 0

Where “My-Header” is the header you are looking for.

Dealing With Errors in Go

Wed, 16 Dec 2020 13:24:42 +1000

There’s a lot to like about Go, and I’ll happily admit being a huge fan of the language. But it will be dishonest of me not to acknowledge that some aspects of programming in Go results in more code than the equivalent in another language. My guess is that the best example of this is how Go programs deal with errors.

For those unfamiliar with how errors work in Go, the short version is that they are just like any other type that you deal with — like strings and integers — and they have no special control structure to handle them in any specific way. This means that, unlike languages that have exceptions, there is nothing like try/catch blocks; you are left with the standard control statements that are available.

The result; you will fall into the practice of having a lot of code that looks like this:

func doStuff() error {
	firstResult, err := doFirstThing()
	if err != nil {
		return err
	}
	
	secondResult, err := doSecondThing(firstResult)
	if err != nil {
		return err
	}
	
	lastResult, err := doOneLastThing(secondResult)
	if err != nil {
		return err
	}
	
	return processResult(lastResult)
}

This is not bad in-and-of-itself, but it does have some shortcomings over the equivalent in languages that use exceptions. The use of an if block after every call to a “do function”¹ adds a bit of noise making it harder to separate the happy path from the error handling. And although the code is technically correct — whereby the errors are being handled appropriately — you may come to wonder whether this could be done in a nicer way.

This post explores some alternatives for dealing with Go errors. It is by no means exhaustive; it’s just a few patterns I’ve found works for me. It is also by no means suggestive that you even should use one of the alternatives. Each use case is different; and one alternative might be a better solution in a particular case, but dramatically worse in another. Everything in coding, much like life itself, is a tradeoff, and I would suggest being mindful of the potential costs of adopting any one of these options alongside the benefits they may bring.

With that said, let’s look at some alternatives.

Option 0: Keep It As It Is

This is probably not an option that you’d like to hear, but it is one worth considering if the function is small enough, and you don’t have the ability to change the functions you are calling. As ugly as the code looks, it does have some advantages:

It makes the erroneous path crystal clear: it indicates that any one of these operations can fail with an error, and that it is the job of the function to handle it in some way, even if it is simply returning it as it’s error.
It makes it reasonably easy to move things around or change how the error is to be handled: if doSecondThing returns an error that no longer blocks the call to doOneLastThing, you only need to adjust one if statements. This is harder to do in any generic solution you may adapt.
It provides an incentive to keep functions small: for example, if there is a need to expand the number of operations from 4 to 30, and each operation returns an error that needs to be handled, then that would impart a large enough pressure to refactor the code, and break it up across multiple functions.

So I’d recommend considering this as a viable option first, if only briefly. Spending effort on a solution that may look neater can actually have the opposite effect of making the code less understandable, while also making it harder to maintain.

Option 1: Don’t Handle The Error

No, don’t go. Let me explain.

This is not a viable option if you are writing code intended for a production setting. Arguably, if something can fail in some way, you should handle it. But I’m listing this option here as it is an alternative to the if statements above if one of the following scenarios is true:

The functions don’t return errors: they may be required to implement a type that does, but if it is clear within the public documentation that they never do, then there is no real need to handle the error. Some care will need to be observed in this case though: public documentation is not the the same as an API, and depending on who’s maintaining these functions, it is very possible that, down the line, the implementor takes advantage of the error return type, and starts returning them.
The error can be safely ignored: this might be test code, or code that is written once, then thrown away. In these case, it may not be worth your while adding support for error handling if it provides no real value.

Adopting this option may make the function look like the following. It may not be possible to simplify further unless you can actually change the return type of the “do functions”; in which case, there are no errors that need handling.

func doStuff() error {
	firstResult, _ := doFirstThing()
	secondResult, _ := doSecondThing(firstResult)
	lastResult, _ := doOneLastThing(secondResult)
	
	// You can probably ignore this error as well, but it's simpler to just return it
	return processResult(lastResult)
}

Option 2: Use Panic

The second option is to use panic to throw the error, and handle it in a single defer and recover handler.

A first draft of this solution may look something like the following:

func doStuff() (err error) {
	defer func() {
		if e, isErr := recover().(error); isErr {
			err = e
		} else {
			panic(e)
		}
	}()
	
	firstResult, err := doFirstThing()
	if err != nil {
		panic(err)
	}
	
	secondResult, err := doSecondThing(firstResult)
	if err != nil {
		panic(err)
	}
	
	lastResult, err := doOneLastThing(secondResult)
	if err != nil {
		panic(err)
	}
	
	return processResult(lastResult)	
}

which is not much better than what we had to begin with. However, if we can modify the “do functions” themselves, we can replace them with versions that panic instead of return an error. These new “must do functions” — so named as the must prefix is used to indicate that they will panic if things go wrong — can bring out the happy path quite clearly:

func doStuff() (err error) {
	defer func() {
		if e, isErr := recover().(error); isErr {
			err = e
		} else {
			panic(e)
		}
	}()
	
	firstResult := mustDoFirstThing()
	secondResult := mustDoSecondThing(firstResult)
	lastResult := mustDoOneLastThing(secondResult)
	mustProcessResult(lastResult)
		
	return 
}

This can be improved further if the “do functions” actually return values of the same type. For that, we don’t actually need to replace the function. Instead, we can build a function that simply takes the result and error, and either return the result or panic depending on whether an error was returned²:

type doResult struct { ... }

func must(res doResult, err error) doResult {
	if err != nil {
		panic(err)
	}
	
	return doResult
}

func doStuff() (err error) {
	defer func() {
		if e, isErr := recover().(error); isErr {
			err = e
		} else {
			panic(e)
		}
	}()
	
	firstResult := must(doFirstThing())
	secondResult := must(doSecondThing(firstResult))
	lastResult := must(doOneLastThing(secondResult))
	
	if err := processResult(lastResult); err != nil {
		panic(err)
	}
		
	return 
}

This will work, but I’d argue it’s not the best use of panic. Go panics should be reserved for unexpected errors, instead of as a poor substitute for exceptions. Instead, I suggest the following option, which provides a nicer API while maintaining the principal of errors as values.

Option 3: Encapsulate The Error Handling Using A Dedicated Type

This is probably my preferred option of the three. Basically, the idea to track the state of the error using a dedicated type, and wrapping the functions that return errors within methods that don’t. The methods will be defined on the type that is maintaining the error state, and each one will check whether an error has been raised before invoking the wrapped function. Finally, the struct will offer a way to get the error, so that it can be logged or returned.

The way this looks in code would be the following:

type DoOperations struct {
	err  error
}

func (d *doOperations) DoFirstThing() (res doResult) {
	if d.err != nil {
		return doResult{}
	}
	
	res, d.err = doFirstThing()
	return
}

func (d *doOperations) DoSecondThing(op doResult) (res doResult) {
	if d.err != nil {
		return doResult{}
	}
	
	res, d.err = doSecondThing(op)
	return
}

// Likewise for doOneLastThing and processResult

func (d *doOperations) Err() error {
	return d.err
}

Then, the our new function will simply become:

func doStuff() error {
	ops := new(doOperations)
	
	firstResult := ops.DoFirstThing()
	secondResult := ops.DoSecondThing(firstResult)
	lastResult := ops.DoOneLastThing(secondResult)
	ops.ProcessResult(lastResult)
	
	return ops.Err()
}

This gives us the ability to write a function with the happy-path clearly shown while still maintaining best practices around error handling.

As nice as this is, the one downside is that this type is specific to the set of operations that we need to deal with. If this is the only function that needs to perform these operations, then the additional maintenance overhead might not offset the nicer API that this gives you. But if you find yourself writing out this sequence of operations in a variety of different ways, it may be worth your while to consider this approach.

To Be Continued

It’s very likely that this topic may be revisited as the Go language evolves. With the design of type parameters imminent, and discussions around adding language features to make error handling nicer in general, additional options may become possible down the line. But for now, these are the options that seem like current viable alternatives to the function-call-then-if-block pattern seen in a lot of Go code.

For brevity, I’ll be referring to the functions doFirstThing, doSecondThing and doOneLastThing collectively as the “do functions”. ↩︎
An example of this in the standard library is the template.Must() function. ↩︎

Thu, 22 Oct 2020 08:25:00 +1000

Over the last few weeks, while Melbourne has been under lock-down to drive the Covid-19 cases down, the government has been ramping up it’s contact tracing infrastructure. It’s been quite flaky at the start but from what I hear now on Coronacast it’s in a pretty decent state. It has delt with outbreaks in both Kilmore and Shepparton, two regional cities here in Victoria.

Now the real test comes, with the potential of an outbreak at a school here in the north of Melbourne, a few days before restrictions are lifted. From what I’m reading, it looks like the testing and contact tracing infrastructure has moved in quite rapidly. The school has closed due to a precaution, popup testing sites have been deployed, and some 300 people have been told to self-isolate.

We’ll see how this goes over the coming days. If all goes well, then I will have greater confidence that the Vic government will be able to handle these outbreaks and we can move to Covid-normal like the rest of the country.

P.S. Only 5 cases today. This is a little higher than the 1 to 2 that we’ve been experiencing over the last week or so, but still quite good.

Let's hold the line, Melbourne. We've got this.

Wed, 23 Sep 2020 09:17:56 +1000

Today is a good day. Melbourne’s 14 day daily Covid-19 case average is now 29.4, which is beyond the 30 to 50 band required to move to the next stage of reopening. Seeing the fruits of our collective sacrifice, bringing the daily case numbers from a peak of around 740 in August down to the 11 we saw on Monday, makes me proud to be a Melburnian.

As much as I like for things to reopen sooner than planned, I think we should hold the line for as long as we possibly can. The potential prizes for doing so – the crushing of the virus, the ability to travel interstate again, the chance to eat at restaurants without fear of infection, the chance for a normalish Christmas and summer – are within reach. I know that’s easy for me to say as someone who has the ability to work from home, and I completely recognise those of us suffering right now being unable to work at all. But just like the darkest hour is before the dawn, so too will the sweet taste of victory and accomplishment be when we finally crush this virus and meet the rest of the country where they are. To rush this, to reopen too early, and see our effort thrown away would be upsetting.

Let’s hold out that little bit longer, Melbourne. We’ve got this.

On Suppression vs. Elimination

Tue, 21 Jul 2020 10:04:48 +1000

It was around the beginning of June, when the number of new Covid-19 cases for Victoria were around 10-20 a day, that there was a general feeling that suppression was working and that it was time to begin opening up. I will admit I took advantage of the looser restrictions, but I always wondered whether it would be better to remain closed for a little while longer and go for elimination. This was not the official strategy though: we have testing and tracing up and running and as long as we know where the virus is, we can continue to roll-back restrictions and achieve some semblance of normalcy.

Fast-forward to today and the daily number of cases is higher than what it was back in March, Melbourne is back under Stage 3 restrictions and I’m shopping on-line for masks.

It seems obvious to me that suppression as a strategy may not be enough. We may eventually (hopefully) get the virus tamped down once more, but it’s still out there and our efforts to keep it at bay are only as strong as our weakest link.

I think it’s time we go for elimination. It won’t be easy, but there are three reasons why I reckon it’s worth a shot:

Most of the other states in the country have effectively achieved eliminated. Some of them have gone weeks without any new cases, and are cautiously in the process of opening up once again. However, this can only hold as long as the state borders remain close to Victorians (and possibly soon to the New South Welsh) and I don’t see these states willing throwing away their hard won achievement just because the official strategy is suppression. If Victoria (and NSW) go for elimination, we can meet the other states where they are, making it a no-brainer to open up interstate travel once again, not to mention the trans-Tasman bubble with New Zealand.
It seems more economically stable over the long term. Economic activity is tied to confidence: people will only go out and spend money if they believe it’s safe to do so. Even when restrictions are rolled-back, I’m doubtful people will be quick to flock to cafes and gyms if there’s a risk of another wave. Compare this with elimination: evidence from New Zealand shows that consumer spending is pretty much back to pre-pandemic levels, despite going harder during the initial lock-down.
It may be a way to win back the public’s confidence in the government. The Victorian government has taken a hit in the polls due to the mistakes that caused the current round of lock-downs. I can see rallying the public around the goal of elimination a way to win them back. You can even use the current situation as a unique opportunity to achieve this, maybe by saying, “given that we’re already going through another round of lock-downs, let’s go for broke and remain locked down until we’ve eliminated this virus once and for all.” Now you have a something that people can work towards, and the feeling that their current sacrifice is not for nothing if (when?) another wave comes through.

I’m aware that this a post written by someone who is in a position of relative privilege. I haven’t lost my job, and I remain relatively healthy and financially secure. I also know that it will be expensive and will cause a fair bit more suffering for those with small businesses that will need to shut their doors. So I recognised that I don’t have all the facts, and this may not be feasible at all. But I also question the feasibility of maintaining a long-term suppression strategy until treatments or a vaccine become available: this is a tricky virus to handle.

In the end, I guess I’m just a bit disappointed by the lack of abition in attempting this as a goal. It seems advantageous, especially now, to seize the moment and go for making our second round of lock-downs our last.

Don't Get it Now

Sun, 22 Mar 2020 11:00:00 +1000

It’s scary times at the moment. The Corona Virus (SARS-CoV-2 and Covid-19) is raging through Europe at this moment, with hundreds of people dying in Italy, Spain and France and most of the those countries, along with the US, in lock-down. The hospital system is currently not equipped to be able to handle the peak number of patients that will require intensive care: doctors from Italy, France and New York are telling stories about how they have to choose who lives and dies, and I’m fearful that we may start hearing stories like that here. There is currently no cure, nor no treatment. There’s been models indicating that even if we take steps to suppress the virus now, there will be continuous surges in outbreaks until a vaccine is ready in 12 to 18 months, suggesting that we may need to be in a state of lock-down or at the very least, rigid social distancing until August 2021 at the latest. The WHO reckons that a majority of the worlds population will get infected over the next year.

I’m not an doctor, nor an etymologist. I cannot begin to suggest what we should do as a society. But I’m going to give a few thoughts as to how I plan to weather this storm.

I think at this current stage, our enemy, along with the virus, is time. I hope I don’t have to tell you that the virus is moving through the worlds population now, even as we speak. But humanity is not standing still either:

We are researching the hell out of this thing. One such example is on Tuesday we learnt how the body reacts to the virus, which could help with understanding how best to treat it. Along with this, there are still some very important unanswered questions about the [actual death rate and transmission rate](www.abc.net.au/news/2020… coronavirus/12068106), as well as [whether heard immunity will work](www.abc.net.au/news/2020… 19-twice/12075878), that we’ll hopefully get the answer to soon.
We’re started clinical trials of potential treatments, and a vaccine. It’s still early days at the moment, and we probably won’t have anything ready soon, but the early indications of this sounds promising.
And, if the above should fail, we are (should?) be ramping up our hospital capacity to handle the influx of patients, meaning that if someone should unfortunately die from this, it won’t be because they didn’t have a bed.

So my mantra for the next few months is “don’t get it now.” Wait to get infected for as long as you can. The ideal case is not to catch it at all, but if we’re destine to get infected, best to get in infected later, when some of the points above have been addressed, instead of sooner when they have not. This will obviously mean sacrificing things like going to the gym, going out for coffee, or seeing friends and family. But I believe that this is a price worth paying, especially if the alternative is loosing someone you love, or potentially your own life.

So that’s my current strategy at this time. I don’t know if it will work, and as things develop it may need refining. But after thinking about this for the previous few weeks, it’s the best strategy I can think of. And I think it will help me get through this.

P.S. A lot of my thoughts on this came from reading this article by Tomas Pueyo. He’s obviously more knowledgeable about how we should act on this as a whole. It is worth your time reading this.

P.P.S. I spoke quite abstractly about the health system, but it’s important to remember that these systems are made up of people: doctors, nurses and paramedics on the front line, along with the researchers, manufacturers and logistics who support them. At this time, they are giving their all, and then some, to help us through this crisis. Once this is over, I think we owe every single one of these individuals a beer.

Update On 4th Dec 2022: Almost three years since writing this post, I tested positive for Covid-19 for the first time. My symptoms were that of a pretty rough cold which, given what the possibilities could have been when I wrote this post, meant that I weathered the disease pretty well. I finally caught it at a time when vaccines and treatments were wildly available and I was up to date with my inoculations. So all in all, I’m glad the whole “don’t get it now” worked in my favour.